面向对象编程(十一)——组合以及与继承的区别

组合(has-a 关系)

我们已经尝试去定义类。定义类，就是新建了一种类型(type)。有了类，我们接着构造相应类型的对象。更进一步，每个类型还应该有一个清晰的接口(interface)，供用户使用。

我们可以在一个新类的定义中使用其他对象。这就是组合(composition)。组合是在Java中实现程序复用(reusibility)的基本手段之一。

组合：一个对象是另一个对象的数据成员。

【例子1 code】

package com.gta.testoop.inherit;

/**@Description:  测试组合    
 * @date 2016-2-1 上午10:30:57    
 */
//一个源文件可以定义多个类
//动物Animal类
public class Animal2 {
    String eye;

    public void run(){
        System.out.println("跑跑");
    }

    public void eat(){
        System.out.println("吃吃");
    }
}
//哺乳动物Mammal类
class Mammal2 {
    Animal2 animal2;//作为Mammal2的一个属性
    public void taiSheng(){
        System.out.println("我是胎生");
    }
}
class Bird {
    Animal2 animal2=new Animal2() ;
    
    public void run(){
        animal2.run();
        System.out.println("我是一个小小小鸟，想要飞的更高");
    }
    public void eggSheng(){
        System.out.println("我是卵生");
    }
}

测试类：

package com.gta.testoop.inherit;

/**@Description: 测试组合
 * @date 2016-2-2 上午9:34:11    
 */
public class TestComposition {

    public static void main(String[] args) {
        Bird b=new Bird();
        b.run();
        b.animal2.eat();
    }

}

执行结果：

跑跑
我是一个小小小鸟，想要飞的更高
吃吃

【例子2 code】充电筒例子；

一个充电电筒中的电池、LED灯、按钮…… 都可以是一个对象。我们可以定义一个Battery类来定义和产生电池对象。而在充电电筒的类定义中，可以用一个电池对象作为其数据成员，来代表电池部分的状态。

我们下面定义一个Battery类，并用power来表示其电量。一个Battery的可以充电(chargeBattery)和使用(useBattery)。我们在随后的Torch类定义中使用Battery类型的对象作为数据成员:

class Battery 
{
    public void chargeBattery(double p)
    {
        if (this.power < 1.) {
            this.power = this.power + p;
        }
    }

    public boolean useBattery(double p)
    {
        if (this.power >= p) {
            this.power = this.power - p;
            return true;
        }
        else {
            this.power = 0.0;
            return false;
        }
    }

    private double power = 0.0;
}

class Torch
{
    /** 
     * 10% power per hour use
     * warning when out of power
     */
    public void turnOn(int hours)
    {
        boolean usable;
        usable = this.theBattery.useBattery( hours*0.1 );
        if (usable != true) {
            System.out.println("No more usable, must charge!");
        }
    }

    /**
     * 20% power per hour charge
     */
    public void charge(int hours)
    {
        this.theBattery.chargeBattery( hours*0.2 );
    }

    /**
     * composition
     */
    private Battery theBattery = new Battery();
}

上面的new为theBattery对象分配内存，不可或缺。

我们定义Battery类。Torch类使用了一个Battery类型的对象(theBattery)来作为数据成员。在Torch的方法中，我们通过操纵theBattery对象的接口，来实现Battery类所提供的功能(functionality)。

我们说，一个Torch对象拥有(has-a)一个Battery对象。上述关系可以表示成:

has-a: 手电有电池 (注意上面的菱形连线)

通过组合，我们可以复用Battery相关的代码。假如我们还有其他使用Battery的类，比如手机，计算器，我们都可以将Battery对象组合进去。这样就不用为每个类单独编写相关功能了。

我们可以增加一个Test类，看看实际效果:

public class Test
{
    public static void main(String[] args)
    {
        Torch aTorch = new Torch();
        System.out.println("Charge: 2 hours");
        aTorch.charge(2);
        System.out.println("First Turn On: 3 hours");
        aTorch.turnOn(3);
        System.out.println("Second Turn On: 3 hours");
        aTorch.turnOn(3);
    }
}

执行结果：

Charge: 2 hours
First Turn On: 3 hours
Second Turn On: 3 hours
No more usable, must charge!

我们通过组合来使用了电池对象所提供的功能，比如探测电量是否用尽(根据useBattery()的返回值)。

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

【组合和继承的综合例子】：

要实现的目标：鸟（Bird）和狼（Wolf）都是动物（Animal），动物都有心跳（beat()），会呼吸（beat()），但是鸟会fly（fly()），狼会奔跑（run()），用java程序实现以上描述。

InheritTest.java 使用继承方式实现目标

CompositeTest.java 使用组合方式实现目标

//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 秒) - 正常终止
*/
    }
}

//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）引用网友的一句很经典的话应该更能让大家分清继承和组合的区别：组合可以被说成“我请了个老头在我家里干活” ，继承则是“我父亲在家里帮我干活"。