类的定义与继承

类

class Person {
  name = 'yang';
  getName() {
    return this.name;
  }
}

const person = new Person();
console.log(person.getName());

类的继承

class Person {
  name = 'yang';
  getName() {
    return this.name;
  }
}

class Teacher extends Person {
  getTeacherName() {
    return 'Teacher'
  }
}

const teacher = new Teacher();
console.log(teacher.getName());
console.log(teacher.getTeacherName());

重写，子类可以重写父类的方法和属性

class Teacher extends Person {
  getTeacherName() {
    return 'Teacher'
  }
  getName(){
    return 'LEE'
  }
}

子类里，如果重写了父类的方法后，如果还想调用父类的方法，通过super

class Teacher extends Person {
  getTeacherName() {
    return 'Teacher'
  }
  // 子类中 super 就相当于父类
  getName(){
    return super.getName() + 'guang';
  }
}

类的访问类型 private,protected,public访问类型

• Public 公共属性，允许我在类的内外被调用； 默认情况下，我们是没有给类的属性和方法，指定访问类型的。这个时候这些属性和方法是有默认的访问类型的public，只不过是隐藏的。

class Person {
  name: string;
  sayHi() {
    console.log('hi');
  }
}

const person = new Person();
person.name = 'yang';
console.log(person.name);  // yang
person.sayHi();  // hi

• private 私有属性，允许在类内被使用；类外(包括子类)不能访问；

class Person {
  private name: string;
  sayHi() {
    console.log(this.name);
  }
}

class Teacher extends Person {
  getTeacherName() {
    // 属性“name”为私有属性，只能在类“Person”中访问。这里会报错
    console.log(super.name);
  }
}

• protected允许在类内及继承的子类中使用；

class Person {
  protected name: string;
  public sayHi() {
    console.log(this.name);
  }
}

class Teacher extends Person {
  public  getTeacherName() {
    console.log(super.name);
  }
}

构造器 constructor,会在类被实例化的时候，自动执行。也就是new一个实例的时候。

• 通常我们会在构造器里给类的属性赋值。

class Person {
  public name: string;
  // 类被实例化的时候，会被执行
  constructor(name:string) {
    this.name = name;
  }
}

const person = new Person('yang');
console.log(person.name);  // yang

• 给类的属性赋值，除了构造器里，还有更简单的方法。在TS里，如果直接在构造器里接收一个参数，并且在参数前边跟一个public。就等价于先定义一个属性，并在构造器里给属性赋值。

class Person {
  // public name: string;
  constructor(public name:string) {
    // this.name = name;
  }
}

const person = new Person('haha');
console.log(person.name); // haha 

当父类有构造器，同时子类也有构造器的时候，必须在子类构造器里调用super方法，同时把父类构造器的参数传进去。

class Person {
  constructor(public name: string) { };
}

class Teacher extends Person {
  constructor(public age: number) {
    // super()  意思就是调用父类的构造器
    // 调用父类的构造函数，同时把父类构造器的参数传进来
    super('yang');
  }
}

const teacher = new Teacher(28);
console.log(teacher.name);  // yang
console.log(teacher.age);  // 28

子类内部如果有构造器，必须调用一下super()，即使父类内部没有构造器

class Person {

}

class Teacher extends Person {
  constructor(public age: number) {
    // 父组件没有构造器的情况下，子组件有构造器的话，也要调用super,只不过super的参数为空。
    super()  
  }
}

类里的Getter和Setter

• Getter的写法; 通过get访问的时候，不带括号

class Person {
  constructor(private name: string) { }
  get getName() {
    return this.name;
  }
}

const person = new Person('yang');
console.log(person.getName);

// Person 类定义了一个私有属性name，在类外是不能访问的
// 如果想访问，就要通过变通的方法，写一个get 然后把name 返回出去
// 这样就可以在Person 类外，通过get访问name了。

• Getter通常用来对属性进行加工，比如加密之类的，从而确保内容的安全性。
• 当然，私有属性的写法，通常是前边加一个下划线。而get通过是不加下划线的属性名

class Person {
  constructor(private _name: string) { }
  get name() {
    return this._name;
  }
}

const person = new Person('yang');
console.log(person.name);

• Setter 也可以用来保护私有变量

class Person {
  constructor(private _name: string) { }
  get name() {
    return this._name;
  }
  set name(name: string) {
    this._name = name;
  }
}

const person = new Person('yang');
// 通过set 修改私有属性 _name的值
person.name = 'hello';

static 静态属性;会挂载到类本身，而不是类创建的实例上。

• 写个单例模式的例子；（单例模式：只能创建一个实例）

class Demo {
  // instance是一个挂载到Demo类上的私有属性，只能在Demo类内访问，用来承载Demo类的实例。
  private static instance: Demo;
  // constructor被定义为私有属性，不能在类外调用。也就是不能 在类外 new Demo()
  private constructor(public name:string) { };
// getInstance是挂载到Demo类上的私有方法，用来判断，instance是否已经赋值，如果是，就返回这个实例。否则就创建一个实例。
  static getInstance() {
    if (!this.instance) {
      this.instance = new Demo('yang');
    }
    return this.instance;
  }
}

const demo1 = Demo.getInstance();
const demo2 = Demo.getInstance();
// 这样的话，无论调用Demo.getInstance()多少次，获得的都是同一个实例
console.log(demo1.name);  // yang
console.log(demo2.name);  // yang

readonly 修饰符，用来限制一个 public的属性，只能读，不能改。

class Person {
  public readonly name: string;
  constructor(name: string) {
    this.name = name;
  };
}

const person = new Person('yang');
person.name = 'hello';
console.log(person.name); // yang

抽象类abstract：当很多类，有一些通性的东西的时候，就可以定义一个抽象类，把这些通性的东西定义出来。

// 下边3中类，都有一个通性，就是都有面积，就可以定义一个抽象类来获取面积
// 抽象类开头是 abstract
abstract class Geom {
  getArea(){}
}


// 圆形类
class circle {

}

// 方形类
class square {

}

// 三角形类
class triangle{

}

• 抽象类里，如果方法也是抽象的，定义抽象类的时候，也不知道具体怎么实现这个方法，那么也可以加一个abstract。只能定义一下这个方法，不能写具体的实现逻辑。

abstract class Geom {
  // 这个抽象方法，会返回一个数字
  abstract getArea():number
}

• 当然了抽象类里，也可以写一些具体的属性和方法，不一定非得是抽象的方法

abstract class Geom {
  with: number;
  getType() {
    return 'Gemo'
  }
  // 这个抽象方法，会返回一个数字
  abstract getArea(): number;
}

• 抽象类只能被继承，不能去实例化，也就是不能new抽象类；注意，子类在继承抽象类的时候，如果抽象类里有抽象方法，子类里必须要具体实现这个持续方法，否则会报错

class circle extends Geom{
  getArea() {
    return 123;
  }
}