java组合

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

组合与"has-a"

一个对象是另一个对象的数据成员

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();//在Torch类(手电筒)定义中使用Battery类型的对象theBattery作为数据成员
}
public class TestCombination{
    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);
    }
}

//定义了电池类Battery，有两个方法chargeBattery（）充电和useBattery（）使用

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

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

组合：（1）在Torch类(手电筒)定义中使用Battery类型的对象作为数据成员

（2）在Torch的方法中，通过操纵theBattery对象的接口，来实现Battery类所提供的功能(functionality)。

（3）一个Torch对象拥有(has-a)一个Battery对象

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