前言

在掌握ArkTS基础语法之后，进一步学习其面向对象编程（OOP）能力，是构建结构清晰、可维护性强的鸿蒙应用的关键一步。ArkTS作为TypeScript的超集，完整支持现代面向对象特性，包括类（Class）、对象（Object）、封装、继承和多态。这些特性不仅让代码更模块化，还能显著提升大型项目的开发效率。

本文将系统讲解ArkTS中的面向对象核心概念，并结合鸿蒙开发中的实际场景——如自定义UI组件、业务模型封装等——帮助你理解如何在真实项目中运用OOP思想。

一、类与对象：封装数据与行为

在ArkTS中，类（Class） 是创建对象的模板，它将数据（属性）和操作数据的方法封装在一起。

1. 定义一个类

class User {
  // 属性
  name: string;
  age: number;

  // 构造函数：初始化对象
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 方法
  introduce(): string {
    return `大家好，我是${this.name}，今年${this.age}岁。`;
  }
}

2. 创建对象并调用方法

const user1 = new User("张三", 28);
console.log(user1.introduce()); // 输出：大家好，我是张三，今年28岁。

💡 提示：在鸿蒙开发中，你可以用User类来封装用户信息，用于登录状态管理、个人中心展示等场景。

二、构造函数与属性初始化

ArkTS支持在构造函数中使用参数属性（Parameter Properties） 简化代码：

class Product {
  constructor(
    public id: number,
    public name: string,
    private price: number // private 表示仅类内部可访问
  ) {}

  getPrice(): number {
    return this.price;
  }
}

const phone = new Product(1001, "智能手机", 3999);
console.log(phone.name);        // ✅ 可访问
// console.log(phone.price);    // ❌ 编译错误！price 是私有的
console.log(phone.getPrice());  // ✅ 通过方法访问

这种写法将属性声明与赋值合并，代码更简洁。

三、继承：代码复用的核心机制

继承（Inheritance） 允许一个类（子类）基于另一个类（父类）进行扩展，复用已有功能并添加新特性。

示例：通用设备类 → 手机类

// 父类：通用设备
class Device {
  protected brand: string;

  constructor(brand: string) {
    this.brand = brand;
  }

  turnOn(): void {
    console.log(`${this.brand} 设备已开机`);
  }
}

// 子类：手机
class Smartphone extends Device {
  private os: string;

  constructor(brand: string, os: string) {
    super(brand); // 调用父类构造函数
    this.os = os;
  }

  // 重写父类方法（多态）
  turnOn(): void {
    console.log(`${this.brand} 手机运行 ${this.os} 系统，正在启动...`);
  }

  makeCall(contact: string): void {
    console.log(`正在拨打 ${contact}...`);
  }
}

使用继承后的类

const myPhone = new Smartphone("华为", "HarmonyOS");
myPhone.turnOn();     // 输出：华为 手机运行 HarmonyOS 系统，正在启动...
myPhone.makeCall("妈妈"); // 输出：正在拨打 妈妈...

🌟 鸿蒙场景应用：在开发多端应用时，可定义通用BaseComponent类，再派生出PhoneComponent、WatchComponent等，实现设备适配逻辑的复用。

四、多态：同一接口，不同实现

多态（Polymorphism） 指的是子类可以以自己的方式实现父类的方法。这使得我们可以编写更通用的代码。

function startDevice(device: Device): void {
  device.turnOn(); // 实际调用哪个 turnOn？取决于传入对象的真实类型
}

const tablet = new Device("华为");
const phone = new Smartphone("荣耀", "HarmonyOS");

startDevice(tablet); // 华为 设备已开机
startDevice(phone);  // 荣耀 手机运行 HarmonyOS 系统，正在启动...

这种设计让代码更具扩展性——未来新增SmartTV类，无需修改startDevice函数。

五、在鸿蒙开发中实践：自定义UI组件类

虽然ArkUI主要使用装饰器（如@Component）定义组件，但在复杂业务逻辑中，我们常通过类来封装状态或行为。

示例：封装一个“计数器逻辑类”

class Counter {
  private _value: number = 0;

  get value(): number {
    return this._value;
  }

  increment(step: number = 1): void {
    this._value += step;
  }

  reset(): void {
    this._value = 0;
  }
}

在页面中使用：

import { Component, Text, Button, Column } from '@ohos/arkui';

@Component
struct CounterPage {
  private counter: Counter = new Counter();

  build() {
    Column() {
      Text(`当前计数: ${this.counter.value}`)
        .fontSize(24)

      Button(' +1 ')
        .onClick(() => {
          this.counter.increment();
        })

      Button(' 重置 ')
        .onClick(() => {
          this.counter.reset();
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

通过将计数逻辑封装在Counter类中，页面组件只负责UI渲染和事件绑定，实现了关注点分离，便于测试和维护。

六、访问修饰符：控制可见性

ArkTS支持三种访问修饰符：

• public（默认）：任何地方可访问；
• protected：仅类自身及子类可访问；
• private：仅类内部可访问。

合理使用这些修饰符，能有效防止外部代码误操作内部状态，提升代码健壮性。

七、总结

面向对象编程是ArkTS乃至现代软件开发的核心范式。通过本篇学习，你应该已经掌握：

• 如何定义类与创建对象；
• 构造函数与属性初始化技巧；
• 继承与方法重写的使用；
• 多态带来的灵活性；
• 在鸿蒙项目中如何用类封装业务逻辑。

✅ 建议实践： 定义一个TodoItem类，包含标题、完成状态、创建时间； 创建TodoList类，管理多个TodoItem，提供添加、删除、标记完成等方法； 在页面中集成该逻辑，构建一个简易待办事项应用。

掌握这些技能后，你将能写出更专业、更易维护的鸿蒙应用代码。下一步，我们将深入ArkUI声明式语法，把OOP能力与UI开发深度融合！