设计模式简介

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

Singleton模式

Singleton模式简介

Singleton模式又称单例模式，是 Java 中最简单的设计模式之一。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。即：
1、单例类只能有一个实例；
2、单例类必须自己创建自己的唯一实例；
3、单例类必须给所有其他对象提供这一实例。

单例模式一般应用于需要确保全局只有一个对象时，如一些需要统一管理的资源（数据库连接池，只能有一个）。

缺点：一个对象被各种线程调用，就会有很多的全局状态，难以统一管理。且需要保证其各个线程的安全性。

Singleton的创建

双重锁模式Double checked locking

第一次在锁的外面去检查全局对象singleton是否为null，如果不是null可以直接拿来用，如果是null则需要加锁（Synchronized），并在锁完之后再检查一次。因为从第一次检查出null到加锁之间的空当，可能会被别人创建出另一个对象，所以还需要第二次加锁。

public class Singleton {  private volatile static Singleton singleton;  private Singleton (){}  public static Singleton getSingleton() {  if (singleton == null) {  synchronized (Singleton.class) {  if (singleton == null) {  singleton = new Singleton();  }  }  }  return singleton;  }  
}

作为Java类的静态变量

Java其实已经实现了类似于双重锁的功能，以保证只有一个对象被创建，这就是Java的静态变量。把我们的类创建在一个Java类的静态变量里，让这个Java类静态变量指向Singleton对象。

public class Singleton {  private static class SingletonHolder {  private static final Singleton INSTANCE = new Singleton();  }  private Singleton (){}  public static final Singleton getInstance() {  return SingletonHolder.INSTANCE;  }  
}

缺点：在程序初始化的时候，就必须创建出静态变量。

变继承关系为组合关系

继承关系可以复用基类的成员变量或者函数，并且可以进行增加或修改。但使用继承关系建模往往也存在局限性，如：

1. 当父类的实现代码修改时，可能使得子类也不得不修改，增加维护难度；
2. 类缺乏独立性，依赖于父类，耦合度较高；
3. 不支持动态拓展，在编译期就决定了父类。

而组合的关系一般在运行时确定，并且支持代码黑盒复用，即被包括的对象内部实现细节对外不可见，封装性好。且支持动态扩展，可在运行时根据具体对象选择不同类型的组合对象。

组合模式

现在假设我们有一个类 Employee，该类被当作组合模型类。CompositePatternDemo 类使用 Employee 类来添加部门层次结构，并打印所有员工。

Employee.java

import java.util.ArrayList;
import java.util.List;public class Employee {private String name;private String dept;private int salary;private List<Employee> subordinates;//构造函数public Employee(String name,String dept, int sal) {this.name = name;this.dept = dept;this.salary = sal;subordinates = new ArrayList<Employee>();}public void add(Employee e) {subordinates.add(e);}public void remove(Employee e) {subordinates.remove(e);}public List<Employee> getSubordinates(){return subordinates;}public String toString(){return ("Employee :[ Name : "+ name +", dept : "+ dept + ", salary :"+ salary+" ]");}   
}

CompositePatternDemo.java

public class CompositePatternDemo {public static void main(String[] args) {Employee CEO = new Employee("John","CEO", 30000);Employee headSales = new Employee("Robert","Head Sales", 20000);Employee headMarketing = new Employee("Michel","Head Marketing", 20000);Employee clerk1 = new Employee("Laura","Marketing", 10000);Employee clerk2 = new Employee("Bob","Marketing", 10000);Employee salesExecutive1 = new Employee("Richard","Sales", 10000);Employee salesExecutive2 = new Employee("Rob","Sales", 10000);CEO.add(headSales);CEO.add(headMarketing);headSales.add(salesExecutive1);headSales.add(salesExecutive2);headMarketing.add(clerk1);headMarketing.add(clerk2);//打印该组织的所有员工System.out.println(CEO); for (Employee headEmployee : CEO.getSubordinates()) {System.out.println(headEmployee);for (Employee employee : headEmployee.getSubordinates()) {System.out.println(employee);}}        }
}

输出：

Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]

装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。

Shape.java

public interface Shape {void draw();
}

Rectangle.java

public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Shape: Rectangle");}
}

Circle.java

public class Circle implements Shape {@Overridepublic void draw() {System.out.println("Shape: Circle");}
}

ShapeDecorator.java

public abstract class ShapeDecorator implements Shape {protected Shape decoratedShape;public ShapeDecorator(Shape decoratedShape){this.decoratedShape = decoratedShape;}public void draw(){decoratedShape.draw();}  
}

RedShapeDecorator.java

public class RedShapeDecorator extends ShapeDecorator {public RedShapeDecorator(Shape decoratedShape) {super(decoratedShape);     }@Overridepublic void draw() {decoratedShape.draw();         setRedBorder(decoratedShape);}private void setRedBorder(Shape decoratedShape){System.out.println("Border Color: Red");}
}

DecoratorPatternDemo.java

public class DecoratorPatternDemo {public static void main(String[] args) {Shape circle = new Circle();ShapeDecorator redCircle = new RedShapeDecorator(new Circle());ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());//Shape redCircle = new RedShapeDecorator(new Circle());//Shape redRectangle = new RedShapeDecorator(new Rectangle());System.out.println("Circle with normal border");circle.draw();System.out.println("\nCircle of red border");redCircle.draw();System.out.println("\nRectangle of red border");redRectangle.draw();}
}

输出结果：

Circle with normal border
Shape: CircleCircle of red border
Shape: Circle
Border Color: RedRectangle of red border
Shape: Rectangle
Border Color: Red

如何创建对象

使用new创建对象的缺点：

1. 在编译时就必须决定创建哪个类的对象；
2. 传入的参数的意义不够明确；

抽象工厂模式

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。客户端通过使用抽象工厂接口来创建产品对象，而不需要直接使用具体产品的实现类。

图中首先创建了 Shape 和 Color 接口和实现这些接口的实体类。然后创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo 类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。