类 class

基础栗子和继承

// 基础栗子
class Hello {
  hello: string

  constructor(msg: string) {
    this.hello = msg
  }

  sayHi() {
    return this.hello + ' you'
  }
}

const ins1 = new Hello('hi')

const res1 = ins1.sayHi()

console.log(res1);

// 继承
class Animal {
  move(who: string) {
    console.log(`${who} move!`);
  }
}

class Dog extends Animal {
  eat() {
    console.log('dog eat');
  }
}

const dog1 = new Dog()
dog1.eat()
dog1.move('gogo')

console.log('------');


// 包含构造函数的派生类
/**
 * 1. 派生类包含构造函数 constructor 必须调用 super() ，而且在构造函数使用this之前必须调用 super()
 * 2. 派生类重写基类的方法，会覆盖基类的方法
 */
class Animal2 {
  name: string

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

  move(long: number) {
    console.log(long + 'm' + ' from Animal2; name: ' + this.name);
  }
}

class Dog2 extends Animal2 {
  constructor(name: string) {
    super(name)
  }

  move() {
    console.log('dog2 move');
    super.move(23)
  }
}

const dog2 = new Dog2('benben')
dog2.move()

公共 私有 受保护 的修饰符

• public 默认值

• private 不能在声明类的外部访问

• protected 不能在声明类的外部访问，可以在派生类中访问

抽象类

/**
 * 1 抽象类作为派生类的基类使用
 * 2 一般不会被直接实例化
 * 3 不同于接口，可以包含成员的实现细节
 * 4 抽象类中的抽象方法不包含具体实现，但必须在派生类中实现
 * 5 抽象方法必须包含 abstract 关键字，可以包含访问修饰符(private protected)
 */

abstract class Department {
  constructor(public name: string) {
    this.name = name
  }

  sayHi() {
    console.log('hi you.')
  }

  // 必须在派生类中实现
  abstract getName(): string; 
}

class Ant extends Department {
  constructor() {
    super('ant')
  }

  getName(): string {
    return this.name
  }

  getSth(): string {
    return 'something'
  }
}

// company: Department 对抽象类型的引用
const company: Department = new Ant() // 抽象子类实例化
const cName = company.getName()
console.log(cName); // ant

// const sth = company.getSth() // 类型“Department”上不存在属性“getSth”