【TS】TypeScript class类

文章目录

class实例属性

class实例方法

class构造方法

class继承

class属性修饰符

public

protected

private

static静态成员

abstract抽象类 

---

TS 中的 class，不仅提供了JS中 class 的语法功能，也作为一种类型存在。

类中有两个成员：属性和方法（属性和方法又分为：非静态属性/方法和静态[static]属性/方法）。

类中属性要加数据类型，方法的参数和返回值也要加数据类型。

class实例属性

问题：TypeScript 有一个编译设置，要求类的属性必须初始化（即有初始值），如果不对属性赋值就会报错。

解决：使用非空断言（ ! ），表示这属性肯定会有值，这样就不会报错了。

注意：非空断言只有在设置 "strictNullChecks": true 时才有意义。如果不打开这个选项，编译器就不会检查变量是否可能为 undefined 或 null 。

class Point {
  x: number; // 报错
  y: number; // 报错
}

class Point {
  x!: number; // 正确
  y!: number; // 正确
}

定义过程中可以充分利用类型推断隐式定义类属性的类型注解，以简化代码。

class Person {
    name: string = "abc";
    age = 23; // 隐式
}

class实例方法

class 实例方法的类型注解（参数和返回值）与函数用法相同。

// 定义类
class Person {
    // 属性
    name: string = "张三";
    // 方法
    eat(): void {
        console.log(this.name + "吃薯片");
    };
}

let p1 = new Person();
p1.eat(); // 张三吃薯片

class构造方法

类的构造方法会在实例化（new）的过程中自动执行，成员在初始化（比如，age: number）后，才可以通过 this.age 来访问实例成员

// 定义类
class Person {
    // 属性
    name: string;
    age: number;
    // 构造方法 
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    };
    // 普通方法
    eat(): void {
        console.log(this.name + "吃薯片");
    };
}

let p1 = new Person('小七', 22);
p1.eat(); // 小七吃薯片

class继承

子类通过 extends 关键字实现类的继承，在子类中通过 super 关键字继承父类的属性和方法。

// 定义父类
class Person {
    // 属性
    name: string;
    age: number;
    // 构造方法 
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    };
    // 普通方法
    eat(): void {
        console.log(this.name + "吃薯片");
    };
}

// 定义子类
class Son extends Person {
    sex: string;
    constructor(name: string, age: number) {
        // 继承父类属性
        super(name, age);
        this.sex = "男";
    };
    eat(): void {
        // 继承父类方法
        super.eat();
    }
}

let s1 = new Son('小九', 10);
s1.eat(); // 小九吃薯片

class属性修饰符

public

在类的属性或方法前面添加 public 关键字，来修饰该属性或方法是公有的。在类的内部，类的外部，子类都可以使用。默认修饰符，可以省略。

// 定义父类
class Person {
    public name: string = '小七';
    public age: number = 22;
    public eat(): void {
        console.log(this.name + "吃薯片"); // 类的内部使用
    };
    public action(): void {
        this.eat(); // 类的内部使用
    }
}

// 定义子类
class Son extends Person {
    constructor() {
        super();
        console.log(this.name); // 子类中使用
        this.eat(); // 子类中使用
    };
}

let s1 = new Son();
console.log(s1.name); // 类的外部使用
s1.eat(); // 类的外部使用

protected

在类属性或方法前面添加 protected 关键字，来修饰该属性或方法是受保护的。在类的内部，子类中可以使用；类的外层不能使用。

// 定义父类
class Person {
    protected name: string = '小七';
    protected age: number = 22;
    protected eat(): void {
        console.log(this.name + "吃薯片"); // 类的内部使用
    };
    protected action(): void {
        this.eat(); // 类的内部使用
    }
}

// 定义子类
class Son extends Person {
    constructor() {
        super();
        console.log(this.name); // 子类中使用
        this.eat(); // 子类中使用
    };
}

let s1 = new Son();
console.log(s1.name); // 类的外部使用  --报错
s1.eat(); // 类的外部使用  --报错

private

在类属性或方法前面添加 private 关键字，来修饰该属性或方法是私有的。在类的内部可以使用；子类，类的外层不能使用。

// 定义父类
class Person {
    private name: string = '小七';
    private age: number = 22;
    private eat(): void {
        console.log(this.name + "吃薯片"); // 类的内部使用
    };
    private action(): void {
        this.eat(); // 类的内部使用
    }
}

// 定义子类
class Son extends Person {
    constructor() {
        super();
        console.log(this.name); // 子类中使用  --报错
        this.eat(); // 子类中使用  --报错
    };
}

let s1 = new Son();
console.log(s1.name); // 类的外部使用  --报错
s1.eat(); // 类的外部使用  --报错

static静态成员

static 静态成员，只能通过类本身使用，不能通过实例对象使用。（静态属性名应大写）

// static静态成员
class Tils {
    // 静态属性
    static PI: number = Math.PI;
    // 静态方法
    static getTime(time: string): number {
        console.log(this.PI); // 3.14...
        return new Date(time).getTime();
    }
}
let tils = new Tils();
console.log(tils.PI); // 通过实例对象使用  --报错

console.log(Tils.PI); // 3.14...
console.log(Tils.getTime('2023/01/01'));

public 和 protected 修饰的静态成员可以被继承。

// 定义父类
class A {
    public static NAME: string = '小七';
    protected static AGE: number = 18;
    public static eat(): void {
        console.log(this.NAME);
    };
}

// 定义子类
class B extends A {
    static getName(): void {
        console.log(B.NAME);
    }
}
A.eat(); // 小七
B.getName(); // 小七
console.log(B.NAME); // 小七
console.log(B.AGE); // 受保护的，不能在外部使用  --报错

abstract抽象类 

abstract 抽象类提供其他类的继承基类，不能直接被实例化。抽象类中用关键字 abstract 去定义抽象属性和抽象方法

抽象类不能被实例化，只能被子类继承。

抽象类中包含抽象方法/属性和实例方法/属性。

抽象类中的抽象方法/属性不能有具体实现。

抽象类中的实例方法/属性可以被子类正常使用。

子类继承父类的抽象方法/属性必须在子类中有具体实现。

// 定义abstract父类
abstract class Person {
    abstract age: number; // 抽象属性 （一般不用，在子类中还要实现）
    abstract getAge(): number; // 抽象方法
    
    name: string = '小七'; // 实例属性
    getName(): void { // 实例方法
        console.log('我是' + this.name);
    };
}

// 定义子类
class Son extends Person {
    age: number = 22;
    getAge(): number {
        return this.age;
    }
}

let s1 = new Son();
console.log(s1.name); // 小七
s1.getName(); // 我是小七
console.log(s1.getAge()); // 18

TypeScript 教程——阮一峰·著

TypeScript 中文网

TypeScript 官网