设计模式知识整理

一、创建型模式

1.1、单例模式

1.1.1、作用

1）一个类只有一个实例对象，提供一个全局访问方法；
2）只有一个实例，减少系统开销；
3）适合共享资源访问（数据库连接池、Spring中默认bean、Application容器等）

1.1.2、饿汉式

package com.example.mp.pattern.singleton;

/**
 * 饿汉式
 */
public class Singleton01 {
	//1/类初始化时，立即加载该对象，加载类时线程安全
	private static Singleton01 instance = new Singleton01();
	//2、私有化构造器
	private Singleton01(){
	}
	//3、无同步方法调用效率更高
	public static Singleton01 getInstance(){
		return instance;
	}
}

1.1.3、懒汉式

package com.example.mp.pattern.singleton;

/**
 * 懒汉式
 */
public class Singleton02 {
	//1、类初始化时，不初始化创建该对象（延时加载，用到时创建）
	private static Singleton02 instance;
	//2、私有化构造器
	private Singleton02(){
	}
	//3、同步方法调用效率更低
	public static  synchronized Singleton02 getInstance(){
		if(instance==null){
			instance = new Singleton02();
		}
		return instance;
	}
}

1.2、工厂模式

1.2.1、作用

1）实例化对象，用工厂方法代替new操作；
2）将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦；

1.2.2、简单工厂模式

1）简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法；
2）不足：不修改代码的话，是无法扩展的；

package com.example.mp.pattern.factory.simplefactory;

public interface Animal {
	void eat();
}

package com.example.mp.pattern.factory.simplefactory;

public class Cat implements Animal {
	@Override
	public void eat() {
		System.out.println("猫吃");
	}
}

package com.example.mp.pattern.factory.simplefactory;

public class Dog implements Animal {
	@Override
	public void eat() {
		System.out.println("狗吃");
	}
}

package com.example.mp.pattern.factory.simplefactory;

/**
 * 简单工厂类
 */
public class AnimalFactory {
	public static Animal createCat(){
		return new Cat();
	}
	public static Animal createDog(){
		return new Dog();
	}
}

package com.example.mp.pattern.factory.simplefactory;

/**
 * 通过工厂创建对象
 */
public class Client {
	public static void main(String[] args) {
		Animal cat =AnimalFactory.createCat();
		Animal dog = AnimalFactory.createDog();
		cat.eat();
		dog.eat();
	}
}

1.2.2、抽象工厂模式

1）用来生产不同产品族的全部产品。（对于增加新的产品，无能为力； 支持增加产品族）；
2）抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务 分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式；

1.3、建造者模式

1.4、原型模式

二、结构型模式

结构型模式从程序的结构上实现松耦合，便于扩展和维护；

2.1、适配器模式

2.1、概念

1）将一个类的接口转换成客户端希望的另外一个接口；
2）Adapter模式使得原 本由于接口不兼容而不能一起工作的那些类可以在一起工作；
3）系统升级时会用到；

2.2、角色

1）目标接口（Target）：客户端期望的接口，目标可以是具体的或抽象 的类，也可以是接口；
2）需要适配的类（Adaptee）：需要适配的类或适配者类；
3）适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成 目标接口；

2.3、类适配器

package com.example.mp.pattern.adapter;

/**
 * 被适配的类
 */
public class Adaptee {
	public void request(){
		System.out.println("客户端真正需要调用的方法");
	}
}

package com.example.mp.pattern.adapter;

/**
  * 目标接口
  */
public interface Target {
	void handleReq();
}

package com.example.mp.pattern.adapter;

/**
 * 适配器 
 */
public class Adapter extends Adaptee implements Target {
	@Override
	public void handleReq() {
		super.request();
	}
}

package com.example.mp.pattern.adapter;

/**
 * 客户端
 */
public class Client {
	public void test1(Target t){
		t.handleReq();
	}
	
	public static void main(String[] args) {
		Client  c = new Client();
		Target t = new Adapter();
		c.test1(t);
	}
}

2.4、对象适配器

Adaptee与Target不变

package com.example.mp.pattern.adapter;

/**
 * 对象适配器
 */
public class Adapter2  implements Target {
	private Adaptee adaptee;
	
