设计模式读书笔记

这段时间学习了一下软件开发中的设计模式，这篇读书笔记就谈谈我对设计模式的理解。

设计模式不是一套api，而是一种可复用的、一般性的解决方式，类似于以前谈过的MSF，其官方定义如下：设计模式（design pattern）是软件开发人员在软件开发过程中面临的一般问题的解决方案。设计模式的提出本身是基于面向对象的语言的，没有了面向对象的继承与多态，所有设计模式都玩不转了。设计模式分为三大类，创建型、结构型、行为型，这次就主要谈谈创建型设计模式。

首先是最常见的工厂模式，官方的说法是：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这句话真的很难懂，所以不如举个例子,到汽车厂提车，无论宝马、奥迪还是奥拓只要提就行了，不必管具体的制造细节。这样的说法感觉清晰了些，可以看出工厂模式提供了一定程度上的封装，但具体它要实现怎样的目的呢？放一段Java源码：

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 class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

public class ShapeFactory {

   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;
   }
}

这样一切都清晰了，用我自己的话说，工厂模式实现的是对一类产品族的封装。其实大家多少都用过工厂模式，当初学习C++虚基类以及Java接口的时候，肯定尝试过通过一个抽象类实现各种相应的实体类，这个过程其实即使工厂模式的核心，即基于接口与实现技术，对于C++也可以说是虚基类与继承技术。要说工厂模式比我们原来写的东西多了什么，就是最后的ShapeFactory类以及其getShape方法，我相信当初大部分人都不会使用这种写法，但仔细一下这种方式实现了对上层非常干净的封装，对于用户来说再也不需要想着new一个什么样的对象，需要的只是产生一个ShapeFactory对象，然后从中getShape得到想要的对象，即只要走进汽车工厂就可以取到各种各样的车。

有句题外话，就是我在看工厂模式的过程中突然模糊了Java中虚基类与接口的区别，查了查才想起来虚基类的部分函数是已经实现了的，子类只需实现那些没有实现的类，而接口的函数全部都是虚函数，实现类必须实现其中全部的函数。

下面看看单例模式，这种模式要求该类自己负责创建自己，且需确保只有单个对象被创建。为了确保该类不会被实例化，有种骚操作就是把构造函数设为 private ，这样如果该类被 new 则编译器报错，这种操作真的是长见识。具体的单例模式代码还分为懒汉模式和饿汉模式。

懒汉模式：

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

其中 synchronized 关键字是为了保证线程安全，即多线程访问时给对象上锁。从下可以看到饿汉模式不存在这种问题。

饿汉模式：

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }

这两者的区别就在于，懒汉模式的初始化在被调用时进行，而饿汉模式的初始化在类加载时就进行了，这带来的结果就是懒汉模式更节省内存，但是其本身存在线程不安全的问题，必须使用 sychronized 关键字，所以性能会比较低，一般在单例用的次数少且消耗资源大时使用。

单例模式这样就讲清楚了，但是带来的新的问题是类到底何时被初始化？我查了相关资料发现，JVM并没有规定类何时被加载（加载到JVM方法区和堆区），但严格规定了何时被初始化，其中最常见的两种情况就是 new 一个类或者调用其静态方法（还包括读取、设置静态字段等情况），一旦出现上述情况类就必须被初始化，而饿汉模式中的static成员instance在类加载时被赋值，同时 new 了自身，所以该类在加载时就初始化，懒汉模式就可以等到被调用再初始化。

可见，这么短短两段代码中蕴藏着那么多知识，充分体现了第一次提出规范单例模式的程序员的智慧。

最后再谈谈原型模式。原型模式的目的是创建重复的对象，比如说，如果类的初始化需要很多资源，不如只保存一份相应的对象。从这个角度看，原型模式很像是单例模式的扩展，可以看成是一个产品族的单例集合。看看如下java代码：

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 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();
   }

   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);
   }
}

java中自带的Cloneable类可以很好地实现原型模式的目的。虽然上述代码有些工厂模式的感觉，但其实原型模式的目的与工厂模式完全不同。但是，原型模式最大的用处之一就是和工厂模式结合，如果把上述代码中的形状改为工厂，具体的形状改为不同的工厂，那么最后的 Cache 提供的就是不同工厂的克隆，这很好地实现了工厂的单例性。

本文描述了工厂模式、单例模式、原型模式三种常见的创建型设计模式，下次再来说说结构型设计模式。