[Java] JAVA设计模式

设计模式

摘自 《Android 源码设计模式 解析与实战》

中介者模式

1. 先定义这个抽象colleague类，但是这个里面为什么要定义中介者？参考下面第二点，是作为一个对象，可能会面向不同的调解Meditor对象，所以对于每个对象应该是一对多。

public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
    public abstract void action();
}

2.再看具体实现类里面，也没有对mediator的调用，但是反过来想中介者应该对多个class起作用，包括自己，所以要在类自己内部给外部的Mediator留下接口，例如在action里面应该可以调用Mediator的一些特定方法。注意这里避免循环。

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }
    @Override
    public void action() {
        Log.d("ch17","colleagueA will handle message to Mediator");
    }
}

3.那Meditor 也要有对Colleague操作的接口，先在内部定义那个面向的对象，然后设置method方便不同的中间者处理。这里应该要把所有调解的对象都要定义。

public abstract class Mediator {
    protected ConcreteColleagueA colleagueA;
    protected ConcreteColleagueB colleagueB;
    public abstract void method();
    public void setColleagueA(ConcreteColleagueA colleagueA){
        this.colleagueA = colleagueA;
    }
    public void setColleagueB(ConcreteColleagueB colleagueB){
        this.colleagueB = colleagueB;
    }
}

4.这样具体的Meditor内部就可以在method方法中调节所有定义的对象。

public class ConcreteMediator extends Mediator {
    @Override
    public void method() {
        colleagueA.action();
        colleagueB.action();
    }
}

代理模式

1. 增加了中间的缓冲，可以在中间的proxy类中对对象进行处理。

public abstract class Subject {
    public abstract void visit();
}
public class RealSubject extends Subject {
    @Override
    public void visit() {
        Log.d("ch18","real subject");
    }
}
public class ProxySubject extends Subject {
    private RealSubject mSubject;
    public ProxySubject(RealSubject mSubject){
        this.mSubject = mSubject;
    }
    @Override
    public void visit() {
        mSubject.visit();
    }
}

2.上述的代理方式是静态代理，但是实际上有很多时候会用到动态代理，也可以理解为就是反射。这样一个代理类可以代理多个类。动态代理的关键是要传入参数给这个invoke。

public class DynamicProxy implements InvocationHandler {
    private Object obj;
    public DynamicProxy(Object obj){
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(obj,args);
        return result;
    }
}

组合模式

注意组合模式使用的全透明形式和安全模式。区别在于基类中是否需要声明子类的所有方法。全透明是需要的，而安全模式则是定义的子类单独声明。