TypeScript 学习笔记之 typeScript类定义,类的继承,类成员修饰符

类的定义

TypeScript 是 JavaScript 的超集，所以它具有 JavaScript 的所有语法，并且添加了一些新的特性。在 TypeScript 中，我们可以使用类来定义对象，它们是创建对象的蓝图，可以描述对象的属性和方法。

类的语法

类的语法如下所示：

class ClassName {
    // 属性和方法
}

其中，ClassName 表示类的名称。一个类可以包含属性和方法，它们定义在类的大括号内。

类的属性和方法

在 TypeScript 类中，可以通过成员变量定义属性，可以通过成员方法定义方法。

例如，下面是一个 Person 类的示例：

class Person {
    name: string;  // 成员变量：姓名
    age: number;   // 成员变量：年龄

    sayHello(): void {            // 成员方法：打招呼
        console.log('Hello!');
    }

    sayName(): void {             // 成员方法：自我介绍
        console.log(`My name is ${this.name}.`);
    }
}

在上面的示例中，Person 类包含了两个成员变量 name 和 age，以及两个成员方法 sayHello() 和 sayName()。

在成员方法中，有一个特殊的关键字 this，表示对当前对象的引用。在上面的示例中，sayName() 方法中的 this.name 表示调用方法的对象的 name 属性。

类的实例化

创建类的实例，即创建类的对象，使用 new 关键字，如下所示：

let person = new Person();
person.name = 'Alice';
person.age = 18;
person.sayHello();  // 输出：Hello!
person.sayName();   // 输出：My name is Alice.

类的继承

TypeScript 支持类的继承，允许我们创建一个类，它从另一个类继承属性和方法。继承的类称为子类或派生类，被继承的类称为父类或基类。子类继承了父类的所有属性和方法，并且可以添加自己的属性和方法。

继承语法

继承语法如下所示：

class ChildClass extends ParentClass {
    // 子类的属性和方法
}

其中，ChildClass 为子类名称，ParentClass 为父类名称。子类可以访问父类的所有属性和方法，并可以添加自己的属性和方法。

继承示例

例如，下面是一个 Teacher 类继承自 Person 类的示例：

class Teacher extends Person {
    subject: string;  // 子类的属性：教授课程

    teach(): void {   // 子类的方法：教学
        console.log(`I am teaching ${this.subject}.`);
    }
}

在上面的示例中，Teacher 类继承了 Person 类的属性和方法，并添加了自己的属性 subject 和方法 teach()。

可以通过以下方式创建 Teacher 类的实例，并调用它的属性和方法：

let teacher = new Teacher();
teacher.name = 'Bob';
teacher.age = 25;
teacher.subject = 'Math';
teacher.sayHello();  // 输出：Hello!
teacher.sayName();   // 输出：My name is Bob.
teacher.teach();     // 输出：I am teaching Math.

类成员修饰符

类成员修饰符可以控制类的属性和方法的访问权限。TypeScript 支持三种类成员修饰符。它们分别是：

• public：默认值，表示公共属性或方法，可以被子类和类的实例访问。
• protected：表示受保护的属性或方法，只能被子类访问。
• private：表示私有属性或方法，只能被类本身访问，不能被子类和类的实例访问。

类成员修饰符示例

例如，下面是一个 Student 类的示例，展示了类成员修饰符的使用：

class Student {
    public name: string;        // 公共属性：姓名
    protected age: number;     // 受保护的属性：年龄
    private grade: number;     // 私有属性：成绩

    constructor(name: string, age: number, grade: number) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    public sayHello(): void {
        console.log('Hello!');
    }

    protected sayAge(): void {
        console.log(`I am ${this.age} years old.`);
    }

    private sayGrade(): void {
        console.log(`My grade is ${this.grade}.`);
    }

    public getInfo(): void {
        this.sayHello();
        this.sayAge();
        this.sayGrade();
    }
}

class ElementaryStudent extends Student {
    constructor(name: string, age: number, grade: number) {
        super(name, age, grade);
    }

    public study(): void {
        console.log('I am studying in the elementary school.');
    }
}

在上面的示例中，Student 类包含了三个属性和三个方法，每个成员都有不同的修饰符。在 Student 类中，name 属性为公共属性，可以被类的实例和子类访问，在构造函数中赋值；age 属性为受保护的属性，只能被子类访问；grade 属性为私有属性，只能被类本身访问，在构造函数中赋值。sayHello() 方法为公共方法，可以被类的实例和子类访问；sayAge() 方法为受保护的方法，只能被子类访问；sayGrade() 方法为私有方法，只能被类本身访问。getInfo() 方法为公共方法，可以被类的实例和子类访问，在内部调用了 sayHello()、sayAge() 和 sayGrade() 方法。ElementaryStudent 类继承了 Student 类，可以访问 Student 类的公共和受保护的属性和方法，并添加了自己的公共方法 study()。

可以通过以下方式创建 Student 类和 ElementaryStudent 类的实例，并调用它们的属性和方法：

let student = new Student('Alice', 15, 85);
student.name = 'Ali';
student.sayHello();  // 输出：Hello!
student.sayAge();    // 报错：属性“age”受保护，只能在类“Student”及其子类中访问。
student.sayGrade();  // 报错：属性“grade”为私有属性，只能在类“Student”中访问。
student.getInfo();   // 输出：Hello!  I am 15 years old.  My grade is 85.

let elementaryStudent = new ElementaryStudent('Bob', 12, 92);
elementaryStudent.study();    // 输出：I am studying in the elementary school.
elementaryStudent.sayHello(); // 输出：Hello!
elementaryStudent.sayAge();   // 报错：属性“age”受保护，只能在类“Student”及其子类中访问。
elementaryStudent.sayGrade(); // 报错：属性“grade”为私有属性，只能在类“Student”中访问。
elementaryStudent.getInfo();  // 输出：Hello!  I am 12 years old.  My grade is 92.

结束语

本篇文章主要介绍了 TypeScript 类的定义、类的继承和类成员修饰符的相关知识。了解这些知识对于深入理解 TypeScript 的面向对象编程非常重要。同时，通过本篇文章的示例代码，可以更好地了解类的继承和类成员修饰符的使用。