目录

1. 概述
2. 工具功能
3. 核心实现
4. Kotlin 源代码
5. JavaScript 编译代码
6. ArkTS 调用代码
7. 实战案例
8. 最佳实践

---

概述

本文档介绍如何在 Kotlin Multiplatform (KMP) 鸿蒙跨端开发中实现一个完整的 BMI（身体质量指数）计算器系统。BMI 是衡量人体体重与身高比例的重要指标，在健康管理、医疗诊断和健身指导中广泛应用。无论是进行个人健康管理、医学研究还是健身应用开发，一个功能强大的 BMI 计算器都能提供便利的支持。

这个案例展示了如何使用 Kotlin 的数学运算、数据分析和健康评估算法来创建一个功能丰富的 BMI 分析工具。BMI 计算器需要能够计算 BMI 值、判断体重分类、提供健康建议、支持多种单位系统、记录历史数据等。通过 KMP，这个工具可以无缝编译到 JavaScript，在 OpenHarmony 应用中运行，并支持用户输入进行实时 BMI 计算和分析。

在实际应用中，BMI 计算器广泛应用于以下场景：个人健康管理应用、医疗诊断系统、健身房管理软件、营养咨询平台、保险风险评估等。通过支持多种单位系统（公制和英制）、提供详细的健康评估、生成个性化的健康建议，我们可以帮助用户更好地了解自己的健康状况。同时，通过 KMP 框架的跨端能力，我们可以在不同平台上使用相同的 BMI 计算逻辑，确保计算结果的准确性和一致性。

工具的特点

• 多单位支持：支持公制（千克、厘米）和英制（磅、英寸）单位
• 精确计算：使用标准 BMI 公式进行精确计算
• 分类评估：根据 WHO 标准进行体重分类
• 健康建议：基于 BMI 值提供个性化的健康建议
• 历史记录：记录用户的 BMI 计算历史，追踪体重变化
• 跨端兼容：一份 Kotlin 代码可同时服务多个平台

---

工具功能

1. BMI 计算

BMI（Body Mass Index）是一个简单的身体质量指数，通过身高和体重计算得出。BMI 的计算公式是：BMI = 体重（千克）/ 身高²（米²）。这个指标虽然简单，但在全球范围内被广泛用于评估成人的体重状况。BMI 计算不需要复杂的医疗设备，只需要身高和体重两个基本数据，因此非常适合在日常健康管理中使用。

• 公制计算：使用千克和厘米进行计算
• 英制计算：使用磅和英寸进行计算
• 单位转换：支持在不同单位系统之间转换
• 精确结果：提供高精度的 BMI 值

2. 体重分类

根据 WHO（世界卫生组织）的标准，BMI 值被分为不同的体重分类。这些分类帮助人们快速了解自己的体重状况是否处于健康范围内。不同的分类对应不同的健康风险水平，从低风险的正常体重到高风险的肥胖。体重分类是 BMI 计算器的核心功能之一，它将抽象的数字转化为易于理解的健康状态。

• 体重过低：BMI < 18.5
• 正常体重：18.5 ≤ BMI < 25
• 超重：25 ≤ BMI < 30
• 肥胖：BMI ≥ 30

3. 健康建议

基于 BMI 值和体重分类，计算器可以提供个性化的健康建议。这些建议涵盖饮食、运动、生活方式等多个方面，帮助用户改善健康状况。对于体重过低的人，建议增加营养摄入和力量训练。对于超重或肥胖的人，建议减少热量摄入和增加有氧运动。这些建议是基于科学研究和医学知识的，能够帮助用户制定更加科学的健康计划。

• 饮食建议：根据体重分类提供饮食指导
• 运动建议：推荐适合的运动类型和强度
• 生活方式建议：提供日常生活中的健康建议
• 风险提示：警告可能的健康风险

4. 历史记录和趋势分析

BMI 计算器可以记录用户的历史数据，帮助用户追踪体重变化趋势。通过比较不同时间点的 BMI 值，用户可以了解自己的健康改善或恶化情况。趋势分析可以激励用户坚持健康计划，或者提醒用户需要调整策略。历史记录还可以用于医学研究和健康评估。

