一：定义
在软件工程中，设计模式（design patern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。
二：常见设计模式及其在JDK中的应用
参考博客：https://www.cnblogs.com/java-my-life
1. 适配器模式
把一个类的接口变换成客户端所期待的另一种接口，使原本因接口不匹配而无法在一起工作的两个类能够在一起工作
JDK 中：
java.util.Arrays#asList()
java.io.InputSreamReader(InputSream)
java.io.OutputSreamWriter(OutputSream)
2. 迭代器模式
提供一个一致的方法来顺序访问集合中的对象，这个方法与底层的集合的具体实现无关。
JDK 中：
java.util.Iterator
java.util.Enumeration
3. 代理模式
目标对象给定代理对象，并由代理对象代替真实对象控制客户端对真实对象的访问。
JDK：
java.lang.reflect.Proxy
RMI
4. 观察者模式
定义了对象的一对多依赖，让多个观察者对象同时监听某一个主题对象。当主题对象改变状态时，所有依赖者会收到通知并更新
JDK 中:
java.util.Observer,Observable
java.util.EventListenr
javax.servlet.http.HttpSesionBindingListener
javax.servlet.http.HttpSesionAttributeListener
javax.faces.event.PhaseListener
5. 装饰器模式
装饰原有对象、在不改变原有对象的情况下扩展增强新功能/新特征
JDK 中:
java.io.BufferedInputSream(InputSream)
java.io.DataInputSream(InputSream)
java.io.BufferedOutputSream(OutputSream)
java.util.zip.ZipOutputSream(OutputSream)
java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap
6. 工厂模式
简单工厂：由一个工厂对象决定创建出哪一种产品类的实例
工厂方法：通过定义创建对象的接口，由子类动态决定实例化，将实际创建工作推迟到子类中
JDK 中：
java.lang.Proxy#newProxyInstance()
java.lang.Object#toString()
java.lang.Class#newInstance()
java.lang.reflect.Array#newInstance()
java.lang.reflect.Constructor#newInstance()
java.lang.Boolean#valueOf(String)
java.lang.Class#forName()
抽象工厂：提供一个接口，用于创建相关或依赖对象的产品族，不需要明确具体工厂类
JDK 中：
java.util.Calendar#getInstance()
java.util.Arrays#asList()
java.util.ResourceBundle#getBundle()
java.sql.DriverManager#getConnection()
java.sql.Connection#createStatement()
java.sql.Statement#excuteQuery()
java.text.NumberFormat#getInstance()
javax.xml.transform.TransformerFactory#newInstance()
7. 建造者模式
定义了一个新的类来构建另一个类的实例，以简化复杂对象的创建
JDK 中：
java.lang.StringBuilder#append()
java.lang.StringBuffer#append()
java.sql.PreparedStatement
javax.swing.GroupLayout.Group#addComponent()
8. 命令模式
把一个请求或者操作封装到一个对象中，允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志可以提供命令的撤销和恢复功能
java.util.concurrent.Runnable
java.util.concurrent.Callable
java.util.concurren.ThreadPoolExecutor
9. 责任链模式
通过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦
JDK 中：
java.util.loging.Logger#log()
javax.servlet.Filter#doFilter()
10. 享元模式
一个类的实例可以提供多个虚拟实例，用同个方法控制。以共享的方式高效地支持大量的细粒度对象
JDK中 ：
java.lang.Integer#valueOf(int)
java.lang.Boolean#valueOf(boolean)
java.lang.Byte#valueOf(byte)
java.lang.Charcter#valueOf(char)
String常量池
11. 中介者模式
通过使用一个中间对象来进行消息分发以及减少类之间的直接依赖。
JDK 中：
java.util.Timer
java.util.concurent.Executor#execute()
java.util.concurent.ExecutorService#submit()
java.lang.reflect.Method#invoke()
12. 备忘录模式
生成对象状态的一个快照，以便对象可以恢复原始状态而不用暴露自身的内容。
JDK 中：
java.util.Date
java.io.Serializable
13. 组合模式
使得客户端看来单个对象和对象的组合是同等的
JDK 中：
javax.swing.JComponet#add(Component)
java.util.Map#addAll(Map)
java.util.List#addAll(Collection)
java.util.Set#addAll(Collection)
14. 模板方法模式
让子类可以重写方法的一部分，而不是整个重写，你可以控制子类需要重写那些操作
JDK 中：
java.util.Collections#sort()
java.io.InputStream#skip()
java.io.InputStream#read()
java.util.AbstractList#indexOf()
ThreadPoolExecutor.Worker
15. 单例模式
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
JDK 中：
java.lang.Runtime
java.text.NumberFormat
三：设计模式的六大原则
- 单一职责原则(Single Responsiblty Princple, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。
- 开闭原则(Open-Closed Princple, OCP)：一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。
- 里氏代换原则(Liskov Substiution Princple, LSP)：所有引用基类（父类）的地方必须能透明地使用其子类的对象。
- 依赖倒转原则(Depndency Inversion Princple, DIP)：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程
- 接口隔离原则(Interface Segration Princple, ISP)：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。
- 迪米特法则(Law of Demter, LoD)：一个软件实体应当尽可能少地与其他实体发生相互作用