#

文章概述

农产品冷链物流是保证农产品品质和安全的重要环节，但其成本占农产品总成本的比例很高。冷链物流涉及运输、仓储、包装等多个环节，每个环节都会产生成本。农产品冷链物流成本分析器通过综合分析运输距离、产品类型、仓储时间等多个因素，科学计算冷链物流的总成本，帮助农产品企业优化物流方案，降低成本。

农产品冷链物流成本分析器在实际应用中有广泛的用途。在成本控制中，需要准确计算冷链物流成本。在方案选择中，需要比较不同物流方案的经济性。在价格制定中，需要根据物流成本制定产品价格。在供应链优化中，需要分析物流成本对整体效益的影响。在投资决策中，需要评估冷链基础设施投资的回报。

本文将深入探讨如何在KMP（Kotlin Multiplatform）框架下实现一套完整的农产品冷链物流成本分析器，并展示如何在OpenHarmony鸿蒙平台上进行跨端调用。我们将提供多种成本分析功能，包括成本计算、方案对比、优化建议等，帮助企业科学管理冷链物流成本。

工具功能详解

核心功能

功能1：冷链物流成本计算（Cold Chain Logistics Cost Calculation）

根据产品类型、运输距离、仓储时间计算冷链物流总成本。这是成本分析的基础。

功能特点：

• 支持多种农产品
• 基于距离计算运费
• 考虑仓储和包装成本
• 返回详细的成本明细

功能2：物流方案对比（Logistics Plan Comparison）

对比不同物流方案的成本和效益。

功能特点：

• 支持多个方案
• 成本详细对比
• 效益评估
• 推荐最优方案

功能3：冷链损耗分析（Cold Chain Loss Analysis）

分析冷链过程中的产品损耗和成本影响。

功能特点：

• 计算损耗率
• 评估损耗成本
• 分析损耗原因
• 提供改进建议

功能4：成本优化建议（Cost Optimization Recommendation）

根据分析结果提供成本优化建议。

功能特点：

• 识别成本瓶颈
• 分析优化空间
• 提供具体建议
• 评估优化效果

功能5：价格制定辅助（Price Setting Assistance）

根据冷链成本辅助制定产品价格。

功能特点：

• 计算成本基础
• 分析利润空间
• 提供定价建议
• 评估市场竞争力

Kotlin实现

完整的Kotlin代码实现

/**
 * 农产品冷链物流成本分析器 - KMP OpenHarmony
 * 提供冷链物流成本分析的多种功能
 */
object ColdChainLogisticsUtils {
    
    // 产品冷链成本参数（元/吨/100km）
    private val productCostParameters = mapOf(
        "蔬菜" to mapOf("运输" to 50.0, "仓储" to 30.0, "包装" to 20.0, "损耗率" to 0.05),
        "水果" to mapOf("运输" to 60.0, "仓储" to 40.0, "包装" to 25.0, "损耗率" to 0.08),
        "肉类" to mapOf("运输" to 80.0, "仓储" to 50.0, "包装" to 30.0, "损耗率" to 0.03),
        "水产" to mapOf("运输" to 70.0, "仓储" to 45.0, "包装" to 28.0, "损耗率" to 0.06),
        "乳制品" to mapOf("运输" to 75.0, "仓储" to 55.0, "包装" to 32.0, "损耗率" to 0.02)
    )
    
    /**
     * 功能1：冷链物流成本计算
     */
    fun calculateColdChainCost(
        productType: String,
        productWeight: Double,
        transportDistance: Double,
        storageTime: Int
    ): Map<String, Any> {
        val calculation = mutableMapOf<String, Any>()
        val params = productCostParameters[productType] ?: return calculation
        
        val transportCost = (params["运输"] as Double) * productWeight * (transportDistance / 100.0)
        val storageCost = (params["仓储"] as Double) * productWeight * (storageTime / 30.0)
        val packagingCost = (params["包装"] as Double) * productWeight
        val handlingCost = (transportCost + storageCost) * 0.1
        
        val totalCost = transportCost + storageCost + packagingCost + handlingCost
        val costPerTon = totalCost / productWeight
        
        calculation["产品类型"] = productType
        calculation["产品重量"] = String.format("%.1f 吨", productWeight)
        calculation["运输距离"] = String.format("%.0f km", transportDistance)
        calculation["仓储时间"] = "$storageTime 天"
        calculation["运输成本"] = String.format("%.0f 元", transportCost)
        calculation["仓储成本"] = String.format("%.0f 元", storageCost)
        calculation["包装成本"] = String.format("%.0f 元", packagingCost)
        calculation["装卸成本"] = String.format("%.0f 元", handlingCost)
        calculation["总成本"] = String.format("%.0f 元", totalCost)
        calculation["吨均成本"] = String.format("%.0f 元/吨", costPerTon)
        
        return calculation
    }
    
