组合

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

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

---

一个对象的数据成员是另一个对象。我们以手电筒为例子：

我们定义一个手电筒类（Torch），我们忽略手电筒的具体细节，它会有开启（turnOn）这个方法。

同时我们定义一个电池类（Battery），并用数据成员 power 来表示其电量。一个电池的可以充电（chargeBattery）和使用（useBattery）。

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

    // 使用电池方法
    // 电量充足时返回 true，否则为 false
    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
{   
    // 开启电筒方法
    // 每小时使用0.1电量，当电量不足时发出警告
    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!");
        }
    }

    // 充电方法
    // 每小时增加0.2电量
    public void charge(int hours)
    {
        this.theBattery.chargeBattery( hours*0.2 );
    }

    // 把 Battery 类的实例作为自己的一个数据对象
    private Battery theBattery = new Battery();
}

我们定义 Battery 类。Torch 类使用了一个 Battery 类的对象 theBattery 来作为数据成员。

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

通过组合，我们可以复用 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!

---

基本类型

在 Java中，我们将 int，float，double，boolean 等称为 基本类型（primitive type），也就是特殊的类。我们可以将一个整数理解称为一个 int 类型的对象。int 类型可以有赋值、加法、减法等操作接口。

普通类型可以视作对基本类型的拓展。我们已经见过了基本类型作为数据成员、方法的参数、方法的返回值和方法内部的自动变量。自然的，普通类型的对象，比如 Battery 和 Torch 类的对象，也都可以用于这些地方。

C语言中，可用的数据类型（基本上）已经预设好，比如 int，float。在 Java 中，我们除了可以用这些预设的数据类型外，还可以通过类来定制自己想要的数据类型，然后通过组合来使用。

但基本类型和普通类型还是有所区别的。基本类型经常被使用，且所占据内存空间不大，所以在 Java 中，为了效率起见，这些基本类型与普通的类型（也就是自定义的类）的内存管理方式不同。比如，基本类型一旦声明就会被分配内存空间，而普通类型需要使用 new 关键字来分配内存空间。

Java 为每个基本类型提供了相应的普通类型。比如 int 基本类型对应 Integer 类型。如果将基本类型的对象转成相应的普通类型变量，所谓的基本类型也就成为了一般意义上的类型（不再有内存管理上的不同）。

这样，我们对 Java “一切皆对象” 的理念有了更深一步的理解。