• 数据记录：记录每次计算的日期、时间和 BMI 值
• 趋势分析：计算 BMI 值的变化趋势
• 统计信息：提供平均值、最大值、最小值等统计数据
• 可视化展示：以图表形式展示历史数据

5. 理想体重计算

基于身高，计算器可以计算理想体重范围。这帮助用户了解自己应该达到的目标体重。理想体重的计算基于 BMI 的正常范围（18.5-25），通过反向计算可以得出对应的体重范围。这个功能对于制定减肥或增肌计划特别有用。

• 理想体重范围：计算对应于正常 BMI 的体重范围
• 目标体重：根据用户目标 BMI 计算目标体重
• 体重差异：计算当前体重与理想体重的差异
• 减重/增重建议：基于差异提供具体的建议

---

核心实现

1. BMI 计算

fun calculateBMI(weight: Double, height: Double, unit: String = "metric"): Double {
    return when (unit.lowercase()) {
        "metric" -> {
            // 体重单位：千克，身高单位：厘米
            val heightInMeters = height / 100
            weight / (heightInMeters * heightInMeters)
        }
        "imperial" -> {
            // 体重单位：磅，身高单位：英寸
            val heightInInches = height
            (weight / (heightInInches * heightInInches)) * 703
        }
        else -> 0.0
    }
}

代码说明： BMI 计算通过不同的公式处理公制和英制单位。对于公制单位，身高需要从厘米转换为米，然后使用标准公式 BMI = 体重 / 身高²。对于英制单位，使用公式 BMI = (体重 / 身高²) × 703，其中 703 是转换系数。这两个公式都是国际标准，确保了计算的准确性。

2. 体重分类

fun classifyWeight(bmi: Double): String {
    return when {
        bmi < 18.5 -> "体重过低"
        bmi < 25.0 -> "正常体重"
        bmi < 30.0 -> "超重"
        else -> "肥胖"
    }
}

fun getClassificationDetails(bmi: Double): Map<String, Any> {
    val classification = classifyWeight(bmi)
    val riskLevel = when {
        bmi < 18.5 -> "低"
        bmi < 25.0 -> "低"
        bmi < 30.0 -> "中等"
        else -> "高"
    }
    
    return mapOf(
        "classification" to classification,
        "bmi" to String.format("%.2f", bmi),
        "riskLevel" to riskLevel,
        "description" to getClassificationDescription(classification)
    )
}

fun getClassificationDescription(classification: String): String {
    return when (classification) {
        "体重过低" -> "体重过低可能导致营养不良、免疫力下降等问题"
        "正常体重" -> "体重在正常范围内，保持健康的生活方式"
        "超重" -> "体重超过正常范围，建议增加运动和控制饮食"
        "肥胖" -> "体重明显超过正常范围，建议咨询医生制定减肥计划"
        else -> "未知分类"
    }
}

代码说明： 体重分类通过 BMI 值的范围进行判断。我们使用 when 表达式根据 BMI 值返回相应的分类。此外，还提供了详细的分类信息，包括风险等级和分类描述。这些信息帮助用户更好地理解自己的健康状况。

3. 健康建议

fun getHealthAdvice(bmi: Double, age: Int = 0): List<String> {
    val advice = mutableListOf<String>()
    val classification = classifyWeight(bmi)
    
    when (classification) {
        "体重过低" -> {
            advice.add("增加营养摄入，特别是蛋白质和健康脂肪")
            advice.add("进行力量训练以增加肌肉质量")
            advice.add("咨询营养师制定个性化的饮食计划")
            advice.add("定期进行健康检查，排除潜在的健康问题")
        }
        "正常体重" -> {
            advice.add("保持当前的健康生活方式")
            advice.add("每周进行至少 150 分钟的中等强度运动")
            advice.add("保持均衡的饮食，多吃蔬菜和水果")
            advice.add("定期进行健康检查")
        }
        "超重" -> {
            advice.add("减少高热量食物的摄入")
            advice.add("增加有氧运动，每周至少 150 分钟")
            advice.add("控制饮食份量，多吃低热量食物")
            advice.add("咨询医生或营养师获得专业指导")
        }
        "肥胖" -> {
            advice.add("立即咨询医生制定减肥计划")
            advice.add("进行医学监督下的减肥治疗")
            advice.add("严格控制饮食，减少热量摄入")
            advice.add("进行适度的运动，逐步增加运动强度")
        }
    }
    
    return advice
}