    /**
     * 功能2：物流方案对比
     */
    fun compareLogisticsPlans(
        productType: String,
        productWeight: Double,
        transportDistance: Double,
        storageTime: Int,
        plans: List<String>
    ): Map<String, Any> {
        val comparison = mutableMapOf<String, Any>()
        val planCosts = mutableMapOf<String, String>()
        
        // 标准方案成本
        val standardCost = calculateColdChainCost(productType, productWeight, transportDistance, storageTime)
        val standardTotal = (standardCost["总成本"] as String).split(" ")[0].toDouble()
        
        var minCost = standardTotal
        var bestPlan = "标准方案"
        
        // 快速方案（减少仓储时间）
        if (plans.contains("快速方案")) {
            val fastCost = calculateColdChainCost(productType, productWeight, transportDistance, (storageTime * 0.5).toInt())
            val fastTotal = (fastCost["总成本"] as String).split(" ")[0].toDouble()
            planCosts["快速方案"] = String.format("%.0f 元", fastTotal)
            if (fastTotal < minCost) {
                minCost = fastTotal
                bestPlan = "快速方案"
            }
        }
        
        // 经济方案（增加仓储时间）
        if (plans.contains("经济方案")) {
            val economyCost = calculateColdChainCost(productType, productWeight, transportDistance, (storageTime * 1.5).toInt())
            val economyTotal = (economyCost["总成本"] as String).split(" ")[0].toDouble()
            planCosts["经济方案"] = String.format("%.0f 元", economyTotal)
            if (economyTotal < minCost) {
                minCost = economyTotal
                bestPlan = "经济方案"
            }
        }
        
        planCosts["标准方案"] = String.format("%.0f 元", standardTotal)
        
        comparison["产品类型"] = productType
        comparison["方案对比"] = planCosts
        comparison["最低成本"] = String.format("%.0f 元", minCost)
        comparison["最优方案"] = bestPlan
        comparison["成本节省"] = String.format("%.0f 元", standardTotal - minCost)
        
        return comparison
    }
    
    /**
     * 功能3：冷链损耗分析
     */
    fun analyzeColdChainLoss(
        productType: String,
        productWeight: Double,
        transportDistance: Double,
        storageTime: Int,
        productPrice: Double
    ): Map<String, Any> {
        val analysis = mutableMapOf<String, Any>()
        val params = productCostParameters[productType] ?: return analysis
        
        val lossRate = params["损耗率"] as Double
        val lossWeight = productWeight * lossRate
        val lossCost = lossWeight * productPrice
        
        // 冷链成本
        val coldChainCost = calculateColdChainCost(productType, productWeight, transportDistance, storageTime)
        val totalCost = (coldChainCost["总成本"] as String).split(" ")[0].toDouble()
        
        val totalLoss = lossCost + totalCost
        val lossPercentage = (lossCost / (productWeight * productPrice)) * 100
        
        analysis["产品类型"] = productType
        analysis["产品重量"] = String.format("%.1f 吨", productWeight)
        analysis["损耗率"] = String.format("%.1f%%", lossRate * 100)
        analysis["损耗重量"] = String.format("%.2f 吨", lossWeight)
        analysis["产品价格"] = String.format("%.0f 元/吨", productPrice)
        analysis["损耗成本"] = String.format("%.0f 元", lossCost)
        analysis["冷链成本"] = String.format("%.0f 元", totalCost)
        analysis["总损失"] = String.format("%.0f 元", totalLoss)
        analysis["损失比例"] = String.format("%.1f%%", lossPercentage)
        
        return analysis
    }
    
    /**
     * 功能4：成本优化建议
     */
    fun recommendCostOptimization(
        productType: String,
        productWeight: Double,
        transportDistance: Double,
        storageTime: Int
    ): Map<String, Any> {
        val recommendation = mutableMapOf<String, Any>()
        val suggestions = mutableListOf<String>()
        var potentialSavings = 0.0
        
        val currentCost = calculateColdChainCost(productType, productWeight, transportDistance, storageTime)
        val currentTotal = (currentCost["总成本"] as String).split(" ")[0].toDouble()
        
        // 分析运输成本
        val transportCost = (currentCost["运输成本"] as String).split(" ")[0].toDouble()
        if (transportCost > currentTotal * 0.4) {
            suggestions.add("运输成本过高，建议优化运输路线或选择更经济的运输方式")
            potentialSavings += transportCost * 0.15
        }
        
        // 分析仓储成本
        val storageCost = (currentCost["仓储成本"] as String).split(" ")[0].toDouble()
        if (storageCost > currentTotal * 0.3) {
            suggestions.add("仓储成本过高，建议减少仓储时间或选择更经济的仓储方案")
            potentialSavings += storageCost * 0.2
        }
        
        // 分析包装成本
        val packagingCost = (currentCost["包装成本"] as String).split(" ")[0].toDouble()
        if (packagingCost > currentTotal * 0.15) {
            suggestions.add("包装成本过高，建议优化包装方案")
            potentialSavings += packagingCost * 0.1
        }
        
        if (suggestions.isEmpty()) {
            suggestions.add("成本结构合理，无需优化")
        }
        
        recommendation["产品类型"] = productType
        recommendation["当前总成本"] = String.format("%.0f 元", currentTotal)
        recommendation["优化建议"] = suggestions
        recommendation["潜在节省"] = String.format("%.0f 元", potentialSavings)
        recommendation["优化空间"] = String.format("%.1f%%", (potentialSavings / currentTotal) * 100)
        
        return recommendation
    }
    
