继承和组合的区别

遗产怎么会是危险的?

让我们举个例子

public class X{    
   public void do(){    
   }    
}    
Public Class Y extends X{
   public void work(){    
       do();    
   }
}

1)正如上面的代码所示，类Y与类X具有很强的耦合性。如果超类X发生任何变化，Y可能会急剧断裂。假设在未来的类X中实现了一个具有以下签名的方法work

public int work(){
}

改变是在类X中完成的，但它将使类Y不可编译。所以这种依赖可以上升到任何程度，这是非常危险的。每次超类都可能对其所有子类中的代码没有完全可见性，子类可能会一直注意到在超类中发生了什么。因此，我们需要避免这种强而不必要的耦合。

合成如何解决这个问题?

让我们复习一下同样的例子

public class X{
    public void do(){
    }
}

Public Class Y{
    X x = new X();    
    public void work(){    
        x.do();
    }
}

这里我们在Y类中创建X类的引用，并通过创建X类的实例调用X类的方法。现在所有的强耦合都消失了。父类和子类现在彼此高度独立。类可以自由地进行更改，这在继承情况下是危险的。

2)第二个非常好的优点是它提供了方法调用的灵活性，例如:

class X implements R
{}
class Y implements R
{}

public class Test{    
    R r;    
}

在测试类中使用r引用，我可以调用X类以及Y类的方法。这种灵活性在继承中是不存在的

3)另一个巨大优势:单元测试

public class X {
    public void do(){
    }
}

Public Class Y {
    X x = new X();    
    public void work(){    
        x.do();    
    }    
}

在上面的例子中，如果x实例的状态未知，可以用一些测试数据很容易地模拟出来，所有的方法都可以很容易地测试出来。这在继承中是完全不可能的，因为您严重依赖于超类来获取实例的状态并执行任何方法。

4)我们应该避免继承的另一个很好的理由是Java不支持多重继承。

让我们举个例子来理解这一点:

Public class Transaction {
    Banking b;
    public static void main(String a[])    
    {    
        b = new Deposit();    
        if(b.deposit()){    
            b = new Credit();
            c.credit();    
        }
    }
}

很高兴知道:

组合在运行时很容易实现，而继承在编译时提供其特性组合也称为HAS-A关系，继承也称为is - a关系

因此，由于上述各种原因，要养成总是喜欢组合而不是继承的习惯。

2013-07-29 05:24:56

继承Vs组合。

继承和组合都用于类行为的可重用性和扩展。

继承主要用在IS-A一类算法编程模型中，关系类型是指相似类型的对象。的例子。

吸尘器是一辆车 Safari是一辆车

这些是Car家族的。

Composition表示HAS-A关系类型。它显示了一个对象的能力，如Duster有五个齿轮，Safari有四个齿轮等。每当我们需要扩展现有类的能力时，就使用复合。例如，我们需要在Duster对象中添加一个齿轮，然后我们必须创建一个齿轮对象，并将其组合到Duster对象中。

除非所有派生类都需要这些功能，否则不应该对基类进行更改。对于这个场景，我们应该使用Composition。如

由类B派生

类A由类C派生

类A由类D派生。

当我们在类A中添加任何功能时，即使类C和类D不需要这些功能，它也可以用于所有子类。对于这个场景，我们需要为这些功能创建一个单独的类，并将其组合到所需的类中(这里是类B)。

下面是例子:

          // This is a base class
                 public abstract class Car
                    {
                       //Define prototype
                       public abstract void color();
                       public void Gear() {
                           Console.WriteLine("Car has a four Gear");
                       }
                    }


           // Here is the use of inheritence
           // This Desire class have four gears.
          //  But we need to add one more gear that is Neutral gear.

          public class Desire : Car
                   {
                       Neutral obj = null;
                       public Desire()
                       {
     // Here we are incorporating neutral gear(It is the use of composition). 
     // Now this class would have five gear. 

                           obj = new Neutral();
                           obj.NeutralGear();
                       }

                       public override void color()
                       {
                           Console.WriteLine("This is a white color car");
                       }

                   }


             // This Safari class have four gears and it is not required the neutral
             //  gear and hence we don't need to compose here.

                   public class Safari :Car{
                       public Safari()
                       { }

                       public override void color()
                       {
                           Console.WriteLine("This is a red color car");
                       }


                   }

   // This class represents the neutral gear and it would be used as a composition.

   public class Neutral {
                      public void NeutralGear() {
                           Console.WriteLine("This is a Neutral Gear");
                       }
                   }

2017-08-08 07:22:48

@Michael Rodrigues给出的答案不正确(我道歉;我不能直接评论)，这可能会导致一些混乱。

接口实现是一种继承形式…当你实现一个接口时，你不仅继承了所有的常量，你还将你的对象提交为接口指定的类型;这仍然是一种“是”的关系。如果汽车实现了Fillable，那么汽车“是-a”Fillable，并且可以在任何需要使用Fillable的代码中使用。

组合从根本上不同于继承。当您使用组合时，您(如其他回答所示)在两个对象之间建立了“has-a”关系，而不是使用继承时所建立的“is-a”关系。

所以，从其他问题中关于汽车的例子来看，如果我想说一辆汽车“有一个”油箱，我会使用如下的组合:

public class Car {

private GasTank myCarsGasTank;

}

希望这能消除任何误解。

2010-06-28 16:05:39

Though both Inheritance and Composition provides code reusablility, main difference between Composition and Inheritance in Java is that Composition allows reuse of code without extending it but for Inheritance you must extend the class for any reuse of code or functionality. Another difference which comes from this fact is that by using Composition you can reuse code for even final class which is not extensible but Inheritance cannot reuse code in such cases. Also by using Composition you can reuse code from many classes as they are declared as just a member variable, but with Inheritance you can reuse code form just one class because in Java you can only extend one class, because multiple Inheritance is not supported in Java. You can do this in C++ though because there one class can extend more than one class. BTW, You should always prefer Composition over Inheritance in Java, its not just me but even Joshua Bloch has suggested in his book

2015-06-03 10:55:59

不，两者都不一样。组合遵循“HAS-A”关系，继承遵循“IS-A”关系。组合的最佳例子是战略模式。

2017-12-24 17:34:46