设计模式

1. 简介

1.1. 什么是设计模式？

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题， 以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

1.2. 设计模式的分类

设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。
行为型模式，共十一种：（策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。这些设计模式特别关注对象之间的通信。

2. 创建型模式

2.1. 工厂模式（Factory Method）

2.1.1. 介绍

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了2、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

2.1.2. 普通工厂模式

	就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建例如下：（我们举一个发送邮件和短信的例子）
首先，创建二者的共同接口：
 public interface Sender {
	public void Send();
 }
其次，创建实现类：
public class MailSender implements Sender {
	@Override
	public void Send() {
		System.out.println("this is mailsender!");
	}
}

public class SmsSender implements Sender {
	@Override
	public void Send() {
		System.out.println("this is sms sender!");
	}
}
最后，建工厂类：
public class SendFactory {
	public Sender produce(String type) {
		if ("mail".equals(type)) {
			return new MailSender();
		} else if ("sms".equals(type)) {
			return new SmsSender();
		} else {
			System.out.println("请输入正确的类型!");
			return null;
		}
	}
}
我们来测试下：
public class FactoryTest {
	public static void main(String[] args) {
		SendFactory factory = new SendFactory();
		Sender sender = factory.produce("sms");
		sender.Send();
	}
}
输出：this is sms sender!
（逻辑不通，传入的字符有问题）

2.1.3. 多个工厂方法模式

是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象
public class SendFactory {
	public Sender produceMail(){
		return new MailSender();
	}
		public Sender produceSms(){
		return new SmsSender();
	}
}
测试类如下:public class FactoryTest {
	public static void main(String[] args) {
		SendFactory factory = new SendFactory();
		Sender sender = factory.produceMail();
		sender.Send();
	}
}

2.1.4. 静态工厂方法

就是工厂类里面的方法是静态的，不要实例化工厂类，直接使用调运方法
public class SendFactory {
		public static Sender produceMail(){
		return new MailSender();
	}
		public static Sender produceSms(){
		return new SmsSender();
	}
}

public class FactoryTest {
	public static void main(String[] args) {	
		Sender sender = SendFactory.produceMail();
		sender.Send();
	}
}
输出：this is mailsender!

2.1.5. 总结

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种----静态工厂方法模式。

名称	区别
普通工厂模式	字符串有误，不能正确的创建对象
多个工厂方法模式	实例化工厂类
静态工厂方法	不需要实例化工厂类

2.2. 抽象工厂模式（Abstract Factory）

2.2.1. 介绍

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则(对扩展开放，对修改关闭)，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

2.2.2. 举例

public interface Provider {
	public Sender produce();  
}

public class SendMailFactory implements Provider {
	@Override
	public Sender produce(){
		return new MailSender();
	}
}
public class SendSmsFactory implements Provider{
	@Override
	public Sender produce() {
		return new SmsSender();
	}
}
测试类:
  
   public class Test {
	  public static void main(String[] args) {
		Provider provider = new SendMailFactory();
		Sender sender = provider.produce();
		sender.Send();
	}
}

2.2.3. 总结

好处：其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口
（使用代码更为的灵活，实现一个类，工厂也做实现类，想使用哪个工厂就使用哪个工厂）

2.3. 单例模式（Singleton Pattern）

2.3.1. 介绍

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC（垃圾回收机制）压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

2.3.2. 举例

单例模式的实现通常有两种方式：“饿汉式”和“懒汉式”。
饿汉式：java实现代码如下：
Public class Singleton
{
Private static final Singleton singleton = new Singleton();
Private Singleton()
{
}
Public static Singleton getInstance()
{
Return singleton;
}
}

懒汉式：java实现代码如下：

public class SingletonClass{
    private static SingletonClass instance=null;
    public static SingletonClass getInstance()
    {
        if(instance==null)
        {
            synchronized(SingletonClass.class)
            {
                if(instance==null)
                    instance=new SingletonClass();
            }
        }
        return instance;
    }
    private SingletonClass(){
    }
}

2.3.3. 总结

减少实例化，减少内存的使用率，控制实例化只能为一个。
单例模式为一个面向对象的应用程序提供了对象惟一的访问点，不管它实现何种功能，整个应用程序都会同享一个实例对象。
懒汉式也是通过一个类的静态变量实现的。但是并没有直接初始化。而是在函数getInstance()中实例化的，也就是每次想用这个实例的时候初始化的，如果已经初始化了，那么就不用初始化了，这样也很好啊，对的，其实懒汉式是比较常用的实现方式。

2.4. 建造者模式（Builder）

2.4.1. 介绍

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性
主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

2.4.2. 举例

我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。
我们将创建一个表示食物条目（比如汉堡和冷饮）的Item接口和实现Item接口的实体类，以及一个表示食物包装的Packing接口和实现Packing接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。
然后我们创建一个Meal类，带有Item的ArrayList和一个通过结合Item来创建不同类型的Meal对象的MealBuilder。BuilderPatternDemo，我们的演示类使用MealBuilder来创建一个Meal。

