目录

1. 概述
2. 功能设计
3. Kotlin 实现代码（KMP）
4. JavaScript 调用示例
5. ArkTS 页面集成与调用
6. 数据输入与交互体验
7. 编译与自动复制流程
8. 总结

---

概述

本案例在 Kotlin Multiplatform (KMP) 工程中实现了一个 金融工具 - 投资理财规划工具：

• 输入：用户的投资信息（初始资金、年投资额、预期年收益率、投资年数、风险等级），使用空格分隔，例如：100000 12000 8 20 medium。
• 输出：
  • 投资基本信息：初始资金、年投资额、预期收益率、投资年数等
  • 投资收益预测：预期最终资产、总投资额、总收益、年均收益等
  • 风险评估：风险等级、风险指数、风险建议
  • 投资建议：根据风险等级的投资策略建议
  • 资产配置建议：根据风险等级的资产配置方案
• 技术路径：Kotlin → Kotlin/JS → JavaScript 模块 → ArkTS 页面调用。

这个案例展示了 KMP 跨端开发在金融投资领域的应用：

把投资理财规划逻辑写在 Kotlin 里，一次实现，多端复用；把规划界面写在 ArkTS 里，专注 UI 和体验。

Kotlin 侧负责解析投资数据、计算收益预测、评估投资风险、生成投资建议；ArkTS 侧只需要把输入字符串传给 Kotlin 函数，并把返回结果原样展示出来即可。借助 KMP 的 Kotlin/JS 能力，这个投资理财规划工具可以在 Node.js、Web 前端以及 OpenHarmony 中复用相同的代码逻辑。

---

功能设计

输入数据格式

投资理财规划工具采用简单直观的输入格式：

• 使用 空格分隔 各个参数。
• 第一个参数是初始资金（整数或浮点数，单位：元）。
• 第二个参数是年投资额（整数或浮点数，单位：元）。
• 第三个参数是预期年收益率（浮点数，单位：百分比）。
• 第四个参数是投资年数（整数，单位：年）。
• 第五个参数是风险等级（low/medium/high）。
• 输入示例：

100000 12000 8 20 medium

这可以理解为：

• 初始资金：100000 元
• 年投资额：12000 元
• 预期年收益率：8%
• 投资年数：20 年
• 风险等级：中等风险

工具会基于这些数据计算出：

• 预期最终资产：根据复利计算的最终资产值
• 总投资额：初始资金加上所有年投资额的总和
• 总收益：预期最终资产减去总投资额
• 年均收益：总收益除以投资年数
• 投资回报率：总收益与总投资额的比例

输出信息结构

为了便于在 ArkTS 页面以及终端中直接展示，Kotlin 函数返回的是一段结构化的多行文本，划分为几个分区：

1. 标题区：例如"💰 投资理财规划"，一眼看出工具用途。
2. 投资基本信息：初始资金、年投资额、预期收益率、投资年数等。
3. 收益预测：预期最终资产、总投资额、总收益等关键指标。
4. 风险评估：风险等级、风险指数、风险建议。
5. 投资建议：根据风险等级的投资策略。
6. 资产配置：根据风险等级的资产配置方案。

这样的输出结构使得：

• 在 ArkTS 中可以直接把整段文本绑定到 Text 组件，配合 monospace 字体，阅读体验类似终端报告。
• 如果将来想把结果保存到日志或者后端，直接保存字符串即可。
• 需要更精细的 UI 时，也可以在前端根据分隔符进行拆分，再按块展示。

---

Kotlin 实现代码（KMP）

核心代码在 src/jsMain/kotlin/App.kt 中，通过 @JsExport 导出。以下是完整的 Kotlin 实现：

