类中的访问类型和构造器

访问类型

1. private 私有
2. protected 受保护的
3. public 公众的

public

// public 允许我在类的内外被调用
class Person {
  // @ts-ignore
  public name: string;
  public sayHi() {
    console.log('hi', this.name) // hi cos
  }
}
const person1 = new Person();
person1.name = 'cos';
console.log(person1.name); // cos
person1.sayHi();

private

// private 允许在类内使用
class Person {
  // @ts-ignore
  private name: string;
  public sayHi() {
    console.log('hi', this.name) // hi undefined
  }
}
const person1 = new Person();
person1.sayHi();

在类外使用就回报错，如下图所示：

protected

允许在类内使用
// protected 允许在类内及继承的子类中使用
class Person {
  // @ts-ignore
  protected name: string;
  public sayHi() {
    console.log('hi', this.name)
  }
}
class Teach extends Person {
  public sayBye() {
    return this.name
  }
}
const person1 = new Person();
person1.sayHi();

构造器 constructor

当我们初始化一个类，我想给一个属性赋值的时候，传统的写法就是先定义一个属性，然后在构造器里面对属性赋值。

// 现在定义了一个名字为name的string，但是现在并不知道name的值是什么。
// 那么我们在创建实例的时候给name赋一个值
class Person {
  public name: string;
  // 在new一个实例的瞬间，constructor 函数就会执行 
  constructor(name: string) {
    this.name = name;
  }
}
const p = new Person('cos');
console.log(p.name); // cos

我们可以简化成下面写法：

class Person {
  constructor(public name: string) {}
}
const p = new Person('cos');
console.log(p.name); // cos

也就是说在ts中，如果在构造器中接受一个参数，
那么在参数前面添加 public ,
就等价于，首先在类里面定义一个属性，然后再在构造器里面给属性赋值。
这是一种简化的语法，我们更加倾向这种写法。

父类有构造器，子类也要声明构造器的时候，子类要手动调用一下父类的构造器
super 指的是父类 那么super() 则表示调用父类的构造函数¸

class Person {
  constructor(public name: string) {}
}
class Man extends Person {
  // 子类中实际上是可以这样去继承到父类的name属性，但是我们不会这么用了
  // sayHi() {
  //   this.name
  // }
  constructor(public age: number) {
    super('cos')
  }
}
const man = new Man(28);
console.log(man.name); // cos
console.log(man.age); // 28

父子继承的时候，如果在子类中写了constructor， 那么必须调用super(‘对应的参数’)，并且传递父类构造器所需要的参数
即便是父类中没有constructor，我们也需要在子类中调用一下空的 super()，否则也会报错。