步骤 1
创建一个表示食物条目和食物包装的接口。
Item.java
public interface Item {
public String name();
public Packing packing();
public float price();
}
Packing.java
public interface Packing {
public String pack();
}
步骤 2
创建实现 Packing 接口的实体类。
Wrapper.java
public class Wrapper implements Packing {
@Override
public String pack() {
return “Wrapper”;
}
}
Bottle.java
public class Bottle implements Packing {
@Override
public String pack() {
return “Bottle”;
}
}
步骤 3
创建实现 Item 接口的抽象类，该类提供了默认的功能。
Burger.java
public abstract class Burger implements Item {
@Override
public Packing packing() {
return new Wrapper();
}
@Override
public abstract float price();
}
ColdDrink.java
public abstract class ColdDrink implements Item {
@Override
public Packing packing() {
return new Bottle();
}
@Override
public abstract float price();
}
步骤 4
创建扩展了 Burger 和 ColdDrink 的实体类。
VegBurger.java
public class VegBurger extends Burger {
@Override
public float price() {
return 25.0f;
}
@Override
public String name() {
return “Veg Burger”;
}
}
ChickenBurger.java
public class ChickenBurger extends Burger {
@Override
public float price() {
return 50.5f;
}
@Override
public String name() {
return “Chicken Burger”;
}
}
Coke.java
public class Coke extends ColdDrink {
@Override
public float price() {
return 30.0f;
}
@Override
public String name() {
return “Coke”;
}
}
Pepsi.java
public class Pepsi extends ColdDrink {
@Override
public float price() {
return 35.0f;
}
@Override
public String name() {
return “Pepsi”;
}
}
步骤 5
创建一个 Meal 类，带有上面定义的 Item 对象。
Meal.java
import java.util.ArrayList;
import java.util.List;
public class Meal {
private List items = new ArrayList();
public void addItem(Item item){
items.add(item);
}
public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;
}
public void showItems(){
for (Item item : items) {
System.out.print("Item : “+item.name());
System.out.print(”, Packing : “+item.packing().pack());
System.out.println(”, Price : “+item.price());
}
}
}
步骤 6
创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。
MealBuilder.java
public class MealBuilder {
public Meal prepareVegMeal (){
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}
public Meal prepareNonVegMeal (){
Meal meal = new Meal();
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
return meal;
}
}
步骤 7
BuiderPatternDemo 使用 MealBuider 来演示建造者模式（Builder Pattern）。
BuilderPatternDemo.java
public class BuilderPatternDemo {
public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();
Meal vegMeal = mealBuilder.prepareVegMeal();
System.out.println(“Veg Meal”);
vegMeal.showItems();
System.out.println(“Total Cost: " +vegMeal.getCost());
Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
System.out.println(”\n\nNon-Veg Meal”);
nonVegMeal.showItems();
System.out.println("Total Cost: " +nonVegMeal.getCost());
}
}
步骤 8
验证输出。
Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0

Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

2.4.3. 总结

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

2.5. 原型模式（Prototype Pattern）

2.5.1. 介绍

原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
使用场景：1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

2.5.2. 举例

步骤 1
创建一个实现了 Clonable 接口的抽象类。
Shape.java
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;
}
}
步骤 2
创建扩展了上面抽象类的实体类。
Rectangle.java 矩形
public class Rectangle extends Shape {
public Rectangle(){
type = “Rectangle”;
}
@Override
public void draw() {
System.out.println(“Inside Rectangle::draw() method.”);
}
}
Square.java 方形
public class Square extends Shape {
public Square(){
type = “Square”;
}
@Override
public void draw() {
System.out.println(“Inside Square::draw() method.”);
}
}
Circle.java 圆形
public class Circle extends Shape {
public Circle(){
type = “Circle”;
}
@Override
public void draw() {
System.out.println(“Inside Circle::draw() method.”);
}
}
步骤 3
创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。
ShapeCache.java
import java.util.Hashtable;
public 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() {
Circle circle = new Circle();
circle.setId(“1”);
shapeMap.put(circle.getId(),circle);
Square square = new Square();
square.setId(“2”);
shapeMap.put(square.getId(),square);
Rectangle rectangle = new Rectangle();
rectangle.setId(“3”);
shapeMap.put(rectangle.getId(),rectangle);
}
}
步骤 4
PrototypePatternDemo 使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆。
PrototypePatternDemo.java
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape = (Shape) ShapeCache.getShape(“1”);
System.out.println("Shape : " + clonedShape.getType());
Shape clonedShape2 = (Shape) ShapeCache.getShape(“2”);
System.out.println("Shape : " + clonedShape2.getType());
Shape clonedShape3 = (Shape) ShapeCache.getShape(“3”);
System.out.println("Shape : " + clonedShape3.getType());
}
}
步骤 5
验证输出。
Shape : Circle
Shape : Square
Shape : Rectangle

2.5.3. 总结

优点： 1、性能提高 2、逃避构造函数的约束。
缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。 3、逃避构造函数的约束。
（ 当调用对象的程序执行结束以后，对象就随之消亡。但是，有时希望将对象的状态记录下来，以便于恢复，这个过程，就叫做对象串行化）

3. 结构模式

在软件系统中，由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是新环境要求的接口是这些现存对象所不满足的。那么如何应对这种“迁移的变化”？如何既能利用现有对象的良好实现，同时又能满足新的应用环境所要求的接口？正是Adapter 模式解决了这些问题。