代码说明： 健康建议基于体重分类提供。对于不同的分类，我们提供不同的建议。这些建议涵盖饮食、运动和医学咨询等多个方面。通过提供具体的、可行的建议，我们帮助用户制定更加科学的健康计划。

4. 理想体重计算

fun calculateIdealWeight(height: Double, unit: String = "metric"): Map<String, Double> {
    val minBMI = 18.5
    val maxBMI = 25.0
    
    return when (unit.lowercase()) {
        "metric" -> {
            val heightInMeters = height / 100
            val minWeight = minBMI * heightInMeters * heightInMeters
            val maxWeight = maxBMI * heightInMeters * heightInMeters
            mapOf(
                "minWeight" to minWeight,
                "maxWeight" to maxWeight,
                "idealWeight" to (minWeight + maxWeight) / 2
            )
        }
        "imperial" -> {
            val minWeight = (minBMI * height * height) / 703
            val maxWeight = (maxBMI * height * height) / 703
            mapOf(
                "minWeight" to minWeight,
                "maxWeight" to maxWeight,
                "idealWeight" to (minWeight + maxWeight) / 2
            )
        }
        else -> emptyMap()
    }
}

fun calculateWeightDifference(currentWeight: Double, height: Double, unit: String = "metric"): Map<String, Any> {
    val idealWeights = calculateIdealWeight(height, unit)
    val idealWeight = idealWeights["idealWeight"] ?: 0.0
    val difference = currentWeight - idealWeight
    
    return mapOf(
        "currentWeight" to currentWeight,
        "idealWeight" to String.format("%.2f", idealWeight),
        "difference" to String.format("%.2f", difference),
        "status" to if (difference > 0) "需要减重" else "需要增重",
        "differencePercentage" to String.format("%.2f%%", (difference / idealWeight) * 100)
    )
}

代码说明： 理想体重计算通过反向使用 BMI 公式来实现。我们根据身高和正常 BMI 范围（18.5-25）计算出理想的体重范围。然后，通过比较当前体重与理想体重，计算出体重差异和百分比。这些信息帮助用户了解自己需要减重还是增重，以及需要改变多少。

5. 历史记录管理

data class BMIRecord(
    val date: String,
    val weight: Double,
    val height: Double,
    val bmi: Double,
    val classification: String,
    val unit: String
)

class BMIHistory {
    private val records = mutableListOf<BMIRecord>()
    
    fun addRecord(weight: Double, height: Double, bmi: Double, classification: String, unit: String) {
        val record = BMIRecord(
            date = java.time.LocalDate.now().toString(),
            weight = weight,
            height = height,
            bmi = bmi,
            classification = classification,
            unit = unit
        )
        records.add(record)
    }
    
    fun getRecords(): List<BMIRecord> = records.toList()
    
    fun getTrend(): String {
        if (records.size < 2) return "数据不足"
        
        val firstBMI = records.first().bmi
        val lastBMI = records.last().bmi
        val change = lastBMI - firstBMI
        
        return when {
            change > 0.5 -> "BMI 上升趋势"
            change < -0.5 -> "BMI 下降趋势"
            else -> "BMI 保持稳定"
        }
    }
    
    fun getStatistics(): Map<String, Double> {
        if (records.isEmpty()) return emptyMap()
        
        val bmiValues = records.map { it.bmi }
        return mapOf(
            "average" to bmiValues.average(),
            "max" to bmiValues.maxOrNull() ?: 0.0,
            "min" to bmiValues.minOrNull() ?: 0.0,
            "latest" to bmiValues.last()
        )
    }
}

代码说明： 历史记录管理通过数据类和集合来实现。我们创建 BMIRecord 数据类来存储每次计算的信息，包括日期、体重、身高、BMI 值和分类。BMIHistory 类管理所有的记录，提供添加记录、获取记录、分析趋势和统计信息等功能。这些功能帮助用户追踪长期的健康变化。

