鸿蒙多功能工具箱开发实战(九)-养老金计算器业务逻辑开发

前言

养老金计算是每个职场人士都关心的话题，涉及多个参数和复杂的计算公式。随着我国养老保险制度的不断完善，了解养老金的计算方法对于规划退休生活具有重要意义。本文将详细讲解养老金计算的业务逻辑实现。

为什么需要养老金计算器？

1. 退休规划：帮助职工提前规划退休生活
2. 政策理解：直观理解养老金计算方式
3. 参数调整：模拟不同缴费情况下的养老金
4. 决策辅助：辅助做出职业和缴费决策

一、养老金计算公式详解

1.1 基础养老金

基础养老金的计算公式：

基础养老金 = (全省上年度在岗职工月平均工资 + 本人指数化月平均缴费工资) ÷ 2 × 缴费年限 × 1%

其中：

• 全省上年度在岗职工月平均工资：由统计局公布
• 本人指数化月平均缴费工资 = 全省平均工资 × 本人平均缴费指数
• 缴费年限：实际缴费年限（含视同缴费年限）

1.2 个人账户养老金

个人账户养老金的计算公式：

个人账户养老金 = 个人账户储存额 ÷ 计发月数

计发月数根据退休年龄确定：

退休年龄	计发月数	说明
50岁	195个月	女工人退休年龄
55岁	170个月	女干部退休年龄
60岁	139个月	男职工退休年龄
65岁	101个月	延迟退休

1.3 计算示例

假设某职工：

• 全省平均工资：8000元
• 个人缴费基数：8000元
• 缴费年限：30年
• 个人账户储存额：150000元
• 退休年龄：60岁

计算结果：

• 基础养老金 = (8000 + 8000) ÷ 2 × 30 × 1% = 2400元
• 个人账户养老金 = 150000 ÷ 139 = 1079.14元
• 月领总额 = 2400 + 1079.14 = 3479.14元

二、计算逻辑实现

2.1 核心计算类

export class PensionCalculator {
  private static MONTH_COUNT: Record<number, number> = {
    50: 195, 55: 170, 60: 139, 65: 101
  }
  
  static calculate(params: PensionParams): PensionResult {
    this.validateParams(params);
    
    const basic = this.calculateBasicPension(
      params.avgSalary, params.personalBase, params.years
    );
    
    const personal = this.calculatePersonalPension(
      params.personalAccount, params.retireAge
    );
    
    return {
      basic: Math.round(basic * 100) / 100,
      personal: Math.round(personal * 100) / 100,
      total: Math.round((basic + personal) * 100) / 100
    };
  }
  
  private static calculateBasicPension(
    avgSalary: number, indexSalary: number, years: number
  ): number {
    return (avgSalary + indexSalary) / 2 * years * 0.01;
  }
  
  private static calculatePersonalPension(
    personalAccount: number, retireAge: number
  ): number {
    const monthCount = this.MONTH_COUNT[retireAge] || 139;
    return personalAccount / monthCount;
  }
  
  private static validateParams(params: PensionParams): void {
    if (params.avgSalary <= 0) throw new Error('全省平均工资必须大于0');
    if (params.years < 15) throw new Error('缴费年限不能少于15年');
  }
}

2.2 缴费指数计算

export class ContributionIndexCalculator {
  static calculateAverageIndex(contributions: ContributionRecord[]): number {
    if (contributions.length === 0) return 1;
    
    const totalIndex = contributions.reduce((sum, record) => {
      return sum + record.personalBase / record.avgSalary;
    }, 0);
    
    return totalIndex / contributions.length;
  }
}

三、界面实现

3.1 主页面结构

@Entry
@Component
struct PensionCalculatorPage {
  @State avgSalary: string = '8000';
  @State personalBase: string = '8000';
  @State years: string = '30';
  @State personalAccount: string = '150000';
  @State retireAge: number = 60;
  @State result: PensionResult | null = null;
  