	@Override
	public void handleReq() {
		adaptee.request();
	}

	public Adapter2(Adaptee adaptee) {
		super();
		this.adaptee = adaptee;
	}
}

package com.example.mp.pattern.adapter;

/**
 * 客户端类
 */
public class Client2 {
	public void test1(Target t){
		t.handleReq();
	}
	
	public static void main(String[] args) {
		Client  c = new Client();
		Adaptee a = new Adaptee();
		Target t = new Adapter2(a);
		c.test1(t);
	}
}

2.2、桥接模式

2.3、装饰模式

2.3.1、概念

装饰模式（Decorator）也叫包装器模式（Wrapper），可以动态的增加或删除对象的功能，降低系统的耦合度；
1）作用
动态的为一个对象增加新功能；
用于代替继承技术，无需通过继承新增子类就可以扩展新功能，避免类过多；
2）优缺点
扩展对象功能比继承灵活，不会导致类过多；可以对一个对象多次装饰，创造不同组合；
会产生很大小对象；出错调试相对较麻烦；
3）常见应用
Servlet API 中提供了一个request对象的Decorator设计模式的默认实 现类HttpServletRequestWrapper，HttpServletRequestWrapper 类，增强了request对象的功能；
IO中输入流和输出流的设计；

2.3.2、角色

1）Component抽象构件角色：真实对象和装饰对象有相同的接口。这样，客户端对象就能够以与真实对象相同的方式同装饰 对象交互；
2）ConcreteComponent 具体构件角色：真实对象，如io流中的FileInputStream、FileOutputStream；
3）Decorator装饰角色：持有一个抽象构件的引用。装饰对象接受所有客户端的请求，并把这些请求转发给真实的对象 。这样，就能在真实对象调用前后增加新的功能；
4）ConcreteDecorator具体装饰角色：负责给构件对象增加新的责任；

2.3.3、示例

package com.example.mp.pattern.decorator;

/**
 * 抽象构建
 */
public interface ICar {
	void move();
}

/**
  * ConcreteComponent 具体构件角色(真实对象) 普通汽车
  */
class Car implements ICar {
	@Override
	public void move() {
		System.out.println("陆地上跑！");
	}
}

/**
  * Decorator装饰角色
  */
class SuperCar implements ICar {
	protected ICar car;
	public SuperCar(ICar car) {
		super();
		this.car = car;
	}

	@Override
	public void move() {
		car.move();
	}
}

/**
  * ConcreteDecorator具体装饰角色（飞行功能）
  */
class FlyCar extends SuperCar {

	public FlyCar(ICar car) {
		super(car);
	}
	
	public void fly(){
		System.out.println("天上飞！");
	}

	@Override
	public void move() {
		super.move();
		fly();
	}
}

/**
  * ConcreteDecorator具体装饰角色（水上功能）
  */
class WaterCar extends SuperCar {
	
	public WaterCar(ICar car) {
		super(car);
	}
	
	public void swim(){
		System.out.println("水上游！");
	}
	
	@Override
	public void move() {
		super.move();
		swim();
	}
}

/**
  * ConcreteDecorator具体装饰角色（智能驾驶功能）
  */
class AICar extends SuperCar {
	
	public AICar(ICar car) {
		super(car);
	}
	
	public void autoMove(){
		System.out.println("自动跑！");
	}
	
	@Override
	public void move() {
		super.move();
		autoMove();
	}
}

package com.example.mp.pattern.decorator;

/**
  * 客户端
  */
public class Client {
	public static void main(String[] args) {
		Car car  = new Car();
		car.move();
		
		System.out.println("增加新的功能，飞行----------");
		FlyCar flycar = new FlyCar(car);
		flycar.move();
		
		System.out.println("增加新的功能，水里游---------");
		WaterCar  waterCar = new WaterCar(car);
		waterCar.move();
		
		System.out.println("增加两个新的功能，飞行，水里游（组合方式）-------");
		WaterCar waterCar2 = new WaterCar(new FlyCar(car));
		waterCar2.move();

//		Reader r = new BufferedReader(new InputStreamReader(new FileInputStream(new File("d:/a.txt"))));
	}
}

2.4、组合模式

2.5、外观模式

2.6、享元模式