3.1. 适配器模式（Adapter Pattern）

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

3.1.1. 类的适配器模式

（1）介绍
适用场景：已经存在的类的接口不符合我们的需求。
适配器模式作用：用来在系统后期扩展、修改时所用。
核心思想：一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里

（2）举例
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 implement Targetable{
public void method2(){
system.out.println(“this is targetable method!”);
}
}
Adapter类继承Source类，实现Targetable接口，下面是测试类：
Public class AdapterTest{
Public static void main(String[] args){
Targetable target = new Adapter();
target.method1();
target.method2();
}
}

3.1.2. 对象的适配器模式

（1）介绍
基本思路和类的适配器模式相同，只是将Adapter类作修改，它不是使用继承再实现的方式，而是使用直接关联。
适用场景：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Adapter类，持有原类的一个实例，在Adapter类的方法中，调用实例的方法就行。

（2）举例
public class Adapter implement Targetable{
//直接关联被适配类
Private Source source;
public Adapter(Source source){
//可以通过构造函数传入具体需要适配的被适配类对象
this.source = source;
}
public void method2(){
system.out.println(“this is targetable method!”);
}
public void method1(){
source.method1();
}
}
下面是测试类：
Public class AdapterTest{
Public static void main(String[]args){
//使用适配器类，创建一个被适配类的对象作为参数
Targetable target=newAdapter(new Adapter());
target.method1();
target.method2();
}
}
（3）总结
从代码中我们可以看出：对象适配器就是修改一下Adapter类中的内部结构，即 Adapter 自身必须先拥有一个被适配类的对象，再把具体的功能委托给这个对象来实现。使用对象适配器模式，可以使得 Adapter 类（适配类）根据传入的被适配类的对象达到适配多个不同被适配类的功能。
优缺点比较：类适配器Adapter不可避免要使用多重继承，我感觉还是要去尽量避免的。优先使用对象适配器。

3.1.3. 接口的适配器

（1）介绍
有时一个接口中有多个抽象方法，并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式。
适用场景：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。
（2）举例
publicinterface Sourceable{
public void method1();
public void method2();
}
//抽象类
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’sfirst 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();
}
}

3.1.4. 总结

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

3.2. 装饰模式（Decorator Pattern）

3.2.1. 介绍

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，相比生成子类更为灵活。
装饰器模式的应用场景：
1、需要扩展一个类的功能。
2、动态的为一个对象增加功能，而且还能动态撤销。
3、在不想增加很多子类的情况下扩展类。
核心思想：Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能

3.2.2. 举例

public interface Sourceable{
public void method();
}
public class Source implements Sourceable {   
public void method() {
 System.out.println("the original method!");  
}
} 
public class Decorator implements Sourceable {  
    private Sourceable source;
    public Decorator(Sourceable source){
this.source=source;
    }   
    public void method(){
        System.out.println("before decorator!");
  source.method();  
System.out.println("after decorator!");  
}
}
        测试类：
            public class DecoratorTest {  
                public static void main(String[] args) {   
                    Sourceable obj = new Decorator(new Source());  
                    obj.method();  
                }  
     }

3.2.3. 总结

好处：使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。
缺点：产生过多相似的对象，不易排错！多层装饰比较复杂。

3.3. 代理模式（Proxy Pattern）

3.3.1. 介绍

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
代理模式的应用场景：
如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：
1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。
2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

3.3.2. 举例

我们将创建一个 Image 接口和实现了 Image 接口的实体类。ProxyImage 是一个代理类，减少 RealImage 对象加载的内存占用。
ProxyPatternDemo，我们的演示类使用 ProxyImage 来获取要加载的 Image 对象，并按照需求进行显示。
public interface Image {
   	     void display();
	}
	public 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); 
	}
      }
	public 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();     
   	}
}
输出结果：
	Loading test_10mb.jpg
	Displaying test_10mb.jpg
	Displaying test_10mb.jpg

3.3.3. 总结

模式	区别
适配器模式	适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。
装饰器模式	装饰模式注重的是功能的拓展，在同一个方法下实现更多的功能。
代理模式	代理模式注重的是隔离限制， 让外部不能访问你实际的调用对象，比如权限控制。

3.4. 外观模式（Facade Pattern）

3.4.1. 介绍

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

3.4.2. 举例

Public class CPU {
public void startup(){  
System.out.println("cpu startup!");  
}
public void shutdown(){  
System.out.println("cpu shutdown!");  
}
}
public class Memory  {  
public void startup(){  
System.out.println("memory  startup!");  
}
    public void shutdown(){  
        System.out.println("memory  shutdown!");  
    }  
} 
public class Disk  {  
    public void startup(){  
        System.out.println("disk  startup!");  
    }  
    public void shutdown(){  
        System.out.println("disk  shutdown!");  
    }  
} 
    public class Computer {  
        private CPU cpu;  
        private Memory memory;  
        private Disk disk;        
        public Computer(){  
            cpu = new CPU();  
            memory = new Memory();  
            disk = new Disk();  
        }  
      
    public void startup(){  
        System.out.println("start the computer!");  
        cpu.startup();  
        memory.startup();  
        disk.startup();  
        System.out.println("start computer finished!");  
    }  
    public void shutdown(){  
        System.out.println("begin to close the computer!");  
        cpu.shutdown();  
        memory.shutdown();  
        disk.shutdown();  
        System.out.println("computer closed!");  
    }  
}  
    //User类
