「前端+鸿蒙」鸿蒙应用开发-TS类-定义&语法

在 TypeScript 中，类（class）是一种构建对象的结构，它允许你定义对象的属性和方法，并支持面向对象编程的基本特性，如封装、继承和多态。以下是 TypeScript 中类的定义和基本语法的快速入门指南。

TS快速入门-类的定义和语法

基本类定义

在 TypeScript 中定义一个类，使用 class 关键字：

class Person {
    // 属性定义
    name: string;
    age: number;

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

    // 方法定义
    greet(): void {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

访问修饰符

TypeScript 中有几种访问修饰符：

• public：成员（属性或方法）可以在任何地方被访问。
• private：成员只能在它被定义的类内部访问。
• protected：成员只能在它被定义的类及其子类中访问。

class Animal {
    protected name: string;

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

class Dog extends Animal {
    bark(): void {
        console.log(`${this.name} barks.`);
    }
}

let dog = new Dog('Buddy');
dog.bark(); // 允许访问，因为 Dog 是 Animal 的子类
// console.log(dog.name); // 错误：name 是 protected，不能在 Animal 外部访问

继承

使用 extends 关键字实现类的继承：

class Animal {
    // ...
}

class Dog extends Animal {
    bark() {
        console.log('Woof!');
    }
}

抽象类

使用 abstract 关键字定义抽象类，它不能被实例化，并且可以包含抽象方法，这些方法必须在子类中实现：

abstract class Animal {
    protected name: string;

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

    abstract makeSound(): void;
}

class Dog extends Animal {
    makeSound(): void {
        console.log('Bark!');
    }
}

静态成员

使用 static 关键字定义静态成员，它属于类本身，而不是类的实例：

class MathUtils {
    static pi: number = 3.14;

    static calculateCircleArea(radius: number): number {
        return MathUtils.pi * radius * radius;
    }
}

console.log(MathUtils.calculateCircleArea(10)); // 使用类名直接调用静态方法

示例代码

以下是一个使用 TypeScript 类的示例，展示了类的基本用法：

// 定义一个类
class Car {
    private make: string;
    public model: string;
    public year: number;

    constructor(make: string, model: string, year: number) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    public start(): void {
        console.log(`${this.model} starts.`);
    }

    private refuel(liters: number): void {
        console.log(`Refueling ${this.model} with ${liters} liters.`);
    }

    public displayInfo(): void {
        console.log(`Car make: ${this.make}, model: ${this.model}, year: ${this.year}`);
    }
}

// 使用类
let myCar = new Car('Tesla', 'Model S', 2021);
myCar.start(); // Car make: Tesla, model: Model S, year: 2021 starts.
myCar.displayInfo(); // Car make: Tesla, model: Model S, year: 2021

// Car类的继承
class ElectricCar extends Car {
    public batteryCapacity: number;

    constructor(make: string, model: string, year: number, batteryCapacity: number) {
        super(make, model, year);
        this.batteryCapacity = batteryCapacity;
    }

    public charge(): void {
        console.log(`Charging the ${this.model} with a ${this.batteryCapacity}kWh battery.`);
    }
}

let myElectricCar = new ElectricCar('Tesla', 'Model 3', 2022, 75);
myElectricCar.charge(); // Charging the Model 3 with a 75kWh battery.

TypeScript 中类的基本用法，包括属性、方法、构造函数、访问修饰符、继承、抽象类和静态成员。这些特性使得 TypeScript 成为一个强大的工具，用于构建健壮和可维护的应用程序。