  build() {
    Column() {
      this.NavigationBar()
      Scroll() {
        Column() {
          this.InputSection()
          this.RetireAgeSelector()
          this.CalculateButton()
          if (this.result) this.ResultSection()
        }.padding(16)
      }.layoutWeight(1)
    }
    .width('100%').height('100%')
    .backgroundColor('#F5F5F5')
  }
}

3.2 输入表单组件

@Builder
InputSection() {
  Column() {
    this.InputItem('全省平均工资', '元', this.avgSalary, v => this.avgSalary = v)
    this.InputItem('个人缴费基数', '元', this.personalBase, v => this.personalBase = v)
    this.InputItem('缴费年限', '年', this.years, v => this.years = v)
    this.InputItem('个人账户储存额', '元', this.personalAccount, v => this.personalAccount = v)
  }
  .width('100%')
  .backgroundColor('#FFFFFF')
  .borderRadius(12)
  .padding(16)
}

@Builder
InputItem(label: string, unit: string, value: string, onChange: (v: string) => void) {
  Row() {
    Text(label).fontSize(16)
    Blank()
    TextInput({ text: value })
      .type(InputType.Number)
      .width(120)
      .onChange(onChange)
    Text(unit).fontSize(14).fontColor('#999999')
  }
  .width('100%')
  .margin({ bottom: 16 })
}

3.3 退休年龄选择器

@Builder
RetireAgeSelector() {
  Column() {
    Text('退休年龄').fontSize(16).margin({ bottom: 12 })
    
    Row() {
      ForEach([
        { age: 50, label: '50岁' },
        { age: 55, label: '55岁' },
        { age: 60, label: '60岁' },
        { age: 65, label: '65岁' }
      ], (item: AgeOption) => {
        Button(item.label)
          .fontSize(14)
          .fontColor(this.retireAge === item.age ? '#FFFFFF' : '#333333')
          .backgroundColor(this.retireAge === item.age ? '#4A90E2' : '#F0F0F0')
          .onClick(() => { this.retireAge = item.age; })
      })
    }
  }
  .width('100%')
  .padding(16)
  .backgroundColor('#FFFFFF')
  .borderRadius(12)
}

3.4 结果展示组件

@Builder
ResultSection() {
  Column() {
    Text('计算结果').fontSize(18).fontWeight(FontWeight.Bold)
    
    Column() {
      Text('月领养老金').fontSize(14).fontColor('#666666')
      Text(`${this.result.total}元`)
        .fontSize(36)
        .fontColor('#FF6B6B')
        .fontWeight(FontWeight.Bold)
    }
    .width('100%')
    .padding(24)
    .backgroundColor('#FFF5F5')
    .borderRadius(12)
    
    Row() {
      Column() {
        Text('基础养老金').fontSize(12).fontColor('#999999')
        Text(`${this.result.basic}元`).fontSize(18)
      }.layoutWeight(1)
      
      Column() {
        Text('个人账户养老金').fontSize(12).fontColor('#999999')
        Text(`${this.result.personal}元`).fontSize(18)
      }.layoutWeight(1)
    }
    .width('100%')
    .padding(16)
    .backgroundColor('#FFFFFF')
    .borderRadius(12)
  }
  .width('100%')
  .padding(16)
}

四、数据验证与错误处理

4.1 参数验证

export class PensionValidator {
  static validate(params: PensionParams): ValidationResult {
    const errors: string[] = [];
    
    // 全省平均工资验证
    if (params.avgSalary <= 0) {
      errors.push('全省平均工资必须大于0');
    } else if (params.avgSalary < 2000) {
      errors.push('全省平均工资过低，请检查输入');
    } else if (params.avgSalary > 50000) {
      errors.push('全省平均工资过高，请检查输入');
    }
    
    // 个人缴费基数验证
    if (params.personalBase <= 0) {
      errors.push('个人缴费基数必须大于0');
    }
    
    // 缴费年限验证
    if (params.years < 15) {
      errors.push('缴费年限不能少于15年');
    } else if (params.years > 45) {
      errors.push('缴费年限过长，请检查输入');
    }
    
    // 个人账户储存额验证
    if (params.personalAccount < 0) {
      errors.push('个人账户储存额不能为负数');
    }
    
    // 退休年龄验证
    if (![50, 55, 60, 65].includes(params.retireAge)) {
      errors.push('退休年龄不合法');
    }
    
    return {
      isValid: errors.length === 0,
      errors
    };
  }
}

