ES6-class类

类的声明方式

1.声明式
class A {}

2.匿名表达式
const A = class {}

3.命名表达式，A可以外部访问，A2只能在内部访问
const A = class A2 {}

4.立即执行
const A = new class {
  constructor(aName) {
    this.aName = aName
  }

  sayName() { return console.log(this.aName)}
}('A')
A.sayName() // A 

类必须使用new调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用new也可以执行。

constructor

实例属性

class A {
  // 与 constructor 中一样
  // constructor 如果没有显示定义则会隐式默认添加一个空的 constructor
  hobby = ['唱', '跳', '篮球', 'rap']

  constructor() {
    // 定义类的实例属性
    this.aName = 'A'
  }
}

继承 extends

class B extends A {
  constructor() {
    super(
      // ES6 要求，子类的构造函数必须执行一次 super 函数，否则会报错。
      // 代表 父类 A 构造函数 返回的 子类B 的实例
      // A.prototype.constructor.call(this)
    )
    // 再声明实例属性
    this.bName = 'B'
  }
  // 此时再 B 可访问 A 的实例属性
}

prototype

构造函数的prototype属性，在 ES6 的“类”上面继续存在。事实上，类的所有方法都定义在类的prototype属性上面。

class A {
  toValue() {} 

  toString() {}
}

等同于
A.prototype = {
  toValue = {}
  toString = {}
}

static 静态方法 静态属性（提名）

加上 static 关键字表示该方法不会被实例继承 再能通过类直接调用(A.getName())
但是会被子类继承
如果静态方法中包含 this 则指向当前类 而不是实例
普通方法内不能调用静态方法 再静态方法内可以调同样是静态方法
且静态方法可以与普通方式同名

静态属性只能再静态方法内访问

class A {

  static introduction = '练习时长两年半'

  constructor() {
    this.hobby = '唱，跳，rap，篮球'
  }

  static getHobby () {
    console.log(this.hobby, this.introduction)
  }
}

const newA = new A()
newA.getHobby()  // TypeError: newA.getHobby is not a function

A.getHobby() // undefined 练习时长两年半

class B extends A {
  constructor() {
    super()
  }
}

B.getHobby() // undefined 练习时长两年半

私有属性 私有方法

私有属性和私有方法 是指只能在类的内部访问的属性和方法
在外部不能访问
实例可以通过 get set 方法访问

class A {
  #hobby = '唱，跳，rap，篮球'

  get value () {
    console.log('get', this.#hobby)
    return this.#hobby
  }

  set value (value) {
    this.#hobby = value
  }
}

class B extends A {
  constructor() {
    super()
  }
}

A.#hobby  // SyntaxError: Private field '#hobby' must be declared in an enclosing class

const newB = new B()
newB.value = '练习时长两年半' // set 
newB.value  // get 练习时长两年半

继承 extends

通过 extends 关键字来实现继承
继承父类的所有属性和方法

class A {}

class B extends A {
  1. 子类必须在 constructor 方法中调用 super 否则创建子类实例时会报错
  2. 这是因为子类自己的this对象 必须先通过父类的构造函数完成塑造 得到与父类同样的实例属性和方法 
     然后再对其进行加工 加上子类自己的实例属性和方法 如果不调用super方法 子类就得不到this对象
  constructor(x,y ) {
    super(
      x, y
      // Parent.apply(this)
    )
  }
}