设计模式常常分为如下三类：
创建型：创建对象时，不在直接实例化对象；而是根据特定场景，由应用程序来确定创建对象的方式，从而保证更高的性能，更好的架构优势。创建型模式主要有简单工厂模式、工厂方法、抽象工厂模式、单列模式、生成器和原型模式。
结构型：用于帮助多个对象组织成更大的结构。结构型模式主要有适配器模式、桥接模式、组合器模式、装饰器模式、门面模式、享元模式和代理模式。
行为型：用于帮助系统间各对象的通信，以及如何控制复杂系统中的流程。行为型模式主要有命令模式、解释器模式、迭代模式、中介者模式、备忘录模式、状态模式、策略模式、模板模式、访问这模式。
1、单列模式
有些时候，运行自由创建某个类实例没有意义，还有可能造成系统性能下降（因为创建对象所带来的系统开销问题）。
主要点：
1）将构造器用private修饰
2）提供一个public static方法，供获取该类对象
3）该类需缓存一个已经创建的对象，否则该类无法知道是否已经创建对象。
示例如下：
class Singleton{
private static Singleton instance;
private Singleton(){
}
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
2、简单工厂模式
将多个对象交给工厂来生成的设计方式被称为简单工厂模式。
例如A类依赖于B类。对于A类而言，它并不关心B对象的实现、创建过程。考虑B类实现一个IB接口，而A类只需要与IB接口耦合——A类并不直接使用new关键字来创建B实例，而是重定义一个工厂类：IBFactory，由该工厂来负责创建IB实现，而A类通过调用IBFactory工厂的方法来得到IB的实例。
下面一个简单的实例来说明简单工厂模式：假设有个Computer对象需要依赖一个输出设备（Printer对象）。让Computer类依赖output属性，将computer类与printer类实现分离，Computer对象只需面向output接口编程即可。computer对象具体依赖哪个实现类完全透明。
public class Computer{
private Output out;
public Computer (Output out){
this.out = out;
}
public void keyIn(String msg){
out.getData(msg);
}
public void print(){
out.out();
}
public static void main(String[] args){
outputFactory of =new outputFactory ();
Computer c = new Computer(of.getOutput());
c.keyIn("轻量级java“）；
c.print();
}
}
以上代码可以看出computer类与printer类已经分离了，只是与该接口耦合。而且Computer不再负责创建output对象，系统将提供一个Output工厂类负责生成output对象，outputFactory工厂类如下：
public class OutputFactory{
public Output getOutput(){
return new Printer();
}
}
以上类提供一个getOutput（）方法，该方法返回一个output实例，该方法负责创建output实例，具体创建哪一个实现类的对象，则由该方法决定。
程序清单： Printer.java代码如下：
public class Printer{
private String[] printData = new String[MAX_CACHE_LINE);
//用以记录当前需打印的页数
private int dataNum=0;
public void out(){
//z只要有作业，继续打印
System.out.println("打印机打印：” + printData[0];
//把作业队列整体前移一位，并将剩下的作业数减一
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
public void getData(String msg){
if(dataNum >= MAX_CACHE_LINE){
System.out.println("输出队列已满，添加失败“）；
}else{
printData[dataNum++] = msg;
}
}
}
上面的printer类模拟了一个简单的打印机，如果系统需要重构，需要使用BetterPrinter来代替Printer类，则需要让BetterPrinter师兄Output接口，并改下OutputFactory类的getOutput()方法。
将OutputFactory类的getOutput()方法改成如下：
return new BetterPrinter();
通过这种方式，可以把所有生成Output对象的逻辑集中在OutputFactory工厂类中管理，所有需要Output对象的类需要与Output接口耦合，而不是与具体的实现类耦合，即使系统中有很多类依赖Printer对象，只需要修改OutputFactory类的getOutput()方法，返回BetterPrinter对象即可。
使用简单工厂模式的优势：让对象的调用者和对象的创建过程分离，当对象调用者需要对象时，直接向工厂请求即可，从而避免对象的调用和对象的实现类以硬编码方式耦合。以提供系统的维护性、扩展性。但工厂模式有个小缺陷：当产品修改时，对应的工厂类也需要修改。
3、抽象工厂
在简单工厂模式里，系统使用工厂类生产所有产品实例，且改工厂类决定生产哪个类的实例，即该工厂类负责所有的逻辑判断、实例创建工作。
如果不想在工厂类中进行逻辑判断，程序为不同的产品类提供不同的工厂，不同的工厂类生产不同的产品。例如为上面的Printer、BetterPrinter提供PrinterFactory和BetterFactory工厂类。
本示例将2中的outputFactory该为一个接口，并为该接口提供两个实现类：PrinterFactory和BetterPrinterFactory
OutputFactory接口代码如：
public interface OutputFactory{
Output getOutput();
}
PrinterFactory实现类如下：
public class PrinterFactory implements OutputFactory{
public Output getOutput(){
return new Printer();
}
}
BetterPrinterFactory 实现类如下：
public class BetterPrinterFactory implements OutputFactory{
public Output getOutput(){
return new BetterPrint();
}
}
修改2中的Couputer类如下：
public class Computer{
private Output out;
public Computer (Output out){
this.out = out;
}
public void keyIn(String msg){
out.getData(msg);
}
public void print(){
out.out();
}
public static void main(String[] args){
outputFactory of =new PrinterFactory ();
Computer c = new Computer(of.getOutput());
c.keyIn("轻量级java“）；
c.print();
}
}
当程序需要调用Output对象的方法时，需要显示的创建不同的工厂实例。程序中创建的是PrinterFactory 实例。这种方式虽然不会修改工厂类的方法，但会带来另一种耦合，客户端代码和工厂类的耦合。
在这种模式下新增一个OutputFactoryFactory工厂类，改工厂类提供了一个getOutputFactory(String type)方法，改方法用于返回一个OutputFactory工厂示例。下面是OutputFactoryFactory的代码：
public class OutputFactoryFactory{
public static OutputFactory getOutputFactory(String type){
if(type.equalsIngnoreCase("better"){
return new BetterPrinterFactory();
}else{
return new PrinterFactory();
}
}
}
修改Computer类的Mian方法如下：
public static void main(String[] args){
outputFactory of =OutputFactoryFactory.getoutputFactory("better");
Computer c = new Computer(of.getOutput());
c.keyIn("轻量级java“）；
c.print();
}
上面程序中用于产生一个OutputFactory工厂，但具体产生哪个工厂则由OutputFactoryFactory抽象工厂决定，不同的工厂生产不同的output对象，通过采用抽象工厂模式，系统可以让客户端代码与被调用对象实现类、具体的工厂类实现分离。
如果工厂直接生产被调用对象，那就是简单工厂模式，如果工厂生产了工厂对象，那就升级为抽象工厂模式。