@OptIn(ExperimentalJsExport::class)
@JsExport
fun investmentPlanner(inputData: String = "100000 12000 8 20 medium"): String {
    // 输入格式: 初始资金 年投资额 预期年收益率(%) 投资年数 风险等级(low/medium/high)
    val parts = inputData.trim().split(" ").filter { it.isNotEmpty() }

    if (parts.size < 5) {
        return "❌ 错误: 请输入完整的信息，格式: 初始资金 年投资额 预期年收益率 投资年数 风险等级\n例如: 100000 12000 8 20 medium"
    }

    val initialCapital = parts[0].toDoubleOrNull() ?: return "❌ 错误: 初始资金必须是数字"
    val annualInvestment = parts[1].toDoubleOrNull() ?: return "❌ 错误: 年投资额必须是数字"
    val annualReturnRate = parts[2].toDoubleOrNull() ?: return "❌ 错误: 预期年收益率必须是数字"
    val investmentYears = parts[3].toIntOrNull() ?: return "❌ 错误: 投资年数必须是整数"
    val riskLevel = parts[4].lowercase()

    if (initialCapital <= 0 || initialCapital > 100000000) {
        return "❌ 错误: 初始资金必须在 1 到 100000000 元之间"
    }

    if (annualInvestment < 0 || annualInvestment > 10000000) {
        return "❌ 错误: 年投资额必须在 0 到 10000000 元之间"
    }

    if (annualReturnRate < -50 || annualReturnRate > 100) {
        return "❌ 错误: 预期年收益率必须在 -50% 到 100% 之间"
    }

    if (investmentYears < 1 || investmentYears > 100) {
        return "❌ 错误: 投资年数必须在 1-100 年之间"
    }

    val validRisks = listOf("low", "medium", "high")
    if (riskLevel !in validRisks) {
        return "❌ 错误: 风险等级必须是以下之一: ${validRisks.joinToString(", ")}"
    }

    // 计算复利收益
    val monthlyRate = annualReturnRate / 100 / 12
    var finalAsset = initialCapital

    // 逐年计算资产增长
    for (year in 1..investmentYears) {
        // 年初投资
        finalAsset += annualInvestment
        // 年度收益
        finalAsset *= (1 + annualReturnRate / 100)
    }

    val totalInvestment = initialCapital + (annualInvestment * investmentYears)
    val totalProfit = finalAsset - totalInvestment
    val annualProfit = totalProfit / investmentYears
    val returnRate = (totalProfit / totalInvestment) * 100

    // 风险评估
    val riskScore = when (riskLevel) {
        "low" -> 30
        "medium" -> 60
        "high" -> 85
        else -> 50
    }

    val riskDescription = when (riskLevel) {
        "low" -> "低风险 - 稳健保守型投资"
        "medium" -> "中等风险 - 平衡型投资"
        "high" -> "高风险 - 激进型投资"
        else -> "未知风险"
    }

    // 投资建议
    val investmentAdvice = when (riskLevel) {
        "low" -> """
            • 优先选择低风险投资品种：国债、定期存款、货币基金
            • 资产配置：债券 60%、股票 30%、现金 10%
            • 投资策略：稳健增长，保本为主
            • 适合人群：保守投资者、退休人士、风险厌恶者
            • 预期收益：3-5% 年均收益
        """.trimIndent()
        "medium" -> """
            • 平衡配置各类投资品种：股票、债券、基金
            • 资产配置：股票 50%、债券 35%、现金 15%
            • 投资策略：稳健增长与风险平衡
            • 适合人群：普通投资者、工薪族、中等风险承受能力
            • 预期收益：6-10% 年均收益
        """.trimIndent()
        "high" -> """
            • 积极配置高收益投资品种：股票、期货、创新基金
            • 资产配置：股票 70%、债券 20%、现金 10%
            • 投资策略：积极增长，追求高收益
            • 适合人群：激进投资者、年轻人、高风险承受能力
            • 预期收益：10-20% 年均收益
        """.trimIndent()
        else -> "根据风险等级选择投资策略"
    }

    // 资产配置建议
    val assetAllocation = when (riskLevel) {
        "low" -> """
            国债: 30% - 安全稳定的政府债券
            定期存款: 30% - 银行定期存款产品
            货币基金: 20% - 低风险基金产品
            股票基金: 15% - 少量股票基金配置
            现金: 5% - 应急资金储备
        """.trimIndent()
        "medium" -> """
            股票基金: 35% - 主要投资品种
            债券基金: 25% - 风险平衡品种
            混合基金: 20% - 灵活配置品种
            定期存款: 15% - 稳定收益品种
            现金: 5% - 应急资金储备
        """.trimIndent()
        "high" -> """
            股票: 40% - 主要投资品种
            股票基金: 25% - 专业管理品种
            期货/期权: 15% - 高收益品种
            债券基金: 12% - 风险平衡品种
            现金: 8% - 应急资金储备
        """.trimIndent()
        else -> "根据风险等级配置资产"
    }

    // 投资建议
    val recommendations = StringBuilder()
    if (annualReturnRate < 3) {
        recommendations.append("• 预期收益率较低，建议考虑提高投资收益率\n")
    }
    if (investmentYears < 5) {
        recommendations.append("• 投资年数较短，建议延长投资期限以获得更好收益\n")
    }
    if (annualInvestment < initialCapital * 0.1) {
        recommendations.append("• 年投资额较低，建议增加定期投资金额\n")
    }
    if (riskLevel == "high" && investmentYears < 10) {
        recommendations.append("• 高风险投资需要较长的投资周期，建议至少10年以上\n")
    }
    if (recommendations.isEmpty()) {
        recommendations.append("• 投资计划合理，继续按计划执行\n")
    }

    // 构建输出文本
    val result = StringBuilder()
    result.append("💰 投资理财规划\n")
    result.append("═".repeat(60)).append("\n\n")
    
    result.append("📋 投资基本信息\n")
    result.append("─".repeat(60)).append("\n")
    result.append("初始资金: ¥${String.format("%.2f", initialCapital)}\n")
    result.append("年投资额: ¥${String.format("%.2f", annualInvestment)}\n")
    result.append("预期年收益率: ${String.format("%.2f", annualReturnRate)}%\n")
    result.append("投资年数: ${investmentYears} 年\n")
    result.append("风险等级: ${riskDescription}\n\n")

    result.append("💹 收益预测\n")
    result.append("─".repeat(60)).append("\n")
    result.append("预期最终资产: ¥${String.format("%.2f", finalAsset)}\n")
    result.append("总投资额: ¥${String.format("%.2f", totalInvestment)}\n")
    result.append("总收益: ¥${String.format("%.2f", totalProfit)}\n")
    result.append("年均收益: ¥${String.format("%.2f", annualProfit)}\n")
    result.append("投资回报率: ${String.format("%.2f", returnRate)}%\n\n")

    result.append("⚠️ 风险评估\n")
    result.append("─".repeat(60)).append("\n")
    result.append("风险等级: ${riskDescription}\n")
    result.append("风险评分: ${riskScore}/100\n")
    result.append("风险特征: 根据选择的风险等级进行评估\n\n")

    result.append("📊 投资建议\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${investmentAdvice}\n\n")

    result.append("🎯 资产配置方案\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${assetAllocation}\n\n")

    result.append("💡 个性化建议\n")
    result.append("─".repeat(60)).append("\n")
    result.append(recommendations.toString()).append("\n")

    result.append("📈 投资建议\n")
    result.append("─".repeat(60)).append("\n")
    result.append("1. 制定明确的投资目标和计划\n")
    result.append("2. 根据风险承受能力选择合适的投资品种\n")
    result.append("3. 定期检查投资组合，进行必要的调整\n")
    result.append("4. 避免追涨杀跌，保持理性投资心态\n")
    result.append("5. 分散投资，降低单一投资风险\n")
    result.append("6. 定期学习投资知识，提升投资能力\n")
    result.append("7. 关注市场动态，及时调整投资策略\n")
    result.append("8. 避免过度交易，控制交易成本\n")
    result.append("9. 建立应急基金，应对突发情况\n")
    result.append("10. 咨询专业投资顾问，获取专业建议\n\n")

    result.append("⚖️ 重要提示\n")
    result.append("─".repeat(60)).append("\n")
    result.append("本工具仅供参考，不构成投资建议。\n")
    result.append("实际收益可能与预期不符，请谨慎投资。\n")
    result.append("投资有风险，请根据自身情况选择合适的投资品种。\n")

    return result.toString()
}

