1、单例模式

饿汉模式（最简单）：类加载的时候就创建对象，线程安全

public class Singleton {
    // 首先，将构造方法 私有化
    private Singleton() {};
    // 创建私有静态实例，意味着在类加载就会进行创建
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
}

　饱汉模式：（双重效验锁）

public class Singleton {

    private Singleton() {}
    // 和饿汉模式相比，这边不需要先实例化出来，注意这里的 volatile，它是必须的
    private static volatile Singleton instance = null;

    public static Singleton getInstance() {
        if (instance == null) {
            // 加锁
            synchronized (Singleton.class) {
                // 这一次判断也是必须的，不然会有并发问题
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

　　双重检查，指的是两次检查 instance 是否为 null。

2、工厂模式

1、简单工厂模式

实例化对象不是用new，用工厂方法替代。一个工厂类 XxxFactory，里面有一个静态方法，根据我们不同的参数，返回不同的派生自同一个父类（或实现同一接口）的实例对象。

 1 public class FoodFactory {
 2 
 3     public static Food makeFood(String name) {
 4         if (name.equals("noodle")) {
 5             Food noodle = new LanZhouNoodle();
 6             noodle.addSpicy("more");
 7             return noodle;
 8         } else if (name.equals("chicken")) {
 9             Food chicken = new HuangMenChicken();
10             chicken.addCondiment("potato");
11             return chicken;
12         } else {
13             return null;
14         }
15     }
16 }
简单工厂

2、工厂模式

之所以需要引入工厂模式，是因为我们往往需要使用两个或两个以上的工厂。

3、抽象工厂模式

为了解决不同的工厂生产产品的兼容问题，提出抽象工厂。直接选择一家品牌工厂，品牌工厂会负责生产所有的东西，而且能保证肯定是兼容可用的。

3、原型模式

有一个原型实例，基于这个原型实例产生新的实例，也就是“克隆”了。 

Object 类中有一个 clone() 方法，它用于生成一个新的对象，当然，如果我们要调用这个方法，java 要求我们的类必须先实现 Cloneable 接口，此接口没有定义任何方法，但是不这么做的话，在 clone() 的时候，会抛出 CloneNotSupportedException 异常。

protected native Object clone() throws CloneNotSupportedException;

Java 的克隆是浅克隆，碰到对象引用的时候，克隆出来的对象和原对象中的引用将指向同一个对象。通常实现深克隆的方法是将对象进行序列化，然后再进行反序列化。