设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
一、设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：
二、设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。
三、Java中具体的设计模式
1.简单工厂模式（Simple Factory）
根据提供给它的参数，返回的是几个可能产品中的一个类的实例。
①Sender接口
package No1_SimpleFactory;
public interface Sender {
public void send();
}
接口中定义了一个Send 方法。
②MailSender类，实现了Sender接口
package No1_SimpleFactory;
public class MailSender implements Sender
{
public void send()
{
System.out.println("发送邮件");
}
}
③MessageSender类，实现了Sender接口
package No1_SimpleFactory;
public class MessageSender implements Sender
{
public void send()
{
System.out.println("发送短信 ");
}
}
④创建SendFactory工厂类
package No1_SimpleFactory;
public class SendFactory {
public Sender produce(String type)
{
if("mail".equals(type))
{
return new MailSender();
}
else if("message".equals(type))
{
return new MessageSender();
}
else
{
System.out.println("请输入正确的类型");
return null;
}
}
}
在SendFactory中定义了一个Sender类型的方法produce()，这个方法可以根据提供给它的参数，返回一个Sender类型的实例。
⑤测试
package No1_SimpleFactory;
public class SimpleFactoryTest
{
public static void main(String[] args)
{
SendFactory factory = new SendFactory();
Sender sender1 = factory.produce("mail");
sender1.send();
}
}
输出的结果为：
发送邮件 发送短信
2.多个工厂方法模式
在普通工厂模式中，如果传递的字符串出错，则不能创建对象，而多个工厂方法模式提供多个工厂方法，分别创建对象：
接口和连个实现接口的类保持不变。
④SendFactoy类
package No2_duogeFactory;
public class SendFactory
{
public Sender produceMail()
{
return new MailSender();
}
public Sender produceMessage()
{
return new MessageSender();
}
}
提供了多个工厂方法，用来分别创建对象。
⑤测试
package No2_duogeFactory;
public class FactoryTest
{
public static void main(String[] args)
{
SendFactory factory = new SendFactory();
Sender sender = factory.produceMail();
sender.send();
Sender sender1 = factory.produceMessage();
sender1.send();
}
}
输出结果：
发送邮件 发送短信
3.静态工厂模式
将上面的多个工厂方法模式里的方法设置为静态的，不需要创建实例，直接调用即可。
①②③接口和连个实现接口的类保持不变。
④SendFactory类
package No2_duogeFactory;
public class SendFactory
{
public Sender produceMail()
{
return new MailSender();
}
public Sender produceMessage()
{
return new MessageSender();
}
}
⑤测试
package No2_duogeFactory;
public class FactoryTest
{
public static void main(String[] args)
{
SendFactory factory = new SendFactory();
Sender sender = factory.produceMail();
sender.send();
Sender sender1 = factory.produceMessage();
sender1.send();
}
}
这三种工厂方式比较起来，大多数情况下，会选择静态工厂方法模式。
4.抽象工厂模式（Abstract Factory）
工厂模式存在的问题：类的创建依赖工厂类，如果需要拓展程序，就需要对工厂类进行修改，违背了闭包原则，所以抽象工厂模式，创建多个工厂类，这样一旦新增加功能，直接增加新的工厂类即可，不需要修改之前的代码。
①Sender接口
public interface Sender
{
public void Send();
}
②MailSender类实现这个接口
public class MailSender implements Sender
{
public void Send()
{
System.out.println("发送邮件");
}
}
③MessageSender类实现这个接口
public class MessageSender implements Sender
{
public void Send()
{
System.out.println("发送短信");
}
}
④ Provider类接口，包含以Sender作为返回类型的方法
public interface Provider
{
public Sender produce();
}
⑤SenderMailFactory类实现这个接口，返回一个MailSender的实例
public class SendMailFactory implements Provider
{
public Sender produce()
{
return new MailSender();
}
}
⑥SenderMessageFactory类实现这个接口，返回一个MessageSender的实例
public class SendMessageFactory implements Provider
{
public Sender produce()
{
return new MessageSender();
}
}
⑦测试
public class FactoryTest
{
public static void main(String[] args)
{
Provider provider = new SendMailFactory();
Sender sender = provider.produce();
sender.Send();
}
}
输出结果：
发送邮件
5.单例模式（Singleton）
单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。
1.某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销；
2.省去了new操作符，降低了系统内存的使用频率，减轻GC压力；
3.有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统会混乱，所以只能使用单例模式，才能保证核心交易服务器独立控制整个流程。
①最简单的单例模式的类
public class Singleton
{
private static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance()
{
if(instance == null)
{
instance = new Singleton();
}
return instance;
}
public Object readResolve()
{
return instance;
}
}
这是最简单的单例模式的类，但是没有线程安全保护，如果放入到多线程的环境中，会出现问题，为了解决这个问题，对getInstance方法加上synchronized关键字。
②对getInstance加上synchronized关键字
public class Singleton_syn
{
//持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载
public static Singleton_syn instance = null;
//私有构造方法，防止被实例化
private Singleton_syn(){
}
public static synchronized Singleton_syn getInstance()
{
if(instance == null)
{
instance = new Singleton_syn();
}
return instance;
}
public Object readResolve()
{
return instance;
}
}
使用synchronized关键字锁住的是这个对象，这样的用法在性能上会下降，因为每次调用getInstance()方法的时候，都会对对象上锁。事实上，只有在第一次创建对象的时候需要枷锁，之后不需要，所以，在此处需要进行改动。