---

Kotlin 源代码

// BMICalculator.kt
data class BMIRecord(
    val date: String,
    val weight: Double,
    val height: Double,
    val bmi: Double,
    val classification: String,
    val unit: String
)

class BMICalculator {
    
    fun calculateBMI(weight: Double, height: Double, unit: String = "metric"): Double {
        return when (unit.lowercase()) {
            "metric" -> {
                val heightInMeters = height / 100
                weight / (heightInMeters * heightInMeters)
            }
            "imperial" -> {
                (weight / (height * height)) * 703
            }
            else -> 0.0
        }
    }
    
    fun classifyWeight(bmi: Double): String {
        return when {
            bmi < 18.5 -> "体重过低"
            bmi < 25.0 -> "正常体重"
            bmi < 30.0 -> "超重"
            else -> "肥胖"
        }
    }
    
    fun getClassificationDetails(bmi: Double): Map<String, Any> {
        val classification = classifyWeight(bmi)
        val riskLevel = when {
            bmi < 18.5 -> "低"
            bmi < 25.0 -> "低"
            bmi < 30.0 -> "中等"
            else -> "高"
        }
        
        return mapOf(
            "classification" to classification,
            "bmi" to String.format("%.2f", bmi),
            "riskLevel" to riskLevel,
            "description" to getClassificationDescription(classification)
        )
    }
    
    fun getClassificationDescription(classification: String): String {
        return when (classification) {
            "体重过低" -> "体重过低可能导致营养不良、免疫力下降等问题"
            "正常体重" -> "体重在正常范围内，保持健康的生活方式"
            "超重" -> "体重超过正常范围，建议增加运动和控制饮食"
            "肥胖" -> "体重明显超过正常范围，建议咨询医生制定减肥计划"
            else -> "未知分类"
        }
    }
    
    fun getHealthAdvice(bmi: Double): List<String> {
        val advice = mutableListOf<String>()
        val classification = classifyWeight(bmi)
        
        when (classification) {
            "体重过低" -> {
                advice.add("增加营养摄入，特别是蛋白质和健康脂肪")
                advice.add("进行力量训练以增加肌肉质量")
                advice.add("咨询营养师制定个性化的饮食计划")
                advice.add("定期进行健康检查，排除潜在的健康问题")
            }
            "正常体重" -> {
                advice.add("保持当前的健康生活方式")
                advice.add("每周进行至少 150 分钟的中等强度运动")
                advice.add("保持均衡的饮食，多吃蔬菜和水果")
                advice.add("定期进行健康检查")
            }
            "超重" -> {
                advice.add("减少高热量食物的摄入")
                advice.add("增加有氧运动，每周至少 150 分钟")
                advice.add("控制饮食份量，多吃低热量食物")
                advice.add("咨询医生或营养师获得专业指导")
            }
            "肥胖" -> {
                advice.add("立即咨询医生制定减肥计划")
                advice.add("进行医学监督下的减肥治疗")
                advice.add("严格控制饮食，减少热量摄入")
                advice.add("进行适度的运动，逐步增加运动强度")
            }
        }
        
        return advice
    }
    
    fun calculateIdealWeight(height: Double, unit: String = "metric"): Map<String, Double> {
        val minBMI = 18.5
        val maxBMI = 25.0
        
        return when (unit.lowercase()) {
            "metric" -> {
                val heightInMeters = height / 100
                val minWeight = minBMI * heightInMeters * heightInMeters
                val maxWeight = maxBMI * heightInMeters * heightInMeters
                mapOf(
                    "minWeight" to minWeight,
                    "maxWeight" to maxWeight,
                    "idealWeight" to (minWeight + maxWeight) / 2
                )
            }
            "imperial" -> {
                val minWeight = (minBMI * height * height) / 703
                val maxWeight = (maxBMI * height * height) / 703
                mapOf(
                    "minWeight" to minWeight,
                    "maxWeight" to maxWeight,
                    "idealWeight" to (minWeight + maxWeight) / 2
                )
            }
            else -> emptyMap()
        }
    }
    
