设计模式

大话设计模式个人总结。

一、简单工厂模式：创建一个工厂，参数是一个标示符，返回一个对象。这个对象的类有几个子类，调用工厂的时候根据标示符去创建子类，然后将子类返回。

二、策略模式：一个父类或是一个接口，有几个子类继承了父类或是实现了这个接口，子类重写了父类的方法或是对接口的方法实现了。然后有一个第三个类，初始化的时候需要传入那个父类或是接口，作为一个变量。且那个第三个类有一个方法，在方法里面调用变量实例的方法。 由此第三个类可以一直保持不变，扩展的话就是用新子类去继承父类就好。

三、装饰模式：类A，类A的子类类B。类B有个decorate（）方法参数是类A对象，B里面有个属性变量对象是类A的实例，decorate（）方法是类A的属性对象实例赋值为传入的参数类A，此外类B还有个一show（）方法。类B有许许多多的子类，重写show（）方法为：新的行为动作+super（）方法。最后操作时候，新建类A对象实例a，新建类B的子类对象实例b，c，d，b调用decorate（）方法，把a当参数；子类c调用decorate（）方法把b当参数；子类d调用decorate（）方法吧c当参数....最后的子类调用decorate方法把上一个子类当参数后，调用show（）方法。上面的操作过程实现了各个新动作的叠加。

四、代理模式：接口A，类B，类C都继承了接口A。类C中有一个类B的对象属性，类C的构造方法需要传入一个类B的参数给其赋值。类C实现接口A的方法就是调用类B实现的接口A的对应方法。使用时，新建一个类C，然后调用类实现类A的接口方法，至此类C实现了代理。

五、工厂方法模式：有一个工厂接口F，接口定义一个create方法，类A和类B都去继承F并实现create方法。类A的create方法返回C的子类D，类B的create方法返回C的子类E。使用的时候新建一个F f=new A()；C d=f.create()这样就得到了D的实例d；F f=new B()；C e=f.create()这样就得到了E的实例e。

六、原型模式：用于复制对象，最重要的方法是super.clone().类A写个 clone()方法，返回一个object对象，clone方法里面调用 super.clone()返回一个object，用的时候再强转成类A对象。

七、模板方法模式：一个抽象类A有多个抽象方法，还有一个调用这些抽象方法的方法F，F中也可以混入一些公共的方法，A的子类B，C等去实现那个抽象方法。

八、外观模式：类A，类B，类C都有各自的方法。类D有类A,B,C的实例对象，类D的方法调用了A，B，C的一个或多个方法的组合。

九、建造者模式：有一个类A，有一些设定自己属性的方法。有个抽象类B定义了一些抽象方法，和一个获取结果的方法b。类C继承B，有一个属性是类A对象，实现B的抽象方法，在那些方法中对属性对象A的属性经行设置。有个指挥类D，有个参数为C类对象的方法f，并在方法里面调用C的方法一些设置对象A属性的方法组合。使用时候新建立C和D的实例，c，d。把c当做参数传给d的f方法进行c的一些方法的调用。调用c的获取结果方法。

十、观察者模式：类A有个类B的对象数组，有增加减少和更新的方法notify（循环数组挨个调用update方法）。类C继承类B实现类B的update方法，新建多个类C对象，新建一个类A对象，把多个类C对象加入类A对象的数组中，调用类A的notify方法实施对多个类C对象的数据刷新。

十一、抽象工厂模式：有一个类A，有抽象法f，类B，类C都继承了A实现了方法f。接口D定义了抽象方法f2，类E，类F都继承了D：E实现f2返回B的实例；类F实现f2返回了C的实例。A a=new E或是A a=new F去获得E还是F的实例，然后调用a.f的方法什么的都不变，实现了不同类对应不同方法，做到了最小的改动。 