public class User {  
           public static void main(String[] args) {  
            Computer computer = new Computer();  
            computer.startup();  
            computer.shutdown();  
            }  
} 

3.4.3. 总结

如果我们没有Computer类，那么，CPU、Memory、Disk他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来其他类的修改，这不是我们想要看到的，有了Computer类，他们之间的关系被放在了Computer类里，这样就起到了解耦的作用，这就是外观模式！
优点： 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。 
缺点：不符合开闭原则，当业务出现变更时，可能需要直接修改外观类。

3.5. 桥接模式（Bridge）

3.5.1. 介绍

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。
这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。

3.5.2. 举例

实例准备：我们假设有一座桥，桥左边为A，桥右边为B，A有A1，A2，A3等，表示桥左边的三个不同地方，B有B1，B2，B3等，表示桥右边的三个不同地方，假设我们要从桥左侧A出发到桥的右侧B，我们可以有多重方案，A1到B1，A1到B2，A1到B3，A2到B1…等等，以此为例
桥接口：Qiao
public interface Qiao {
//目的地B
void targetAreaB();
}
目的地B1,B2,B3：
/**
* 目的地B1
*/
public class AreaB1 implements Qiao {
@Override
public void targetAreaB() {
System.out.println(“我要去B1”);
}
}

/**
 * 目的地B2
 */
public class AreaB2 implements Qiao {
    @Override
    public void targetAreaB() {
        System.out.println("我要去B2");
    }
}
/**
 * 目的地B3
 */
public class AreaB3 implements Qiao {
    @Override
    public void targetAreaB() {
        System.out.println("我要去B3");
    }
}
public abstract class AreaA {
    //引用桥接口
     Qiao qiao;
    //来源地
     abstract void fromAreaA();
}
来源地A1，A2，A3：
/**
 * 来源地A1
 */
public class AreaA1 extends AreaA {

    @Override
    void fromAreaA() {
        System.out.println("我来自A1");
    }
}
/**
 * 来源地A2
 */
public class AreaA2 extends AreaA {
    @Override
    void fromAreaA() {
        System.out.println("我来自A2");
    }
}
/**
 * 来源地A3
 */
public class AreaA3 extends AreaA {
    @Override
    void fromAreaA() {
        System.out.println("我来自A3");
    }
}
测试类：Clienter
public class Clienter {
    public static void main(String[] args) {
        AreaA a = new AreaA2();
        a.qiao = new AreaB3();
        a.fromAreaA();
        a.qiao.targetAreaB();
    }
}
运行结果：
	我来自A2
	我要去B3

3.5.3. 总结

如果要添加来源地和目的地，只要继续继承AreaA和实现Qiao即可。如果我们不使用桥接模式，我们会怎么想实现这个实例呢？很简单，我们分别定义来源地A1、A2、A3类和目的地B1、B2、B3，然后具体的实现就是，A1到B1一个类，A1到B2一个类，等，如果我们要扩展了A和B ,要直接增加An类和Bn类，如此编写不说类内部重复性代码多，而且还会导致类结构的急剧膨胀，最重要的是，在通过继承实现路径的时候，会造成双方耦合性增大，而这又进一步加剧了扩展的复杂性。使用桥结构模式可以很好地规避这些问题：重在解耦。

3.6. 组合模式（Composite Pattern）

3.6.1. 介绍

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。
就拿剪发办卡的事情来分析一下。首先，一张卡可以在总部，分店，加盟店使用，那么总部可以刷卡，分店也可以刷卡，加盟店也可以刷卡，这个属性结构的店面层级关系就明确。

3.6.2. 举例

public abstract class Market {
String name;
public abstract void add(Market m);
public abstract void remove(Market m);
public abstract void PayByCard();
}
 // 分店 下面可以有加盟店
public class MarketBranch extends Market {
// 加盟店列表
List<Market> list = new ArrayList<PayDemo.Market>();
public MarketBranch(String s) {
this.name = s;
}
 
@Override
public void add(Market m) {
list.add(m);
}
@Override
public void remove(Market m) {
list.remove(m);
}
// 消费之后，该分店下的加盟店自动累加积分
public void PayByCard() {
System.out.println(name + "消费,积分已累加入该会员卡");
for (Market m : list) {
m.PayByCard();
}
}
}
// 加盟店 下面不在有分店和加盟店，最底层
public class MarketJoin extends Market {
public MarketJoin(String s) {
his.name = s;
}
@Override
public void add(Market m) {
}
@Override
public void remove(Market m) {
}
@Override
public void PayByCard() {
System.out.println(name + "消费,积分已累加入该会员卡");
}
}
public class Test{
public static void main(String[] args) {
MarketBranch rootBranch = new MarketBranch("总店");
MarketBranch qhdBranch = new MarketBranch("南京分店");
MarketJoin hgqJoin = new MarketJoin("南京分店一玄武区加盟店");
MarketJoin btlJoin = new MarketJoin("南京分店二雨花区加盟店");
qhdBranch.add(hgqJoin);
qhdBranch.add(btlJoin);
rootBranch.add(qhdBranch);
rootBranch.PayByCard();
}
}

