23种设计模式解析

1、工厂方法模式（Factory Method）

工厂方法模式分为三种：
1、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：

举例如下：（我们举一个发送邮件和短信的例子）首先，创建二者的共同接口：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!1) 工厂模式适合凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。

2) 在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

2、抽象工厂模式（Abstract Factory）

1) 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。

请看例子：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 SendMailFactory implements Provider {           @Override      public Sender produce(){          return new MailSender();      }  }  public class SendSmsFactory implements Provider{      @Override      public Sender produce() {          return new SmsSender();      }  }  在提供一个接口：public interface Provider {      public Sender produce();  } 测试类：public class Test {      public static void main(String[] args) {          Provider provider = new SendMailFactory();          Sender sender = provider.produce();          sender.Send();      }  }  

3、单例模式（Singleton）

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

public class Singleton {        /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */      private static Singleton instance = null;        /* 私有构造方法，防止被实例化 */      private Singleton() {      }        /* 静态工程方法，创建实例 */      public static Singleton getInstance() {          if (instance == null) {              instance = new Singleton();          }          return instance;      }        /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */      public Object readResolve() {          return instance;      }  }  

4、建造者模式（Builder）

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

还和前面一样，一个Sender接口，两个实现类MailSender和SmsSender。最后，建造者类如下：public class Builder {            private List<Sender> list = new ArrayList<Sender>();           public void produceMailSender(int count){          for(int i=0; i<count; i++){              list.add(new MailSender());          }      }            public void produceSmsSender(int count){          for(int i=0; i<count; i++){              list.add(new SmsSender());          }      }  } 测试类：public class Test {        public static void main(String[] args) {          Builder builder = new Builder();          builder.produceMailSender(10);      }  }  

5、原型模式（Prototype）

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

public class Prototype implements Cloneable {        public Object clone() throws CloneNotSupportedException {          Prototype proto = (Prototype) super.clone();          return proto;      }  } 很简单，一个原型类，只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB，因为此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object类中，clone()是native的，具体怎么实现，我会在另一篇文章中，关于解读Java中本地方法的调用，此处不再深究。在这儿，我将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念：浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。public class Prototype implements Cloneable, Serializable {       private static final long serialVersionUID = 1L;      private String string;       private SerializableObject obj;      /* 浅复制 */      public Object clone() throws CloneNotSupportedException {          Prototype proto = (Prototype) super.clone();          return proto;      }        /* 深复制 */      public Object deepClone() throws IOException, ClassNotFoundException {            /* 写入当前对象的二进制流 */          ByteArrayOutputStream bos = new ByteArrayOutputStream();          ObjectOutputStream oos = new ObjectOutputStream(bos);          oos.writeObject(this);            /* 读出二进制流产生的新对象 */          ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());          ObjectInputStream ois = new ObjectInputStream(bis);          return ois.readObject();      }  public String getString() {          return string;      }       public void setString(String string) {          this.string = string;      }        public SerializableObject getObj() {          return obj;      }        public void setObj(SerializableObject obj) {          this.obj = obj;      }   }    class SerializableObject implements Serializable {      private static final long serialVersionUID = 1L;  }  

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类的功能。

总结一下三种适配器模式的应用场景：
类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。
接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

7、装饰模式（Decorator）

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，关系图如下：
Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：

public interface Sourceable {      public void method();  } public class Source implements Sourceable {        @Override      public void method() {          System.out.println("the original method!");      }  }public class Decorator implements Sourceable {        private Sourceable source;           public Decorator(Sourceable source){          super();          this.source = source;      }      @Override      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 source = new Source();          Sourceable obj = new Decorator(source);          obj.method();      }  }  输出：before decorator!the original method!after decorator!

装饰器模式的应用场景：
1、需要扩展一个类的功能。
2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）
缺点：产生过多相似的对象，不易排错！