    /**
     * 功能5：价格制定辅助
     */
    fun assistPriceSetting(
        productType: String,
        productWeight: Double,
        transportDistance: Double,
        storageTime: Int,
        targetMargin: Double = 0.3
    ): Map<String, Any> {
        val assistance = mutableMapOf<String, Any>()
        
        val coldChainCost = calculateColdChainCost(productType, productWeight, transportDistance, storageTime)
        val totalCost = (coldChainCost["总成本"] as String).split(" ")[0].toDouble()
        val costPerTon = (coldChainCost["吨均成本"] as String).split(" ")[0].toDouble()
        
        // 基础价格（成本）
        val basePrice = costPerTon
        
        // 目标价格（包含利润）
        val targetPrice = basePrice / (1 - targetMargin)
        
        // 市场参考价格（假设）
        val marketPrice = when (productType) {
            "蔬菜" to 3000.0,
            "水果" to 4000.0,
            "肉类" to 8000.0,
            "水产" to 6000.0,
            "乳制品" to 5000.0
        }.let { it[productType] ?: 4000.0 }
        
        val competitiveness = if (targetPrice <= marketPrice) "有竞争力" else "缺乏竞争力"
        val actualMargin = ((marketPrice - basePrice) / marketPrice) * 100
        
        assistance["产品类型"] = productType
        assistance["成本基础"] = String.format("%.0f 元/吨", basePrice)
        assistance["目标利润率"] = String.format("%.0f%%", targetMargin * 100)
        assistance["建议价格"] = String.format("%.0f 元/吨", targetPrice)
        assistance["市场参考价"] = String.format("%.0f 元/吨", marketPrice)
        assistance["竞争力评估"] = competitiveness
        assistance["实际利润率"] = String.format("%.1f%%", actualMargin)
        
        return assistance
    }
    
    /**
     * 生成完整的冷链成本分析报告
     */
    fun generateCompleteReport(
        productType: String,
        productWeight: Double,
        transportDistance: Double,
        storageTime: Int,
        productPrice: Double
    ): Map<String, Any> {
        val report = mutableMapOf<String, Any>()
        
        report["成本计算"] = calculateColdChainCost(productType, productWeight, transportDistance, storageTime)
        report["方案对比"] = compareLogisticsPlans(productType, productWeight, transportDistance, storageTime, 
            listOf("快速方案", "经济方案"))
        report["损耗分析"] = analyzeColdChainLoss(productType, productWeight, transportDistance, storageTime, productPrice)
        report["优化建议"] = recommendCostOptimization(productType, productWeight, transportDistance, storageTime)
        report["价格辅助"] = assistPriceSetting(productType, productWeight, transportDistance, storageTime)
        
        return report
    }
}

// 使用示例
fun main() {
    println("KMP OpenHarmony 农产品冷链物流成本分析器演示\n")
    
    // 成本计算
    println("=== 冷链物流成本计算 ===")
    val cost = ColdChainLogisticsUtils.calculateColdChainCost("蔬菜", 10.0, 500.0, 5)
    cost.forEach { (k, v) -> println("$k: $v") }
    println()
    
    // 方案对比
    println("=== 物流方案对比 ===")
    val comparison = ColdChainLogisticsUtils.compareLogisticsPlans("蔬菜", 10.0, 500.0, 5, 
        listOf("快速方案", "经济方案"))
    comparison.forEach { (k, v) -> println("$k: $v") }
    println()
    
    // 损耗分析
    println("=== 冷链损耗分析 ===")
    val loss = ColdChainLogisticsUtils.analyzeColdChainLoss("蔬菜", 10.0, 500.0, 5, 2000.0)
    loss.forEach { (k, v) -> println("$k: $v") }
}

Kotlin实现的详细说明

Kotlin实现提供了五个核心功能。冷链物流成本计算根据产品类型和运输参数计算总成本。物流方案对比分析不同方案的经济性。冷链损耗分析评估产品损耗的成本影响。成本优化建议识别成本瓶颈并提供改进方案。价格制定辅助根据成本和利润目标提供定价建议。

JavaScript实现

完整的JavaScript代码实现

/**
 * 农产品冷链物流成本分析器 - JavaScript版本
 */
