关于class类的总结

类的简介

代码在这里运行：https://www.typescriptlang.org/zh/play
使用class关键字来定义一个类
主要包含两个内容

• 属性

  • 直接定义的属性是实例属性，需要通过对象的实例去访问
  • 使用static开头的属性是静态属性（类型），可以直接通过类去访问
  • 使用readonly开头的属性表示一个只读的属性无法修改（仅在ts中使用）

• 方法

  • 在类上可执行的函数

  // 实例属性
  class Person {
    name = 'sb';
    // 方法
    age = 22
  }
  
  const per = new Person()
  console.log(per.name, per.age) // sb, 22
  
  // 静态属性
  class Person {
    static name = 'sb';
    // 方法
    age = 22
  }
  
  const per = new Person()
  console.log(Person.name, Person.age) // sb,  undefined
  console.log(per.name, per.age) // undefined, 22
  
  // 只读属性
  class Person {
    readonly name: string = 'sb';
    // 方法
    age = 22
  }
  
  const per = new Person()
  per.age = 23
  per.name = 'dsb' // ts类型检测会告诉你不可以修改，因为是只读的
  
  

  构造函数

• constructor被称为构造函数，构造函数会在对象创建时调用
• 在实例方法中，this就表示当前的实例
• 在构造函数中当前对象就是当前新建的那个对象
• 可以通过this向新建的对象中添加属性

class  Dog {
    name: string;
    age: number;
    constructor(name: string, age: number) {
        this.name = name,
        this.age = age
    }

    bark(){
        alert('汪汪汪！！');
        console.log(this.name);
    }
}
const dog = new Dog('sb', 3)
console.log(dog) // Dog{name: 'sb', age: 3}
dog.bark() // 汪汪汪， sb

继承

• 简单来说，就是子类通过extends可以使用父类的所有内容，并可扩展
• 遵循OCP原则，对扩展开放，对修改关闭

// 定义一个Animal类
class Animal{
    name: string;
    age: number;
    constructor(name: string, age: number){
        this.name = name;
        this.age = age;
    }

    sayHello(){
        console.log('Animal在叫!!!');
    }
}
// 造一只狗
// 此时，Animal被称为父类，Dog被称为子类
// 使用继承后，子类将会拥有父类所有的方法和属性
// 通过继承可以将多个类中共有的代码写在一个父类
// 这样只需要写一次即可让所有的子类都同时拥有父类中的属性和方法

class Dog extends Animal{}
const dot = new Dog('sb', 3)
console.log(dot) // Dog{name: 'sb', age: '3'}
dot.sayHello() // animal在叫

重写父类方法

// 如果子类中添加了和父类相同的方法，则子类方法会覆盖掉父类的方法
//这种子类覆盖掉父类方法的形式，我们称为重写
class Dog extends Animal{
    sayHello(){
        console.log('汪汪汪!!');
    }
    run(){
        console.log(`${this.name}在跑~~`);
    }
}
const dot = new Dog('sb', 3)
dot.sayHello() // 汪汪汪!!
dot.run() // sb 在跑

super

• 如果在子类中写了构造函数，在子类构造函数中必须对父类的构造函数进行调用

class Animal{
    name: string;
    constructor(name: string){

        this.name = name;
    }
    sayHello(){
        console.log('在叫~~')
    }
}

class Dog extends Animal{

    age: number

    constructor(name: string, age: number){
        //如果在子类中写了构造函数，在子类构造函数中必须对父类的构造函数进行调用
        super(name)//调用父类的构造函数
        this.age = age
    }

    sayHello() {
        console.log('汪汪汪~~')
    }
    sayFather() {
        // 在类的方法中 super就表示当前类的父类
        super.sayHello()
    }
}

const dog = new Dog("sb", 3)
dog.sayHello() // 汪汪汪
dog.sayFather() // 在叫

抽象类

• 以abstract开头的类是抽象类
• 抽象类和其他类区别不大，只是不能用来创建对象
• 抽象类就是专门用来被继承的类
• 抽象类中可以添加抽象方法

abstract class Animal{
    name: string;
    constructor(name: string){

        this.name = name;
    }

    // 定义一个抽象方法
    // 抽象方法使用abstract开头，没有方法体
    // 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
    abstract sayHello():void;
}

class Dog extends Animal{

    sayHello() {
        console.log('汪汪汪~~')
    }
}
const dog = new Dog("SB");
dog.sayHello() // 汪汪汪

//const an = new Animal() // ts检测会告诉你无法创建抽象类的实例