    fun calculateWeightDifference(currentWeight: Double, height: Double, unit: String = "metric"): Map<String, Any> {
        val idealWeights = calculateIdealWeight(height, unit)
        val idealWeight = idealWeights["idealWeight"] ?: 0.0
        val difference = currentWeight - idealWeight
        
        return mapOf(
            "currentWeight" to currentWeight,
            "idealWeight" to String.format("%.2f", idealWeight),
            "difference" to String.format("%.2f", difference),
            "status" to if (difference > 0) "需要减重" else "需要增重",
            "differencePercentage" to String.format("%.2f%%", (difference / idealWeight) * 100)
        )
    }
    
    fun analyzeBMI(weight: Double, height: Double, unit: String = "metric"): Map<String, Any> {
        val bmi = calculateBMI(weight, height, unit)
        val classification = classifyWeight(bmi)
        val details = getClassificationDetails(bmi)
        val advice = getHealthAdvice(bmi)
        val idealWeights = calculateIdealWeight(height, unit)
        
        return mapOf(
            "weight" to weight,
            "height" to height,
            "bmi" to String.format("%.2f", bmi),
            "classification" to classification,
            "details" to details,
            "advice" to advice,
            "idealWeights" to idealWeights
        )
    }
}

fun main() {
    val calculator = BMICalculator()
    
    val weight = 70.0
    val height = 175.0
    val bmi = calculator.calculateBMI(weight, height, "metric")
    val classification = calculator.classifyWeight(bmi)
    
    println("体重: ${weight}kg, 身高: ${height}cm")
    println("BMI: ${"%.2f".format(bmi)}")
    println("分类: $classification")
    
    val advice = calculator.getHealthAdvice(bmi)
    println("健康建议:")
    advice.forEach { println("- $it") }
    
    val analysis = calculator.analyzeBMI(weight, height, "metric")
    println("完整分析: $analysis")
}

Kotlin 代码说明： 这个实现提供了完整的 BMI 计算和分析功能。BMICalculator 类包含了 BMI 计算、体重分类、健康建议、理想体重计算等多个方法。每个方法都有明确的功能定义和错误处理。通过组合这些方法，我们可以为用户提供全面的健康评估。

---

JavaScript 编译代码

// BMICalculator.js
class BMICalculator {
    calculateBMI(weight, height, unit = "metric") {
        if (unit.toLowerCase() === "metric") {
            const heightInMeters = height / 100;
            return weight / (heightInMeters * heightInMeters);
        } else if (unit.toLowerCase() === "imperial") {
            return (weight / (height * height)) * 703;
        }
        return 0;
    }
    
    classifyWeight(bmi) {
        if (bmi < 18.5) return "体重过低";
        if (bmi < 25.0) return "正常体重";
        if (bmi < 30.0) return "超重";
        return "肥胖";
    }
    
    getClassificationDetails(bmi) {
        const classification = this.classifyWeight(bmi);
        let riskLevel;
        if (bmi < 18.5) riskLevel = "低";
        else if (bmi < 25.0) riskLevel = "低";
        else if (bmi < 30.0) riskLevel = "中等";
        else riskLevel = "高";
        
        return {
            classification: classification,
            bmi: bmi.toFixed(2),
            riskLevel: riskLevel,
            description: this.getClassificationDescription(classification)
        };
    }
    
    getClassificationDescription(classification) {
        switch (classification) {
            case "体重过低":
                return "体重过低可能导致营养不良、免疫力下降等问题";
            case "正常体重":
                return "体重在正常范围内，保持健康的生活方式";
            case "超重":
                return "体重超过正常范围，建议增加运动和控制饮食";
            case "肥胖":
                return "体重明显超过正常范围，建议咨询医生制定减肥计划";
            default:
                return "未知分类";
        }
    }
    
