TypeScript | 类 Class

·  阅读 336
TypeScript | 类 Class

类描述了所创建的对象共同的属性和方法。通过 class 关键字声明一个类,主要包含以下模块:

  • 属性
  • 构造函数
  • 方法

属性和方法

使用 class 定义类,使用 constructor 定义构造函数。

通过 new 生成新实例的时候,会自动调用构造函数。

class Animal {
  public name;
  constructor(name) {
      this.name = name;
  }
  sayHi() {
      return `My name is ${this.name}`;
  }
}

let a = new Animal('Jack');
console.log(a.sayHi()); // My name is Jack
复制代码

存取器

TypeScript支持通过getters/setters来截取对对象成员的访问。 它能帮助你有效的控制对对象成员的访问。

class Animal {
  constructor(name) {
    this.name = name;
  }
  get name() {
    return 'Jack';
  }
  set name(value) {
    console.log('setter: ' + value);
  }
}

let a = new Animal('Kitty'); // setter: Kitty
a.name = 'Tom'; // setter: Tom
console.log(a.name); // Jack
复制代码

类的继承与重写

使用 extends 关键字实现继承,子类中使用 super 关键字来调用父类的构造函数和方法。这样可以抽出公共部分让子类复用。

重写就是子类可以重新编写父类里边的代码。

class Animal {
    name: string;
    constructor(theName: string) { this.name = theName; }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

class Snake extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 5) {
        console.log("Slithering...");
        super.move(distanceInMeters);
    }
}

class Horse extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters);
    }
}

let sam = new Snake("Sammy the Python");
let tom: Animal = new Horse("Tommy the Palomino");

sam.move();
tom.move(34);
复制代码

访问修饰符

public

public 修饰的属性或方法是公有的,在程序类的内部和外部都可以访问。类的成员全部默认为 public

class Animal {
  public name;
  public constructor(name) {
    this.name = name;
  }
}

let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom';
console.log(a.name); // Tom
复制代码

private

private 修饰的属性或方法是私有的,不能在声明它的类的外部访问,只能被类的内部访问,在子类中也不允许访问。

当构造函数修饰为 private 时,该类不允许被继承或者实例化:

protected

protected 修饰的属性或方法是受保护的,只能被类的内部以及类的子类访问。

class Animal {
  protected name; 
  public constructor(name) {
    this.name = name;
  }
}
class Cat extends Animal {
  constructor(name) {
    super(name);
    console.log(this.name); // name 在子类中允许访问
  }
}
复制代码

当构造函数修饰为 protected 时,该类允许被继承,不允许被实例化:

readonly

通过 readonly 关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。

静态方法

使用 static 修饰符修饰的方法称为静态方法,它们不需要实例化,而是直接通过类来调用,类的实例无法访问:

静态方法调用同一个类中的其他静态方法,可使用 this 关键字:

class StaticMethodCall {

  static staticMethod() {
      return 'Static method has been called'
  }
  
  //静态方法中的 this 指向类本身,而静态方法也存在于类本身
  //所以可以在静态方法中用 this 访问在同一类中的其他静态方法
  static anotherStaticMethod() {
      return this.staticMethod() + ' from another static method'
  }
}
复制代码

非静态方法中,不能直接使用 this 关键字来访问静态方法。而要用类本身或者构造函数的属性来调用该方法:

class StaticMethodCall {
  constructor() {
      // 类本身调用
      console.log(StaticMethodCall.staticMethod())

      // 构造函数的属性调用
      console.log(this.constructor.staticMethod())
  }
  static staticMethod() {
      return 'static method has been called.'
  }
}
复制代码

类指向其构造函数本身,在非静态方法中,this.constructor === StaticMethodCall 为 true

抽象类

abstract 用于定义抽象类、抽象类内部定义抽象方法。

抽象类不允许被实例化,抽象类中的抽象方法必须被子类实现

抽象类中的抽象方法被子类实现后不报错了

把类当做接口使用

class Point {
    x: number;
    y: number;
}

interface Point3d extends Point {
    z: number;
}

let point3d: Point3d = {x: 1, y: 2, z: 3};
复制代码

总结

  • 类指向其构造函数本身。
  • 静态方法存在于类本身上面而不是类的实例上。
  • 抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
  • TypeScript 新增了 public、protected、private 等访问修饰符。
  • 子类继承父类时,在其构造函数 constructor() 中不要忘了 super() 方法。

学习链接

分类:
前端
标签:
分类:
前端
标签:
收藏成功!
已添加到「」, 点击更改