abp-159，js最理想的继承——寄生组合式继承

寄生组合式继承 是 JavaScript 中一种理想的继承方式，它结合了构造函数继承和原型继承的优点，避免了两者的缺点。它主要通过创建一个继承自父类实例的中介对象，并且通过原型链继承父类的原型方法，从而实现了更高效的继承。

为什么寄生组合式继承是最理想的继承方式？

1. 避免了父类构造函数被多次调用：
   • 传统的构造函数继承（例如 经典继承）会导致子类构造函数中多次调用父类构造函数，造成性能浪费。而寄生组合式继承通过将父类构造函数的调用和子类构造函数分离，避免了这个问题。
2. 保留了原型链的正确性：
   • 通过使用原型继承，子类能够继承父类的方法，同时不会导致子类和父类共享同一个实例对象。
3. 没有继承父类的静态属性：
   • 因为采用了原型继承，所以父类的静态属性不会被继承到子类，避免了不必要的副作用。

实现原理：

1. 通过寄生的方式创建父类实例：首先，定义一个继承自父类实例的辅助函数（即“寄生”部分）。
2. 通过组合的方式将父类实例与子类的原型链连接起来：子类的原型被设置为寄生函数创建的父类实例。

寄生组合式继承的实现代码：

// 父类构造函数
function Animal(name) {
    this.name = name;
}

// 父类原型方法
Animal.prototype.sayHello = function() {
    console.log(`${this.name} says hello!`);
};

// 寄生组合式继承实现
function inheritPrototype(subClass, superClass) {
    // 创建一个父类实例并且使其指向父类原型
    const prototype = Object.create(superClass.prototype);
    prototype.constructor = subClass;  // 修复构造函数指向子类
    subClass.prototype = prototype;  // 将子类的原型指向新的对象
}

// 子类构造函数
function Dog(name, breed) {
    Animal.call(this, name);  // 调用父类构造函数
    this.breed = breed;
}

// 使用寄生组合式继承
inheritPrototype(Dog, Animal);

// 子类添加自己的方法
Dog.prototype.bark = function() {
    console.log(`${this.name} barks!`);
};

// 实例化子类
const dog = new Dog('Buddy', 'Golden Retriever');
dog.sayHello();  // 输出：Buddy says hello!
dog.bark();      // 输出：Buddy barks!

// 检查继承
console.log(dog instanceof Dog);     // true
console.log(dog instanceof Animal);  // true

解释：

1. Animal.call(this, name);
   • 子类构造函数中使用 call 方法显式地调用父类构造函数，从而实现父类属性的继承。此时，this指向子类实例。
2. inheritPrototype(Dog, Animal);
   • 该函数通过 Object.create(superClass.prototype) 创建一个新的对象，它的原型是父类的原型，这样就能够继承父类的原型方法。
   • 然后，我们修复 subClass.prototype.constructor 为 subClass，确保子类构造函数正确指向。
3. dog.sayHello(); 和 dog.bark();
   • sayHello 是从父类 Animal 继承的，而 bark 是 Dog 类定义的方法。
4. instanceof 检测：
   • dog instanceof Dog 返回 true，表示 dog 是 Dog 类的实例。
   • dog instanceof Animal 返回 true，表示 dog 是 Animal 类的实例。这个验证确保了通过寄生组合式继承，子类对象能正确继承父类的属性和方法。

寄生组合式继承的优缺点：

优点：

1. 效率高：避免了父类构造函数的重复调用。
2. 性能好：不需要通过 new 关键字重新实例化父类对象，因此性能上有明显提升。
3. 正确的原型链：确保了子类原型链指向父类的原型，继承方法正确。

缺点：

• 不能继承父类的静态属性：这种继承方式仅能继承父类的实例属性和方法，静态属性需要通过其他方法处理。
• 只能继承实例方法：静态方法和属性需要显式地通过其他方式复制到子类中。

总结：

寄生组合式继承是 JavaScript 中一种非常理想的继承方式，它通过组合的方式解决了经典继承和伪经典继承的缺点，并且保留了原型链的正确性和性能上的优势。在大多数情况下，寄生组合式继承比其他继承方式更为高效且具有更好的扩展性。

以下是 寄生组合式继承 的详细代码实现，包括解释和注释，帮助你更好地理解每个步骤。

