类的关系

继承

1. Class对象的子类继承父类的所有属性和方法。
2. 子类可以通过改写覆盖从父类继承的属性和方法，但不会对父类产生影响。
3. 多个实例间可以互相影响吗：

//Class对象的继承可以使用extends关键字来完成。以下是一个示例：
// 父类
class Animal {
  constructor(name) {
    this.name = name;
  }

  makeSound() {
    console.log("Generic animal sound");
  }
}
// 子类
class Dog extends Animal { 
  makeSound() {
    console.log("Bark!");
  }
}
const myDog = new Dog("Fido");
console.log(myDog.name);
myDog.makeSound();

实例属性与静态属性

class Animal {
  static numberOflegs = 4; // 静态属性

  constructor(name) {
    this.name = name; //实例属性
  }
}

1. 静态属性定义在类本身上，而非实例或原型上

• 如何定义：Class对象的静态属性是使用static关键字定义在类本身上的属性。
• 如何访问：要访问 Class 对象的静态属性，你需要直接在类本身上引用该属性。在提供的示例中，可以通过调用 Dog.numberOflegs 来访问 numberOflegs 静态属性。

class Animal {
  static numberOflegs = 4; // 静态属性

  constructor(name) {
    this.name = name;
  }
}
class Dog extends Animal {
  makeSound() {
    console.log("Bark!");
  }
  printNumberOfLegs() {
    console.log(Animal.numberOflegs); // 通过类名访问父类静态属性
    console.log(this.constructor.numberOflegs); // 通过this.constructor访问父类静态属性
  }
}
const myDog = new Dog("Fido");
myDog.printNumberOfLegs();

• 是否可以修改：Class的静态属性是可以修改的。你可以通过类名或子类名对其进行修改。
• 类内部方法访问静态属性：通过this.constructor.yourStaticp

//静态方法可以通过`this.`访问静态属性
class Parent {
  static abc = 'myabc'
  getSome(){
    console.log('getSome', this.constructor.abc)
  }
  static getAbc(){
    console.log('getAbc', this.abc)
  }
}
Parent.getAbc() // 输出： getAbc, myabc
//实例方法可通过 this.constructor. 获取
const p = new Parent()
p.getSome() // 输出：getSome, myabc

• 子类可以访问父类的静态属性，通过super.yourStaticp访问, 如下示例：

class Animal {
  static numberOflegs = 4; // 静态属性

  constructor(name) {
    this.name = name;
  }
}
class Dog extends Animal {
  static newNumberOflegs = super.numberOflegs; // 访问父类的静态属性
  makeSound() {
    console.log(`我是新的静态${this.constructor.newNumberOflegs}`);
  }
}
const dog = new Dog('三花')
dog.makeSound()

• 子类的方法内部可以通过super.constructor访问父类的静态属性

class Parent{
    static abc = 'my abc'
}
class Child extends Parent {
    getSome(){
        console.log('Child', super.constructor.abc)
    }
}
const c = new Child()
c.getSome() // undefined

• 子类的静态方法内部可以通过super.访问父类的静态属性

class Parent {
  static abc = 'myabc'
}
class Child extends Parent {
  static childabc = 'childabc'
  static getAbc(){
    console.log('Child-getAbc-parent', super.abc)
    console.log('Child-getAbc-my', this.childabc)
  }
}
Child.getAbc() // 输出： `Child-getAbc-parent, myabc`   `Child-getAbc-my, childabc`

• 静态方法不可以访问实例属性和类的其他方法

2. Class对象的实例属性是通过构造函数中使用this关键字来创建的属性。在给实例对象赋值时，使用点语法将属性与实例对象关联起来。例如，在以下代码中，通过构造函数中的this.name = name;创建了name属性，同时将其与myAnimal实例对象关联起来：const myAnimal = new Animal("Rex"); console.log(myAnimal.name); // "Rex"
   因此，在该代码中，name是Animal类的实例属性。

• Class对象实例是通过使用new关键字来实例化类的对象。
• 类的方法（除静态方法）可以通过this.contructor.来访问类的静态属性和静态方法

class P {
  static abc='my abc'
  static getAbc(){
    console.log('getAbc-static')
  }
  getSome(){
    this.constructor.getAbc()
    console.log('getSome', this.constructor.abc)
  }
}
const p = new P()
p.getSome()// 输出：`getAbc-static`  `getSome, my abc`

super

1. 子类可以在其构造函数中使用super()函数来调用其父类的构造函数并注入属性
2. 只能用于子类，super()只能在子类的构造函数内调用，返回的是子类的实例，super()执行中this是指向子类的

class Parent {
  getSome(){}
}
class Child extends Parent {
  constructor(){
    super() //正确调用
  }
  getSome(){
    super() // 报错
  }
}

3. 作为对象时：super指向父类的原型

• 子类的方法内部不可以访问父类的实例属性
• 使用super.对属性赋值时,super指向子类的this

class P {
  abc='12'
}
class Child extends P {
  constructor(){
    super()
    super.ca = '321'
    console.log(super.ca) //undefined
    console.log(this.ca) // '321'
  }
}

4. 子类的方法中可以通过super. 访问父类的方法,但不能访问父类的属性：Class对象的方法是保存在原型上，而属性是保存在类实例上(除静态属性)