组合和继承——面向对象编程思想

在 1994 年，由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 四人合著出版了一本名为 Design Patterns - Elements of Reusable Object-Oriented Software（中文译名：设计模式 - 可复用的面向对象软件元素） 的书，该书首次提到了软件开发中设计模式的概念。

四位作者合称 GOF（四人帮，全拼 Gang of Four）。他们所提出的设计模式主要是基于以下的面向对象设计原则：

• 对接口编程而不是对实现编程

• 优先使用对象组合而不是继承

此处提到了对象组合和继承，那我们来看一下组合和继承的关系

继承(is-a)和组合(has-a)

Example：

要实现的目标：鸟（Bird）和狼（Wolf）都是动物（Animal），动物都有心跳（beat()），会呼吸（beat()），但是鸟会fly（fly()），狼会奔跑（run()）

继承方式：

package inherit;
​
//inherit.InheritTest.java 使用继承方式实现目标
class Animal{
    private void beat(){
        System.out.println("心脏跳动...");
    }
​
    public void breath(){
        beat();
        System.out.println("吸一口气，呼一口气，呼吸中...");
    }
}
​
//继承Animal，直接复用父类的breath()方法
class Bird extends Animal{
    //创建子类独有的方法fly()
    public void fly(){
        System.out.println("我是鸟，我在天空中自由的飞翔...");
    }
}
​
//继承Animal，直接复用父类的breath()方法
class Wolf extends Animal{
    //创建子类独有的方法run()
    public void run(){
        System.out.println("我是狼，我在草原上快速奔跑...");
    }
}
​
public class InheritTest {
    public static void main(String[] args) {
        //创建继承自Animal的Bird对象新实例b
        Bird b=new Bird();
        //新对象实例b可以breath()
        b.breath();
        //新对象实例b可以fly()
        b.fly();
        Wolf w=new Wolf();
        w.breath();
        w.run();
/*
---------- 运行Java程序 ----------
心脏跳动...
吸一口气，呼一口气，呼吸中...
我是鸟，我在天空中自由的飞翔...
心脏跳动...
吸一口气，呼一口气，呼吸中...
我是狼，我在草原上快速奔跑...
​
输出完毕 (耗时 0 秒) - 正常终止
*/
    }
}

组合方式：

package composite;
​
//composite.CompositeTest.java  使用组合方式实现目标
class Animal{
    private void beat(){
        System.out.println("心脏跳动...");
    }
​
    public void breath(){
        beat();
        System.out.println("吸一口气，呼一口气，呼吸中...");
    }
}
​
class Bird{
    //定义一个Animal成员变量，以供组合之用
    private Animal a;
    //使用构造函数初始化成员变量
    public Bird(Animal a){
        this.a=a;
    }
    //通过调用成员变量的固有方法（a.breath()）使新类具有相同的功能（breath()）
    public void breath(){
        a.breath();
    }
    //为新类增加新的方法
    public void fly(){
        System.out.println("我是鸟，我在天空中自由的飞翔...");
    }
}
​
class Wolf{
    private Animal a;
    public Wolf(Animal a){
        this.a=a;
    }
    public void breath(){
        a.breath();
    }
    public void run(){
        System.out.println("我是狼，我在草原上快速奔跑...");
    }
}
​
public class CompositeTest{
    public static void main(String[] args) {
        //显式创建被组合的对象实例a1
        Animal a1=new Animal();
        //以a1为基础组合出新对象实例b
        Bird b=new Bird(a1);
        //新对象实例b可以breath()
        b.breath();
        //新对象实例b可以fly()
        b.fly();
        Animal a2=new Animal();
        Wolf w=new Wolf(a2);
        w.breath();
        w.run();
/*
---------- 运行Java程序 ----------
心脏跳动...
吸一口气，呼一口气，呼吸中...
我是鸟，我在天空中自由的飞翔...
心脏跳动...
吸一口气，呼一口气，呼吸中...
我是狼，我在草原上快速奔跑...
​
输出完毕 (耗时 0 秒) - 正常终止
*/
    }
}

总结

继承和组合都可以实现代码的复用

• "is-a"（是）关系使用继承！

• "has-a"（拥有）关系使用组合！

总结：
1）组合(has-a)关系可以显式地获得被包含类（继承中称为父类）的对象，而继承(is-a)则是隐式地获得父类的对象，被包含类和父类对应，而组合外部类和子类对应。
2）组合关系在运行期决定，而继承关系在编译期就已经决定了。
3）组合是在组合类和被包含类之间的一种松耦合关系，而继承则是父类和子类之间的一种紧耦合关系。
4）当选择使用组合关系时，在组合类中包含了外部类的对象，组合类可以调用外部类必须的方法，而使用继承关系时，父类的所有方法和变量都被子类无条件继承，子类不能选择。
5）最重要的一点，使用继承关系时，可以实现类型的回溯，即用父类变量引用子类对象，这样便可以实现多态，而组合没有这个特性。
6）还有一点需要注意，如果你确定复用另外一个类的方法永远不需要改变时，应该使用组合，因为组合只是简单地复用被包含类的接口，而继承除了复用父类的接口外，它甚至还可以覆盖这些接口，修改父类接口的默认实现，这个特性是组合所不具有的。
7）从逻辑上看，组合最主要地体现的是一种整体和部分的思想，例如在电脑类是由内存类，CPU类，硬盘类等等组成的，而继承则体现的是一种可以回溯的父子关系，子类也是父类的一个对象。
8）这两者的区别主要体现在类的抽象阶段，在分析类之间的关系时就应该确定是采用组合还是采用继承。
9）引用网友的一句很经典的话应该更能让大家分清继承和组合的区别：组合可以被说成“我请了个老头在我家里干活” ，继承则是“我父亲在家里帮我干活"。