设计模式初步学习

创建型模式

单例模式

简单的单例模式

public class Signleton{
    private static Signleton instance;
    private Signleton(){
        System.out.println(" Signleton is Instantiated ");
    }
    public static Signleton getInstance(){
        if(null == instance){
            instance = new Signleton();
            return instance;
        }
    }
    public void dosomething(){
        System.out.println(" Something is Done ");
    }
}

​ 调用

Signleton.getInstance().dosomething();

同步锁单例模式

public static synchronized Signleton getInstance(){
        if(null == instance){
            instance = new Signleton();
            return instance;
        }
    }

synchronized(Signleton.class){
    if(null == instance){
            instance = new Signleton();
            return instance;
        }
}

双重锁校验机制的同步锁单例模式

if(null == instance){
    synchronized(Signleton.class){
    if(null == instance){
            instance = new Signleton();
            return instance;
        }
	}
}

无锁的线程安全单例模式

public class Signleton{
    private static final Signleton instance = new Signleton();
    private Signleton(){
        System.out.println(" Signleton is Instantiated ");
    }
    public static Signleton getInstance(){
        return instance;
    }
    public void dosomething(){
        System.out.println(" Something is Done ");
    }
}

提前加载和延迟加载

最安全的无锁的线程安全单例模式

public enum Signleton{
    
    INSTANCE;
    
    public void dosomething(){
        System.out.println(" Something is Done ");
    }
}

工厂模式

简单静态工厂模式

public interface Vehicle {
	void run();
}

public class Bike implements Vehicle {
	@Override
	public void run() {
		System.out.println("骑自行车");
	}
}

public class Car implements Vehicle {
	@Override
	public void run() {
		System.out.println("开小汽车");
	}
}

public class VehicleMain {
	public static void main(String[] args) {
		Vehicle car = VehicleFactory.create(VehicleFactory.VehicleType.Car);
		car.run();
		Vehicle bike = VehicleFactory.create(VehicleFactory.VehicleType.Bike);
		bike.run();
	}
}

public class VehicleFactory {
	public enum  VehicleType{
		Bike,Car;
	}
	public static Vehicle create(VehicleType type) {
		if(type.equals(VehicleType.Bike)) {
			return new Bike();
		} else if(type.equals(VehicleType.Car)) {
			return new Car();
		}else {
			return null;
		}
	}
}

反射机制进行类注册的的简单工厂模式

public interface Vehicle {
	void run();
}
public class Bike implements Vehicle {
	private String name; 
	public Bike(String name) {
			super();
			this.name = name;
		}
	@Override
	public void run() {
		System.out.println("骑"+name+"牌自行车");
	}
}
public class Car implements Vehicle {
	 private String name;
	 
	 public Car(String name) {
			super();
			this.name = name;
		}
	@Override
	public void run() {
		System.out.println("开"+name+"牌小汽车");
	}	
}

public class VehicleFactory {
	private Map<String, Class> registeredProduct=new HashMap<>();	
	// 注册工厂产品的方法
	public void registerVehicle(String type, Class Vehicle) {
		registeredProduct.put(type, Vehicle);
	}

	public Vehicle create(String type, String name) {
		try {
           	Class cls =registeredProduct.get(type);
           	Constructor<?> con = cls.getConstructor(String.class);
           	return (Vehicle)con.newInstance(name);
	        } catch (Exception e) {
	        	System.out.println("通过反射实现静态工厂模式出现异常");
	        	return null;
	        } 	
	}
}

public class VehicleMain {
	public static void main(String[] args) {
		VehicleFactory vehicleFactory = new VehicleFactory();
		vehicleFactory.registerVehicle("Car", Car.class);
		vehicleFactory.registerVehicle("Bike", Bike.class);
		Vehicle car = vehicleFactory.create("Car","宝马");
		car.run();
		Vehicle bike = vehicleFactory.create("Bike","凤凰");
		bike.run();
	}
}   

使用newInstance方法进行类注册的简单工厂模式

public interface Vehicle {	
	abstract public Vehicle newInstance();	
	void run();
}

public class Bike implements Vehicle {
	private String name; 
	public Bike(String name) {
			super();
			this.name = name;
		}
	public Bike() {
	}
	@Override
	public void run() {
		System.out.println("骑"+name+"牌自行车");
	}
	@Override
	public Bike newInstance() {		
		return new Bike();
	}
}
public class Car implements Vehicle {
	 private String name;
	 
	 public Car(String name) {
			super();
			this.name = name;
		}
	public Car() {
	}
	@Override
	public void run() {
		System.out.println("开"+name+"牌小汽车");
	}
	@Override
	public Car newInstance() {		
		return new Car();
	}	
}

import java.util.HashMap;
import java.util.Map;
public class VehicleFactory {
	private Map<String, Vehicle> registeredProduct=new HashMap<>();
	
	// 注册工厂产品的方法
	public void registerVehicle(String type, Vehicle Vehicle) {
		registeredProduct.put(type, Vehicle);
	}

	public Vehicle create(String type, String name) {
		return 	registeredProduct.get(type).newInstance();
	}
}

public class VehicleMain {
	public static void main(String[] args) {
		Vehicle vehicle=null;
		VehicleFactory vehicleFactory = new VehicleFactory();
		vehicle = new Car();
		vehicleFactory.registerVehicle("Car", vehicle);
		vehicle = new Bike();
		vehicleFactory.registerVehicle("Bike", vehicle);
		Vehicle car = vehicleFactory.create("Car","宝马");
		car.run();
		Vehicle bike = vehicleFactory.create("Bike","凤凰");
		bike.run();
	}
}   

工厂方法模式

public interface Vehicle {
	void run();
}

public class Car implements Vehicle {
	 private String name;	 
	 public Car(String name) {
			super();
			this.name = name;
		}
	public Car() {
	}
	@Override
	public void run() {
		System.out.println("开"+name+"牌小汽车");
	}	
}

public class Bike implements Vehicle {
	private String name; 
	public Bike(String name) {
			super();
			this.name = name;
		}
	public Bike() {
	}
	@Override
	public void run() {
		System.out.println("骑"+name+"牌自行车");
	}
}

public abstract class VehicleFactory {
	protected abstract Vehicle createVehicle(String item);
	public Vehicle orderVehicle(String size) {
		Vehicle vehicle = createVehicle(size);
		vehicle.run();
		return vehicle;
	}
}
public class CarFactory extends VehicleFactory {
	@Override
	protected Vehicle createVehicle(String item) {
		if(item.equals("Bike")) {
			return new Bike();
		}else if (item.equals("Car")) {
			return new Car();
		}else {
			return null;
		}
	}
}

