[018]Java编程思想——聚合

聚合：类之间的一种引用，表示两个对象之间是整体和部分的弱关系，部分的生命周期可以超过整体，如电脑和鼠标；
组合：表示两个对象之间是整体和部分的强关系，部分的生命周期不能超越整体，如人和眼睛。
聚合关系的部分,可以在构造器中通过参数传递的形式进行初始化，有时聚合比继承好用。
下面代码例子就是很好的解释：

public interface Moveable {
    void move();
}

import java.util.Random;

public class Tank implements Moveable {

    @Override
    public void move() {
        System.out.println("Tank Moving...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

现在我们想在调用move()方法时候，计算一下它的运行时间，一种解决办法是用继承，继承Tank这个类，重写move()方法。

public class Tank2 extends Tank{
    @override
    public void move(){
        long start = System.currentTimeMillis();
        super.move();
        long end = System.currentTimeMillis();
        System.out.println("time:" + (end-start);
    }
}

当我想在调用move()方法时再调用一段话，又要写Tank3继承Tanks2并重写move()方法，但是我想先调用Tank3的方法，再调用Tank2的方法，则又要重写，当组合多了的时候，任意组合顺序则显得极为困难，一个好的解决办法就是用聚合。

public class TankTimeProxy implements Moveable{

    Moveable target;
    public TankTimeProxy (Moveable target) {
        super();
        this.target = target;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();
        System.out.println("starttime:" + start);
        target.move();
        long end = System.currentTimeMillis();
        System.out.println("time:" + (end-start));
    }
}

public class TankLogProxy implements Moveable{

    Moveable target;
    public TankTimeProxy (Moveable target) {
        super();
        this.target = target;
    }

    @Override
    public void move() {
        System.out.println("Tank Start...");
        target.move();
        System.out.println("Tank Stop...");
    }
}

如此便实现了两种不同的逻辑添加，下面我们来看测试代码：

public class Client {
    public static void main(String[] args){
        Tank t = new Tank();
        //方式1：先打印时间，再打印日志
        //TankTimeProxy ttp = new TankTimeProxy (t);
        //TankLogProxy tlp = new TankLogProxy (ttp);
        //方式1：先打印日志，再打印时间
        TankLogProxy tlp = new TankLogProxy (t);
        TankTimeProxy ttp = new TankTimeProxy (tlp);
        Moveable m = ttp;
        m.move();
    }
}

上面非常巧妙的进行了两种组合，有再多的限制条件，都可以用这种方法任意组合，程序更加容易维护。这实际是一种静态代理模式。