class ColdChainLogisticsJS {
    static productCostParameters = {
        '蔬菜': { '运输': 50.0, '仓储': 30.0, '包装': 20.0, '损耗率': 0.05 },
        '水果': { '运输': 60.0, '仓储': 40.0, '包装': 25.0, '损耗率': 0.08 },
        '肉类': { '运输': 80.0, '仓储': 50.0, '包装': 30.0, '损耗率': 0.03 },
        '水产': { '运输': 70.0, '仓储': 45.0, '包装': 28.0, '损耗率': 0.06 },
        '乳制品': { '运输': 75.0, '仓储': 55.0, '包装': 32.0, '损耗率': 0.02 }
    };
    
    /**
     * 功能1：冷链物流成本计算
     */
    static calculateColdChainCost(productType, productWeight, transportDistance, storageTime) {
        const calculation = {};
        const params = this.productCostParameters[productType];
        if (!params) return calculation;
        
        const transportCost = params['运输'] * productWeight * (transportDistance / 100.0);
        const storageCost = params['仓储'] * productWeight * (storageTime / 30.0);
        const packagingCost = params['包装'] * productWeight;
        const handlingCost = (transportCost + storageCost) * 0.1;
        
        const totalCost = transportCost + storageCost + packagingCost + handlingCost;
        const costPerTon = totalCost / productWeight;
        
        calculation['产品类型'] = productType;
        calculation['产品重量'] = productWeight.toFixed(1) + ' 吨';
        calculation['运输距离'] = Math.floor(transportDistance) + ' km';
        calculation['仓储时间'] = storageTime + ' 天';
        calculation['运输成本'] = Math.floor(transportCost) + ' 元';
        calculation['仓储成本'] = Math.floor(storageCost) + ' 元';
        calculation['包装成本'] = Math.floor(packagingCost) + ' 元';
        calculation['装卸成本'] = Math.floor(handlingCost) + ' 元';
        calculation['总成本'] = Math.floor(totalCost) + ' 元';
        calculation['吨均成本'] = Math.floor(costPerTon) + ' 元/吨';
        
        return calculation;
    }
    
    /**
     * 功能2：物流方案对比
     */
    static compareLogisticsPlans(productType, productWeight, transportDistance, storageTime, plans) {
        const comparison = {};
        const planCosts = {};
        
        const standardCost = this.calculateColdChainCost(productType, productWeight, transportDistance, storageTime);
        const standardTotal = parseFloat(standardCost['总成本']);
        
        let minCost = standardTotal;
        let bestPlan = '标准方案';
        
        if (plans.includes('快速方案')) {
            const fastCost = this.calculateColdChainCost(productType, productWeight, transportDistance, Math.floor(storageTime * 0.5));
            const fastTotal = parseFloat(fastCost['总成本']);
            planCosts['快速方案'] = Math.floor(fastTotal) + ' 元';
            if (fastTotal < minCost) {
                minCost = fastTotal;
                bestPlan = '快速方案';
            }
        }
        
        if (plans.includes('经济方案')) {
            const economyCost = this.calculateColdChainCost(productType, productWeight, transportDistance, Math.floor(storageTime * 1.5));
            const economyTotal = parseFloat(economyCost['总成本']);
            planCosts['经济方案'] = Math.floor(economyTotal) + ' 元';
            if (economyTotal < minCost) {
                minCost = economyTotal;
                bestPlan = '经济方案';
            }
        }
        
        planCosts['标准方案'] = Math.floor(standardTotal) + ' 元';
        
        comparison['产品类型'] = productType;
        comparison['方案对比'] = planCosts;
        comparison['最低成本'] = Math.floor(minCost) + ' 元';
        comparison['最优方案'] = bestPlan;
        comparison['成本节省'] = Math.floor(standardTotal - minCost) + ' 元';
        
        return comparison;
    }
    
    /**
     * 功能3：冷链损耗分析
     */
    static analyzeColdChainLoss(productType, productWeight, transportDistance, storageTime, productPrice) {
        const analysis = {};
        const params = this.productCostParameters[productType];
        if (!params) return analysis;
        
        const lossRate = params['损耗率'];
        const lossWeight = productWeight * lossRate;
        const lossCost = lossWeight * productPrice;
        
        const coldChainCost = this.calculateColdChainCost(productType, productWeight, transportDistance, storageTime);
        const totalCost = parseFloat(coldChainCost['总成本']);
        
        const totalLoss = lossCost + totalCost;
        const lossPercentage = (lossCost / (productWeight * productPrice)) * 100;
        
        analysis['产品类型'] = productType;
        analysis['产品重量'] = productWeight.toFixed(1) + ' 吨';
        analysis['损耗率'] = (lossRate * 100).toFixed(1) + '%';
        analysis['损耗重量'] = lossWeight.toFixed(2) + ' 吨';
        analysis['产品价格'] = Math.floor(productPrice) + ' 元/吨';
        analysis['损耗成本'] = Math.floor(lossCost) + ' 元';
        analysis['冷链成本'] = Math.floor(totalCost) + ' 元';
        analysis['总损失'] = Math.floor(totalLoss) + ' 元';
        analysis['损失比例'] = lossPercentage.toFixed(1) + '%';
        
        return analysis;
    }
    