public class VehicleMain {
	public static void main(String[] args) {
		VehicleFactory vehicleFactory = new CarFactory();
		vehicleFactory.orderVehicle("Car");
	}
}

匿名具体工厂模式

public class VehicleMain {
	public static void main(String[] args) {		
		VehicleFactory vehicleFactory = new VehicleFactory() {			
			@Override
			protected Vehicle createVehicle(String item) {
				if(item.equals("small")) {
					return new Bike();
				}else if (item.equals("larger")) {
					return new Car();
				}else {
					return null;
				}
			}
		};
	}
}

抽象工厂模式

建造者模式

简单的建造者模式

// 产品
public class Robot {
    private String head;
    private String body;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

// 创建者 builder
public interface IBuildRobot {
  void buildHead();
  void buildBody();
  void buildFoot();
  Robot fitRobot();
}
// 具体的建造者类concreteBuilder
public class BuildRobot implements IBuildRobot{
    private Robot robot;
    public BuildRobot(){
        robot=new Robot();
    }
    @Override
    public void buildHead() {
        robot.setHead("头部组装");
    }

    @Override
    public void buildBody() {
        robot.setBody("身体组装");
    }

    @Override
    public void buildFoot() {
        robot.setFoot("足部组装");
    }
    //组合
    @Override
    public Robot fitRobot() {
        return robot;
    }
}

// 指挥者 director
public class Director {
  public Robot createBuild(IBuildRobot iBuildRobot){
      iBuildRobot.buildHead();
      iBuildRobot.buildBody();
      iBuildRobot.buildFoot();
      return iBuildRobot.fitRobot();
  }
}
// 调用
public class Test {
	public static void main(String[] args) {
		IBuildRobot iBuildRobot=new BuildRobot();
        Director director=new Director();
        Robot build = director.createBuild(iBuildRobot);
        System.out.println(build.getHead());
        System.out.println(build.getBody());
        System.out.println(build.getFoot());
	}
}

拥有方法链的匿名建造者

public class Robot {
    private String head;
    private String body;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
    //定义静态方法获取内部建造者类
    public static Robot.BuildRobot builder(){
        return new Robot.BuildRobot();
    }
    // 私有化全参构造函数
    private Robot(String head, String body, String foot) {
		this.head = head;
		this.body = body;
		this.foot = foot;
	}
    // 具体建造者类
    public static class BuildRobot { 
    	private String head;
        private String body;
        private String foot;
    	
        public BuildRobot buildHead(String head) {
        	this.head = head;
        	return this;
        }

        public BuildRobot buildBody(String body) {
        	this.body = body;
        	return this;
        }

        public BuildRobot buildFoot(String foot) {
        	this.foot = foot;
        	return this;
        }
        public Robot builderRobot() {
            return new  Robot(head, body, foot);
        }
    }
}

原型模式

package designPattern.prototypePattern;
import java.util.Hashtable;
public abstract class Shape implements Cloneable {
	   
	   private String id;
	   protected String type;
	   
	   abstract void draw();
	   
	   public String getType(){
	      return type;
	   }
	   
	   public String getId() {
	      return id;
	   }
	   
	   public void setId(String id) {
	      this.id = id;
	   }
	   
	   public Object clone() {
	      Object clone = null;
	      try {
	         clone = super.clone();
	      } catch (CloneNotSupportedException e) {
	         e.printStackTrace();
	      }
	      return clone;
	   }
	}

class Rectangle extends Shape {
	 
	   public Rectangle(){
	     type = "Rectangle";
	   }
	 
	   @Override
	   public void draw() {
	      System.out.println("Inside Rectangle::draw() method.");
	   }
	}
class Square extends Shape {	 
	   public Square(){
	     type = "Square";
	   }	 
	   @Override
	   public void draw() {
	      System.out.println("Inside Square::draw() method.");
	   }
	}

class ShapeCache {
    
	   private static Hashtable<String, Shape> shapeMap 
	      = new Hashtable<String, Shape>();
	 
	   public static Shape getShape(String shapeId) {
	      Shape cachedShape = shapeMap.get(shapeId);
	      return (Shape) cachedShape.clone();
	   }
	 