代码说明

这段 Kotlin 代码实现了完整的投资理财规划和风险评估功能。让我详细解释关键部分：

数据验证：首先验证输入的初始资金、年投资额、预期收益率、投资年数和风险等级是否有效，确保数据在合理范围内。

复利计算：使用复利公式逐年计算资产增长，考虑年初投资和年度收益。

收益预测：计算预期最终资产、总投资额、总收益和投资回报率等关键指标。

风险评估：根据风险等级给出风险评分和风险描述。

投资建议生成：根据风险等级生成相应的投资策略和资产配置建议。

---

JavaScript 调用示例

编译后的 JavaScript 代码可以在 Node.js 或浏览器中直接调用。以下是 JavaScript 的使用示例：

// 导入编译后的 Kotlin/JS 模块
const { investmentPlanner } = require('./hellokjs.js');

// 示例 1：保守型投资
const result1 = investmentPlanner("100000 12000 5 20 low");
console.log("示例 1 - 保守型投资:");
console.log(result1);
console.log("\n");

// 示例 2：平衡型投资
const result2 = investmentPlanner("100000 12000 8 20 medium");
console.log("示例 2 - 平衡型投资:");
console.log(result2);
console.log("\n");

// 示例 3：激进型投资
const result3 = investmentPlanner("100000 12000 12 20 high");
console.log("示例 3 - 激进型投资:");
console.log(result3);
console.log("\n");

