TypeScript从精通到入门4：什么是ts中的类

在 TypeScript 中，类（Class）是一种面向对象编程（OOP）的构造，它用于创建用户自定义的对象类型。类是对象的蓝图或模板，它定义了对象的属性和方法。通过类，我们可以创建具有相同属性和方法的多个对象实例。

定义类

使用 class 关键字来定义一个类。

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");

在这个例子中，Greeter 是一个类，它有一个属性 greeting 和一个方法 greet。constructor 是类的构造函数，用于初始化类的实例。

创建类的实例

使用 new 关键字可以创建类的实例。

let greeter = new Greeter("world");

现在 greeter 是 Greeter 类的一个实例，你可以访问它的属性和方法。

console.log(greeter.greet()); // 输出 "Hello, world"

继承

TypeScript 支持类之间的继承，允许一个类继承另一个类的属性和方法。

class Animal {  
    name: string;  
  
    constructor(theName: string) { this.name = theName; }  
  
    move(distanceInMeters: number = 0) {  
        console.log(`${this.name} moved ${distanceInMeters}m.`);  
    }  
}  
  
class Dog extends Animal {  
    bark() {  
        console.log('Woof! Woof!');  
    }  
}  
  
const dog = new Dog('Fido');  
dog.bark(); // 输出 "Woof! Woof!"  
dog.move(10); // 输出 "Fido moved 10m."  
dog.name; // 输出 "Fido"

在这个例子中，Dog 类继承了 Animal 类，因此 Dog 的实例可以访问 Animal 类的 name 属性和 move 方法，同时它还有自己的 bark 方法。

访问修饰符

TypeScript 支持三种访问修饰符：public、private 和 protected，用于控制类成员（属性和方法）的可见性。

• public：成员可以在任何地方被访问。
• private：成员只能在类内部被访问。
• protected：成员可以在类内部和子类中被访问。

class Animal {  
    private name: string;  
  
    constructor(theName: string) { this.name = theName; }  
  
    public move(distanceInMeters: number = 0) {  
        console.log(`${this.name} moved ${distanceInMeters}m.`);  
    }  
}
let animal = new Animal('dog');
console.log(animal.name); // 报错， 只能内部使用

在这个例子中，name 属性是私有的，只能在 Animal 类内部访问。

抽象类和接口

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('roaming the earch...');
    }
}

抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似。 两者都是定义方法签名但不包含方法体。 然而，抽象方法必须包含 abstract关键字并且可以包含访问修饰符。

abstract class Department {

    constructor(public name: string) {
    }

    printName(): void {
        console.log('Department name: ' + this.name);
    }

    abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {

    constructor() {
        super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
    }

    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }

    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在