类

示例

class Greeter {
  greeting: string;
  constructor(greeting: string) {
    this.greeting = greeting;
  }
  greet() {
    return 'Hello' + this.greeting;
  }
}
const greeter = new Greeter('typescript');

类继承

关键字：extends 继承父类，super 代表父类

class Animal {
  name: string;
  constructor(n: string) {
    this.name = n;
  }
  run(step: number = 10) {
    console.log(`${this.name}run${step}m...`);
  }
}
class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }
}
class Horse extends Animal {
  constructor(name: string) {
    super(name);
  }
  run() {
    super.run();
    console.log('horse runing');
  }
}
const dog = new Dog('哈士奇');
dog.run();
// 可以指定父类
const horse: Animal = new Horse('赤兔');
horse.run();

封装

修饰属性或者方法、构造方法

public

默认，所有地方都可以访问

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  setName(name: string) {
    this.name = name;
  }
}
class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }
  setPName(name: string) {
    super.setName(name);
  }
}
let animal = new Animal('旺财');
// 可以自由访问
console.log(animal.name);
let dog = new Dog('二哈');
console.log(dog.name);

protect

只能在类或者子类中才能访问或方法 给类加 protectd 可以限制父类被创建实例

class Animal {
  protected name: string; // 只能在类或者子类中才能访问
  constructor(name: string) {
    // 如果加protected，只能在子类调用构造方法
    this.name = name;
  }
}
class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }
}
let animal = new Animal('旺财');
// error:属性“name”受保护，只能在类“Animal”及其子类中访问
console.log(animal.name);
let dog = new Dog('二哈');
// error:属性“name”受保护，只能在类“Animal”及其子类中访问
console.log(dog.name);

private

类中才能访问

class Animal {
  private name: string; // 只能在类或者子类中才能访问
  constructor(name: string) {
    // 如果加protected，只能在子类调用构造方法
    this.name = name;
  }
}
class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }
}
let animal = new Animal('旺财');
// error:属性“name”为私有属性，只能在类“Animal”中访问
console.log(animal.name);
let dog = new Dog('二哈');
// error:属性“name”为私有属性，只能在类“Animal”中访问
console.log(dog.name);

readonly:

只读属性

class Cat {
  private name: string;
  readonly color: string;
  constructor(name: string, color: string) {
    this.color = color;
    this.name = name;
  }
}
let cat = new Cat('黑猫警长', 'black');
// error:无法分配到 "color" ，因为它是只读属性。
cat.color = 'red';

存取器 get/get

class Employee {
  private _fullName: string;
  private _setable: boolean;
  constructor(_fullName: string, setable: boolean) {
    this._fullName = _fullName;
    this._setable = setable;
  }
  get fullName(): string {
    return this._fullName;
  }
  set fullName(fullName: string) {
    if (this._setable) {
      this._fullName = fullName;
    } else {
      console.error('不支持修改');
    }
  }
}
const e1 = new Employee('李狗蛋', false);
e1.fullName = '吴彦祖';
const e2 = new Employee('张翠华', true);
e2.fullName = '汤唯';

static 静态属性、方法

class Student {
  static grade = 2;
  constructor() {}
  static study() {
    console.log(Student.grade);
  }
}

抽象类和抽象方法 abstract

抽象类不能用于创建实例
抽象方法和接口定义方法类似
也可以加修饰符 protected

abstract class Animal {
  constructor() {}
  // 方法“run”不能具有实现，因为它标记为抽象
  abstract run(): void;
  eat() {
    console.log('eat');
  }
}
class Dog extends Animal {
  run() {
    console.log('run');
  }
  sleep() {}
}
var dog = new Dog();
dog.run();
// 无法创建抽象类的实例
// var a = new Animal()
var dog2: Animal = new Dog();
// 类型“Animal”上不存在属性“sleep”
// dog2.sleep()

高级技巧

class Greeter {
  static defaultMsg = '你好！';
  greeting: string | undefined;
  constructor(msg?: string) {
    this.greeting = msg;
  }
  greet() {
    if (this.greeting) {
      return 'hello' + this.greeting;
    } else {
      return Greeter.defaultMsg;
    }
  }
}
const g = new Greeter('hahhah');
console.log(g.greet());
// 修改构造器的静态属性
let GreeterMaker: typeof Greeter = Greeter;
GreeterMaker.defaultMsg = 'miximixi';
const g2: Greeter = new GreeterMaker();
console.log(g2.greet());
const g3 = new Greeter();
console.log(g3.greet());