寄生组合式继承的详细实现

1. 父类定义：
   • Animal 类定义了一个构造函数和一个原型方法 sayHello，子类将继承这个方法。
2. 继承机制：
   • 我们通过 Object.create() 创建一个父类原型的副本，并且修复子类原型的构造函数指向子类。
3. 子类定义：
   • Dog 类继承自 Animal，并且扩展了一个新的方法 bark。

详细代码：

// 1. 父类构造函数
function Animal(name) {
    this.name = name;  // 设置父类的属性
}

// 2. 父类的原型方法
Animal.prototype.sayHello = function() {
    console.log(`${this.name} says hello!`);
};

// 3. 寄生组合式继承的辅助函数
function inheritPrototype(subClass, superClass) {
    // 通过 Object.create 创建一个新对象，使其原型指向父类的原型
    const prototype = Object.create(superClass.prototype);
    
    // 修复子类构造函数指向
    prototype.constructor = subClass;

    // 让子类的原型指向新创建的对象
    subClass.prototype = prototype;
}

// 4. 子类构造函数
function Dog(name, breed) {
    // 调用父类构造函数
    Animal.call(this, name);  // 传递 name 参数到父类构造函数
    this.breed = breed;  // 子类新增的属性
}

// 5. 使用寄生组合式继承
inheritPrototype(Dog, Animal);

// 6. 子类添加自己的方法
Dog.prototype.bark = function() {
    console.log(`${this.name} barks!`);
};

// 7. 实例化子类对象
const dog1 = new Dog('Buddy', 'Golden Retriever');
const dog2 = new Dog('Max', 'Bulldog');

// 8. 调用方法，验证继承和扩展
dog1.sayHello();  // 输出：Buddy says hello!
dog1.bark();      // 输出：Buddy barks!

dog2.sayHello();  // 输出：Max says hello!
dog2.bark();      // 输出：Max barks!

// 9. 验证对象的继承关系
console.log(dog1 instanceof Dog);     // true
console.log(dog1 instanceof Animal);  // true
console.log(dog2 instanceof Dog);     // true
console.log(dog2 instanceof Animal);  // true

// 10. 验证子类实例和父类实例的方法
console.log(dog1.constructor === Dog);  // true
console.log(dog2.constructor === Dog);  // true

详细解析：

1. 父类 Animal：
   • Animal 是一个简单的构造函数，定义了 name 属性，并且在原型上定义了 sayHello 方法，表示 Animal 实例可以说 “Hello”。
2. inheritPrototype 函数：
   • 该函数用来实现寄生组合式继承的核心，它有两项工作：
     1. 创建一个新的对象，其原型指向父类 superClass.prototype。
     2. 修复子类的原型链，让子类的 prototype 指向这个新对象，并且修复 constructor 属性，确保它指向子类 subClass。
3. 子类 Dog：
   • Dog 构造函数调用父类 Animal 的构造函数来初始化 name 属性，并且为 Dog 添加了一个新的属性 breed。
   • 继承父类的 sayHello 方法，子类还可以定义自己的方法 bark。
4. 实例化和方法调用：
   • 使用 new Dog() 创建 Dog 类的实例，可以看到 dog1 和 dog2 都能够调用 sayHello 和 bark 方法，验证了继承和扩展的正确性。
5. 验证继承关系：
   • 使用 instanceof 操作符来检查 dog1 和 dog2 是否分别是 Dog 和 Animal 类的实例。
   • 使用 constructor 来检查子类实例的构造函数是否指向 Dog。

输出示例：

Buddy says hello!
Buddy barks!
Max says hello!
Max barks!
true
true
true
true
true
true

寄生组合式继承的优点总结：

• 性能优化：父类构造函数只被调用一次，避免了经典继承中的性能浪费。
• 继承关系清晰：通过原型链继承父类的方法，确保子类的原型指向正确，子类和父类能够共享方法。
• 构造函数修复：通过 inheritPrototype 修复了子类构造函数的指向问题，确保 constructor 始终指向子类。

总结：

寄生组合式继承提供了一种高效且优雅的方式来实现 JavaScript 中的继承。通过创建一个父类原型的副本并将其指向子类原型，避免了父类构造函数的多次调用，同时保留了正确的原型链关系。