Java 设计模式复习 之 适配器 ，桥，命令，解释器，中介者，观察者，原型，访问者

1. 适配器

适配器有3种，一种对象适配器，类适配器，缺省适配器

其中缺省适配器 以一个 abstract 的class 实现接口的所有方法，是一个空class ，而所需要的类只需要实现他们自己需要的方法

package adapter;
//这是所谓的缺省适配器模式，是使用一个抽象类实现了所有的接口方法
public interface IFood
{
    public void getApple();
    public void getBanana();
    public void getBread();
}

　　

package adapter;

public class FoodImpl implements IFood{

    @Override
    public void getApple() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void getBanana() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void getBread() {
        // TODO Auto-generated method stub
        
    }

}

　　

package adapter;

public class PersonA extends FoodImpl{
    public void getApple()
    {
        System.out.println("i like apple");
    }
    
    public void getBanana() {
        // TODO Auto-generated method stub
        System.out.println("i like banana");
    }

}

　　

package adapter;

public class PersonB extends FoodImpl{
    public void getBread()
    {
        System.out.println("i like bread");
    }

}

　　

package adapter;

public class Client {
    public static void main(String [] args)
    {
        PersonA a = new PersonA();
        PersonB b = new PersonB();
        a.getApple();
        a.getBanana();
        b.getBread();
    }
}

　　对象适配器，实现所需要实现的接口，包含现在已有的类

package adapter_object;

public interface Target {
    public void getApple();
    public void getBanana();
    public void getBread();
}

　　

package adapter_object;

public class Adaptee {
    public void getApple()
    {
        System.out.println("i like apple");
    }

}

　　

package adapter_object;

//适用范围：系统需要使用现有的类，但是接口不符合系统要求
public class Adapter implements Target{
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee)
    {
        this.adaptee = adaptee;
    }

    @Override
    public void getApple() {
        // TODO Auto-generated method stub
        adaptee.getApple();
    }

    @Override
    public void getBanana() {
        // TODO Auto-generated method stub
        System.out.println("i like banana");
    }

    @Override
    public void getBread() {
        // TODO Auto-generated method stub
        System.out.println("i like break");
    }
    
    
    public static void main(String [] args)
    {
        Adaptee adaptee = new Adaptee();
        Adapter adapter = new Adapter(adaptee);
        adapter.getApple();
        adapter.getBanana();
        adapter.getBread();
    }

}

　　类适配器，实现所需要实现的接口，继承现在有的

package adapter_class;

public interface Target {
    public void getApple();
    public void getBanana();
    public void getBread();
}

　　

package adapter_class;
//原来的类，要被适配的类
public class Adaptee {
    public void getApple()
    {
        System.out.println("i like apple");
    }

}

　　

package adapter_class;
//用target 去适配 adaptee 
public class Adapter extends Adaptee implements Target{

    @Override
    public void getBanana() {
        // TODO Auto-generated method stub
        System.out.println("i like banana");
    }

    @Override
    public void getBread() {
        // TODO Auto-generated method stub
        System.out.println("i like bread");
    }
    
    public static void main(String [] args)
    {
        Adapter adapter = new Adapter();
        adapter.getApple();
        adapter.getBanana();
        adapter.getBread();
    }

}

　　

2.  桥接模式

桥模式主要用于在两个维度上变化， 在 一个维度的抽象包含有另一个维度的引用： public Implementor impl;

例子

一个抽象路和抽象车两个方向的变化相会不会影响

例如在抽象路中有抽象车的引用：

package bridge_example;

public abstract class AbstractRoad {
    protected AbstractCar car;
    public AbstractRoad(AbstractCar car)
    {
        this.car = car;
    }
    public abstract void run();

}

　　

3.  命令模式 

一个命令模式的具体命令含有命令接受者的引用

public class ConcreteCommandB implements Command{
    private Receiver receiver;
    public ConcreteCommandB(Receiver receiver)
    {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        // TODO Auto-generated method stub
        receiver.action();
        System.out.println("by  ConcreteCommandB!");
    }

}

　　而接受者可以对命令作出反应

package command;
//receiver 是命令的接收者

public class Receiver {
    public Receiver()
    {
        
    }
    public void action()
    {
        System.out.print("Action ");
    }

}

　　

请求者负责调度整个命令

package command;
//请求者

public class Invoker {
    public Command command;
    public Invoker(Command command)
    {
        this.command = command;
    }
    public void action()
    {
        this.command.execute();
    }

}

　　另外，命令模式还可以实现 undo redo的功能

public void redo(int levels)
    {
        System.out.println("-----redo " + levels + "levels");
        for(int i = 0;i < levels; i ++)
        {
            int result = count();
            if(current < result - 1)
                ((Command)commands.get(current ++)).execute();
            
        }
    }
    
    public void undo(int levels)
    {
        System.out.println("-------undo " + levels + "levels");
        for(int i = 0;i < levels;i ++)
            if(current > 0)
            ((Command)commands.get(--current)).unExecute();
            
    }

　　4. 解释器模式，主要用于解释执行，例子为 简单的 逻辑运算符解析

      5. 中介者模式，主要由于各个类之间关系调用复杂时，由一个统一的类去调度，而各个类都含有这个中介者的引用，在具体中介者中，也含有各个类的引用

     6 原型模式，设计Java中的浅拷贝和深拷贝的问题，Java中有实现的接口Cloneable

    7. 观察者模式 

    8 访问者模式

   上传一下这一两天抽时间写的模式，算是复习加强记==  

https://files.cnblogs.com/hitwtx/src.zip