本文主要介绍一下设计模式中的创建型模式。
开篇之前，先说一下，什么是设计模式，一言以蔽之，设计模式是代码设计经验的总结。设计模式的原理非常简单，但是也绝不可能通过一篇文章或者一本书来完全掌握（在学习任何一种知识的时候都应该博采众长，取舍有度，而不是盯着一本书或者一篇文章看，偏信一家之言，要如鲁迅所说：“运用脑髓，放出眼光，自己来拿！”）。其次，死记硬背设计模式的UML图或者示例代码没有意义，和OOP编程一下，设计模式本质上是一种思想，须得领会后方能灵活运用。
设计模式主要基于以下两个面向对象的编程思想：
- 面向接口编程
- 组合优于继承
设计模式还有所谓的六大原则，这里择其重点说明一下：
- 对扩展开放，对修改关闭
- 任何基类可以出现的地方，子类一定可以出现。理解这个原则：只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。
- 使用多个隔离的接口，比使用单个接口要好
- 一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立
创建型模式，顾名思义，就是一种创建对象的方法。
创建型模式有五种：工厂、抽象工厂、单例、建造者、原型。
工厂
工厂模式在工厂、策略和桥接这篇文章中已经介绍过，这里不再赘述。
抽象工厂
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
先看图：
再看代码：
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public interface Color {
void fill();
}
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape) ;
}
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
public Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("RED")){
return new Red();
} else if(color.equalsIgnoreCase("GREEN")){
return new Green();
} else if(color.equalsIgnoreCase("BLUE")){
return new Blue();
}
return null;
}
}
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
} else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//获取形状为 Circle 的对象
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("Green");
//调用 Green 的 fill 方法
color2.fill();
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
//调用 Blue 的 fill 方法
color3.fill();
}
}
总结：抽象工厂相较于工厂而言，多了一个产品族的概念，实际上就是在工厂接口下再做一个细分。
单例
单例模式在多线程下的单例模式这篇文章已经有过初步介绍，这里详细列出：
-
懒汉式，
线程不安全，懒加载public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } -
懒汉式，线程安全，懒加载
加锁会影响效率。
public class Singleton { private static Singleton instance; private Singleton (){} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } -
饿汉式，线程安全，
非懒加载，常用没有加锁，执行效率会提高。
类加载时就初始化，浪费内存：虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
public class Singleton { private static Singleton instance = new Singleton(); private Singleton (){} public static Singleton getInstance() { return instance; } } -
双重校验锁，线程安全，懒加载
4和2比较起来，可以在保证线程安全的情况下依然保持高性能。
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; } } -
使用静态内部类，线程安全，懒加载
这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。
public class Singleton { private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } private Singleton (){ } public static final Singleton getInstance() { return SingletonHolder.INSTANCE; } } -
使用枚举，线程安全，
非懒加载这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。
public enum Singleton { INSTANCE; public void whateverMethod() { } }总结一下：加锁降低执行效率，非懒加载产生垃圾对象，浪费内存。根据具体场景决定使用哪种方式。
建造者
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种模式的应用非常广泛，比如Java中的StringBuilder，Android中的AlertDialog.Builder。
用一个组装计算机的例子来说明。
先上图：这张图里的聚合和依赖关系标注有误，具体结合代码理解。
聚合关系（成员）：如果A由B聚合成，表现为A包含有B的全局对象，但是B对象可以不在A创建的时刻创建。
组合关系（成员）：如果A由B组成，表现为A包含有B的全局对象，并且B对象在A创建的时刻创建。
依赖关系（局部）：如果A依赖于B，则B体现为局部变量，方法的参数、或静态方法的调用。
所以这里应该是Director由Builder组合而成，MacBookBuilder由MacBook组合而成。图上有误。
再上代码：
public class MacBook{
protected MacBook() {
}
public void setBoard(String board){
mBoard=board;
}
public void setDisplay(String display) {
this.mDisplay = display;
}
}
// 可以使用抽象类，也可以使用接口
public abstract class Builder {
abstract void buildBoard(String board);
abstract void buildDisplay(String display);
abstract MacBook build();
}
public class MacBookBuilder extends Builder {
private MacBook mMacBook = new MacBook();
@Override
void buildBoard(String board) {
mMacBook.setBoard(board);
}
@Override
void buildDisplay(String display) {
mMacBook.setDisplay(display);
}
@Override
Computer build() {
return mMacBook;
}
}
public class Director {
Builder mBuilder=null;
public Director(Builder builder) {
this.mBuilder = builder;
}
public void construct(String board,String display){
mBuilder.buildDisplay(display);
mBuilder.buildBoard(board);
}
}
// 具体使用
public class Test {
public static void main(String[] args){
// 定义每个建造环节的具体实现
Builder builder = new MacBookBuilder();
// 设计建造流程，将各个环节组装排序
Director director = new Director(builder);
director.construct("英特尔主板", "Retina显示器");
MacBook macBook = builder.build();
}
}
原型
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
用代码直观理解一下：
public abstract class Shape implements Cloneable {
private String id;
protected String type;
abstract void draw();
public String getType(){
return type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
public class Rectangle extends Shape {
public Rectangle(){
type = "Rectangle";
}
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square extends Shape {
public Square(){
type = "Square";
}
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class Circle extends Shape {
public Circle(){
type = "Circle";
}
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
// 从数据库获取实体类，并把它们存储在一个 Hashtable 中。
public class ShapeCache {
private static Hashtable<String, Shape> shapeMap
= new Hashtable<String, Shape>();
public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}
// 对每种形状都运行数据库查询，并创建该形状
// shapeMap.put(shapeKey, shape);
// 例如，我们要添加三种形状
public static void loadCache() {
Circle circle = new Circle();
circle.setId("1");
shapeMap.put(circle.getId(),circle);
Square square = new Square();
square.setId("2");
shapeMap.put(square.getId(),square);
Rectangle rectangle = new Rectangle();
rectangle.setId("3");
shapeMap.put(rectangle.getId(),rectangle);
}
}
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape = (Shape) ShapeCache.getShape("1");
System.out.println("Shape : " + clonedShape.getType());
Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
System.out.println("Shape : " + clonedShape2.getType());
Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
System.out.println("Shape : " + clonedShape3.getType());
}
}
注意：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
微信公众号 长夜西风
