Class（类）类的简介 ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过cl

类的简介

ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。其中包含两个部分：属性、方法。

定义属性

1.直接定义的属性是实例属性，通过对象的实例去访问

const per = new Person()
per.name // '八戒'

2.通过static开头的属性是类属性（静态属性），可以通过类直接访问

Person.age

通过readonly开头的属性是只读属性，无法修改

定义方法

如果方法名前加static，则是类方法，不加static，则是实例方法

示例：

class Person{
  // 实例属性
  name: string = '八戒'
  // 类属性（静态属性）
  static age: number = 12
  // 只读属性
  readonly sex: number = 1

  // 类方法
  static sayHello() {
    console.log('你好')
  }
  // 实例方法
  sayHi() {
    console.log('hi')
  }
}
  const per = new Person()
  per.name            // 八戒
  per.sex             // 1
  per.sayHi()         // 'hi'

  Person.sayHello()   // '你好'
  Person.age          // 12

类的构造函数 constructor()

constructor() 方法被称为构造函数，是类的默认方法，通过new命令生成对象实例时自动调用。一个类必须有 constructor() 方法，如果没有显式定义将会被默认添加

class Dog{
  name: string
  age: number
  constructor(name: string, age: number) {
    // this表示当前的实例
    this.name = name
    this.age = age
  }
  sayHi() {
    alert(this.name)
  }
}
const wangcai = new Dog('旺财', 12)
const aQi = new Dog('阿奇', 13)
wangcai.sayHi()         // '旺财'
aQi.sayHi()             // '阿奇'

类的继承 extends

继承后，子类将拥有父类的所有属性和方法
通过继承，可以将多个相同代码写在一个类中
如果子类和父类中有相同的方法，子类将覆盖所继承父类的方法

class PublicClass{
  name: string
  age: number
  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
  sayHello() {
    console.log('动物在叫')
  }
}
// 继承 PublicClass类 的属性和方法
class DogClass extends PublicClass{
  sayHello() {
    console.log(`${this.age}的${this.name}在叫汪汪汪！`)
  }
}
// 继承 PublicClass类 的属性和方法
class CatClass extends PublicClass{
  sayHello() {
    console.log(`${this.age}的${this.name}在叫喵喵喵!`)
  }
}

const dog = new DogClass('旺财', 13)
const cat = new DogClass('咪咪', 12)
console.log(dog, cat)

dog.sayHello() // 13的旺财在叫
cat.sayHello() // 12的咪咪在叫

Description

类的 super 关键字

在类的方法中，super就是当前类的父类
如果在子类中写了构造函数，那么在子类构造函数中必须对父类的构造函数调用

class PublicAnimal{
  name: string
  constructor(name: string) {
    this.name = name
  }
  sayHello() {
    console.log('我是父类的方法')
  }
}
class Pig extends PublicAnimal{
  age: number
  constructor(name: string, age: number) {
    // 如果在子类中写了构造函数，那么在子类构造函数中必须对父类的构造函数调用
    super(name)
    this.age = age
  }

  sayHello(){
    // 在类的方法中，super就是当前类的父类 
    super.sayHello()
  }
}

const Peiqi = new Pig('佩奇', 12)
//  这里调用的sayHello方法，其实是父类的方法
Peiqi.sayHello()   // 我是父类的方法

抽象类 abstract 关键字

抽象类：以abstract开头的类为抽象类

抽象类和其他类差不多，只是不能用来创建对象
抽象类就是专门用来继承的类
抽象类中可以添加抽象方法，是用来约束子类的，必须对父类的抽象方法重写

抽象方法：

抽象方法只能写在抽象类中
依然是用abstract开头，创建方法，只是没有函数体和返回值
子类中必须对父类的抽象方法进行重写

// 定义一个抽象类
abstract class Animal{
  name: string
  constructor(name: string) {
    this.name = name
  }
  abstract sayHello(): void
}
class Chicken extends Animal{
  age: number
  constructor(name: string, age: number) {
    // 如果在子类中写了构造函数，那么在子类构造函数中必须对父类的构造函数调用
    super(name)
    this.age = age
  }

  sayHello(){
    // 抽象方法
    console.log('抽象方法：这里对父类的抽象方法进行了重写')
  }
}

const xiaoji = new Chicken('小鸡', 12)
xiaoji.sayHello() // '抽象方法：这里对父类的抽象方法进行了重写'

当然这只是一最最最基础的知识，革命尚未成功，壮士仍需努力。活到老学到老！