// 示例 4：小额投资
const result4 = investmentPlanner("50000 5000 8 15 medium");
console.log("示例 4 - 小额投资:");
console.log(result4);
console.log("\n");

// 示例 5：大额投资
const result5 = investmentPlanner("500000 50000 10 25 high");
console.log("示例 5 - 大额投资:");
console.log(result5);
console.log("\n");

// 示例 6：使用默认参数
const result6 = investmentPlanner();
console.log("示例 6 - 使用默认参数:");
console.log(result6);

// 实际应用场景：从用户输入获取数据
function planInvestment(userInput) {
    try {
        const result = investmentPlanner(userInput);
        return {
            success: true,
            data: result
        };
    } catch (error) {
        return {
            success: false,
            error: error.message
        };
    }
}

// 测试实际应用
const userInput = "200000 15000 9 25 medium";
const plan = planInvestment(userInput);
if (plan.success) {
    console.log("投资规划结果:");
    console.log(plan.data);
} else {
    console.log("规划失败:", plan.error);
}

// 多个投资方案对比
function compareInvestmentPlans(plans) {
    console.log("\n投资方案对比:");
    console.log("═".repeat(60));
    
    const results = plans.map((plan, index) => {
        const planning = investmentPlanner(plan);
        return {
            number: index + 1,
            plan,
            planning
        };
    });

    results.forEach(result => {
        console.log(`\n方案 ${result.number} (${result.plan}):`);
        console.log(result.planning);
    });

    return results;
}

// 测试多个投资方案对比
const plans = [
    "100000 12000 5 20 low",
    "100000 12000 8 20 medium",
    "100000 12000 12 20 high",
    "100000 20000 8 20 medium"
];

compareInvestmentPlans(plans);