8、代理模式（Proxy）

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。public interface Sourceable {      public void method();  }public class Source implements Sourceable {        @Override      public void method() {          System.out.println("the original method!");      }  } 根据上文的阐述，代理模式就比较容易的理解了，我们看下代码：public class Source implements Sourceable {      @Override      public void method() {          System.out.println("the original method!");      }  }  public class Proxy implements Sourceable {      private Source source;      public Proxy(){          super();          this.source = new Source();      }      @Override      public void method() {          before();          source.method();          atfer();      }      private void atfer() {          System.out.println("after proxy!");      }      private void before() {          System.out.println("before proxy!");      }  }  测试类：public class ProxyTest {        public static void main(String[] args) {          Sourceable source = new Proxy();          source.method();      }    } 输出：before proxy!the original method!after proxy!

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

9、外观模式（Facade）

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

10、桥接模式（Bridge）

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

11、组合模式（Composite）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便
使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

public class TreeNode {            private String name;      private TreeNode parent;      private Vector<TreeNode> children = new Vector<TreeNode>();                public TreeNode(String name){          this.name = name;      }       public String getName() {          return name;      }        public void setName(String name) {          this.name = name;      }       public TreeNode getParent() {          return parent;      }        public void setParent(TreeNode parent) {          this.parent = parent;      }            //添加孩子节点      public void add(TreeNode node){          children.add(node);      }            //删除孩子节点      public void remove(TreeNode node){          children.remove(node);      }            //取得孩子节点      public Enumeration<TreeNode> getChildren(){          return children.elements();      }  }  public class Tree {        TreeNode root = null;           public Tree(String name) {          root = new TreeNode(name);      }        public static void main(String[] args) {          Tree tree = new Tree("A");          TreeNode nodeB = new TreeNode("B");          TreeNode nodeC = new TreeNode("C");                    nodeB.add(nodeC);          tree.root.add(nodeB);          System.out.println("build the tree finished!");      }  }  

12、享元模式（Flyweight）

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

13、策略模式（strategy）

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。首先统一接口：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);      }  }  

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

解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用

15、观察者模式（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();  }

16、迭代子模式（Iterator）

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

有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。

18、命令模式（Command）

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


命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉Struts的同学应该知道，Struts其实就是一种将请求和呈现分离的技术，其中必然涉及命令模式的思想！
其实每个设计模式都是很重要的一种思想，看上去很熟，其实是因为我们在学到的东西中都有涉及，尽管有时我们并不知道，其实在Java本身的设计之中处处都有体现，像AWT、JDBC、集合类、IO管道或者是Web框架，里面设计模式无处不在。因为我们篇幅有限，很难讲每一个设计模式都讲的很详细，不过我会尽我所能，尽量在有限的空间和篇幅内，把意思写清楚了，更好让大家明白。

19、备忘录模式（Memento）

主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。

20、状态模式（State）

核心思想就是：当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点：1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。

package com.xtfggef.dp.state;    /**  * 状态类的核心类  * 2012-12-1  * @author erqing  *  */  public class State {            private String value;            public String getValue() {          return value;      }        public void setValue(String value) {          this.value = value;      }        public void method1(){          System.out.println("execute the first opt!");      }           public void method2(){          System.out.println("execute the second opt!");      }  } package com.xtfggef.dp.state;    /**  * 状态模式的切换类   2012-12-1  * @author erqing  *   */  public class Context {        private State state;        public Context(State state) {          this.state = state;      }        public State getState() {          return state;      }       public void setState(State state) {          this.state = state;      }        public void method() {          if (state.getValue().equals("state1")) {              state.method1();          } else if (state.getValue().equals("state2")) {              state.method2();          }      }  } 测试类：public class Test {        public static void main(String[] args) {                    State state = new State();          Context context = new Context(state);                    //设置第一种状态          state.setValue("state1");          context.method();                    //设置第二种状态          state.setValue("state2");          context.method();      }  }输出： execute the first opt!execute the second opt!根据这个特性，状态模式在日常开发中用的挺多的，尤其是做网站的时候，我们有时希望根据对象的某一属性，区别开他们的一些功能，比如说简单的权限控制等。

21、访问者模式（Visitor）

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

22、中介者模式（Mediator）

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

23、解释器模式（Interpreter）

解释器模式是我们暂时的最后一讲，一般主要应用在OOP开发中的编译器的开发中，所以适用面比较窄。
解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等！