	   // 对每种形状都运行数据库查询，并创建该形状
	   // shapeMap.put(shapeKey, shape);
	   // 例如，我们要添加三种形状
	   public static void loadCache() {
	 
	      Square square = new Square();
	      square.setId("2");
	      shapeMap.put(square.getId(),square);
	 
	      Rectangle rectangle = new Rectangle();
	      rectangle.setId("3");
	      shapeMap.put(rectangle.getId(),rectangle);
	   }
	}

public class PrototypePatternDemo {
	public static void main(String[] args) {
		ShapeCache.loadCache();
	
	      Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
	      System.out.println("Shape : " + clonedShape2.getType());        
	 
	      Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
	      System.out.println("Shape : " + clonedShape3.getType());
	}
}

对象池模式

实际应用:数据库连接池

行为型模式

责任链模式

介绍

主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

何时使用：在处理消息的时候以过滤很多道。

如何解决：拦截的类都实现统一接口。

关键代码：Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

应用实例： 1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        //组装责任链
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);
        //提交请求
        handler1.handleRequest("two");
    }
}
//抽象处理者角色
abstract class Handler {
    private Handler next;
    public void setNext(Handler next) {
        this.next = next;
    }
    public Handler getNext() {
        return next;
    }
    //处理请求的方法
    public abstract void handleRequest(String request);
}
//具体处理者角色1
class ConcreteHandler1 extends Handler {
    public void handleRequest(String request) {
        if (request.equals("one")) {
            System.out.println("具体处理者1负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}
//具体处理者角色2
class ConcreteHandler2 extends Handler {
    public void handleRequest(String request) {
        if (request.equals("two")) {
            System.out.println("具体处理者2负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

命令模式

应用场景

在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合

意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。

主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

何时使用：在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。

如何解决：通过调用者调用接受者执行命令，顺序：调用者→命令→接受者。

关键代码：定义三个角色：1、received 真正的命令执行对象 2、Command 3、invoker 使用命令对象的入口

应用实例：struts 1 中的 action 核心控制器 ActionServlet 只有一个，相当于 Invoker，而模型层的类会随着不同的应用有不同的模型类，相当于具体的 Command。

优点： 1、降低了系统耦合度。 2、新的命令可以很容易添加到系统中去。

缺点：使用命令模式可能会导致某些系统有过多的具体命令类。

使用场景：认为是命令的地方都可以使用命令模式，比如： 1、GUI 中每一个按钮都是一条命令。 2、模拟 CMD

package designPattern.CommandPattern;

public class CommandPattern {
    public static void main(String[] args) {
        Command cmd = new ConcreteCommand();
        Invoker ir = new Invoker(cmd);
        System.out.println("客户访问调用者的call()方法...");
        ir.call();
    }
}

//调用者
class Invoker {
    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public void setCommand(Command command) {
        this.command = command;
    }

    public void call() {
        System.out.println("调用者执行命令command...");
        command.execute();
    }
}

//抽象命令
interface Command {
    public abstract void execute();
}

//具体命令
class ConcreteCommand implements Command {
    private Receiver receiver;

    ConcreteCommand() {
        receiver = new Receiver();
    }

    public void execute() {
        receiver.action();
    }
}

//接收者
class Receiver {
    public void action() {
        System.out.println("接收者的action()方法被调用...");
    }
}

解释器模式

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

主要解决：对于一些固定文法构建一个解释句子的解释器。

何时使用：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

如何解决：构建语法树，定义终结符与非终结符。

关键代码：构建环境类，包含解释器之外的一些全局信息，一般是 HashMap。

应用实例：编译器、运算表达式计算。

优点： 1、可扩展性比较好，灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。

缺点： 1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。 4、解释器模式采用递归调用方法。

使用场景： 1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。

// Context环境角色
public class Context {
    private String input;
    private String output;

    public String getInput() {
        return input;
    }
    public void setInput(String input) {
        this.input = input;
    }
    public String getOutput() {
        return output;
    }
    public void setOutput(String output) {
        this.output = output;
    }
}
//  抽象表达式
public abstract class AbstractExpression {
    public abstract void Interpret(Context context);
}
// 终结符表达式
public class TerminalExpression extends AbstractExpression {
    @Override
    public void Interpret(Context context) {
        System.out.println("终端解释器");
    }
}
// 非终结符表达式
public class NonterminalExpression extends AbstractExpression {
    @Override
    public void Interpret(Context context) {
        System.out.println("非终端解释器");
    }
}

// Client客户端
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        List<AbstractExpression> list = new ArrayList<>();

        list.add(new TerminalExpression());
        list.add(new NonterminalExpression());
        list.add(new TerminalExpression());
        list.add(new TerminalExpression());
        for (AbstractExpression abstractExpression : list) {
            abstractExpression.Interpret(context);
        }
    }
}

迭代器模式IteratorPattern

意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决：不同的方式来遍历整个整合对象。

何时使用：遍历一个聚合对象。

如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码：定义接口：hasNext, next。

应用实例：JAVA 中的 iterator。

/**
 * 示例：迭代器模式
 */
interface Iterator {
	/** 前移 */
	public Object previous(); 
	/** 后移 */
	public Object next(); 
	/** 判断是否有下一个元素 */
	public boolean hasNext();
}
interface Collection {
	public Iterator iterator();
	/** 取得集合中的某个元素 */
	public Object get(int i);
	/** 取得集合大小 */
	public int size();
}
/**
 * 集合
 */
class MyCollection implements Collection {
	private String[] strArray = { "aa", "bb", "cc", "dd" };
	@Override
	public Iterator iterator() {
		return new MyIterator(this);
	}
	@Override
	public Object get(int i) {
		return strArray[i];
	}
	@Override
	public int size() {
		return strArray.length;
	}
} 
/**
 * 迭代器
 */
class MyIterator implements Iterator {
	private Collection collection;
	private int pos = -1; 
	public MyIterator(Collection collection) {
		this.collection = collection;
	}
	@Override
	public Object previous() {
		if (pos > 0) {
			pos--;
		}
		return collection.get(pos);
	}
	@Override
	public Object next() {
		if (pos < collection.size() - 1) {
			pos++;
		}
		return collection.get(pos);
	}
	@Override
	public boolean hasNext() {
		if (pos < collection.size() - 1) {
			return true;
		}
		return false;
	}
}

public class IteratorPattern {
	public static void main(String[] args) {
		/**
		 * 实例化容器
		 */
		Collection collection = new MyCollection();
		/**
		 * 创建迭代器
		 */
		Iterator iterator = collection.iterator();
		/**
		 * 遍历集合中的元素
		 */
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

观察者模式

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。

优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

使用场景：

一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
一个对象必须通知其他对象，而并不知道这些对象是谁。
需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。
注意事项： 1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

// 观察者数组
class Subject {
    //观察者数组
    private Vector<Observer> oVector = new Vector<>();
    //增加一个观察者
    public void addObserver(Observer observer) {
        this.oVector.add(observer);
    }
    //删除一个观察者
    public void deleteObserver(Observer observer) {
        this.oVector.remove(observer);
    }
    //通知所有观察者
    public void notifyObserver() {
        for(Observer observer : this.oVector) {
            observer.update();
        }
    }
}
// 具体主题
class ConcreteSubject extends Subject {
    //具体业务
    public void doSomething() {
        //...
        super.notifyObserver();
    }
}
// 抽象观察者Observer
interface Observer {
     //更新
     public void update();
 }
// 具体观察者
class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("收到消息，进行处理");
    }
}

public class Client {
	public static void main(String[] args) {
		//创建一个主题
        ConcreteSubject subject = new ConcreteSubject();
        //定义一个观察者
        Observer observer = new ConcreteObserver();
        //观察
        subject.addObserver(observer);
        //开始活动
        subject.doSomething();
	}
}

中介者模式

意图：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

何时使用：多个类相互耦合，形成了网状结构。

如何解决：将上述网状结构分离为星型结构。

关键代码：对象 Colleague 之间的通信封装到一个类中单独处理。

应用实例： 1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。4、定时发送任务。

优点： 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。

缺点：中介者会庞大，变得复杂难以维护

// 抽象同事类
abstract class SmartDevice {
	//相关设备打开之后 使其进入准备状态
	public abstract void readyState(String instruction);
        //操作该设备
	public abstract void operateDevice(String instruction, SmartMediator mediator);
}

// 具体同事类1
class CurtainDevice extends SmartDevice{
	public void operateDevice(String instruction,SmartMediator mediator) {
		System.out.println("窗帘已"+instruction);//通过传入指令，打开或关闭窗帘
		mediator.curtain(instruction);//窗帘通过中介者唤醒音乐设备和洗浴设备
	}
	public void readyState(String instruction) {
        //如果其他设备开启则调用此方法，唤醒窗帘
		    System.out.println("窗帘设备准备"+instruction);
	}
}
// 具体同事类2
class MusicDevice extends SmartDevice{
	public void operateDevice(String instruction,SmartMediator mediator) {
		System.out.println("音乐设备已"+instruction);
		mediator.music(instruction);
	}
	public void readyState(String instruction) {
		System.out.println("音乐设备准备"+instruction);
	}
}
// 具体同事类3
class BathDevice extends SmartDevice{
	public void operateDevice(String instruction, SmartMediator mediator) {
		System.out.println("洗浴设备"+instruction);
		mediator.bath(instruction);
	} 
	public void readyState(String instruction) {
		System.out.println("洗浴设备正在准备"+instruction);
	}
}
// 抽象中介者
abstract class SmartMediator {
    //保留所有设备的引用是为了当接收指令时可以唤醒其他设备的操作
	SmartDevice bd;
	SmartDevice md;
	SmartDevice cd;
	public SmartMediator(SmartDevice bd, SmartDevice md, SmartDevice cd) {
		super();
		this.bd = bd;
		this.md = md;
		this.cd = cd;
	}
	public abstract void music(String instruction);
	public abstract void curtain(String instruction);
	public abstract void bath(String instruction);
}

// 具体中介者
class ConcreteMediator extends SmartMediator{
	public ConcreteMediator(SmartDevice bd, SmartDevice cd, SmartDevice md) {
		super(bd, cd, md);
	}
	public void music(String instruction) {//音乐被唤醒后，使其他设备进入准备状态
		cd.readyState(instruction);//调用窗帘的准备方法
		bd.readyState(instruction);//调用洗浴设备的准备方法
	} 
	public void curtain(String instruction) {
		md.readyState(instruction);
		bd.readyState(instruction);
	}
	public void bath(String instruction) {
		cd.readyState(instruction);
		md.readyState(instruction);
	}
}

public class Client {
	public static void main(String[] args) {
		SmartDevice bd=new BathDevice();
		SmartDevice cd=new CurtainDevice();
		SmartDevice md=new MusicDevice();
		SmartMediator sm=new ConcreteMediator(bd, cd, md);//把设备引用都保存在调停者中
		cd.operateDevice("open",sm); //开启窗帘
		md.operateDevice("close",sm);//关闭音乐
	}
}

备忘录模式

意图：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

主要解决：所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。

何时使用：很多时候我们总是需要记录一个对象的内部状态，这样做的目的就是为了允许用户取消不确定或者错误的操作，能够恢复到他原先的状态，使得他有"后悔药"可吃。

如何解决：通过一个备忘录类专门存储对象状态。

关键代码：客户不与备忘录类耦合，与备忘录管理类耦合。

应用实例： 1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri + z。 4、IE 中的后退。 4、数据库的事务管理。

优点： 1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。 2、实现了信息的封装，使得用户不需要关心状态的保存细节。

缺点：消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

使用场景： 1、需要保存/恢复数据的相关状态场景。 2、提供一个可回滚的操作。

注意事项： 1、为了符合迪米特原则，还要增加一个管理备忘录的类。 2、为了节约内存，可使用原型模式+备忘录模式

// 发起人角色
class Originator {
    private String state;
    public String getState() {
        return state;
    }
    public void setState(String state) {
        this.state = state;
    }
    public Memento createMento() {
        return (new Memento(state));
    }
    public void setMemento(Memento memento) {
        state = memento.getState();
    }
    public void show() {
        System.out.println("state = " + state);
    }
}

// 备忘录角色
class Memento {
    private String state;
    public Memento(String state) {
        this.state = state;
    }
    public String getState() {
        return state;
    }
}

// 备忘录管理员角色
class Caretaker {
    private Memento memento;
    public Memento getMemento() {
        return memento;
    }
    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        originator.setState("On");    //Originator初始状态
        originator.show();

        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.createMento());

        originator.setState("Off");    //Originator状态变为Off
        originator.show();

        originator.setMemento(caretaker.getMemento());    //回复初始状态
        originator.show();
    }
}

状态模式

意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。

主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

何时使用：代码中包含大量与对象状态有关的条件语句。

如何解决：将各种具体的状态类抽象出来。

关键代码：通常命令模式的接口中只有一个方法。而状态模式的接口中有一个或者多个方法。而且，状态模式的实现类的方法，一般返回值，或者是改变实例变量的值。也就是说，状态模式一般和对象的状态有关。实现类的方法有不同的功能，覆盖接口中的方法。状态模式和命令模式一样，也可以用于消除 if...else 等条件选择语句。

应用实例： 1、打篮球的时候运动员可以有正常状态、不正常状态和超常状态。 2、曾侯乙编钟中，'钟是抽象接口','钟A'等是具体状态，'曾侯乙编钟'是具体环境（Context）。

优点： 1、封装了转换规则。 2、枚举可能的状态，在枚举状态之前需要确定状态种类。 3、将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。 4、允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。 5、可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

缺点： 1、状态模式的使用必然会增加系统类和对象的个数。 2、状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。 3、状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码。

使用场景： 1、行为随状态改变而改变的场景。 2、条件、分支语句的代替者。

注意事项：在行为受状态约束的时候使用状态模式，而且状态不超过 5 个。

package designPattern.StatePattern;
// 抽象状态角色
interface State {
    //行为1
    public void handle1();
    //行为2
    public void handle2();
}
// 具体状态角色
class ConcreteStateA implements State {
    private Context context;
    public ConcreteStateA(Context context) {
        this.context = context;
    }
    @Override
    public void handle1() {
        //当前状态下handle1行为的处理
        //...
    	System.out.println("当前ConcreteStateA状态下handle1行为的处理");
    }
    @Override
    public void handle2() {
        //当前状态下handle2行为的处理
        //...
        this.context.setCurrentSate(Context.STATE_B);
        System.out.println("当前ConcreteStateA状态下handle2行为的处理");
    }
}
class ConcreteStateB implements State {
    private Context context;
    public ConcreteStateB(Context context) {
        this.context = context;
    }
    @Override
    public void handle1() {
        //当前状态下handle1行为的处理
        //...
    	System.out.println("当前ConcreteStateB状态下handle1行为的处理");
    }
    @Override
    public void handle2() {
        //当前状态下handle2行为的处理
        //...
        this.context.setCurrentSate(Context.STATE_A);
        System.out.println("当前ConcreteStateB状态下handle2行为的处理");
    }
}
// 上下文角色
class Context {
    public static State STATE_A;
    public static State STATE_B;
    private State currentSate;

    public Context() {
        STATE_A = new ConcreteStateA(this);
        STATE_B = new ConcreteStateB(this);
    }

    public void setCurrentSate(State currentSate) {
        this.currentSate = currentSate;
    }

    public void handle1(){
        this.currentSate.handle1();
    }

    public void handle2(){
        this.currentSate.handle2();
    }
}
public class Client {
    public static void main(String[] args) {
        //创建环境对象
        Context context = new Context();
        //初始化状态
        context.setCurrentSate(new ConcreteStateA(context));
        //执行动作
        context.handle1();
        context.handle2();
    }
}

策略模式

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

// Context上下文
class Context {

    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    //上下文接口
    public void contextInterface() {
        strategy.algorithmInterface();
    }

}
// 策略角色
abstract class Strategy {
	//算法方法
    public abstract void algorithmInterface();
}
// 具体策略角色
class ConcreteStrategyA extends Strategy {
    @Override
    public void algorithmInterface() {
        System.out.println("算法A实现");
    }
}

class ConcreteStrategyB extends Strategy {
    @Override
    public void algorithmInterface() {
        System.out.println("算法B实现");
    }
}
class ConcreteStrategyC extends Strategy {
    @Override
    public void algorithmInterface() {
        System.out.println("算法C实现");
    }
}
public class Client {
    public static void main(String[] args) {
        Context context;
        
        context = new Context(new ConcreteStrategyA());
        context.contextInterface();

        context = new Context(new ConcreteStrategyB());
        context.contextInterface();

        context = new Context(new ConcreteStrategyC());
        context.contextInterface();
    }

}

模板方法模式

意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

主要解决：一些方法通用，却在每一个子类都重新写了这一方法。

何时使用：有一些通用的方法。

如何解决：将这些通用算法抽象出来。

关键代码：在抽象类实现，其他步骤在子类实现。

应用实例： 1、在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。 2、西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。 3、spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。

package designPattern.TemplatePattern;
abstract class Game {
	   abstract void initialize();
	   abstract void startPlay();
	   abstract void endPlay();	 
	   //模板
	   public final void play(){	 
	      //初始化游戏
	      initialize();	 
	      //开始游戏
	      startPlay();	 
	      //结束游戏
	      endPlay();
	   }
	}

class Cricket extends Game {	 
	   @Override
	   void endPlay() {
	      System.out.println("Cricket Game Finished!");
	   }	 
	   @Override
	   void initialize() {
	      System.out.println("Cricket Game Initialized! Start playing.");
	   }	 
	   @Override
	   void startPlay() {
	      System.out.println("Cricket Game Started. Enjoy the game!");
	   }
	}

class Football extends Game {	 
	   @Override
	   void endPlay() {
	      System.out.println("Football Game Finished!");
	   }	 
	   @Override
	   void initialize() {
	      System.out.println("Football Game Initialized! Start playing.");
	   }	 
	   @Override
	   void startPlay() {
	      System.out.println("Football Game Started. Enjoy the game!");
	   }
	}

public class TemplatePatternDemo {
	public static void main(String[] args) {
		Game game = new Cricket();
	      game.play();
	      System.out.println();
	      game = new Football();
	      game.play();
	}
}

空对象模式

在空对象模式（Null Object Pattern）中，一个空对象取代 NULL 对象实例的检查。Null 对象不是检查空值，而是反应一个不做任何动作的关系。这样的 Null 对象也可以在数据不可用的时候提供默认的行为。

在空对象模式中，我们创建一个指定各种要执行的操作的抽象类和扩展该类的实体类，还创建一个未对该类做任何实现的空对象类，该空对象类将无缝地使用在需要检查空值的地方。

package designPattern.NullObjectPattern;

// 抽象类
abstract class AbstractCustomer {
	   protected String name;
	   public abstract boolean isNil();
	   public abstract String getName();
	}
// 实例化的对象
class RealCustomer extends AbstractCustomer {
	 
	   public RealCustomer(String name) {
	      this.name = name;    
	   }
	   
	   @Override
	   public String getName() {
	      return name;
	   }
	   
	   @Override
	   public boolean isNil() {
	      return false;
	   }
	}
// 未实例化的对象
class NullCustomer extends AbstractCustomer {
	 
	   @Override
	   public String getName() {
	      return "Not Available in Customer Database";
	   }
	 
	   @Override
	   public boolean isNil() {
	      return true;
	   }
	}
// 工厂模式创建对象
class CustomerFactory {	   
	   public static final String[] names = {"Rob", "Joe", "Julie"};// 这边可以优化成枚举	 
	   public static AbstractCustomer getCustomer(String name){
	      for (int i = 0; i < names.length; i++) {
	         if (names[i].equalsIgnoreCase(name)){
	            return new RealCustomer(name);
	         }
	      }
	      return new NullCustomer();
	   }
	}
// 客户端
public class NullPatternDemo {
	public static void main(String[] args) {
		AbstractCustomer customer1 = CustomerFactory.getCustomer("Rob");
	      AbstractCustomer customer2 = CustomerFactory.getCustomer("Bob");
	      AbstractCustomer customer3 = CustomerFactory.getCustomer("Julie");
	      AbstractCustomer customer4 = CustomerFactory.getCustomer("Laura");
	 
	      System.out.println("Customers");
	      System.out.println(customer1.getName());
	      System.out.println(customer2.getName());
	      System.out.println(customer3.getName());
	      System.out.println(customer4.getName());
	}
}

访问者模式

意图：主要将数据结构与数据操作分离。

主要解决：稳定的数据结构和易变的操作耦合问题。

何时使用：需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。

如何解决：在被访问的类里面加一个对外提供接待访问者的接口。

关键代码：在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。

应用实例：您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。

优点： 1、符合单一职责原则。 2、优秀的扩展性。 3、灵活性。

缺点： 1、具体元素对访问者公布细节，违反了迪米特原则。 2、具体元素变更比较困难。 3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

使用场景： 1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。

注意事项：访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。

package designPattern.VisitorPattern;
// 元素接口
interface ComputerPart {
	public void accept(ComputerPartVisitor computerPartVisitor);
}
// 具体实现元素
class Keyboard  implements ComputerPart {	 
	   @Override
	   public void accept(ComputerPartVisitor computerPartVisitor) {
	      computerPartVisitor.visit(this);
	   }
	}
class Monitor  implements ComputerPart {	 
	   @Override
	   public void accept(ComputerPartVisitor computerPartVisitor) {
	      computerPartVisitor.visit(this);
	   }
	}
class Mouse  implements ComputerPart {	 
	   @Override
	   public void accept(ComputerPartVisitor computerPartVisitor) {
	      computerPartVisitor.visit(this);
	   }	   	   
}
class Computer implements ComputerPart {	   
	   ComputerPart[] parts;	 
	   public Computer(){
	      parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};      
	   } 	 
	   @Override
	   public void accept(ComputerPartVisitor computerPartVisitor) {
	      for (int i = 0; i < parts.length; i++) {
	         parts[i].accept(computerPartVisitor);
	      }
	      computerPartVisitor.visit(this);
	   }
}
// 访问者接口
interface ComputerPartVisitor {
	   public void visit(Computer computer);
	   public void visit(Mouse mouse);
	   public void visit(Keyboard keyboard);
	   public void visit(Monitor monitor);
}
class ComputerPartDisplayVisitor implements ComputerPartVisitor {	 
	   @Override
	   public void visit(Computer computer) {
	      System.out.println("Displaying Computer.");
	   }	 
	   @Override
	   public void visit(Mouse mouse) {
	      System.out.println("Displaying Mouse.");
	   }	 
	   @Override
	   public void visit(Keyboard keyboard) {
	      System.out.println("Displaying Keyboard.");
	   }	 
	   @Override
	   public void visit(Monitor monitor) {
	      System.out.println("Displaying Monitor.");
	   }
}
public class VisitorPatternDemo {
	public static void main(String[] args) {
		 ComputerPart computer = new Computer();
	     computer.accept(new ComputerPartDisplayVisitor());
	}
}

结构性模式

适配器模式

意图：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

主要解决：主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

何时使用： 1、系统需要使用现有的类，而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。 3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）

如何解决：继承或依赖（推荐）。

关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。

应用实例： 1、美国电器 110V，中国 220V，就要有一个适配器将 110V 转化为 220V。 2、JAVA JDK 1.1 提供了 Enumeration 接口，而在 1.2 中提供了 Iterator 接口，想要使用 1.2 的 JDK，则要将以前系统的 Enumeration 接口转化为 Iterator 接口，这时就需要适配器模式。 3、在 LINUX 上运行 WINDOWS 程序。 4、JAVA 中的 jdbc。

优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。

缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

使用场景：有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。

注意事项：适配器不是在详细设计时添加的，而是解决正在服役的项目的问题。

// 接口
interface MediaPlayer {
	   public void play(String audioType, String fileName);
	}
interface AdvancedMediaPlayer { 
	   public void playVlc(String fileName);
	   public void playMp4(String fileName);
	}
// 接口实现类
class VlcPlayer implements AdvancedMediaPlayer{
	   @Override
	   public void playVlc(String fileName) {
	      System.out.println("Playing vlc file. Name: "+ fileName);      
	   }
	 
	   @Override
	   public void playMp4(String fileName) {
	      //什么也不做
	   }
	}
class Mp4Player implements AdvancedMediaPlayer{	 
	   @Override
	   public void playVlc(String fileName) {
	      //什么也不做
	   }
	 
	   @Override
	   public void playMp4(String fileName) {
	      System.out.println("Playing mp4 file. Name: "+ fileName);      
	   }
	}
// 适配器类
class MediaAdapter implements MediaPlayer {	 
	   AdvancedMediaPlayer advancedMusicPlayer;
	 
	   public MediaAdapter(String audioType){
	      if(audioType.equalsIgnoreCase("vlc") ){
	         advancedMusicPlayer = new VlcPlayer();       
	      } else if (audioType.equalsIgnoreCase("mp4")){
	         advancedMusicPlayer = new Mp4Player();
	      }  
	   }
	 
	   @Override
	   public void play(String audioType, String fileName) {
	      if(audioType.equalsIgnoreCase("vlc")){
	         advancedMusicPlayer.playVlc(fileName);
	      }else if(audioType.equalsIgnoreCase("mp4")){
	         advancedMusicPlayer.playMp4(fileName);
	      }
	   }
	}
class AudioPlayer implements MediaPlayer {
	   MediaAdapter mediaAdapter; 	 
	   @Override
	   public void play(String audioType, String fileName) {    
	 
	      //播放 mp3 音乐文件的内置支持
	      if(audioType.equalsIgnoreCase("mp3")){
	         System.out.println("Playing mp3 file. Name: "+ fileName);         
	      } 
	      //mediaAdapter 提供了播放其他文件格式的支持
	      else if(audioType.equalsIgnoreCase("vlc") 
	         || audioType.equalsIgnoreCase("mp4")){
	         mediaAdapter = new MediaAdapter(audioType);
	         mediaAdapter.play(audioType, fileName);
	      }
	      else{
	         System.out.println("Invalid media. "+
	            audioType + " format not supported");
	      }
	   }   
	}
public class AdapterPatternDemo {
	public static void main(String[] args) {
		AudioPlayer audioPlayer = new AudioPlayer();		 
	      audioPlayer.play("mp3", "beyond the horizon.mp3");
	      audioPlayer.play("mp4", "alone.mp4");
	      audioPlayer.play("vlc", "far far away.vlc");
	      audioPlayer.play("avi", "mind me.avi");
	}
}

代理模式

分类 远程代理 保护代理 缓存代理 虚拟和智能代理
意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

关键代码：实现与被代理类组合。

应用实例： 1、Windows 里面的快捷方式。 2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。 3、买火车票不一定在火车站买，也可以去代售点。 4、一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。 5、spring aop。

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

package designPattern.ProxyPattern;
// 共同接口
interface Image {
	   void display();
	}
// RealSubject 真实对象的类
class RealImage implements Image {
	 
	   private String fileName;
	 
	   public RealImage(String fileName){
	      this.fileName = fileName;
	      loadFromDisk(fileName);
	   }
	 
	   @Override
	   public void display() {
	      System.out.println("Displaying " + fileName);
	   }
	 
	   private void loadFromDisk(String fileName){
	      System.out.println("Loading " + fileName);
	   }
	}
// ProxySubject 代理类
class ProxyImage implements Image{
	 
	   private RealImage realImage;
	   private String fileName;
	 
	   public ProxyImage(String fileName){
	      this.fileName = fileName;
	   }
	 
	   @Override
	   public void display() {
	      if(realImage == null){
	         realImage = new RealImage(fileName);
	      }
	      realImage.display();
	   }
	}
public class ProxyPatternDemo {
	public static void main(String[] args) {
		Image image = new ProxyImage("test_10mb.jpg");		 
	      // 图像将从磁盘加载
	      image.display(); 
	      System.out.println("");
	      // 图像不需要从磁盘加载
	      image.display();
	}
}

装饰器模式

意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用：在不想增加很多子类的情况下扩展类。

如何解决：将具体功能职责划分，同时继承装饰者模式。

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

应用实例： 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点：多层装饰比较复杂。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承

package designPattern.DecoratorPattern;
// 创建接口 抽象组件Component
interface Shape {
	void draw();
}
// 实现接口的实体类 想装饰的组件Componentimplementation
class Rectangle implements Shape {
	 
	   @Override
	   public void draw() {
	      System.out.println("Shape: Rectangle");
	   }
	}
class Circle implements Shape {
	 
	   @Override
	   public void draw() {
	      System.out.println("Shape: Circle");
	   }
	}
// 创建实现了 Shape 接口的抽象装饰类。 抽象的组件装饰器Decorator
abstract class ShapeDecorator implements Shape {
	   protected Shape decoratedShape;
	 
	   public ShapeDecorator(Shape decoratedShape){
	      this.decoratedShape = decoratedShape;
	   }
	 
	   public void draw(){
	      decoratedShape.draw();
	   }  
	}
// 创建扩展了 ShapeDecorator 类的实体装饰类
// 添加额外功能的组件装饰器
class RedShapeDecorator extends ShapeDecorator {
	 
	   public RedShapeDecorator(Shape decoratedShape) {
	      super(decoratedShape);     
	   }
	 
	   @Override
	   public void draw() {
	      decoratedShape.draw();         
	      setRedBorder(decoratedShape);
	   }
	 
	   private void setRedBorder(Shape decoratedShape){
	      System.out.println("Border Color: Red");
	   }
	}
public class DecoratorPatternDemo {
	public static void main(String[] args) {
		Shape circle = new Circle();
	      ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
	      ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
	      //Shape redCircle = new RedShapeDecorator(new Circle());
	      //Shape redRectangle = new RedShapeDecorator(new Rectangle());
	      System.out.println("Circle with normal border");
	      circle.draw();
	 
	      System.out.println("\nCircle of red border");
	      redCircle.draw();
	 
	      System.out.println("\nRectangle of red border");
	      redRectangle.draw();
	}
}

桥接模式

意图：将抽象部分与实现部分分离，使它们都可以独立的变化。

主要解决：在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活。

何时使用：实现系统可能有多个角度分类，每一种角度都可能变化。

如何解决：把这种多角度分类分离出来，让它们独立变化，减少它们之间耦合。

关键代码：抽象类依赖实现类。

应用实例： 1、猪八戒从天蓬元帅转世投胎到猪，转世投胎的机制将尘世划分为两个等级，即：灵魂和肉体，前者相当于抽象化，后者相当于实现化。生灵通过功能的委派，调用肉体对象的功能，使得生灵可以动态地选择。 2、墙上的开关，可以看到的开关是抽象的，不用管里面具体怎么实现的。

优点： 1、抽象和实现的分离。 2、优秀的扩展能力。 3、实现细节对客户透明。

缺点：桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。

使用场景： 1、如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。 2、对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。 3、一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。

注意事项：对于两个独立变化的维度，使用桥接模式再适合不过了。

package designPattern.BridgePattern;
// 创建实现桥接接口
interface DrawAPI {
	   public void drawCircle(int radius, int x, int y);
	}
// 创建实现了 DrawAPI 接口的实体桥接实现类。
class RedCircle implements DrawAPI {
	   @Override
	   public void drawCircle(int radius, int x, int y) {
	      System.out.println("Drawing Circle[ color: red, radius: "
	         + radius +", x: " +x+", "+ y +"]");
	   }
	}
class GreenCircle implements DrawAPI {
	   @Override
	   public void drawCircle(int radius, int x, int y) {
	      System.out.println("Drawing Circle[ color: green, radius: "
	         + radius +", x: " +x+", "+ y +"]");
	   }
	}
// 使用 DrawAPI 接口创建抽象类 Shape。
abstract class Shape {
	   protected DrawAPI drawAPI;
	   protected Shape(DrawAPI drawAPI){
	      this.drawAPI = drawAPI;
	   }
	   public abstract void draw();  
	}
// 创建实现了 Shape 抽象类的实体类。
class Circle extends Shape {
	   private int x, y, radius;	 
	   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
	      super(drawAPI);
	      this.x = x;  
	      this.y = y;  
	      this.radius = radius;
	   }	 
	   public void draw() {
	      drawAPI.drawCircle(radius,x,y);
	   }
	}
// 使用 Shape 和 DrawAPI 类画出不同颜色的圆
public class BridgePatternDemo {
	public static void main(String[] args) {
		 Shape redCircle = new Circle(100,100, 10, new RedCircle());
	      Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
	      redCircle.draw();
	      greenCircle.draw();
	}
}

组合模式

意图：将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

主要解决：它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

何时使用： 1、您想表示对象的部分-整体层次结构（树形结构）。 2、您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

如何解决：树枝和叶子实现统一接口，树枝内部组合该接口。

关键代码：树枝内部组合该接口，并且含有内部属性 List，里面放 Component。

应用实例： 1、算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数。 2、在 JAVA AWT 和 SWING 中，对于 Button 和 Checkbox 是树叶，Container 是树枝。

优点： 1、高层模块调用简单。 2、节点自由增加。

缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

使用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。

注意事项：定义时为具体类。

package designPattern.CompositePattern;

import java.util.ArrayList;
import java.util.List;

/**
 * 组合模式
 * @author port
 *
 */
// Component抽象节点  也可以是接口
abstract class Component {
    protected String name;

    public Component(String name) {
        this.name = name;
    }

    public abstract void operation();

   public void add(Component c) {
        throw new UnsupportedOperationException();
    }

    public void remove(Component c) {
        throw new UnsupportedOperationException();
    }

    public Component getChild(int i) {
        throw new UnsupportedOperationException();
    }

    public List<Component> getChildren() {
        return null;
    }
}
// Composite复合节点
class Composite extends Component {
    private List<Component> components = new ArrayList<>();

    public Composite(String name) {
        super(name);
    }

    @Override
    public void operation() {
        System.out.println("组合节点"+name+"的操作");
        //调用所有子节点的操作
        for (Component component : components) {
             component.operation();
        }
    }

    @Override
    public void add(Component c) {
        components.add(c);
    }

    @Override
    public void remove(Component c) {
        components.remove(c);
    }

    @Override
    public Component getChild(int i) {
        return components.get(i);
    }

    @Override
    public List<Component> getChildren() {
        return components;
    }
}
// Leaf 叶子节点
class Leaf extends Component {

    public Leaf(String name) {
        super(name);
    }

    @Override
    public void operation() {
        System.out.println("叶节点"+name+"的操作");
    }
}
// 客户端
public class Client {

	public static void main(String[] args) {
		//创建根节点对象
        Component component = new Composite("component");

        //创建两个组合节点对象
        Component composite1 = new Composite("composite1");
        Component composite2 = new Composite("composite2");

        //将两个组合节点对象添加到根节点
        component.add(composite1);
        component.add(composite2);

        //给第一个组合节点对象添加两个叶子节点
        Component leaf1 = new Leaf("leaf1");
        Component leaf2 = new Leaf("leaf2");
        composite1.add(leaf1);
        composite1.add(leaf2);

        //给第二个组合节点对象添加一个叶子节点和一个组合节点
        Component leaf3 = new Leaf("leaf3");
        Component composite3 = new Composite("composite3");
        composite2.add(leaf3);
        composite2.add(composite3);

        //给第二个组合节点下面的组合节点添加两个叶子节点
        Component leaf4 = new Leaf("leaf4");
        Component leaf5 = new Leaf("leaf5");
        composite3.add(leaf4);
        composite3.add(leaf5);

        //执行所有节点的操作
        component.operation();
	}

}

外观模式

意图：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。

何时使用： 1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个"接待员"即可。 2、定义系统的入口。

如何解决：客户端不与系统耦合，外观类与系统耦合。

关键代码：在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。

应用实例： 1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。 2、JAVA 的三层开发模式。

优点： 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。

缺点：不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。

使用场景： 1、为复杂的模块或子系统提供外界访问的模块。 2、子系统相对独立。 3、预防低水平人员带来的风险。

注意事项：在层次化结构中，可以使用外观模式定义系统中每一层的入口

// 子系统接口
interface Shape {
	   void draw();
	}
// 子系统实现类
class Rectangle implements Shape {
	 
	   @Override
	   public void draw() {
	      System.out.println("Rectangle::draw()");
	   }
	}

class Square implements Shape {
	 
	   @Override
	   public void draw() {
	      System.out.println("Square::draw()");
	   }
	}

class Circle implements Shape {
	 
	   @Override
	   public void draw() {
	      System.out.println("Circle::draw()");
	   }
	}
// 外观类
class ShapeMaker {
	   private Shape circle;
	   private Shape rectangle;
	   private Shape square;
	 
	   public ShapeMaker() {
	      circle = new Circle();
	      rectangle = new Rectangle();
	      square = new Square();
	   }	 
	   public void drawCircle(){
	      circle.draw();
	   }
	   public void drawRectangle(){
	      rectangle.draw();
	   }
	   public void drawSquare(){
	      square.draw();
	   }
	}
// client 实现类
public class FacadePatternDemo {
	public static void main(String[] args) {
		ShapeMaker shapeMaker = new ShapeMaker();
		 
	      shapeMaker.drawCircle();
	      shapeMaker.drawRectangle();
	      shapeMaker.drawSquare();
	}
}

享元模式

意图：运用共享技术有效地支持大量细粒度的对象。

主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。

何时使用： 1、系统中有大量对象。 2、这些对象消耗大量内存。 3、这些对象的状态大部分可以外部化。 4、这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。 5、系统不依赖于这些对象身份，这些对象是不可分辨的。

如何解决：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。

关键代码：用 HashMap 存储这些对象。

应用实例： 1、JAVA 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。 2、数据库的数据池。

优点：大大减少对象的创建，降低系统的内存，使效率提高。

缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

使用场景： 1、系统有大量相似对象。 2、需要缓冲池的场景。

注意事项： 1、注意划分外部状态和内部状态，否则可能会引起线程安全问题。 2、这些类必须有一个工厂对象加以控制。

// Flyweight抽象类 抽象享元类
abstract class Flyweight {

    //内部状态
    public String intrinsic;
    //外部状态
    protected final String extrinsic;

    //要求享元角色必须接受外部状态
    public Flyweight(String extrinsic) {
        this.extrinsic = extrinsic;
    }

    //定义业务操作
    public abstract void operate(int extrinsic);

    public String getIntrinsic() {
        return intrinsic;
    }

    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }

}
// ConcreteFlyweight类 与其同伴共享状态的享元对象
class ConcreteFlyweight extends Flyweight {
    //接受外部状态
    public ConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }
    //根据外部状态进行逻辑处理
    @Override
    public void operate(int extrinsic) {
        System.out.println("具体Flyweight:" + extrinsic);
    }
}
// UnsharedConcreteFlyweight类 不共享其状态的享元对象
class UnsharedConcreteFlyweight extends Flyweight {