// 投资收益分析
function analyzeInvestmentReturn(initialCapital, annualInvestment, annualRate, years) {
    const input = `${initialCapital} ${annualInvestment} ${annualRate} ${years} medium`;
    const planning = investmentPlanner(input);
    
    console.log("\n投资收益分析:");
    console.log(`初始资金: ¥${initialCapital.toFixed(2)}`);
    console.log(`年投资额: ¥${annualInvestment.toFixed(2)}`);
    console.log(`预期年收益率: ${annualRate}%`);
    console.log(`投资年数: ${years}年`);
    
    // 计算关键指标
    const totalInvestment = initialCapital + (annualInvestment * years);
    const monthlyRate = annualRate / 100 / 12;
    let finalAsset = initialCapital;
    
    for (let year = 1; year <= years; year++) {
        finalAsset += annualInvestment;
        finalAsset *= (1 + annualRate / 100);
    }
    
    const totalProfit = finalAsset - totalInvestment;
    
    console.log(`总投资额: ¥${totalInvestment.toFixed(2)}`);
    console.log(`预期最终资产: ¥${finalAsset.toFixed(2)}`);
    console.log(`总收益: ¥${totalProfit.toFixed(2)}`);
    console.log(`投资回报率: ${((totalProfit / totalInvestment) * 100).toFixed(2)}%`);
}

analyzeInvestmentReturn(100000, 12000, 8, 20);

JavaScript 代码说明

这段 JavaScript 代码展示了如何在 Node.js 环境中调用编译后的 Kotlin 函数。关键点包括：

模块导入：使用 require 导入编译后的 JavaScript 模块，获取导出的 investmentPlanner 函数。

多个示例：展示了不同风险等级和投资金额的调用方式。

错误处理：在实际应用中，使用 try-catch 块来处理可能的错误。

方案对比：compareInvestmentPlans 函数展示了如何对比多个投资方案。

收益分析：analyzeInvestmentReturn 函数演示了如何进行投资收益分析。

---

ArkTS 页面集成与调用

在 OpenHarmony 的 ArkTS 页面中集成这个投资理财规划工具。以下是完整的 ArkTS 实现代码：

import { investmentPlanner } from './hellokjs';

@Entry
@Component
struct InvestmentPlannerPage {
  @State initialCapital: string = "100000";
  @State annualInvestment: string = "12000";
  @State annualReturnRate: string = "8";
  @State investmentYears: string = "20";
  @State riskLevel: string = "medium";
  @State planningResult: string = "";
  @State isLoading: boolean = false;

  private riskLevels = ["low", "medium", "high"];