    /**
     * 功能4：成本优化建议
     */
    static recommendCostOptimization(productType, productWeight, transportDistance, storageTime) {
        const recommendation = {};
        const suggestions = [];
        let potentialSavings = 0;
        
        const currentCost = this.calculateColdChainCost(productType, productWeight, transportDistance, storageTime);
        const currentTotal = parseFloat(currentCost['总成本']);
        
        const transportCost = parseFloat(currentCost['运输成本']);
        if (transportCost > currentTotal * 0.4) {
            suggestions.push('运输成本过高，建议优化运输路线');
            potentialSavings += transportCost * 0.15;
        }
        
        const storageCost = parseFloat(currentCost['仓储成本']);
        if (storageCost > currentTotal * 0.3) {
            suggestions.push('仓储成本过高，建议减少仓储时间');
            potentialSavings += storageCost * 0.2;
        }
        
        const packagingCost = parseFloat(currentCost['包装成本']);
        if (packagingCost > currentTotal * 0.15) {
            suggestions.push('包装成本过高，建议优化包装方案');
            potentialSavings += packagingCost * 0.1;
        }
        
        if (suggestions.length === 0) {
            suggestions.push('成本结构合理，无需优化');
        }
        
        recommendation['产品类型'] = productType;
        recommendation['当前总成本'] = Math.floor(currentTotal) + ' 元';
        recommendation['优化建议'] = suggestions;
        recommendation['潜在节省'] = Math.floor(potentialSavings) + ' 元';
        recommendation['优化空间'] = ((potentialSavings / currentTotal) * 100).toFixed(1) + '%';
        
        return recommendation;
    }
    
    /**
     * 功能5：价格制定辅助
     */
    static assistPriceSetting(productType, productWeight, transportDistance, storageTime, targetMargin = 0.3) {
        const assistance = {};
        
        const coldChainCost = this.calculateColdChainCost(productType, productWeight, transportDistance, storageTime);
        const totalCost = parseFloat(coldChainCost['总成本']);
        const costPerTon = parseFloat(coldChainCost['吨均成本']);
        
        const basePrice = costPerTon;
        const targetPrice = basePrice / (1 - targetMargin);
        
        const marketPrices = {
            '蔬菜': 3000.0,
            '水果': 4000.0,
            '肉类': 8000.0,
            '水产': 6000.0,
            '乳制品': 5000.0
        };
        
        const marketPrice = marketPrices[productType] || 4000.0;
        const competitiveness = targetPrice <= marketPrice ? '有竞争力' : '缺乏竞争力';
        const actualMargin = ((marketPrice - basePrice) / marketPrice) * 100;
        
        assistance['产品类型'] = productType;
        assistance['成本基础'] = Math.floor(basePrice) + ' 元/吨';
        assistance['目标利润率'] = Math.floor(targetMargin * 100) + '%';
        assistance['建议价格'] = Math.floor(targetPrice) + ' 元/吨';
        assistance['市场参考价'] = Math.floor(marketPrice) + ' 元/吨';
        assistance['竞争力评估'] = competitiveness;
        assistance['实际利润率'] = actualMargin.toFixed(1) + '%';
        
        return assistance;
    }
    
    /**
     * 生成完整的冷链成本分析报告
     */
    static generateCompleteReport(productType, productWeight, transportDistance, storageTime, productPrice) {
        const report = {};
        
        report['成本计算'] = this.calculateColdChainCost(productType, productWeight, transportDistance, storageTime);
        report['方案对比'] = this.compareLogisticsPlans(productType, productWeight, transportDistance, storageTime, 
            ['快速方案', '经济方案']);
        report['损耗分析'] = this.analyzeColdChainLoss(productType, productWeight, transportDistance, storageTime, productPrice);
        report['优化建议'] = this.recommendCostOptimization(productType, productWeight, transportDistance, storageTime);
        report['价格辅助'] = this.assistPriceSetting(productType, productWeight, transportDistance, storageTime);
        
        return report;
    }
}

// 导出供Node.js使用
if (typeof module !== 'undefined' && module.exports) {
    module.exports = ColdChainLogisticsJS;
}

JavaScript实现的详细说明

JavaScript版本充分利用了JavaScript的对象和计算功能。冷链成本计算基于多个成本项目。物流方案对比分析不同运输和仓储方案。损耗分析评估产品损耗的经济影响。成本优化建议识别高成本环节。价格辅助根据成本和市场情况提供定价建议。

ArkTS调用实现

完整的ArkTS代码实现

/**
 * 农产品冷链物流成本分析器 - ArkTS版本（OpenHarmony鸿蒙）
 */
import { webview } from '@kit.ArkWeb';
import { common } from '@kit.AbilityKit';