3.7. 享元模式（Flyweight Pattern）

3.7.1. 介绍

共享元对象。如果在一个系统中存在多个相同的对象，那么只需要共享一份对象的拷贝，而不必为每一次使用创建新的对象。
作用：享元模式是为数不多的、只为提升系统性能而生的设计模式。享元的目的是将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。

3.7.2. 举例

建筑接口：Construction 
public interface Construction {
	void use();
}
体育馆实现类：Stadium
public class Stadium implements Construction {
private String name;
private String shape;
private String sport;
public Stadium (String sport){
this.soprt = soprt;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getShape() {
return shape;
}
public void setShape(String shape) {
this.shape = shape;
}
public String getSoprt() {
return sport;
}
public void setSport(String sport) {
this.sport = sport;
}
@Override
public void use() {
System.out.println("该体育馆被使用来召开奥运会" + "  运动为："+ sport+"  形状为："+shape+ "  名称为："+name);
}
}
建筑工厂类：ConstructionFactory
public class ConstructionFactory {
private static final Map<String,Stadium> stamap = new HashMap<String,Stadium>();
public static Stadium getStadium(String sport){
Stadium sta = stamap.get(sport);
if(sta == null){
sta = new Stadium(sport);
stamap.put(sport,sta);
}
return sta;
}
public static int getSize(){
return stamap.size();
}
}
测试类：Clienter
public class Clienter {
public static void main(String[] args) {
Stadium sta1 = ConstructionFactory.getStadium("篮球");
sta1.setName("中国体育馆");
sta1.setShape("圆形");
sta1.use();
Stadium sta2 = ConstructionFactory.getStadium("乒乓球");
ta2.setName("中国体育馆");
sta2.setShape("圆形");
ta2.use();
Stadium sta3 = ConstructionFactory.getStadium("篮球");
sta3.setName("中国体育馆");
ta3.setShape("圆形");
sta3.use();
System.out.println("对象池中对象数量为："+ConstructionFactory.getSize());
}
}

测试结果：
该体育馆被使用来召开该体育馆被使用来召开奥运会 运动为：篮球 形状为：圆形 名称为：中国体育馆
该体育馆被使用来召开奥运会 运动为：篮球 形状为：圆形 名称为：中国体育馆
对象池中对象数量为：2奥运会 运动为：篮球 形状为：圆形 名称为：中国体育馆
该体育馆被使用来召开奥运会 运动为：乒乓球 形状为：圆形 名称为：中国体育馆
该体育馆被使用来召开奥运会 运动为：篮球 形状为：圆形 名称为：中国体育馆
对象池中对象数量为：2

3.7.3. 总结

通过执行结果可以看出，我们定义了3个对象，其中有2个是相同的，按照享元模式的定义“篮球”应该共享一个对象，在实际的对象数中我们可以看出实际的对象只有2个。

4. 行为型模式

第一类：通过父类与子类的关系进行实现。第二类：两个类之间。第三类：类的状态。第四类：通过中间类

4.1. 策略模式(Strategy Pattern)

4.1.1. 介绍

定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数
将这些算法封装成一个一个的类，想用哪个策略就使用哪个，随着策略的改变而改变context对象。
使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

4.1.2. 举例

步骤 1
创建一个接口。
Strategy.java
public interface Strategy {
   public int doOperation(int num1, int num2);
}
步骤 2
创建实现接口的实体类。
OperationAdd.java
public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}
OperationSubstract.java
public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}
OperationMultiply.java
public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}
步骤 3
创建 Context 类。
Context.java
public class Context {
  	 private Strategy strategy;
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }

}
步骤 4
使用 Context 来查看当它改变策略 Strategy 时的行为变化。
StrategyPatternDemo.java
public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());        
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
      context = new Context(new OperationSubstract());        
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
      context = new Context(new OperationMultiply());        
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

步骤 5
验证输出。
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50

4.1.3. 总结

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。
缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。
策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可

工厂模式和策略模式的对比：
工厂模式的时候更在意的是我需要一个实现了该接口的对象，具体的实现类内部有啥，工厂模式并不关心。
策略模式更在意的是实现了该接口的子类内部的实现是什么，是否适合我现在的需求。
从使用者角度来说，策略模式比工厂模式更复杂一点，因为使用者需要了解每一个子类里面的细节。

4.2. 模板模式（Template Pattern）

4.2.1. 介绍

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

4.2.2. 举例

步骤 1
创建一个抽象类，它的模板方法被设置为 final。
Game.java
public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();

   //模板
   public final void play(){

      //初始化游戏
      initialize();

      //开始游戏
      startPlay();

      //结束游戏
      endPlay();
   }
}
步骤 2
创建扩展了上述类的实体类。
Cricket.java
public 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!");
   }
}
Football.java
public 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!");
   }
}
步骤 3
使用 Game 的模板方法 play() 来演示游戏的定义方式。
TemplatePatternDemo.java
public class TemplatePatternDemo {
   public static void main(String[] args) {

      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();        
   }
}
步骤 4
验证输出。
Cricket Game Initialized! Start playing.
Cricket Game Started. Enjoy the game!
Cricket Game Finished!

