设计模式

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

创建型模式：

1.工厂模式（根据功能去创建工厂）

第一种：申明一个接口，提供一个test()方法，创建两个实现类，实现test()方法，创建一个工厂类，工厂类提供一个创建方法create(type),该方法返回值设置为接ko口，根据传入的type,判断该返回哪种具体的实现类。

第二种：改进后写法：申明一个接口Sender，提供send()方法，创建两个实现类ASender和BSender，实现test()方法，在创建一个接口Provider，提供一个produce()方法，该方法返回类型为Sender，创建两个工厂类AFactory和BFactory实现接口Provider，实现producer方法，AFactory具体方法实现做的是new ASender(),BFactory具体方法实现做的是new BSender(),这样，如果此时我可以通过 Provider aFactory = new AFactory();  产生一个AFactory工厂对象，Sender aSender = aFactory.produce();  然后通过工厂去产生业务实现类ASender，然后在调用send()方法，此时就会调用 ASender实现类中的send()方法。

此种方法的好处是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

2.单例模式(特点，一个类只需要创建一次，构造器为私有构造器）

第一种：单线程 ，创建一个Single类，静态变量private static Single single = new Single();提供getInstance()方法，返回类型为Single；

第二种：单线程 ，创建一个Single类，静态变量private static Single single = null，提供getInstance()方法，if(single == null){single = new Single()};

第三种：多线程，用synchronized， 锁定该方法。

3.原型模式，复制对象

1. public class Prototype implements Cloneable {  
2.   
3.     public Object clone() throws CloneNotSupportedException {  
4.         Prototype proto = (Prototype) super.clone();  
5.         return proto;  
6.     }  
7. }

结构型模式：

4.适配器模式（项目搭建基类的时候可以用）

第一种：类的适配器模式，主要是申明一个接口，接口中有一个test()方法，一个test1()方法，在申明一个类A,此类并不去实现接口，里面具体去实现test()方法，此时我在声明一个类继承A和实现接口，这个接口对test1()进行具体实现，当你测试的时候，其实他会调用类A中的test(),由于他实现了接口，则必须要实现接口中的方法，而他继承了类A，所以继承了test()方法，若没有重写，则会调用父类的方法。

第二种：接口适配器，主要是申明一个接口B，接口中有一个test()方法，一个test1()方法，在声明一个抽象类A，抽象类实现接口，但是方法不具体实现，还可以在添加一个方法test3(),此时我在声明一个类继承A和实现接口B，在该类中去实现test3(),实现A接口的类，这样该类就同时拥有了test(),test1(),test3()的特性

5.装饰模式(注入配置类的时候用)

申明一个接口，提供一个test()方法，申明一个类source实现接口，实现他的方法，在创建一个装饰类实现接口，将类source作为对象属性private Sourceable source;  

，该类构造函数注入类source， public Decorator(Sourceable source){this.source = source; }该类实现方法test()就可以将A类中实现的test()方法进行使用，同时装饰类中的实现方法还可以添加自己的特点。

6.代理模式

申明一个接口，提供一个test()方法，申明一个类source实现接口，实现他的方法,在创建一个代理类，将类Source作为对象属性，private Source source;  该类构造函数中this.source = new Source();   虽然他获得了source中的方法，但是不同的是，他不向外暴露Source这个类，代理类也可以在实现接口类中添加自己元素，然后引用source中的方法。

7.外观模式(电脑包含cpu,磁盘disk,内存memory)

申明一个类cpu，申明一个类disk，申明一个类memory，这三个类都包含一个启动方法startup(),包含一个关闭方法shutdown(),申明一个类computer，提供启动方法startup(),一个关闭方法shutdown()，电脑启动需要这三个类都启动，才能正常运行，所以设置三个对象属性cpu，disk，memory，初始化电脑computer的时候，将这三个对象初始化，然后startup方法中将他依赖的这三个类分别调用自己的startup方法，computer关闭的时候，也一样，shutdown中三个类去关闭自己的shutdow方法。

8.桥接模式

申明一个接口C，提供一个test()方法，申明一个类A，实现接口，实现test()方法，申明一个类B,实现接口，实现test()方法，创建一个桥接类，该类为抽象类，将接口A作为对象属性，通过get方法注入，但是get注入的实现应该是他的具体实现类型，提供test()方法，他的test()方法，里面写入c.method方法,c这个对象因为是具体实现类，所以调用的是A或者B的test()方法，在创建一个子类D,该类去继承桥接抽象类，并且具体实现test()方法，因为有继承关系，所以他也拥有getSource()和setSource()方法，所以，可以直接使用getSource().test(),但是这样我觉得抽象类里面的test()方法相当于白写了，可以直接用super().test()方法，交给抽象类去处理。

9.组合模式(用的很普遍)

一个人拥有多辆汽车，则类A中，添加一个属性List<car> ;

一个车对应一个发动机，发动机有自己的特征，private Engine engine,查询结果就可以把车和发动机的特征一起返回。

10.亨元模式(jdbc连接池的创建与释放)

声明一个连接池类ConnectionPool ，定义一个vector线程安全的线程池集合，private Vector<Connection> pool;  在连接池初始化的时候，初始化这个集合 pool = new Vector<Connection>(poolSize);  ，然后根据设置的连接池大小例如100个，则在pool集合中添加100个连接，该类还提供一个getConnet方法,该方法加了一个synchronized 锁定，当外界获取一个连接池后，该集合就少一个，pool.remove(conn),此类还有一个release方法，该方法作用是外界关闭一个连接的时候，则应该归还给线程池，则线程池会多一个conn，所以该类做的是pool.add(conn),此方法应该也是同步操作，所以方法上也需要添加一个synchronized 

行为型模式：

11.策略模式（strategy）

申明一个接口，该接口提供一个策略方法test(),申明一个抽象类，该类提供一个辅助方法，该方法应该是做一些公共的操作，申明类A实现接口继承抽象类，然后实现接口的策略方法test()，方法里面也会引用抽象类的方法，然后再写自己的逻辑，申明类B实现接口继承抽象类，然后实现接口的策略方法，方法里面也会引用抽象类的方法，然后再写自己的逻辑。测试的时候，用接口指向一个具体的类，然后调用策略方法test()。

12.模板方法模式

申明一个抽象类，申明一个主方法test()，其他的多个方法，然后主方法去调用其他的方法，申明一个类继承抽象类，然后重写他的抽象方法，测试的时候，用抽象类指向子类，然后调用主方法test()。

13.观察者模式

申明一个接口Observer，里面一个update()方法，申明两个子类，子类Observer1和子类Observer2,实现update()方法，在申明一个接口Subject,申明 四个方法，

/*增加观察者*/     public void add(Observer observer);           

/*删除观察者*/      public void del(Observer observer);         

/*通知所有的观察者*/      public void notifyObservers();       

 /*自身的操作*/      public void operation();  

申明一个抽象类AbstractSubject

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

申明一个类Mysubject继承抽象类，这样接口和抽象类的东西都被子类继承了(适配器模式)

@Override public void operation() {System.out.println("update self!"); notifyObservers();}  

测试类ObserverTest，main方法里面写法。

Subject sub = new MySubject(); sub.add(new Observer1());sub.add(new Observer2()); sub.operation();  

14.迭代子模式

15.责任链模式

申明一个接口Handler，提供一个operator方法,申明一个抽象类，抽象类设置参数 private Handler handler; 提供get，set方法，申明一个类继承抽象类和实现接口，该类具体实现operator方法，方法如下，通过设置handler对象来实现方法重复调用，类似于递归。

@Override public void operator(){System.out.println(name+"deal!");if(getHandler()!=null){getHandler().operator();}}  

测试类test h1调用operator方法时，走到getHandler判断时，因为有设置为h2，所以为true，然后调用getHandler().operator()，此时得到的getHandler是h2实例，则调用h2的operator()方法，调用的其实是同一个operator方法，然后又要判断getHandler，因为有设置为h3，则为true，此时得到的getHandler是h3实例，则调用h3的operator方法，调用的其实还是用一个operator方法，然后在判断getHandiler，因为h3并未设置handler，所以此时getHandler为空，则为false，此时递归结束。

 public static void main(String[] args) {

MyHandler h1 = new MyHandler("h1");

MyHandler h2 = new MyHandler("h2");

MyHandler h3 = new MyHandler("h3");

h1.setHandler(h2);h2.setHandler(h3);h1.operator();

}  

16.命令模式(command) -----------长官下达命令  长官只关注命令下达成功与否，不关注如何实现

申明长官类Invoker，引入Command接口，提供一个行动方法。

private Command command;public Invoker(Command command) {this.command = command;} public void action(){command.exe();}  

申明命令接口Command

提供public void exe(); 

申明实现类MyCommand，该类注入接收者

 private Receiver receiver;public MyCommand(Receiver receiver) {this.receiver = receiver;}  

 @Override  public void exe() {receiver.toExcuteCommand();}  

申明一个接收者Receiver,提供一个执行命令的方法

 public void toExcuteCommand(){   System.out.println("command received!");}  

test类public static void main(String[] args) {

Receiver receiver = new Receiver();

Command cmd = new MyCommand(receiver);

Invoker invoker = new Invoker(cmd);

invoker.action();

}  

17.备忘录模式(有点复杂，先放着，这个需要手敲代码试验一下)

18.状态模式

19.访问者模式

20.中介者模式

21.解释器模式

本文是引用这篇文章详解https://www.cnblogs.com/geek6/p/3951677.html