    getHealthAdvice(bmi) {
        const advice = [];
        const classification = this.classifyWeight(bmi);
        
        switch (classification) {
            case "体重过低":
                advice.push("增加营养摄入，特别是蛋白质和健康脂肪");
                advice.push("进行力量训练以增加肌肉质量");
                advice.push("咨询营养师制定个性化的饮食计划");
                advice.push("定期进行健康检查，排除潜在的健康问题");
                break;
            case "正常体重":
                advice.push("保持当前的健康生活方式");
                advice.push("每周进行至少 150 分钟的中等强度运动");
                advice.push("保持均衡的饮食，多吃蔬菜和水果");
                advice.push("定期进行健康检查");
                break;
            case "超重":
                advice.push("减少高热量食物的摄入");
                advice.push("增加有氧运动，每周至少 150 分钟");
                advice.push("控制饮食份量，多吃低热量食物");
                advice.push("咨询医生或营养师获得专业指导");
                break;
            case "肥胖":
                advice.push("立即咨询医生制定减肥计划");
                advice.push("进行医学监督下的减肥治疗");
                advice.push("严格控制饮食，减少热量摄入");
                advice.push("进行适度的运动，逐步增加运动强度");
                break;
        }
        
        return advice;
    }
    
    calculateIdealWeight(height, unit = "metric") {
        const minBMI = 18.5;
        const maxBMI = 25.0;
        
        if (unit.toLowerCase() === "metric") {
            const heightInMeters = height / 100;
            const minWeight = minBMI * heightInMeters * heightInMeters;
            const maxWeight = maxBMI * heightInMeters * heightInMeters;
            return {
                minWeight: minWeight,
                maxWeight: maxWeight,
                idealWeight: (minWeight + maxWeight) / 2
            };
        } else if (unit.toLowerCase() === "imperial") {
            const minWeight = (minBMI * height * height) / 703;
            const maxWeight = (maxBMI * height * height) / 703;
            return {
                minWeight: minWeight,
                maxWeight: maxWeight,
                idealWeight: (minWeight + maxWeight) / 2
            };
        }
        return {};
    }
    
    calculateWeightDifference(currentWeight, height, unit = "metric") {
        const idealWeights = this.calculateIdealWeight(height, unit);
        const idealWeight = idealWeights.idealWeight || 0;
        const difference = currentWeight - idealWeight;
        
        return {
            currentWeight: currentWeight,
            idealWeight: idealWeight.toFixed(2),
            difference: difference.toFixed(2),
            status: difference > 0 ? "需要减重" : "需要增重",
            differencePercentage: ((difference / idealWeight) * 100).toFixed(2) + "%"
        };
    }
    
    analyzeBMI(weight, height, unit = "metric") {
        const bmi = this.calculateBMI(weight, height, unit);
        const classification = this.classifyWeight(bmi);
        const details = this.getClassificationDetails(bmi);
        const advice = this.getHealthAdvice(bmi);
        const idealWeights = this.calculateIdealWeight(height, unit);
        
        return {
            weight: weight,
            height: height,
            bmi: bmi.toFixed(2),
            classification: classification,
            details: details,
            advice: advice,
            idealWeights: idealWeights
        };
    }
}

// 使用示例
const calculator = new BMICalculator();
const weight = 70;
const height = 175;
const bmi = calculator.calculateBMI(weight, height, "metric");
const classification = calculator.classifyWeight(bmi);

console.log(`体重: ${weight}kg, 身高: ${height}cm`);
console.log(`BMI: ${bmi.toFixed(2)}`);
console.log(`分类: ${classification}`);

const advice = calculator.getHealthAdvice(bmi);
console.log("健康建议:");
advice.forEach(item => console.log(`- ${item}`));

const analysis = calculator.analyzeBMI(weight, height, "metric");
console.log("完整分析:", analysis);

JavaScript 代码说明： JavaScript 版本是 Kotlin 代码的直接转译。由于 JavaScript 和 Kotlin 在语法上有差异，我们使用 if-else 语句替代 when 表达式。整体逻辑和算法与 Kotlin 版本保持一致，确保跨平台的一致性。

---

ArkTS 调用代码

// BMICalculatorPage.ets
import { BMICalculator } from './BMICalculator';