2.7、代理模式

2.7.1、作用与应用

1）作用
通过代理，控制对对象的访问，将统一流程代码放到代理类中处理（如AOP面向切面编程）
2）应用
安全代理：屏蔽对真实角色的直接访问
远程代理：通过代理类处理远程方法调用(RMI)
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象（如缩略图与原图访问）

2.7.2、角色

1）抽象角色：定义代理角色和真实角色的公共对外方法
2）真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑， 供代理角色调用（关注真正的业务逻辑）
3）代理角色：实现抽象角色，是真实角色的代理，通过真实角色 的业务逻辑方法来实现抽象方法，并可以附加 自己的操作（统一流程控制在代理角色中处理）

2.7.3、静态代理

package com.example.mp.pattern.proxy.staticProxy;

/**
  * 抽象角色
  */
public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收钱
	 */
	void collectMoney();
}

package com.example.mp.pattern.proxy.staticProxy;

/**
  * 真实角色
  */
public class RealStar implements Star {

	@Override
	public void bookTicket() {
		System.out.println("RealStar.bookTicket()");
	}
	@Override
	public void collectMoney() {
		System.out.println("RealStar.collectMoney()");
	}
	@Override
	public void confer() {
		System.out.println("RealStar.confer()");
	}
	@Override
	public void signContract() {
		System.out.println("RealStar.signContract()");
	}
	@Override
	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}

package com.example.mp.pattern.proxy.staticProxy;

/**
  * 代理角色
  */
public class ProxyStar implements Star {
	
	private Star star;
	
	public ProxyStar(Star star) {
		super();
		this.star = star;
	}

	@Override
	public void bookTicket() {
		System.out.println("ProxyStar.bookTicket()");
	}
	@Override
	public void collectMoney() {
		System.out.println("ProxyStar.collectMoney()");
	}
	@Override
	public void confer() {
		System.out.println("ProxyStar.confer()");
	}
	@Override
	public void signContract() {
		System.out.println("ProxyStar.signContract()");
	}
	@Override
	public void sing() {
		//调用真实对象实现
		star.sing();
	}
}

package com.example.mp.pattern.proxy.staticProxy;

/**
  * 客户端
  */
public class Client {
	public static void main(String[] args) {
		Star real = new RealStar();
		Star proxy = new ProxyStar(real);
		
		proxy.confer();
		proxy.signContract();
		proxy.bookTicket();
		proxy.sing();//通过代理对象，访问真实对象实现
		proxy.collectMoney();
	}
}

2.7.4、动态代理

与静态代理相比：–抽象角色中(接口)声明的所以方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法；

package com.example.mp.pattern.proxy.dynamicProxy;

/**
  * 抽象角色
  */
public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收钱
	 */
	void collectMoney();
}

package com.example.mp.pattern.proxy.dynamicProxy;

/**
  * 真实角色
  */
public class RealStar implements Star {

	@Override
	public void bookTicket() {
		System.out.println("RealStar.bookTicket()");
	}
	@Override
	public void collectMoney() {
		System.out.println("RealStar.collectMoney()");
	}
	@Override
	public void confer() {
		System.out.println("RealStar.confer()");
	}
	@Override
	public void signContract() {
		System.out.println("RealStar.signContract()");
	}
	@Override
	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}

package com.example.mp.pattern.proxy.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
  * 处理器
  */
public class StarHandler implements InvocationHandler {
	
	Star realStar;
	
	public StarHandler(Star realStar) {
		super();
		this.realStar = realStar;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object object = null;
		System.out.println("真正的方法执行前！");
		System.out.println("面谈，签合同，预付款，订机票");
		//判断是否为被代理的真实对象方法
		if(method.getName().equals("sing")){
			object = method.invoke(realStar, args);
		}
		System.out.println("真正的方法执行后！");
		System.out.println("收尾款");
		return object;
	}
}

package com.example.mp.pattern.proxy.dynamicProxy;

import java.lang.reflect.Proxy;

/**
  * 客户端
  */
public class Client {
	public static void main(String[] args) {
		Star realStar = new RealStar();
		StarHandler handler = new StarHandler(realStar);
		//动态获取代理对象，调用真实对象方法
		Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), 
				new Class[]{Star.class}, handler);
		proxy.sing();
	}
}