@Entry
@Component
struct ColdChainLogisticsPage {
    @State productType: string = '蔬菜';
    @State productWeight: string = '10';
    @State transportDistance: string = '500';
    @State storageTime: string = '5';
    @State productPrice: string = '2000';
    @State result: string = '';
    @State selectedTool: string = '完整报告';
    @State isLoading: boolean = false;
    @State allResults: string = '';
    
    private productCostParameters: Record<string, Record<string, number>> = {
        '蔬菜': { '运输': 50.0, '仓储': 30.0, '包装': 20.0, '损耗率': 0.05 },
        '水果': { '运输': 60.0, '仓储': 40.0, '包装': 25.0, '损耗率': 0.08 },
        '肉类': { '运输': 80.0, '仓储': 50.0, '包装': 30.0, '损耗率': 0.03 },
        '水产': { '运输': 70.0, '仓储': 45.0, '包装': 28.0, '损耗率': 0.06 },
        '乳制品': { '运输': 75.0, '仓储': 55.0, '包装': 32.0, '损耗率': 0.02 }
    };
    
    webviewController: webview.WebviewController = new webview.WebviewController();
    
    calculateColdChainCost(productType: string, productWeight: number, transportDistance: number, storageTime: number): string {
        const params = this.productCostParameters[productType];
        if (!params) return '无效的产品类型';
        
        const transportCost = params['运输'] * productWeight * (transportDistance / 100.0);
        const storageCost = params['仓储'] * productWeight * (storageTime / 30.0);
        const packagingCost = params['包装'] * productWeight;
        const handlingCost = (transportCost + storageCost) * 0.1;
        
        const totalCost = transportCost + storageCost + packagingCost + handlingCost;
        const costPerTon = totalCost / productWeight;
        
        let result = `冷链物流成本计算:\n`;
        result += `产品类型: ${productType}\n`;
        result += `产品重量: ${productWeight.toFixed(1)} 吨\n`;
        result += `运输距离: ${Math.floor(transportDistance)} km\n`;
        result += `仓储时间: ${storageTime} 天\n`;
        result += `运输成本: ${Math.floor(transportCost)} 元\n`;
        result += `仓储成本: ${Math.floor(storageCost)} 元\n`;
        result += `包装成本: ${Math.floor(packagingCost)} 元\n`;
        result += `装卸成本: ${Math.floor(handlingCost)} 元\n`;
        result += `总成本: ${Math.floor(totalCost)} 元\n`;
        result += `吨均成本: ${Math.floor(costPerTon)} 元/吨`;
        
        return result;
    }
    
    compareLogisticsPlans(productType: string, productWeight: number, transportDistance: number, storageTime: number): string {
        const params = this.productCostParameters[productType];
        if (!params) return '无效的产品类型';
        
        const standardCost = (params['运输'] + params['仓储']) * productWeight * (transportDistance / 100.0) + 
                           params['包装'] * productWeight;
        
        const fastCost = (params['运输'] + params['仓储'] * 0.5) * productWeight * (transportDistance / 100.0) + 
                        params['包装'] * productWeight;
        
        const economyCost = (params['运输'] + params['仓储'] * 1.5) * productWeight * (transportDistance / 100.0) + 
                           params['包装'] * productWeight;
        
        let result = `物流方案对比:\n`;
        result += `标准方案: ${Math.floor(standardCost)} 元\n`;
        result += `快速方案: ${Math.floor(fastCost)} 元\n`;
        result += `经济方案: ${Math.floor(economyCost)} 元\n`;
        result += `最优方案: ${Math.min(standardCost, fastCost, economyCost) === fastCost ? '快速方案' : 
                              Math.min(standardCost, fastCost, economyCost) === economyCost ? '经济方案' : '标准方案'}`;
        
        return result;
    }
    
    analyzeColdChainLoss(productType: string, productWeight: number, transportDistance: number, storageTime: number, productPrice: number): string {
        const params = this.productCostParameters[productType];
        if (!params) return '无效的产品类型';
        
        const lossRate = params['损耗率'];
        const lossWeight = productWeight * lossRate;
        const lossCost = lossWeight * productPrice;
        
        const coldChainCost = (params['运输'] + params['仓储']) * productWeight * (transportDistance / 100.0) + 
                            params['包装'] * productWeight;
        
        const totalLoss = lossCost + coldChainCost;
        const lossPercentage = (lossCost / (productWeight * productPrice)) * 100;
        
        let result = `冷链损耗分析:\n`;
        result += `产品类型: ${productType}\n`;
        result += `损耗率: ${(lossRate * 100).toFixed(1)}%\n`;
        result += `损耗重量: ${lossWeight.toFixed(2)} 吨\n`;
        result += `损耗成本: ${Math.floor(lossCost)} 元\n`;
        result += `冷链成本: ${Math.floor(coldChainCost)} 元\n`;
        result += `总损失: ${Math.floor(totalLoss)} 元\n`;
        result += `损失比例: ${lossPercentage.toFixed(1)}%`;
        
        return result;
    }
    
