本文档是学习后的个人总结，用于备查，如果有冒犯，请联系我删除。
参考文档：
1、简单工厂模式，工厂方法模式，抽象工厂模式
2、Java中常用的设计模式
上面这个链接写的特别清楚，也有代码示例，非常好

创建型模式(5种)：

用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。

1、单例模式（Singleton）

单例模式是设计模式中最常见也最简单的一种设计模式，保证了在程序中只有一个实例存在并且能全局的访问到。简单

2、工厂模式

角色组成：
产品接口： 定义了产品的共用资源例如方法，提供给子类继承使用。
产品类： 继承产品接口，实现接口的方法，从而产生各种各类的产品。
工厂类： 定义了创建产品的方法，负责创建产品对象。

实现方案：
有一个汽车（Car）接口，包含一个方法start() 输出自己的信息，然后现在有两种车辆，奔驰、吉普。

工厂方法模式

角色组成：
产品接口： 定义了产品的共用资源例如方法，提供给子类继承使用，强制子类实现。
产 品 类： 继承产品接口，实现接口的方法，也可以覆盖接口的方法，从而产生各种各类的产品。
工厂接口： 定义了创建产品的方法，具体创建者必须继承该类，实现工厂方法。
工厂实现类： 继承工厂接口，实现工厂方法，负责创建产品对象。

实现方案：
如图，我们提供了一个工厂接口，创建产品由他的子类完成，拿车子来说，就是每一种汽车都有专门的工厂生产，而工厂继承于工厂接口。

扩展性：
如果这个时候还要添加一种新的车辆，只需添加对应的车辆和工厂类。例如我想添加个吉普车，我只需要声明一个“吉普车类”继承Car车辆接口，再声明一个“吉普车工厂类”继承于CarFactory车辆工厂接口，不用再去修改原有的类，如图：
缺点

• 一个具体产品对应一个类，当具体产品过多时会使系统类的数目过多，增加系统复杂度。

• 每增加一个产品时，都需要一个产品类和一个产品工厂类，使得类的个数成倍增加，导致系统类数目过多，复杂性增加。

3、抽象工厂模式

角色组成：
产品族接口：产品家族的父类，由此可以衍生很多子产品。

具体产品：继承抽象产品接口，由工厂方法直接创建。

工厂接口：客户端直接引用，由未实现的工厂方法组成，子类必须实现其工厂方法创建产品家族。

具体工厂：实现工厂接口，负责实现工厂方法，一个具体工厂可以创建一组产品。


缺点：

• 抽象工厂是使用组合的方式把工厂方法集合到一个类中，当新增一个产品家族成员时就要修改抽象工厂类及其下面的具体工厂类，所以它的扩展性比较差。

• 产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

适用场景：
抽象工厂方法适用于产品种类结构多的场合，主要用于创建一组相关的产品，为它们提供创建的接口，就是当具有多个抽象角色时，抽象工厂便可以派上用场。

工厂模式总结
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了。而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了

4、建造者模式（Builder）

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。

5、原型模式（Prototype）

原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类：

public class Prototype implements Cloneable {
 
	public Object clone() throws CloneNotSupportedException {
		Prototype proto = (Prototype) super.clone();
		return proto;
	}
}

---

结构型模式(7种)：

用于描述如何将类或对象按某种布局组成更多的结构。

6、适配器模式（Adapter）

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

• 类的适配器模式
  核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口是Targetable，通过Adapter类，将Source的功能扩展到Targetable里。
  

public class Source {
 
	public void method1() {
		System.out.println("this is original method!");
	}
}
public interface Targetable {
 
	/* 与原类中的方法相同 */
	public void method1();
 
	/* 新类的方法 */
	public void method2();
}
public class Adapter extends Source implements Targetable {
 
	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}
}

//Adapter类继承Source类，实现Targetable接口，下面是测试类：

public class AdapterTest {
 
	public static void main(String[] args) {
		Targetable target = new Adapter();
		target.method1();
		target.method2();
	}
}

输出：

this is original method!
this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能。

把Source类的功能通过接口Targetable扩展到类Adapter里

• 对象的适配器模式
  基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：
  
  只需要修改Adapter类的源码即可：

public class Wrapper implements Targetable {
 
	private Source source;
	
	public Wrapper(Source source){
		super();
		this.source = source;
	}
	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}
 
	@Override
	public void method1() {
		source.method1();
	}
}
//测试类：

public class AdapterTest {
 