三、行为型模式

3.1、模板方法模式

3.2、命令模式

3.3、迭代器模式

3.4、观察者模式

3.4.1、概念

1）包括Subject主题对象（目标对象）和Observer观察者对象，用于消息的通知发布，也可以叫发布订阅模式（Publish/Subscribe）；
2）通知观察者的两种方式：
推送：把通知消息以广播方式推送给所有观察者；
拉取：观察者根据需要主动从主题对象获取；

3.4.2、自定义观察者模式

package com.example.mp.pattern.observer;

/**
  * 观察者
  */
public interface Observer {
	void  update(Subject subject);
}

package com.example.mp.pattern.observer;

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

/**
  * 主题对象
  */
public class Subject {
	
	protected List<Observer> list = new ArrayList<Observer>();
	
	public void registerObserver(Observer obs){
		list.add(obs);
	}
	public void removeObserver(Observer obs){
		list.add(obs);
	}

	//通知所有的观察者更新状态
	public void notifyAllObservers(){
		for (Observer obs : list) {
			obs.update(this);
		}
	}	
}

package com.example.mp.pattern.observer;

public class ObserverA implements Observer {

	private int myState;   //myState需要跟目标对象的state值保持一致！
	
	@Override
	public void update(Subject subject) {
		myState = ((ConcreteSubject)subject).getState();
	}

	public int getMyState() {
		return myState;
	}
	public void setMyState(int myState) {
		this.myState = myState;
	}
}

package com.example.mp.pattern.observer;

public class ConcreteSubject extends Subject {
	
	private int state;

	public int getState() {
		return state;
	}

	public void setState(int state) {
		this.state = state;
		//主题对象值变化时通知所有的观察者
		this.notifyAllObservers();
	} 	
}

package com.example.mp.pattern.observer;

/**
  * 客户端
  */
public class Client {
	public static void main(String[] args) {
		//1、目标对象
		ConcreteSubject subject = new ConcreteSubject();
		//2、创建多个观察者
		ObserverA  obs1 = new ObserverA();
		ObserverA  obs2 = new ObserverA();
		ObserverA  obs3 = new ObserverA();
		//3、将观察者添加到subject对象的观察者队伍中
		subject.registerObserver(obs1);
		subject.registerObserver(obs2);
		subject.registerObserver(obs3);
		//4、改变subject的状态
		subject.setState(1);
		System.out.println("########################");
		//5、打印观察者状态
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());
	}
}

3.4.3、JavaSE中的观察者模式

package com.example.mp.pattern.observer2;

import java.util.Observable;
import java.util.Observer;

public class ObserverA implements Observer {

	private int myState;

	@Override
	public void update(Observable o, Object arg) {
		myState = ((ConcreteSubject)o).getState();
	}

	public int getMyState() {
		return myState;
	}

	public void setMyState(int myState) {
		this.myState = myState;
	}
}

package com.example.mp.pattern.observer2;

import java.util.Observable;

//目标对象
public class ConcreteSubject extends Observable {
	
	private int state; 
	
	public void set(int s){
		state = s;  //目标对象的状态发生了改变
		setChanged();  //表示目标对象已经做了更改
		notifyObservers(state);  //通知所有的观察者
	}

	public int getState() {
		return state;
	}

	public void setState(int state) {
		this.state = state;
	}
}

package com.example.mp.pattern.observer2;

public class Client {
	public static void main(String[] args) {
		//1、创建目标对象Obserable
		ConcreteSubject subject = new ConcreteSubject();
		//2、创建观察者
		ObserverA obs1 = new ObserverA();
		ObserverA obs2 = new ObserverA();
		ObserverA obs3 = new ObserverA();
		//3、将观察者对象添加到目标对象subject的观察者容器中
		subject.addObserver(obs1);
		subject.addObserver(obs2);
		subject.addObserver(obs3);
		//4、改变subject对象的状态
		subject.set(10);
		System.out.println("===============状态修改了！");
		//5、观察者的状态发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());
	}
}

3.5、中介者模式

3.6、备忘录模式

3.7、解释器模式

3.8、状态模式

3.9、策略模式

3.10、职责链模式

3.11、访问者模式