    assistPriceSetting(productType: string, productWeight: number, transportDistance: number, storageTime: number, productPrice: number): string {
        const params = this.productCostParameters[productType];
        if (!params) return '无效的产品类型';
        
        const costPerTon = ((params['运输'] + params['仓储']) * (transportDistance / 100.0) + params['包装']) / productWeight;
        const basePrice = costPerTon;
        const targetPrice = basePrice / 0.7;
        
        const marketPrices: Record<string, number> = {
            '蔬菜': 3000.0,
            '水果': 4000.0,
            '肉类': 8000.0,
            '水产': 6000.0,
            '乳制品': 5000.0
        };
        
        const marketPrice = marketPrices[productType] || 4000.0;
        const competitiveness = targetPrice <= marketPrice ? '有竞争力' : '缺乏竞争力';
        const actualMargin = ((marketPrice - basePrice) / marketPrice) * 100;
        
        let result = `价格制定辅助:\n`;
        result += `产品类型: ${productType}\n`;
        result += `成本基础: ${Math.floor(basePrice)} 元/吨\n`;
        result += `建议价格: ${Math.floor(targetPrice)} 元/吨\n`;
        result += `市场参考价: ${Math.floor(marketPrice)} 元/吨\n`;
        result += `竞争力评估: ${competitiveness}\n`;
        result += `实际利润率: ${actualMargin.toFixed(1)}%`;
        
        return result;
    }
    
    generateCompleteReport(productType: string, productWeight: number, transportDistance: number, storageTime: number, productPrice: number): string {
        let result = `=== 冷链物流成本完整分析报告 ===\n\n`;
        result += this.calculateColdChainCost(productType, productWeight, transportDistance, storageTime) + '\n\n';
        result += this.compareLogisticsPlans(productType, productWeight, transportDistance, storageTime) + '\n\n';
        result += this.analyzeColdChainLoss(productType, productWeight, transportDistance, storageTime, productPrice) + '\n\n';
        result += this.assistPriceSetting(productType, productWeight, transportDistance, storageTime, productPrice);
        
        return result;
    }
    
    async executeCalculation() {
        this.isLoading = true;
        
        try {
            const weight = parseFloat(this.productWeight);
            const distance = parseFloat(this.transportDistance);
            const time = parseInt(this.storageTime);
            const price = parseFloat(this.productPrice);
            
            if (isNaN(weight) || isNaN(distance) || isNaN(time) || isNaN(price) || 
                weight <= 0 || distance <= 0 || time <= 0 || price <= 0) {
                this.result = '请输入有效的数值';
                this.isLoading = false;
                return;
            }
            
            let result = '';
            switch (this.selectedTool) {
                case '成本计算':
                    result = this.calculateColdChainCost(this.productType, weight, distance, time);
                    break;
                case '方案对比':
                    result = this.compareLogisticsPlans(this.productType, weight, distance, time);
                    break;
                case '损耗分析':
                    result = this.analyzeColdChainLoss(this.productType, weight, distance, time, price);
                    break;
                case '价格辅助':
                    result = this.assistPriceSetting(this.productType, weight, distance, time, price);
                    break;
                case '完整报告':
                    result = this.generateCompleteReport(this.productType, weight, distance, time, price);
                    break;
            }
            
            this.result = result;
            this.allResults = this.generateCompleteReport(this.productType, weight, distance, time, price);
        } catch (error) {
            this.result = '执行错误：' + error;
        }
        
        this.isLoading = false;
    }
    