Football Game Initialized! Start playing.
Football Game Started. Enjoy the game!
Football Game Finished!

4.2.3. 总 结

优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。
缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

4.3. 观察者模式（Observer）

4.3.1. 介绍

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。
当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系

4.3.2. 举例

例如：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();
	}
}

一个类发生变化，其他跟着这个类有关系的类都要变化----观察者模式

4.3.3. 总结

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

4.4. 迭代子模式（Iterator）

4.4.1. 介绍

顾名思义，迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
使用场景： 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。

4.4.2. 举例

public interface Collection {
	public Iterator iterator();
		/*取得集合元素*/
	public Object get(int i);
		/*取得集合大小*/
	public int size();
}
public interface Iterator {
	    //前移
	public Object previous();
		//后移
	public Object next();
	public boolean hasNext();
		//取得第一个元素
	public Object first();
}

public class MyCollection implements Collection {
	public String string[] = {"A","B","C","D","E"};
	@Override
	public Iterator iterator() {
		return new MyIterator(this);
	}

	@Override
	public Object get(int i) {
		return string[i];
	}
	@Override
	public int size() {
		return string.length;
	}
}

public 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;
		}else{
			return false;
		}
	}

	@Override
	public Object first() {
		pos = 0;
		return collection.get(pos);
	}

}
测试类：

   public class Test {
	public static void main(String[] args) {
		Collection collection = new MyCollection();
		Iterator it = collection.iterator();
				while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

4.4.3. 总结

优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

4.5. 责任链模式（Chain of Responsibility）

4.5.1. 介绍

为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦
接下来我们将要谈谈责任链模式，有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

4.5.2. 举例

ErrorLogger -- nextLogger（FileLogger ）-- ConsoleLogger

步骤 1

创建抽象的记录器类。

AbstractLogger.java
public abstract class AbstractLogger {
   public static int INFO = 1;
   public static int DEBUG = 2;
   public static int ERROR = 3;

   protected int level;

   //责任链中的下一个元素
   protected AbstractLogger nextLogger;

   public void setNextLogger(AbstractLogger nextLogger){
      this.nextLogger = nextLogger;
   }

   public void logMessage(int level, String message){
      if(this.level <= level){
         write(message);
      }
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }

   abstract protected void write(String message); }

步骤 2

创建扩展了该记录器类的实体类。

ConsoleLogger.java
public class ConsoleLogger extends AbstractLogger {

   public ConsoleLogger(int level){
      this.level = level;
   }

   @Override
   protected void write(String message) {        
      System.out.println("Standard Console::Logger: " + message);
   }
}

ErrorLogger.java
public class ErrorLogger extends AbstractLogger {

   public ErrorLogger(int level){
      this.level = level;
   }

   @Override
   protected void write(String message) {        
      System.out.println("Error Console::Logger: " + message);
   }
}

FileLogger.java
public class FileLogger extends AbstractLogger {

   public FileLogger(int level){
      this.level = level;
   }

   @Override
   protected void write(String message) {        
      System.out.println("File::Logger: " + message);
   }
}

步骤 3

创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。

ChainPatternDemo.java
public class ChainPatternDemo {
    
   private static AbstractLogger getChainOfLoggers(){

      AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
      AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
      AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

      errorLogger.setNextLogger(fileLogger);
      fileLogger.setNextLogger(consoleLogger);

      return errorLogger;    
   }

   public static void main(String[] args) {
      AbstractLogger loggerChain = getChainOfLoggers();

      loggerChain.logMessage(AbstractLogger.INFO, 
         "This is an information.");

      loggerChain.logMessage(AbstractLogger.DEBUG, 
         "This is an debug level information.");

      loggerChain.logMessage(AbstractLogger.ERROR, 
         "This is an error information.");
   }
}

步骤 4

验证输出。
Standard Console::Logger: This is an information.

File::Logger: This is an debug level information.
Standard Console::Logger: This is an debug level information.

Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

4.5.3. 总结

优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。
缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

4.6. 命令模式（Command）

4.6.1. 介绍

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。
举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的

4.6.2. 举例

   关键代码：定义三个角色：1、received 真正的命令执行对象 2、Command 3、invoker 使用命令对象的入口
public interface Command {
	public void exe();
}
public class MyCommand implements Command {
	private Receiver receiver;
		public MyCommand(Receiver receiver) {
		this.receiver = receiver;
	}
	@Override
	public void exe() {
		receiver.action();
	}
}
public class Receiver {
	public void action(){
		System.out.println("command received!");
	}
}
public class Invoker {
		private Command command;
		public Invoker(Command command) {
		this.command = command;
	}
	public void action(){
		command.exe();
	}
}
public class Test {

	public static void main(String[] args) {
		Receiver receiver = new Receiver();
		Command cmd = new MyCommand(receiver);
		Invoker invoker = new Invoker(cmd);
		invoker.action();
	}
}

4.6.3. 总结

命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开

4.7. 备忘录模式（Memento Pattern）

4.7.1. 介绍

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。
所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。
何时使用：很多时候我们总是需要记录一个对象的内部状态，这样做的目的就是为了允许用户取消不确定或者错误的操作，能够恢复到他原先的状态，使得他有"后悔药"可吃。

4.7.2. 举例

步骤 1
创建 Memento 类。
Memento.java
public class Memento {
   private String state;

   public Memento(String state){
      this.state = state;
   }

   public String getState(){
      return state;
   }    
}
步骤 2
创建 Originator 类。
Originator.java
public class Originator {
   private String state;
   public void setState(String state){
      this.state = state;
   }
   public String getState(){
      return state;
   }
   public Memento saveStateToMemento(){
      return new Memento(state);
   }
   public void getStateFromMemento(Memento Memento){
      state = Memento.getState();
   }
}
步骤 3
创建 CareTaker 类。
CareTaker.java
import java.util.ArrayList;
import java.util.List;
public class CareTaker {
   private List<Memento> mementoList = new ArrayList<Memento>();

   public void add(Memento state){
      mementoList.add(state);
   }
   public Memento get(int index){
      return mementoList.get(index);
   }
}

步骤 4

使用 CareTaker 和 Originator 对象。
MementoPatternDemo.java
public class MementoPatternDemo {
   public static void main(String[] args) {
      Originator originator = new Originator();
      CareTaker careTaker = new CareTaker();
      originator.setState("State #1");
      originator.setState("State #2");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #3");
      careTaker.add(originator.saveStateToMemento());
      originator.setState("State #4");

      System.out.println("Current State: " + originator.getState());        
      originator.getStateFromMemento(careTaker.get(0));
      System.out.println("First saved State: " + originator.getState());
      originator.getStateFromMemento(careTaker.get(1));
      System.out.println("Second saved State: " + originator.getState());
   }
}
步骤 5
验证输出。
Current State: State #4
First saved State: State #2
Second saved State: State #3

4.7.3. 总结

优点： 1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。 2、实现了信息的封装，使得用户不需要关心状态的保存细节。
缺点：消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

4.8. 状态模式（State Pattern）

4.8.1. 介绍

（qq隐身，操作隐身把状态保存到context，好友取得你的状态执行方法，灰掉隐身）
在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。
在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

4.8.2. 举例

代码演示：
步骤 1
创建一个接口。
State.java
public interface State {
   public void doAction(Context context);
}

步骤 2锁

创建实现接口的实体类。

StartState.java
public class StartState implements State {
   public void doAction(Context context) {
      System.out.println("Player is in start state");
      context.setState(this);    
   }

   public String toString(){
      return "Start State";
   }
}

StopState.java
public class StopState implements State {
   public void doAction(Context context) {
      System.out.println("Player is in stop state");
      context.setState(this);    
   }

   public String toString(){
      return "Stop State";
   }
}

步骤 3

创建 Context 类。
Context.java
public class Context {
   private State state;
   public Context(){
      state = null;
   }
   public void setState(State state){
      this.state = state;        
   }
   public State getState(){
      return state;
   }
}

步骤 4
使用 Context 来查看当状态 State 改变时的行为变化。
StatePatternDemo.java
public class StatePatternDemo {
   public static void main(String[] args) {
      Context context = new Context();
      StartState startState = new StartState();
      startState.doAction(context);
      System.out.println(context.getState().toString());
      StopState stopState = new StopState();
      stopState.doAction(context);
      System.out.println(context.getState().toString());
   }
}

步骤 5

验证输出。
Player is in start state
Start State
Player is in stop state
Stop State
开始状态存起来到context 执行不同tostring

4.8.3. 总结

核心思想就是：当对象的状态改变时，同时改变其行为

4.9. 访问者模式（Visitor Pattern）

4.9.1. 介绍

一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。

该模式适用场景：如果我们想为一个现有的类增加新功能，不得不考虑几个事情：1、新功能会不会与现有功能出现兼容性问题？2、以后会不会再需要添加？3、如果类不允许修改代码怎么办？面对这些问题，最好的解决方法就是使用访问者模式，访问者模式适用于数据结构相对稳定的系统，把数据结构和算法解耦。
关键代码：在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。

4.9.2. 举例

源码：一个Visitor类，存放要访问的对象
public interface Visitor {
	public void visit(Subject sub);
}
public class MyVisitor implements Visitor {
	@Override
	public void visit(Subject sub) {
		System.out.println("visit the subject："+sub.getSubject());
	}
}
Subject类，accept方法，接受将要访问它的对象，getSubject()获取将要被访问的属性。

public interface Subject {
	public void accept(Visitor visitor);
	public String getSubject();
}
public class MySubject implements Subject {
	@Override
	public void accept(Visitor visitor) {
		visitor.visit(this);
	}
	@Override
	public String getSubject() {
		return "love";
	}
}
测试：
public class Test {
	public static void main(String[] args) {
		Visitor visitor = new MyVisitor();
		Subject sub = new MySubject();
		sub.accept(visitor);	
	}
}
输出：visit the subject：love

4.10. 中介者模式（Mediator Pattern）

4.10.1. 介绍

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

4.10.2. 举例

这里我们就以租房为例，这里中介机构充当租房者与房屋所有者之间的中介者。UML结构图：

首先是抽象中介者:Mediator.java

public abstract class Mediator {
//申明一个联络方法
public abstract void constact(String message,Person person);
}
两个具体同事类：HouseOwner.java
public class HouseOwner extends Person{

HouseOwner(String name, Mediator mediator) {
    super(name, mediator);
}

/**
 * @desc 与中介者联系
 * @param message
 * @return void
 */
public void constact(String message){
    mediator.constact(message, this);
}

/**
 * @desc 获取信息
 * @param message
 * @return void
 */
public void getMessage(String message){
    System.out.println("房主:" + name +",获得信息：" + message);
}

}
Tenant.java
public class Tenant extends Person{

Tenant(String name, Mediator mediator) {
    super(name, mediator);
}

/**
 * @desc 与中介者联系
 * @param message
 * @return void
 */
public void constact(String message){
    mediator.constact(message, this);
}

/**
 * @desc 获取信息
 * @param message
 * @return void
 */
public void getMessage(String message){
    System.out.println("租房者:" + name +",获得信息：" + message);
}

}

具体中介者对象：中介结构、MediatorStructure.java
public class MediatorStructure extends Mediator{
//首先中介结构必须知道所有房主和租房者的信息
private HouseOwner houseOwner;
private Tenant tenant;

public HouseOwner getHouseOwner() {
    return houseOwner;
}

public void setHouseOwner(HouseOwner houseOwner) {
    this.houseOwner = houseOwner;
}

public Tenant getTenant() {
    return tenant;
}

public void setTenant(Tenant tenant) {
    this.tenant = tenant;
}

public void constact(String message, Person person) {
    if(person == houseOwner){          //如果是房主，则租房者获得信息
        tenant.getMessage(message);
    }
    else{       //反正则是房主获得信息
        houseOwner.getMessage(message);
    }
}

}
客户端：Client.java
public class Client {
public static void main(String[] args) {
//一个房主、一个租房者、一个中介机构
MediatorStructure mediator = new MediatorStructure();

    //房主和租房者只需要知道中介机构即可
    HouseOwner houseOwner = new HouseOwner("张三", mediator);
    Tenant tenant = new Tenant("李四", mediator);
    
    //中介结构要知道房主和租房者
    mediator.setHouseOwner(houseOwner);
    mediator.setTenant(tenant);
    
    tenant.constact("听说你那里有三室的房主出租.....");
    houseOwner.constact("是的!请问你需要租吗?");
}

}
运行结果：
房主:张三,获得信息：听说你那里有三室的房主出租…
租房者:李四,获得信息：是的!请问你需要租吗?

4.10.3. 总结

优点：1.降低了系统对象之间的耦合性，使得对象易于独立的被复用。
2.提高系统的灵活性，使得系统易于扩展和维护。
缺点：因为这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。

模式	区别
中介者模式	A，B之间的对话通过C来传达。A,B可以互相不认识（减少了A和B对象间的耦合）；中介者模式是用一个中介对象来封装一系列同事对象的交互行为；中介者模式则由中心协调同事类和中心本身共同完成业务。中介者模式则是多对多，中介者的功能多样，客户也可以多个。
代理模式	A要送B礼物，A,B互相不认识，那么A可以找C来帮它实现送礼物的愿望（封装了A对象）；代理模式针对的是单个对象，一对一；代理角色与真实角色接口相同，功能一致，代理角色实现的是真实角色的功能。
外观模式	A和B都要实现送花，送巧克力的方法，那么我可以通过一个抽象类C实现送花送巧克力的方法（A和B都继承C）。（封装了A，B子类）；外观模式是对子系统提供统一的接口，针对的是所有子类；外观模式所有的请求处理都委托给子系统完成。外观者模式的子系统功能不同，根据用户不同需要与外观类统一配置。

4.11. 解释器模式（Interpreter Pattern）

4.11.1. 介绍

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等
一般主要应用在OOP开发中的编译器的开发中，所以适用面比较窄。Context类是一个上下文环境类，Plus和Minus分别是用来计算的实现

4.11.2. 举例

public interface Expression {
	public int interpret(Context context);
}
public class Plus implements Expression {
	@Override
	public int interpret(Context context) {
		return context.getNum1()+context.getNum2();
	}
}
public class Minus implements Expression {
	@Override
	public int interpret(Context context) {
		return context.getNum1()-context.getNum2();
	}
}
public class Context {
	private int num1;
	private int num2;
	
	public Context(int num1, int num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	public int getNum1() {
		return num1;
	}
	public void setNum1(int num1) {
		this.num1 = num1;
	}
	public int getNum2() {
		return num2;
	}
	public void setNum2(int num2) {
		this.num2 = num2;
	}
}
测试类：
public class Test {

	public static void main(String[] args) {

		// 计算9+2-8的值
		int result = new Minus().interpret((new Context(new Plus()
				.interpret(new Context(9, 2)), 8)));
		System.out.println(result);
	}
}

4.11.3. 总结

解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等！可利用场景比较少
|