Java中一般认为有23种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式单例模式
最好理解的一种设计模式，分为懒汉式和饿汉式。
饿汉式：publicclassSingleton{//直接创建对象publicstaticSingletoninstance=newSingleton();//私有化构造函数privateSingleton(){}//返回对象实例publicstaticSingletongetInstance(){returninstance;}}懒汉式：publicclassSingleton{//声明变量privatestaticvolatileSingletonsingleton2=null;//私有构造函数privateSingleton2(){}//提供对外方法publicstaticSingleton2getInstance(){if(singleton2==null){synchronized(Singleton2.class){if(singleton==null){singleton=newSingleton();}}}returnsingleton;}}工厂设计模式
工厂模式分为工厂方法模式和抽象工厂模式。工厂方法模式分为三种：
普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
普通工厂模式：
publicinterfaceSender{publicvoidSend();}publicclassMailSenderimplementsSender{@OverridepublicvoidSend(){System.out.println("thisismailsender!");}}publicclassSmsSenderimplementsSender{@OverridepublicvoidSend(){System.out.println("thisissmssender!");}}publicclassSendFactory{publicSenderproduce(Stringtype){if("mail".equals(type)){returnnewMailSender();}elseif("sms".equals(type)){returnnewSmsSender();}else{System.out.println("请输入正确的类型!");returnnull;}}}
多个工厂方法模式：
该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
publicclassSendFactory{publicSenderproduceMail(){returnnewMailSender();}publicSenderproduceSms(){returnnewSmsSender();}}publicclassFactoryTest{publicstaticvoidmain(String[]args){SendFactoryfactory=newSendFactory();Sendersender=factory.produceMail();sender.send();}}
静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
publicclassSendFactory{publicstaticSenderproduceMail(){returnnewMailSender();}publicstaticSenderproduceSms(){returnnewSmsSender();}}publicclassFactoryTest{publicstaticvoidmain(String[]args){Sendersender=SendFactory.produceMail();sender.send();}}
抽象工厂模式：
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
publicinterfaceProvider{publicSenderproduce();}publicinterfaceSender{publicvoidsend();}publicclassMailSenderimplementsSender{@Overridepublicvoidsend(){System.out.println("thisismailsender!");}}publicclassSmsSenderimplementsSender{@Overridepublicvoidsend(){System.out.println("thisissmssender!");}}publicclassSendSmsFactoryimplementsProvider{@OverridepublicSenderproduce(){returnnewSmsSender();}}publicclassSendMailFactoryimplementsProvider{@OverridepublicSenderproduce(){returnnewMailSender();}}publicclassTest{publicstaticvoidmain(String[]args){Providerprovider=newSendMailFactory();Sendersender=provider.produce();sender.send();}}建造者模式（Builder）
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
publicclassBuilder{privateList<Sender>list=newArrayList<Sender>();publicvoidproduceMailSender(intcount){for(inti=0;i<count;i++){list.add(newMailSender());}}publicvoidproduceSmsSender(intcount){for(inti=0;i<count;i++){list.add(newSmsSender());}}}publicclassTestBuilder{publicstaticvoidmain(String[]args){Builderbuilder=newBuilder();builder.produceMailSender(10);}}适配器设计模式
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
类的适配器模式：
publicclassSource{publicvoidmethod1(){System.out.println("thisisoriginalmethod!");}}publicinterfaceTargetable{/*与原类中的方法相同*/publicvoidmethod1();/*新类的方法*/publicvoidmethod2();}publicclassAdapterextendsSourceimplementsTargetable{@Overridepublicvoidmethod2(){System.out.println("thisisthetargetablemethod!");}}publicclassAdapterTest{publicstaticvoidmain(String[]args){Targetabletarget=newAdapter();target.method1();target.method2();}}
对象的适配器模式：
基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。
publicclassWrapperimplementsTargetable{privateSourcesource;publicWrapper(Sourcesource){super();this.source=source;}@Overridepublicvoidmethod2(){System.out.println("thisisthetargetablemethod!");}@Overridepublicvoidmethod1(){source.method1();}}publicclassAdapterTest{publicstaticvoidmain(String[]args){Sourcesource=newSource();Targetabletarget=newWrapper(source);target.method1();target.method2();}}
接口的适配器模式：
接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
装饰模式（Decorator）
顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
publicinterfaceSourceable{publicvoidmethod();}publicclassSourceimplementsSourceable{@Overridepublicvoidmethod(){System.out.println("theoriginalmethod!");}}publicclassDecoratorimplementsSourceable{privateSourceablesource;publicDecorator(Sourceablesource){super();this.source=source;}@Overridepublicvoidmethod(){System.out.println("beforedecorator!");source.method();System.out.println("afterdecorator!");}}publicclassDecoratorTest{publicstaticvoidmain(String[]args){Sourceablesource=newSource();Sourceableobj=newDecorator(source);obj.method();}}策略模式（strategy）
策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。
publicinterfaceICalculator{publicintcalculate(Stringexp);}publicclassMinusextendsAbstractCalculatorimplementsICalculator{@Overridepublicintcalculate(Stringexp){intarrayInt[]=split(exp,"-");returnarrayInt[0]-arrayInt[1];}}publicclassPlusextendsAbstractCalculatorimplementsICalculator{@Overridepublicintcalculate(Stringexp){intarrayInt[]=split(exp,"\\+");returnarrayInt[0]+arrayInt[1];}}publicclassAbstractCalculator{publicint[]split(Stringexp,Stringopt){Stringarray[]=exp.split(opt);intarrayInt[]=newint[2];arrayInt[0]=Integer.parseInt(array[0]);arrayInt[1]=Integer.parseInt(array[1]);returnarrayInt;}}publicclassStrategyTest{publicstaticvoidmain(String[]args){Stringexp="2+8";ICalculatorcal=newPlus();intresult=cal.calculate(exp);System.out.println(result);}}观察者模式（Observer）
观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
publicinterfaceObserver{publicvoidupdate();}publicclassObserver1implementsObserver{@Overridepublicvoidupdate(){System.out.println("observer1hasreceived!");}}publicclassObserver2implementsObserver{@Overridepublicvoidupdate(){System.out.println("observer2hasreceived!");}}publicinterfaceSubject{/*增加观察者*/publicvoidadd(Observerobserver);/*删除观察者*/publicvoiddel(Observerobserver);/*通知所有的观察者*/publicvoidnotifyObservers();/*自身的操作*/publicvoidoperation();}publicabstractclassAbstractSubjectimplementsSubject{privateVector<Observer>vector=newVector<Observer>();@Overridepublicvoidadd(Observerobserver){vector.add(observer);}@Overridepublicvoiddel(Observerobserver){vector.remove(observer);}@OverridepublicvoidnotifyObservers(){Enumeration<Observer>enumo=vector.elements();while(enumo.hasMoreElements()){enumo.nextElement().update();}}}publicclassMySubjectextendsAbstractSubject{Overridepublicvoidoperation(){System.out.println("updateself!");notifyObservers();}}publicclassObserverTest{publicstaticvoidmain(String[]args){Subjectsub=newMySubject();sub.add(newObserver1());sub.add(newObserver2());sub.operation();}}