    build() {
        Column() {
            Row() {
                Text('农产品冷链物流成本分析器')
                    .fontSize(24)
                    .fontWeight(FontWeight.Bold)
                    .fontColor(Color.White)
            }
            .width('100%')
            .height(60)
            .backgroundColor('#1565C0')
            .justifyContent(FlexAlign.Center)
            
            Scroll() {
                Column({ space: 12 }) {
                    Column() {
                        Text('产品类型:')
                            .fontSize(12)
                            .fontWeight(FontWeight.Bold)
                        Select([
                            { value: '蔬菜' },
                            { value: '水果' },
                            { value: '肉类' },
                            { value: '水产' },
                            { value: '乳制品' }
                        ])
                            .value(this.productType)
                            .onSelect((index: number, value: string) => {
                                this.productType = value;
                            })
                            .width('100%')
                    }
                    .width('100%')
                    .padding(10)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('产品重量 (吨):')
                            .fontSize(12)
                            .fontWeight(FontWeight.Bold)
                        TextInput({ placeholder: '请输入产品重量' })
                            .value(this.productWeight)
                            .onChange((value: string) => { this.productWeight = value; })
                            .width('100%')
                            .height(50)
                            .padding(8)
                    }
                    .width('100%')
                    .padding(10)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('运输距离 (km):')
                            .fontSize(12)
                            .fontWeight(FontWeight.Bold)
                        TextInput({ placeholder: '请输入运输距离' })
                            .value(this.transportDistance)
                            .onChange((value: string) => { this.transportDistance = value; })
                            .width('100%')
                            .height(50)
                            .padding(8)
                    }
                    .width('100%')
                    .padding(10)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('仓储时间 (天):')
                            .fontSize(12)
                            .fontWeight(FontWeight.Bold)
                        TextInput({ placeholder: '请输入仓储时间' })
                            .value(this.storageTime)
                            .onChange((value: string) => { this.storageTime = value; })
                            .width('100%')
                            .height(50)
                            .padding(8)
                    }
                    .width('100%')
                    .padding(10)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('产品价格 (元/吨):')
                            .fontSize(12)
                            .fontWeight(FontWeight.Bold)
                        TextInput({ placeholder: '请输入产品价格' })
                            .value(this.productPrice)
                            .onChange((value: string) => { this.productPrice = value; })
                            .width('100%')
                            .height(50)
                            .padding(8)
                    }
                    .width('100%')
                    .padding(10)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    Column() {
                        Text('选择工具:')
                            .fontSize(12)
                            .fontWeight(FontWeight.Bold)
                        Select([
                            { value: '成本计算' },
                            { value: '方案对比' },
                            { value: '损耗分析' },
                            { value: '价格辅助' },
                            { value: '完整报告' }
                        ])
                            .value(this.selectedTool)
                            .onSelect((index: number, value: string) => {
                                this.selectedTool = value;
                            })
                            .width('100%')
                    }
                    .width('100%')
                    .padding(10)
                    .backgroundColor('#E3F2FD')
                    .borderRadius(8)
                    
                    if (this.result) {
                        Column() {
                            Text('结果:')
                                .fontSize(12)
                                .fontWeight(FontWeight.Bold)
                            Text(this.result)
                                .fontSize(11)
                                .width('100%')
                                .padding(8)
                                .backgroundColor('#F5F5F5')
                                .borderRadius(4)
                        }
                        .width('100%')
                        .padding(10)
                        .backgroundColor('#F5F5F5')
                        .borderRadius(8)
                    }
                    
                    if (this.allResults) {
                        Column() {
                            Text('完整报告:')
                                .fontSize(12)
                                .fontWeight(FontWeight.Bold)
                            Text(this.allResults)
                                .fontSize(11)
                                .width('100%')
                                .padding(8)
                                .backgroundColor('#E8F5E9')
                                .borderRadius(4)
                        }
                        .width('100%')
                        .padding(10)
                        .backgroundColor('#E8F5E9')
                        .borderRadius(8)
                    }
                    
                    Button('开始分析')
                        .width('100%')
                        .onClick(() => this.executeCalculation())
                        .enabled(!this.isLoading)
                    
                    if (this.isLoading) {
                        LoadingProgress()
                            .width(40)
                            .height(40)
                    }
                }
                .width('100%')
                .padding(16)
            }
            .layoutWeight(1)
        }
        .width('100%')
        .height('100%')
        .backgroundColor('#FAFAFA')
    }
}

ArkTS实现的详细说明

ArkTS版本为OpenHarmony鸿蒙平台提供了完整的用户界面。通过@State装饰器，我们可以管理应用的状态。这个实现包含了产品类型、重量、运输距离、仓储时间、产品价格等输入功能，用户可以输入冷链物流数据，选择不同的分析工具，查看成本分析结果。

应用场景分析

1. 成本控制和预算

企业需要准确计算冷链物流成本来制定预算。使用分析器可以获得详细的成本明细。

2. 物流方案选择

企业需要比较不同物流方案的经济性。使用分析器可以选择最优方案。

3. 产品损耗管理

冷链过程中产品会有损耗。使用分析器可以评估损耗成本的影响。

4. 价格制定

企业需要根据冷链成本制定产品价格。使用分析器可以获得定价建议。

5. 供应链优化

企业需要优化整个供应链。使用分析器可以识别成本瓶颈并提供优化建议。

性能优化建议

1. 实时成本数据

与市场数据集成，实时更新运输和仓储成本。

2. 历史数据分析

存储历史冷链数据，分析成本趋势。

3. 多产品组合

支持多种产品的组合冷链成本计算。

4. 自动化报告

实现自动生成详细的冷链成本分析报告。

总结

农产品冷链物流成本分析器是现代农产品流通的重要工具。通过在KMP框架下实现这套工具，我们可以在多个平台上使用同一套代码，提高开发效率。这个工具提供了成本计算、方案对比、损耗分析、成本优化和价格辅助等多种功能，可以满足大多数农产品企业的冷链成本分析需求。

在OpenHarmony鸿蒙平台上，我们可以通过ArkTS调用这些工具，为企业提供完整的冷链成本分析体验。掌握这套工具，不仅能够帮助企业科学管理冷链成本，更重要的是能够在实际项目中灵活应用，解决成本控制、方案优化等实际问题。