4.2 异常处理

export class PensionCalculator {
  static calculateSafe(params: PensionParams): Result<PensionResult> {
    try {
      // 验证参数
      const validation = PensionValidator.validate(params);
      if (!validation.isValid) {
        return {
          success: false,
          error: validation.errors.join('; ')
        };
      }
      
      // 计算养老金
      const result = this.calculate(params);
      
      return {
        success: true,
        data: result
      };
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
}

五、测试用例

5.1 单元测试

describe('PensionCalculator', () => {
  it('should calculate basic pension correctly', () => {
    const result = PensionCalculator.calculate({
      avgSalary: 8000,
      personalBase: 8000,
      years: 30,
      personalAccount: 150000,
      retireAge: 60
    });
    
    expect(result.basic).toBe(2400);
    expect(result.personal).toBeCloseTo(1079.14, 2);
    expect(result.total).toBeCloseTo(3479.14, 2);
  });
  
  it('should throw error for invalid years', () => {
    expect(() => {
      PensionCalculator.calculate({
        avgSalary: 8000,
        personalBase: 8000,
        years: 10,
        personalAccount: 150000,
        retireAge: 60
      });
    }).toThrow('缴费年限不能少于15年');
  });
  
  it('should handle different retire ages', () => {
    const result50 = PensionCalculator.calculate({
      avgSalary: 8000, personalBase: 8000, years: 30,
      personalAccount: 150000, retireAge: 50
    });
    
    const result60 = PensionCalculator.calculate({
      avgSalary: 8000, personalBase: 8000, years: 30,
      personalAccount: 150000, retireAge: 60
    });
    
    // 50岁退休的个人账户养老金应该更高（分母更小）
    expect(result50.personal).toBeGreaterThan(result60.personal);
  });
});

5.2 边界测试

describe('Edge Cases', () => {
  it('should handle minimum years', () => {
    const result = PensionCalculator.calculate({
      avgSalary: 8000, personalBase: 8000, years: 15,
      personalAccount: 50000, retireAge: 60
    });
    
    expect(result.basic).toBe(1200);
  });
  
  it('should handle zero personal account', () => {
    const result = PensionCalculator.calculate({
      avgSalary: 8000, personalBase: 8000, years: 30,
      personalAccount: 0, retireAge: 60
    });
    
    expect(result.personal).toBe(0);
    expect(result.total).toBe(result.basic);
  });
});

六、实际应用场景

6.1 场景一：退休规划

用户可以：

1. 输入当前工资和缴费情况
2. 查看预期养老金
3. 调整缴费基数、年限等参数
4. 对比不同方案的结果

6.2 场景二：政策对比

export class PolicyComparator {
  static compare(
    params: PensionParams,
    policies: Policy[]
  ): ComparisonResult[] {
    return policies.map(policy => ({
      policyName: policy.name,
      result: PensionCalculator.calculate({
        ...params,
        avgSalary: policy.avgSalary
      })
    }));
  }
}

6.3 场景三：历年趋势分析

export class TrendAnalyzer {
  static analyze(
    baseParams: PensionParams,
    years: number[]
  ): TrendData[] {
    return years.map(year => ({
      year,
      avgSalary: this.getAvgSalaryByYear(year),
      result: PensionCalculator.calculate({
        ...baseParams,
        avgSalary: this.getAvgSalaryByYear(year)
      })
    }));
  }
}

七、常见问题与解决方案

7.1 问题：计算结果与实际不符

原因：

• 各地政策略有差异
• 未考虑过渡性养老金
• 未考虑职业年金

解决方案：

// 添加地区配置
const REGIONAL_CONFIG = {
  'beijing': { adjustment: 1.05 },
  'shanghai': { adjustment: 1.03 },
  'default': { adjustment: 1.0 }
};

// 计算时应用地区调整
const adjustedResult = result * config.adjustment;

7.2 问题：过渡性养老金计算

解决方案：

static calculateTransitionalPension(params: TransitionalParams): number {
  // 1997年前参加工作的人员
  if (params.workStartYear < 1997) {
    const years = 1997 - params.workStartYear;
    return params.avgSalary * params.index * years * 0.012;
  }
  return 0;
}

7.3 问题：职业年金计算

解决方案：

static calculateOccupationalPension(params: OccupationalParams): number {
  // 职业年金 = 个人账户储存额 ÷ 计发月数
  return params.occupationalAccount / this.MONTH_COUNT[params.retireAge];
}

八、性能优化

8.1 缓存策略

export class PensionCache {
  private cache: Map<string, PensionResult> = new Map();
  
  get(params: PensionParams): PensionResult | null {
    const key = this.generateKey(params);
    return this.cache.get(key) || null;
  }
  
  set(params: PensionParams, result: PensionResult): void {
    const key = this.generateKey(params);
    this.cache.set(key, result);
  }
  
  private generateKey(params: PensionParams): string {
    return `${params.avgSalary}_${params.personalBase}_${params.years}_${params.retireAge}`;
  }
}

8.2 批量计算优化

export class BatchCalculator {
  static calculateBatch(paramsList: PensionParams[]): PensionResult[] {
    return paramsList.map(params => PensionCalculator.calculate(params));
  }
}

九、扩展功能

9.1 养老金增长预测

export class GrowthPredictor {
  static predict(
    currentResult: PensionResult,
    growthRate: number,
    years: number
  ): PredictionResult[] {
    const predictions: PredictionResult[] = [];
    let current = currentResult.total;
    
    for (let i = 1; i <= years; i++) {
      current = current * (1 + growthRate);
      predictions.push({
        year: new Date().getFullYear() + i,
        amount: Math.round(current)
      });
    }
    
    return predictions;
  }
}

9.2 退休年龄建议

export class RetireAgeAdvisor {
  static advise(params: PensionParams): Advice {
    const results = [50, 55, 60, 65].map(age => ({
      age,
      pension: PensionCalculator.calculate({ ...params, retireAge: age })
    }));
    
    // 找到最佳退休年龄
    const optimal = results.reduce((best, current) => 
      current.pension.total > best.pension.total ? current : best
    );
    
    return {
      optimalAge: optimal.age,
      pension: optimal.pension,
      alternatives: results.filter(r => r.age !== optimal.age)
    };
  }
}

图1 养老金计算页面展示

十、总结

10.1 技术要点回顾

1. 计算公式：准确实现基础养老金和个人账户养老金计算
2. 参数验证：完善的输入验证和错误处理
3. 界面设计：直观的输入和结果展示
4. 扩展功能：趋势分析、政策对比等高级功能

10.2 核心代码统计

• 计算引擎：150行
• 界面实现：200行
• 数据验证：80行
• 测试用例：100行
• 总计：约530行代码

10.3 实现效果

通过本文的实现，我们完成了一个功能完整的养老金计算器：

• ✅ 支持多种退休年龄
• ✅ 准确计算基础养老金和个人账户养老金
• ✅ 完善的参数验证
• ✅ 详细的结果展示
• ✅ 支持政策对比和趋势分析

10.4 未来展望

后续可以考虑的扩展方向：

1. 地区适配：支持各地政策差异
2. 过渡性养老金：完善1997年前参加工作人员的计算
3. 职业年金：加入职业年金计算
4. 数据可视化：图表展示养老金趋势
5. 智能建议：根据用户情况给出退休建议

10.5 开发心得

开发养老金计算器的关键点：

1. 政策理解：准确理解养老金计算政策是基础
2. 边界处理：充分考虑各种边界情况和异常输入
3. 用户友好：提供详细的计算过程和结果解释
4. 可扩展性：设计良好的架构便于后续扩展

---

系列文章导航：
下期预告：鸿蒙多功能工具箱开发实战(十)-计算器模块界面设计与交互优化