面试题: 对象继承的方式有哪些

在 JavaScript 中，对象继承可以通过多种方式实现。每种方法都有其特点和适用场景。以下是几种常见的对象继承方式：

1. 原型链继承（Prototype Chain Inheritance）

这是最基础的对象继承方式，利用了 JavaScript 的原型机制。每个对象都有一个内部属性 [[Prototype]]，它指向另一个对象，即该对象的原型。当尝试访问一个对象的属性时，如果对象本身没有这个属性，JavaScript 引擎会沿着原型链向上查找，直到找到该属性或到达原型链的末端（通常是 Object.prototype）。

function Parent() {this.name = 'parent';
}Parent.prototype.sayHello = function() {console.log('Hello from ' + this.name);
};function Child() {}// 设置 Child 的 prototype 为 Parent 的实例
Child.prototype = new Parent();
Child.prototype.constructor = Child; // 修复构造函数指针const child = new Child();
child.sayHello(); // 输出: Hello from parent

缺点：所有子类实例共享同一个父类实例的属性，可能会导致意外的状态共享问题。

2. 构造函数继承（Constructor Function Inheritance）

通过使用 call 或 apply 方法，可以在子类构造函数中调用父类构造函数，从而将父类的属性复制到子类实例上。这种方式可以避免原型链继承中的状态共享问题。

function Parent(name) {this.name = name;
}Parent.prototype.sayHello = function() {console.log('Hello from ' + this.name);
};function Child(name, age) {Parent.call(this, name); // 调用父类构造函数this.age = age;
}const child = new Child('child', 10);
console.log(child.name); // 输出: child
console.log(child.age);  // 输出: 10

缺点：子类不能继承父类的原型方法，需要额外的方法来继承这些方法。

3. 组合继承（Combination Inheritance）

组合继承结合了原型链继承和构造函数继承的优点，既可以通过构造函数继承父类的属性，又可以通过原型链继承父类的方法。

function Parent(name) {this.name = name;this.colors = ['red', 'blue'];
}Parent.prototype.sayHello = function() {console.log('Hello from ' + this.name);
};function Child(name, age) {Parent.call(this, name); // 第一次调用 Parentthis.age = age;
}Child.prototype = new Parent(); // 第二次调用 Parent
Child.prototype.constructor = Child;const child1 = new Child('child1', 10);
const child2 = new Child('child2', 20);child1.colors.push('green');
console.log(child1.colors); // 输出: ['red', 'blue', 'green']
console.log(child2.colors); // 输出: ['red', 'blue']

缺点：两次调用父类构造函数，第一次是在创建子类实例时，第二次是在设置子类原型时，这可能会造成不必要的开销。

4. 原型式继承（Prototypal Inheritance）

这种继承方式不依赖于构造函数，而是直接基于对象创建新的对象。通常使用 Object.create() 方法来实现。

const parent = {name: 'parent',sayHello: function() {console.log('Hello from ' + this.name);}
};const child = Object.create(parent);
child.name = 'child';child.sayHello(); // 输出: Hello from child

优点：简单明了，适合不需要复杂构造函数的情况。

5. 寄生式继承（Parasitic Inheritance）

寄生式继承是原型式继承的增强版，它在创建新对象的基础上，进一步增强对象的功能，然后再返回这个对象。

function createChild(parent) {const child = Object.create(parent); // 使用原型式继承child.sayHi = function() {console.log('Hi from ' + this.name);};return child;
}const parent = {name: 'parent',sayHello: function() {console.log('Hello from ' + this.name);}
};const child = createChild(parent);
child.name = 'child';
child.sayHi(); // 输出: Hi from child

优点：可以自由地添加或修改对象的功能。

6. 寄生组合式继承（Parasitic Combination Inheritance）

寄生组合式继承是组合继承的优化版本，它只调用一次父类构造函数，避免了组合继承中的效率问题。这是目前最常用的继承模式之一。

function inheritPrototype(child, parent) {const prototype = Object.create(parent.prototype); // 创建父类原型的副本prototype.constructor = child; // 修正构造函数指针child.prototype = prototype;   // 将副本赋值给子类的原型
}function Parent(name) {this.name = name;this.colors = ['red', 'blue'];
}Parent.prototype.sayHello = function() {console.log('Hello from ' + this.name);
};function Child(name, age) {Parent.call(this, name); // 只调用一次 Parentthis.age = age;
}inheritPrototype(Child, Parent);const child1 = new Child('child1', 10);
const child2 = new Child('child2', 20);child1.colors.push('green');
console.log(child1.colors); // 输出: ['red', 'blue', 'green']
console.log(child2.colors); // 输出: ['red', 'blue']

优点：只调用一次父类构造函数，避免了重复调用的问题，同时保持了组合继承的优点。

7. 类（Class）继承（ES6+）

ES6 引入了 class 语法糖，使得继承更加简洁和直观。实际上，class 仍然是基于原型的，但它提供了一种更接近传统面向对象语言的语法。

class Parent {constructor(name) {this.name = name;}sayHello() {console.log('Hello from ' + this.name);}
}class Child extends Parent {constructor(name, age) {super(name); // 调用父类构造函数this.age = age;}sayAge() {console.log('I am ' + this.age + ' years old.');}
}const child = new Child('child', 10);
child.sayHello(); // 输出: Hello from child
child.sayAge();   // 输出: I am 10 years old.