TypeScript-类

发表于 | 分类于 | 本文总阅读量 次
TypeScript类的定义、继承、修饰符、静态方法、静态属性、抽象类、多态

类的定义

class 关键字，constructor 构造函数

1
2
3
4
5
6
7
class Person {
  name: string;

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

类的继承

extends 关键字，super 调用父类方法

1
2
3
4
5
class Student extends Person {
  constructor(name: string) {
    super(name);
  }
}

修饰符

  • private 只能在当前类中访问
  • protected 在当前类和子类中访问
  • public 在任何地方访问

get ， set 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Person {
  private _name: string;

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

  get name(): string {
    return this._name;
  }

  set name(value: string) {
    this._name = value;
  }
}
const p: Person= new Person('小明');
p.name = '小陈';

静态方法，静态属性

static 关键字

1
2
3
4
5
6
7
8
9
class Person {
  public static age: number = 20;

  static Print(): void {
    console.log(`age is ${Person.age}`);
  }
}

Person.Print();

抽象类

abstract 关键字 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 抽象类， 不能被实例化
abstract class Animal {
  projected name: string;

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

  abstract eat(): void; // 抽象方法
}
// 子类必须实现抽象类的抽象方法
class Dog extends Animal {

  constructor(name: string) {
    super(name);
  }

  // 实现抽象方法
  eat(): void {
    console.log(`${this.name}正在吃狗粮`);
  }
}

多态

父类定义一个方法不去实现，让继承它的子类去实现 每一个子类有不同的表现 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 抽象类， 不能被实例化
abstract class Animal {
  projected name: string;

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

  abstract eat(): void; // 抽象方法
}
// 子类必须实现抽象类的抽象方法
class Dog extends Animal {

  constructor(name: string) {
    super(name);
  }

  // 实现抽象方法
  eat(): void {
    console.log(`${this.name}正在吃狗粮`);
  }
}

class Cat extends Animal {

  constructor(name: string) {
    super(name);
  }

  // 实现抽象方法
  eat(): void {
    console.log(`${this.name}正在抓老鼠`);
  }
}

let f: Animal; // 声明变量为Animal类型
f = new Cat('Tom');
f.eat();
0%