@Entry
@Component
struct BMICalculatorPage {
    @State weight: number = 70;
    @State height: number = 175;
    @State unit: string = 'metric';
    @State bmi: number = 0;
    @State classification: string = '';
    @State advice: string[] = [];
    @State idealWeights: string = '';
    @State weightDifference: string = '';
    @State showResult: boolean = false;
    
    private calculator: BMICalculator = new BMICalculator();
    
    calculateBMI() {
        try {
            this.bmi = this.calculator.calculateBMI(this.weight, this.height, this.unit);
            this.classification = this.calculator.classifyWeight(this.bmi);
            this.advice = this.calculator.getHealthAdvice(this.bmi);
            
            const ideal = this.calculator.calculateIdealWeight(this.height, this.unit);
            this.idealWeights = `理想体重范围: ${ideal.minWeight.toFixed(1)} - ${ideal.maxWeight.toFixed(1)} ${this.unit === 'metric' ? 'kg' : 'lb'}`;
            
            const diff = this.calculator.calculateWeightDifference(this.weight, this.height, this.unit);
            this.weightDifference = `${diff.status}: ${diff.difference} ${this.unit === 'metric' ? 'kg' : 'lb'} (${diff.differencePercentage})`;
            
            this.showResult = true;
        } catch (error) {
            AlertDialog.show({
                message: 'BMI 计算失败: ' + error.message
            });
        }
    }
    
    build() {
        Column() {
            Text('BMI 计算器')
                .fontSize(24)
                .fontWeight(FontWeight.Bold)
                .margin({ top: 20, bottom: 20 })
            
            // 单位选择
            Row() {
                Text('单位:')
                    .fontSize(14)
                    .margin({ right: 10 })
                
                Select([
                    { value: '公制 (kg/cm)', text: 'metric' },
                    { value: '英制 (lb/in)', text: 'imperial' }
                ])
                    .value(this.unit)
                    .onSelect((index: number, value?: string) => {
                        this.unit = value || 'metric';
                    })
            }
            .margin({ bottom: 20 })
            .width('100%')
            
            // 体重输入
            Row() {
                Text('体重:')
                    .width(60)
                TextInput({ placeholder: '输入体重' })
                    .type(InputType.Number)
                    .value(this.weight.toString())
                    .onChange((value: string) => {
                        this.weight = parseFloat(value) || 0;
                    })
                    .flex(1)
                    .padding(10)
                    .border({ width: 1, color: '#cccccc' })
                
                Text(this.unit === 'metric' ? 'kg' : 'lb')
                    .width(40)
                    .textAlign(TextAlign.Center)
            }
            .margin({ bottom: 15 })
            
            // 身高输入
            Row() {
                Text('身高:')
                    .width(60)
                TextInput({ placeholder: '输入身高' })
                    .type(InputType.Number)
                    .value(this.height.toString())
                    .onChange((value: string) => {
                        this.height = parseFloat(value) || 0;
                    })
                    .flex(1)
                    .padding(10)
                    .border({ width: 1, color: '#cccccc' })
                
                Text(this.unit === 'metric' ? 'cm' : 'in')
                    .width(40)
                    .textAlign(TextAlign.Center)
            }
            .margin({ bottom: 20 })
            
            // 计算按钮
            Button('计算 BMI')
                .width('100%')
                .height(40)
                .margin({ bottom: 20 })
                .onClick(() => {
                    this.calculateBMI();
                })
            
            // 结果显示
            if (this.showResult) {
                Column() {
                    Text('计算结果')
                        .fontSize(16)
                        .fontWeight(FontWeight.Bold)
                        .margin({ bottom: 15 })
                    
                    Row() {
                        Text('BMI 值:')
                            .width(80)
                        Text(this.bmi.toFixed(2))
                            .fontSize(18)
                            .fontColor('#ff6b35')
                            .fontWeight(FontWeight.Bold)
                    }
                    .margin({ bottom: 10 })
                    
                    Row() {
                        Text('分类:')
                            .width(80)
                        Text(this.classification)
                            .fontSize(16)
                            .fontWeight(FontWeight.Bold)
                    }
                    .margin({ bottom: 15 })
                    
                    Text(this.idealWeights)
                        .fontSize(12)
                        .fontColor('#666666')
                        .margin({ bottom: 10 })
                    
                    Text(this.weightDifference)
                        .fontSize(12)
                        .fontColor('#666666')
                        .margin({ bottom: 15 })
                    
                    Text('健康建议:')
                        .fontSize(14)
                        .fontWeight(FontWeight.Bold)
                        .margin({ bottom: 10 })
                    
                    Column() {
                        ForEach(this.advice, (item: string) => {
                            Row() {
                                Text('•')
                                    .margin({ right: 8 })
                                Text(item)
                                    .flex(1)
                            }
                            .margin({ bottom: 8 })
                        })
                    }
                    .width('100%')
                }
                .width('100%')
                .padding(15)
                .backgroundColor('#f5f5f5')
                .borderRadius(4)
            }
        }
        .padding(20)
        .width('100%')
        .height('100%')
        .backgroundColor('#ffffff')
        .scrollable(true)
    }
}