	public static void main(String[] args) {
		Source source = new Source();
		Targetable target = new Wrapper(source);
		target.method1();
		target.method2();
	}

• 接口的适配器模式
  有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
  

public interface Sourceable {
	
	public void method1();
	public void method2();
}
//抽象类Wrapper：
public abstract class Wrapper implements Sourceable{
	
	public void method1(){}
	public void method2(){}
}
public class SourceSub1 extends Wrapper {
	public void method1(){
		System.out.println("the sourceable interface's first Sub1!");
	}
}
public class SourceSub2 extends Wrapper {
	public void method2(){
		System.out.println("the sourceable interface's second Sub2!");
	}
}
public class WrapperTest {
 
	public static void main(String[] args) {
		Sourceable source1 = new SourceSub1();
		Sourceable source2 = new SourceSub2();
		
		source1.method1();
		source1.method2();
		source2.method1();
		source2.method2();
	}
}

测试输出：

the sourceable interface’s first Sub1!
the sourceable interface’s second Sub2!

总结一下三种适配器模式的应用场景：

• 类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

• 对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

• 接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

7、装饰模式（Decorator）

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口。装饰对象持有被装饰对象的实例。

装饰器模式的应用场景：

• 需要扩展一个类的功能。
• 动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

8、代理者模式（Proxy）

控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。比如我们在租房子的时候会去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。

代理模式的应用场景：

• 如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法
  1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。
  2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。
  使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

9、外观模式（Facade）

外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口。

10、桥接模式

桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。

11、组合模式（Composite）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

12、享元模式（Flyweight）

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

FlyWeightFactory负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight是超类。一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。

看个例子：

看下数据库连接池的代码：

public class ConnectionPool {
	
	private Vector<Connection> pool;
	
	/*公有属性*/
	private String url = "jdbc:mysql://localhost:3306/test";
	private String username = "root";
	private String password = "root";
	private String driverClassName = "com.mysql.jdbc.Driver";
 
	private int poolSize = 100;
	private static ConnectionPool instance = null;
	Connection conn = null;
 