  build() {
    Column() {
      // 顶部栏
      Row() {
        Text("💰 投资理财规划")
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor(Color.White)
      }
      .width("100%")
      .height(60)
      .backgroundColor("#FF6F00")
      .justifyContent(FlexAlign.Center)
      .padding({ top: 10, bottom: 10 })

      // 主容器
      Scroll() {
        Column() {
          // 初始资金输入
          Text("初始资金 (元)")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ top: 20, left: 15 })

          TextInput({
            placeholder: "例如: 100000",
            text: this.initialCapital
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#FFE0B2")
            .border({ width: 1, color: "#FF6F00" })
            .onChange((value: string) => {
              this.initialCapital = value;
            })

          // 年投资额输入
          Text("年投资额 (元)")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          TextInput({
            placeholder: "例如: 12000",
            text: this.annualInvestment
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#FFE0B2")
            .border({ width: 1, color: "#FF6F00" })
            .onChange((value: string) => {
              this.annualInvestment = value;
            })

          // 预期年收益率输入
          Text("预期年收益率 (%)")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          TextInput({
            placeholder: "例如: 8",
            text: this.annualReturnRate
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#FFE0B2")
            .border({ width: 1, color: "#FF6F00" })
            .onChange((value: string) => {
              this.annualReturnRate = value;
            })

          // 投资年数输入
          Text("投资年数 (年)")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          TextInput({
            placeholder: "例如: 20",
            text: this.investmentYears
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#FFE0B2")
            .border({ width: 1, color: "#FF6F00" })
            .onChange((value: string) => {
              this.investmentYears = value;
            })

          // 风险等级选择
          Text("风险等级")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          Select(this.riskLevels)
            .value(this.riskLevel)
            .onSelect((index: number, value?: string) => {
              this.riskLevel = value || this.riskLevels[index];
            })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .backgroundColor("#FFE0B2")
            .border({ width: 1, color: "#FF6F00" })

          // 按钮区域
          Row() {
            Button("📊 制定规划")
              .width("45%")
              .height(45)
              .backgroundColor("#FF6F00")
              .fontColor(Color.White)
              .fontSize(16)
              .fontWeight(FontWeight.Bold)
              .onClick(() => {
                this.isLoading = true;
                setTimeout(() => {
                  const input = `${this.initialCapital} ${this.annualInvestment} ${this.annualReturnRate} ${this.investmentYears} ${this.riskLevel}`;
                  this.planningResult = investmentPlanner(input);
                  this.isLoading = false;
                }, 300);
              })

            Blank()

            Button("🔄 重置")
              .width("45%")
              .height(45)
              .backgroundColor("#2196F3")
              .fontColor(Color.White)
              .fontSize(16)
              .fontWeight(FontWeight.Bold)
              .onClick(() => {
                this.initialCapital = "100000";
                this.annualInvestment = "12000";
                this.annualReturnRate = "8";
                this.investmentYears = "20";
                this.riskLevel = "medium";
                this.planningResult = "";
                this.isLoading = false;
              })
          }
          .width("90%")
          .margin({ top: 10, bottom: 20, left: 15, right: 15 })
          .justifyContent(FlexAlign.SpaceBetween)

          // 加载指示器
          if (this.isLoading) {
            Row() {
              LoadingProgress()
                .width(40)
                .height(40)
                .color("#FF6F00")
              Text("  正在规划中...")
                .fontSize(14)
                .fontColor("#666666")
            }
            .width("90%")
            .height(50)
            .margin({ bottom: 15, left: 15, right: 15 })
            .justifyContent(FlexAlign.Center)
            .backgroundColor("#FFE0B2")
            .borderRadius(8)
          }

          // 结果显示区域
          if (this.planningResult.length > 0) {
            Column() {
              Text("📋 规划结果")
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .fontColor("#FF6F00")
                .margin({ bottom: 10 })

              Text(this.planningResult)
                .width("100%")
                .fontSize(12)
                .fontFamily("monospace")
                .fontColor("#333333")
                .lineHeight(1.6)
                .padding(10)
                .backgroundColor("#FAFAFA")
                .border({ width: 1, color: "#E0E0E0" })
                .borderRadius(8)
            }
            .width("90%")
            .margin({ top: 20, bottom: 30, left: 15, right: 15 })
            .padding(15)
            .backgroundColor("#FFE0B2")
            .borderRadius(8)
            .border({ width: 1, color: "#FF6F00" })
          }
        }
        .width("100%")
      }
      .layoutWeight(1)
      .backgroundColor("#FFFFFF")
    }
    .width("100%")
    .height("100%")
    .backgroundColor("#F5F5F5")
  }
}

ArkTS 代码说明

这段 ArkTS 代码实现了完整的用户界面和交互逻辑。关键点包括：

导入函数：从编译后的 JavaScript 模块中导入 investmentPlanner 函数。

状态管理：使用 @State 装饰器管理七个状态：初始资金、年投资额、预期年收益率、投资年数、风险等级、规划结果和加载状态。

UI 布局：包含顶部栏、五个输入框、制定规划和重置按钮、加载指示器和结果显示区域。

交互逻辑：用户输入投资信息后，点击制定规划按钮。应用会调用 Kotlin 函数进行规划，显示加载动画，最后展示详细的规划结果。

样式设计：使用橙色主题，与金融和投资相关的主题相符。所有输入框、按钮和结果显示区域都有相应的样式设置。

---

数据输入与交互体验

输入数据格式规范

为了确保工具能够正确处理用户输入，用户应该遵循以下规范：

1. 初始资金：整数或浮点数，单位元，范围 1 到 100000000。
2. 年投资额：整数或浮点数，单位元，范围 0 到 10000000。
3. 预期年收益率：浮点数，单位百分比，范围 -50 到 100。
4. 投资年数：整数，单位年，范围 1-100。
5. 风险等级：low（低风险）、medium（中等风险）或 high（高风险）。
6. 分隔符：使用空格分隔各个参数。

示例输入

• 保守型投资：100000 12000 5 20 low
• 平衡型投资：100000 12000 8 20 medium
• 激进型投资：100000 12000 12 20 high
• 小额投资：50000 5000 8 15 medium
• 大额投资：500000 50000 10 25 high

交互流程

1. 用户打开应用，看到输入框和默认数据
2. 用户输入初始资金、年投资额、预期年收益率、投资年数，选择风险等级
3. 点击"制定规划"按钮，应用调用 Kotlin 函数进行规划
4. 应用显示加载动画，表示正在处理
5. 规划完成后，显示详细的规划结果，包括收益预测、风险评估、投资建议等
6. 用户可以点击"重置"按钮清空数据，重新开始

---

编译与自动复制流程

编译步骤

1. 编译 Kotlin 代码：

   ./gradlew build
   

2. 生成 JavaScript 文件：
   编译过程会自动生成 hellokjs.d.ts 和 hellokjs.js 文件。

3. 复制到 ArkTS 项目：
   使用提供的脚本自动复制生成的文件到 ArkTS 项目的 pages 目录：

   ./build-and-copy.bat
   

文件结构

编译完成后，项目结构如下：

kmp_openharmony/
├── src/
│   └── jsMain/
│       └── kotlin/
│           └── App.kt (包含 investmentPlanner 函数)
├── build/
│   └── js/
│       └── packages/
│           └── hellokjs/
│               ├── hellokjs.d.ts
│               └── hellokjs.js
└── kmp_ceshiapp/
    └── entry/
        └── src/
            └── main/
                └── ets/
                    └── pages/
                        ├── hellokjs.d.ts (复制后)
                        ├── hellokjs.js (复制后)
                        └── Index.ets (ArkTS 页面)

---

总结

这个案例展示了如何使用 Kotlin Multiplatform 技术实现一个跨端的金融工具 - 投资理财规划工具。通过将核心逻辑写在 Kotlin 中，然后编译为 JavaScript，最后在 ArkTS 中调用，我们实现了代码的一次编写、多端复用。

核心优势

1. 代码复用：Kotlin 代码可以在 JVM、JavaScript 和其他平台上运行，避免重复开发。
2. 类型安全：Kotlin 的类型系统确保了代码的安全性和可维护性。
3. 性能优化：Kotlin 编译为 JavaScript 后，性能与手写 JavaScript 相当。
4. 易于维护：集中管理业务逻辑，使得维护和更新变得更加容易。
5. 用户体验：通过 ArkTS 提供的丰富 UI 组件，可以创建美观、易用的用户界面。

扩展方向

1. 数据持久化：将用户的投资规划记录保存到本地存储或云端。
2. 数据可视化：使用图表库展示投资增长曲线和资产配置。
3. 多币种支持：支持不同货币的投资规划。
4. 实时行情：集成实时行情数据，动态调整预期收益率。
5. 投资组合：支持多个投资组合的管理和对比。
6. 风险评估：更精细的风险评估和风险管理建议。
7. 税收优化：考虑税收因素的投资规划。
8. AI 推荐：使用机器学习提供个性化的投资建议。

通过这个案例，开发者可以学到如何在 KMP 项目中实现复杂的投资理财规划逻辑，以及如何在 OpenHarmony 平台上构建高效的跨端应用。这个投资理财规划工具可以作为金融应用、财富管理平台或个人理财工具的核心模块。
欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net