设计模式学习笔记(三)之静(动)态代理模式、适配器模式

一、代理模式(Proxy)：

(1)静态代理模式：

简单理解：

一个人或事物代替另一个人或事物做某件事。例如：在Tom自我介绍之前，代理器自动帮他说Hello。

实现：

public interface Subject {

    public void print();
}

public class RealSubject implements Subject{

    public void print(){
        System.out.println("I am Tom");
    }
    
}

public class Proxy implements Subject {
    private Subject subject;
    public Proxy(Subject subject){
        this.subject=subject;
    }        
    @Override
    public void print() {
        // TODO Auto-generated method stub
        System.out.println("Hello");
        this.subject.print();
    }    
}

public class Test {

    public static void main(String[] args) {
        Subject staticProxy=new RealSubject();
        Proxy proxy=new Proxy(staticProxy);
        proxy.print();
        
    }
}

输出：

Hello
I am Tom

静态代理模式的缺点：

静态代理模式写的太死，不利于维护和扩展。也就是说当我们有多个目标对象需要代理时，我就需要建立多个代理类，改变原有的代码。

动态代理模式运用反射解决了这个每个代理类都要重复写的问题。

(2)动态代理模式：

实现：

public interface IAnimal {

    public void go();
    public void bark();
}

public class Cat implements IAnimal {

    @Override
    public void go() {
        // TODO Auto-generated method stub
        System.out.println("going...");
    }

    @Override
    public void bark() {
        // TODO Auto-generated method stub
        System.out.println("barking...");
    }

}

public class DyProxy implements InvocationHandler{

    private Object obj;
    
    public DyProxy(Object obj){
        this.obj=obj;
    }    
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        
        System.out.println("动态代理！");
        
        return method.invoke(this.obj, args);
    }

}

public class Test {

    public static void main(String[] args) {
    
        IAnimal animal=new Cat();
        
        InvocationHandler handler=new DyProxy(animal); 
        
        Object o=Proxy.newProxyInstance(animal.getClass().getClassLoader(), 
                animal.getClass().getInterfaces(), handler);
        
        ((IAnimal)o).go();
        ((IAnimal)o).bark();
        
    }    
}

 输出： 

动态代理！
going...
动态代理！
barking...

二、适配器模式(Adapter)：

简单理解：

将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

就像翻译官能让两个不同语言的人沟通；手机充电器能降压给手机充电。

(1)类的适配器模式(采用继承实现)：

适配器使本来无法兼容到一起的植物和动物产生了联系。

public interface Plant {
    public void water();
}

public class Animal {

    public void bark(){
        System.out.println("叫");
    }
    
}

public class Adapter extends Animal implements Plant{

    @Override
    public void water() {
        // TODO Auto-generated method stub
        super.bark();
    }

}

public class Test {

    public static void main(String[] args) {
        Plant p=new Adapter();
        p.water();
    }
}

(2)对象适配器模式(采用对象组合方式实现)： 

public interface Plant {

    public void water();
}

public class Animal {

    public void bark(){
        System.out.println("叫");
    }
}

public class Adapter implements Plant{
    private Animal animal=new Animal();
    @Override
    public void water() {
        // TODO Auto-generated method stub
        animal.bark();
    }

}

public class Test {

    public static void main(String[] args) {
        Plant p=new Adapter();
        p.water();
    }
}