6种继承的优点和缺点

本文详细探讨了JavaScript中的六种继承方式:原型链继承、借用构造函数、组合继承、原型式继承、寄生式继承和寄生组合式继承,分析了各自的优点和缺点。例如,原型链继承存在引用值共享和无法传参的问题,而借用构造函数解决了这些问题但多执行了一次函数。寄生组合式继承则试图解决组合继承中调用两次父构造函数的弊端。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、原型链继承

Parent.prototype.grand = 'grand';

function Parent (name) {
     this.name = name || 'parent';
     this.color = ['red', 'orange', 'yellow'];
 }

 function Child () {

 }

 Child.prototype = new Parent();
 var child1 = new Child('child1');
 var child2 = new Child('child2');
缺点

1.引用值共享问题
引用值会被所有的实例(这里以两个为例,下面也将都是)共享,一个对象修改了原型属性,那么另一个的原型属性也会被修改

2.不能传参
在创建Child的实例时,不能向Parent传递参数;如果传递也不会有作用

在这里插入图片描述


二、借用构造函数(经典继承)

	Parent.prototype.grand = 'grand';

    function Parent (name) {
         this.name = name || 'parent';
         this.color = ['red', 'orange', 'yellow'];
     }

     function Child (name,) {
          Parent.call(this, name);
     }

     var child1 = new Child('child1');
     var child2 = new Child('child2');

优点

1.解决了引用值共享的问题

2.可以通过Child向Parent传参
在这里插入图片描述

缺点

1.多执行了一次函数 call

2.Parent上的原型不能被继承

在这里插入图片描述

注:为了证明Parent的原型上有grand这个属性值,我在控制台新建了一个parent对象


三、组合继承(伪经典继承)

将原型链继承和借用构造函数阶乘结合在一起

Parent.prototype.grand = 'grand';

function Parent(name) {
    this.name = name || 'parent';
    this.color = ['red', 'orange', 'yellow'];
}


function Child(name, age) {
    Parent.call(this, name);
    this.age = age;
}

Child.prototype = new Parent();
Child.prototype.constructor = Child;

var child1 = new Child('child1', 18);
var child2 = new Child('child2', 19);
	

优点(结合了原型链继承和构造函数继承的优点)

1.Parent上的原型可以被继承

2.解决了引用值共享的问题

3.可以通过Child向Parent传参

在这里插入图片描述

缺点

函数多执行了一次call


四、原型式继承

    var car = {
        name : 'car',
        color : ['red', 'orange', 'yellow']
    }

    function create (o) {
        function F () {};
        F.prototype = o;
        return new F();
    }

    var car1 = create(car);
    var car2 = create(car);

重点:用一个函数包装一个对象,然后返回这个函数的调用,这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。

特点:类似于复制一个对象,用函数来包装。

缺点:1、所有实例都会继承原型上的属性。

2、无法实现复用。(新实例属性都是后面添加的)


五、寄生式继承

     function createObject (o) {
         var clone = Object.create(o);
         // var clone = object(o);
         clone.sayHi = function () {
             console.log('hi');
         }
         return clone;
     }

     var car = {
         name : 'car',
         color : ['red', 'orange', 'yellow']
     }

     var car1 = createObject(car);


重点:就是给原型式继承外面套了个壳子。

优点:没有创建自定义类型,因为只是套了个壳子返回对象(这个),这个函数顺理成章就成了创建的新对象。

缺点:没用到原型,无法复用。


六、寄生组合式继承

为了方便大家阅读,在这里重复一下组合继承的代码:

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}

Child.prototype = new Parent();

var child1 = new Child('kevin', '18');

console.log(child1)

组合继承最大的缺点是会调用两次父构造函数。

一次是设置子类型实例的原型的时候:

Child.prototype = new Parent();
一次在创建子类型实例的时候:

var child1 = new Child(‘kevin’, ‘18’);
回想下 new 的模拟实现,其实在这句中,我们会执行:

Parent.call(this, name);
在这里,我们又会调用了一次 Parent 构造函数。

所以,在这个例子中,如果我们打印 child1 对象,我们会发现 Child.prototype 和 child1 都有一个属性为colors,属性值为[‘red’, ‘blue’, ‘green’]。

那么我们该如何精益求精,避免这一次重复调用呢?

如果我们不使用 Child.prototype = new Parent() ,而是间接的让 Child.prototype 访问到 Parent.prototype 呢?

看看如何实现:


function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}

// 关键的三步
var F = function () {};

F.prototype = Parent.prototype;

Child.prototype = new F();


var child1 = new Child('kevin', '18');

console.log(child1);
最后我们封装一下这个继承方法:

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}

function prototype(child, parent) {
    var prototype = object(parent.prototype);
    prototype.constructor = child;
    child.prototype = prototype;
}

// 当我们使用的时候:
prototype(Child, Parent);

ps:建议去看下红宝石书

### 组合与继承在软件设计中的优缺点对比 #### 1. 继承的优缺点 ##### 优点 - **代码重用**:通过继承,子类可以复用父类中的方法属性,从而减少重复代码。这种机制有助于提高开发效率[^1]。 - **层次结构清晰**:继承能够建立一种自然的层级关系,使得类之间的关系更加直观易于理解。例如,在一个动物类体系中,哺乳动物可以继承自动物类,进一步细化为狗、猫等具体类[^2]。 ##### 缺点 - **紧耦合**:继承导致子类与父类之间形成紧密的依赖关系。一旦父类发生变化,可能会影响到所有继承它的子类,增加了维护成本[^1]。 - **灵活性不足**:由于继承是一种静态关系,定义后难以改变。如果需要修改行为或添加新功能,通常需要创建新的子类或调整现有类结构,这可能会导致复杂性增加。 #### 2. 组合的优缺点 ##### 优点 - **高内聚低耦合**:组合强调“使用而非扩展”,通过将对象嵌套在一起实现功能,而不是依赖于类的继承关系。这种方式减少了类之间的耦合度,提高了模块的独立性可维护性。 - **动态性更强**:相比于继承,组合允许在运行时动态地构建对象,灵活调整行为。例如,可以通过组合不同的策略对象来实现多样的业务逻辑,而无需修改原有代码结构[^2]。 ##### 缺点 - **初始复杂度较高**:采用组合方式设计系统时,可能需要更多的前期规划实现工作。因为需要明确各个组件之间的协作关系,并且确保它们能够正确交互。 - **潜在性能开销**:在某些情况下,过多的组合可能会引入额外的性能开销,尤其是在涉及大量小对象的情况下。不过,这种影响通常可以通过优化设计来缓解。 #### 3. 示例代码比较 以下是一个简单的例子,展示如何通过继承组合分别实现类似的功能: ```python # 使用继承方式 class Engine: def start(self): print("Engine started") class Car(Engine): # 继承自Engine def drive(self): self.start() # 调用父类方法 print("Car is driving") car = Car() car.drive() # 使用组合的方式 class Engine: def start(self): print("Engine started") class Car: def __init__(self): self.engine = Engine() # 将Engine作为成员变量 def drive(self): self.engine.start() # 调用组合对象的方法 print("Car is driving") car = Car() car.drive() ``` #### 4. 总结 在面向对象编程中,选择使用继承还是组合取决于具体需求场景。继承适用于当多个类共享相同的行为属性时,可以有效减少冗余代码并建立清晰的分类体系;然而,它也可能带来紧耦合的问题。相比之下,组合提供了更高的灵活性更低的耦合度,但可能需要更多初期设计投入。因此,在实际项目中应根据具体情况权衡利弊,合理选用这两种机制[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值