	/*构造方法，做一些初始化工作*/
	private ConnectionPool() {
		pool = new Vector<Connection>(poolSize);
 
		for (int i = 0; i < poolSize; i++) {
			try {
				Class.forName(driverClassName);
				conn = DriverManager.getConnection(url, username, password);
				pool.add(conn);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
 
	/* 返回连接到连接池 */
	public synchronized void release() {
		pool.add(conn);
	}
 
	/* 返回连接池中的一个数据库连接 */
	public synchronized Connection getConnection() {
		if (pool.size() > 0) {
			Connection conn = pool.get(0);
			pool.remove(conn);
			return conn;
		} else {
			return null;
		}
	}
}

通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！

---

行为型模式(11种)：

用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。

13、策略模式（strategy）

策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下：

图中ICalculator提供统一的方法，AbstractCalculator是辅助类，提供辅助方法，接下来，依次实现下每个类。

//首先统一接口
public interface ICalculator {
	public int calculate(String exp);
}
//辅助类
public abstract class AbstractCalculator {	
	public int[] split(String exp,String opt){
		String array[] = exp.split(opt);
		int arrayInt[] = new int[2];
		arrayInt[0] = Integer.parseInt(array[0]);
		arrayInt[1] = Integer.parseInt(array[1]);
		return arrayInt;
	}
}
//三个实现类
public class Plus extends AbstractCalculator implements ICalculator { 
	@Override
	public int calculate(String exp) {
		int arrayInt[] = split(exp,"\\+");
		return arrayInt[0]+arrayInt[1];
	}
}
public class Minus extends AbstractCalculator implements ICalculator {
 
	@Override
	public int calculate(String exp) {
		int arrayInt[] = split(exp,"-");
		return arrayInt[0]-arrayInt[1];
	}
 
}
public class Multiply extends AbstractCalculator implements ICalculator {
 
	@Override
	public int calculate(String exp) {
		int arrayInt[] = split(exp,"\\*");
		return arrayInt[0]*arrayInt[1];
	}
}
//简单的测试类： 
public class StrategyTest { 
	public static void main(String[] args) {
		String exp = "2+8";
		ICalculator cal = new Plus();
		int result = cal.calculate(exp);
		System.out.println(result);
	}
}
//输出：10

14、模板方法模式（Template Method）

模板方法（TemplateMethod）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。即：一个抽象类中，有一个主方法，再定义1…n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。

就是在AbstractCalculator类中定义一个主方法calculate，calculate()调用spilt()等，Plus和Minus分别继承AbstractCalculator类，通过对AbstractCalculator的调用实现对子类的调用。

public abstract class AbstractCalculator {
	
	/*主方法，实现对本类其它方法的调用*/
	public final int calculate(String exp,String opt){
		int array[] = split(exp,opt);
		return calculate(array[0],array[1]);
	}
	
	/*被子类重写的方法*/
	abstract public int calculate(int num1,int num2);
	
	public int[] split(String exp,String opt){
		String array[] = exp.split(opt);
		int arrayInt[] = new int[2];
		arrayInt[0] = Integer.parseInt(array[0]);
		arrayInt[1] = Integer.parseInt(array[1]);
		return arrayInt;
	}
}
public class Plus extends AbstractCalculator {
 
	@Override
	public int calculate(int num1,int num2) {
		return num1 + num2;
	}
}
//测试类：
public class StrategyTest { 
	public static void main(String[] args) {
		String exp = "8+8";
		AbstractCalculator cal = new Plus();
		int result = cal.calculate(exp, "\\+");
		System.out.println(result);
	}
}

我跟踪下这个小程序的执行过程：首先将exp和"\+"做参数，调用AbstractCalculator类里的calculate(String,String)方法，在calculate(String,String)里调用同类的split()，之后再调用calculate(int ,int)方法，从这个方法进入到子类中，执行完return num1 + num2后，将值返回到AbstractCalculator类，赋给result，打印出来。

模板方法模式是策略模式的升级，他把公共的部分抽取出来做了split，不同的部分放在calculate（int，int）里，不用所有的功能全部写一遍

15、观察者模式（Observer）

观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，会把这种改变通知给其他多个对象，从而影响其他对象的行为。先来看看关系图

MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。

//一个Observer接口：
public interface Observer {
	public void update();
}
//两个实现类：
public class Observer1 implements Observer { 
	@Override
	public void update() {
		System.out.println("observer1 has received!");
	}
}
public class Observer2 implements Observer { 
	@Override
	public void update() {
		System.out.println("observer2 has received!");
	}
}
//Subject接口及实现类：
public interface Subject {	
	/*增加观察者*/
	public void add(Observer observer);	
	/*删除观察者*/
	public void del(Observer observer);	
	/*通知所有的观察者*/
	public void notifyObservers();	
	/*自身的操作*/
	public void operation();
}
public abstract class AbstractSubject implements Subject { 
	private Vector<Observer> vector = new Vector<Observer>();
	@Override
	public void add(Observer observer) {
		vector.add(observer);
	} 
	@Override
	public void del(Observer observer) {
		vector.remove(observer);
	} 
	@Override
	public void notifyObservers() {
		Enumeration<Observer> enumo = vector.elements();
		while(enumo.hasMoreElements()){
			enumo.nextElement().update();
		}
	}
}

public class MySubject extends AbstractSubject { 
	@Override
	public void operation() {
		System.out.println("update self!");
		notifyObservers();
	} 
}
//测试类：
public class ObserverTest { 
	public static void main(String[] args) {
		Subject sub = new MySubject();
		sub.add(new Observer1());
		sub.add(new Observer2());		
		sub.operation();
	} 
}

输出：

update self!
observer1 has received!
observer2 has received!

16、迭代子模式（Iterator）

提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。

17、责任链模式（Chain of Responsibility）

把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。

链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象。

18、命令模式（Command）

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。

命令模式的目的就是将命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉Struts的同学应该知道，Struts其实就是一种将请求和呈现分离的技术，其中必然涉及命令模式的思想。

19、备忘录模式（Memento）

不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。

20、状态模式（State）

允许一个对象在其内部状态发生改变时改变其行为能力。比如QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点：1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。

状态模式在日常开发中用的挺多的，尤其是做网站的时候，我们有时希望根据对象的某一属性，区别开他们的一些功能，比如说简单的权限控制等。

21、访问者模式（Visitor）

在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。

访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。

简单来说，访问者模式就是一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。

22、中介者模式（Mediator）

定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用。

23、解释器模式（Interpreter）

提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。一般主要应用在OOP开发中的编译器的开发中，所以适用面比较窄。
解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等。

---

花了一天时间学习，凭空理解还是比较难于理解的，需要一定的项目经验才能理解。
捋了一遍，我要做的工作需要抽象工厂模式，将逻辑结构拆分好，还需要模板模式，将不同的算法分开。