聚合:类之间的一种引用,表示两个对象之间是整体和部分的弱关系,部分的生命周期可以超过整体,如电脑和鼠标;
组合:表示两个对象之间是整体和部分的强关系,部分的生命周期不能超越整体,如人和眼睛。
聚合关系的部分,可以在构造器中通过参数传递的形式进行初始化,有时聚合比继承好用。
下面代码例子就是很好的解释:
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();
}
}
上面非常巧妙的进行了两种组合,有再多的限制条件,都可以用这种方法任意组合,程序更加容易维护。这实际是一种静态代理模式。