十二、状态模式：有个抽象类A，它有一个抽象方法f（B b）。类B有个A类的实例属性a，和一个状态属性c，有方法f2（A a）{a=a}和f3（）里面是a.f(this)。类C，D，E都继承了A实现f方法，传入的b，通过怕段b的属性c去决定调用b.f2(a)a是C，D，E之中的实例和b.f3()还是做出对应的反应。这样可以一直把状态从C，D，E一路传递下去，直到对应此状态做出的反应。

十三、适配器模式：有个抽象类A，有一个属性a和抽象方法f1，f2,。有个类B和类A没啥关系。类C继承了A，并且有个类B的实例化对象属性b，类C重写A类的抽象方法，在重写的方法里面调用了b的方法。

十四、备忘录模式：类A是一个有很多数据属性的（或是操作存储数据）类。类B包含了类A的属性，并且有个新建类A实例的方法f1（）就是新建一个A的实例并赋好属性值，有一个需要传入类A实例的方法发f2（A a），就是把a的值赋给B的属性。有个类C，里面有个类A的实例属性a。使用的时候，新建一个类B实例b，然后设置好属性的值，新建一个类C的实例c，c.a=b.f1()；然后b更改自己的属性的值，可再用b.f2(c.a)恢复初始状态。这样做隐藏了B的实现细节。

十五、组合模式：有一个抽象类A，B和C分别继承A，B是叶节点，C是支节点，C中数组用于存放节点，和增减节点的方法参数用A的类型就好。

十六、迭代器模式：简单说就是有一个列表管理的类，负责遍历管理列表，只提供出对应的方法，实现都隐藏在那个类内部。

十七、单例模式：比较简单，就是初始化方法变成私有，然后有个私有的此对象实体，然后有一个静态的方法去在里面判断下这个类的属性的对象实例是否为空，为空的话 新建这个类的实例并赋值给这个类的属性的对象实例，然后返回该对象实例；不为空的话直接返回。

十八、桥接模式：有个抽象类A，它有抽象方法f1（）。类B和类C继承A实现f1（）。有个类D，它有一个类A的参数，并在其f()2中调用此参数的f1()方法。用的时候新建一个D的实例b，然后把B,或是C赋值给b的参数，b.f()2实现了调用。

十九、命令模式：有个类A，有个执行方法f1()。有个类B，它有一个属性为类A的对象a和抽象的方法f2()。类C继承B实现f2()，其实就是f2()调用a.f1()。有个类D，他有一个类B的实例属性b，他有一个方法f3()，其实就是调用b.f2()。用的时候，新建一个类A实例a，新建一个类B实例c，新建一个类D实例d，把a赋值给c的属性，把c赋值给d的属性，d.f3()，实现了对A的方法f1()的调用。

二十、 责任链模式：有一个类A，它有一个类A的属性a，方法f1(int n)。类B类C继承了A。类B实现f1(int n)方法，通过判断n去执行对应的操作或是直接调用自己属性a.f1(int n)。C也类似。使用的时候A b=new B（）;A c=new C();b.a=c;b.f1(n)。

二十一、中介者模式：

二十二、享元模式：

二十三、解释器模式：

二十四、访问者模式：

写到这里，也慢慢有些感悟，最经也在梳理项目的基础功能和项目设计，发现以前学校里学的一直感觉没啥用的UML渐渐派上用场，文字叙述没有UML来的直观，所以把之前的UML图都加上。

单一原则：就一个类而言，应该仅有一个引起它变化的原因。

开发封闭原则：软件实体（类，模块，函数等），可以扩展，但是不能修改。

依赖倒转原则：高层模块不应该依赖底层模块，两个模块都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。

里氏代换原则：子类必须能替换掉他们的父类。

迪米特法则：如果两个类不必彼此通信，那么这两个类就不应当发色直接的作用，如果其中一个类调用另个一个类的方法，可以通过第三者转发这个调用。

github上面放了完整最简单的例子   https://github.com/Tineste/JavaPatterns