    public UnsharedConcreteFlyweight(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate(int extrinsic) {
        System.out.println("不共享的具体Flyweight:" + extrinsic);
    }

}
// FlyweightFactory类
class FlyweightFactory {

    //定义一个池容器
    private static HashMap<String, Flyweight> pool = new HashMap<>();

    //享元工厂
    public static Flyweight getFlyweight(String extrinsic) {
        Flyweight flyweight = null;

        if(pool.containsKey(extrinsic)) {    //池中有该对象
            flyweight = pool.get(extrinsic);
            System.out.print("已有 " + extrinsic + " 直接从池中取---->");
        } else {
            //根据外部状态创建享元对象
            flyweight = new ConcreteFlyweight(extrinsic);
            //放入池中
            pool.put(extrinsic, flyweight);
            System.out.print("创建 " + extrinsic + " 并从池中取出---->");
        }

        return flyweight;
    }
}
// 客户端
public class Client {

	public static void main(String[] args) {
		int extrinsic = 22;

        Flyweight flyweightX = FlyweightFactory.getFlyweight("X");
        flyweightX.operate(++ extrinsic);

        Flyweight flyweightY = FlyweightFactory.getFlyweight("Y");
        flyweightY.operate(++ extrinsic);

        Flyweight flyweightZ = FlyweightFactory.getFlyweight("Z");
        flyweightZ.operate(++ extrinsic);

        Flyweight flyweightReX = FlyweightFactory.getFlyweight("X");
        flyweightReX.operate(++ extrinsic);

        Flyweight unsharedFlyweight = new UnsharedConcreteFlyweight("X");
        unsharedFlyweight.operate(++ extrinsic);
	}

}