ArkTS 代码说明： 这个示例展示了如何在 ArkTS 中构建一个完整的 BMI 计算器用户界面。页面包含了单位选择、体重输入、身高输入、计算按钮和结果显示等组件。用户可以选择单位系统，输入体重和身高，然后点击计算按钮查看 BMI 值、分类、理想体重范围和健康建议。整个界面采用了现代化的设计，提供了良好的用户体验。

---

实战案例

案例 1: 个人健康管理

在个人健康管理应用中，用户可以定期计算自己的 BMI，追踪体重变化，并获得个性化的健康建议。

val calculator = BMICalculator()
val weight = 75.0
val height = 180.0
val analysis = calculator.analyzeBMI(weight, height, "metric")
println("BMI 分析: $analysis")

案例 2: 健身房管理系统

健身房可以使用 BMI 计算器为会员提供初始的健康评估，帮助制定个性化的健身计划。

val calculator = BMICalculator()
val memberWeight = 85.0
val memberHeight = 175.0
val bmi = calculator.calculateBMI(memberWeight, memberHeight, "metric")
val advice = calculator.getHealthAdvice(bmi)
println("会员健身建议: $advice")

案例 3: 医疗诊断辅助

医疗专业人士可以使用 BMI 计算器作为初步诊断工具，帮助识别患者的体重相关健康风险。

val calculator = BMICalculator()
val patientWeight = 95.0
val patientHeight = 170.0
val classification = calculator.classifyWeight(
    calculator.calculateBMI(patientWeight, patientHeight, "metric")
)
println("患者体重分类: $classification")

---

最佳实践

1. 数据验证

• 验证输入范围：确保体重和身高在合理范围内
• 处理异常值：对于异常的输入提供清晰的错误提示
• 单位一致性：确保在计算前统一单位

2. 精度管理

• 适当的小数位数：BMI 值通常显示 2 位小数
• 避免浮点数误差：在比较 BMI 值时使用容差值
• 清晰的数值显示：为用户提供易于理解的数值格式

3. 健康建议的准确性

• 基于科学标准：使用 WHO 等权威机构的标准
• 个性化建议：根据不同的 BMI 分类提供不同的建议
• 免责声明：明确说明这不是医学诊断

4. 用户体验

• 简洁的界面：避免过度复杂的设计
• 实时反馈：在用户输入时提供实时的计算结果
• 历史记录：帮助用户追踪长期的健康变化

5. 隐私和安全

• 数据保护：保护用户的健康数据隐私
• 本地存储：优先在本地存储用户数据
• 用户控制：让用户控制自己的数据

---

总结

BMI 计算器是现代健康管理应用中的一个重要组件。通过使用 Kotlin Multiplatform，我们可以编写一次代码，然后在多个平台上运行，大大提高了开发效率和代码的可维护性。这个案例展示了如何实现 BMI 计算、体重分类、健康建议、理想体重计算等功能。

在实际应用中，应该根据具体的需求选择合适的功能和用户界面设计，并遵循最佳实践来确保数据的准确性和用户的隐私。同时，应该定期进行测试和优化，以提高应用的性能和用户体验。通过合理使用 BMI 计算器，我们可以帮助用户更好地了解自己的健康状况，制定更加科学的健康计划。
欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net