工厂模式

定义了一个床架对象的接口，但由子类决定实例化的类是哪一个，工厂方法让类的实例化推迟到子类中。

Pizza 案例

Pizza 店需要生产 Pizza，如果直接用 new 的方式，不利用扩展。我们要封装变化。

// 这样太“硬”编码了，不利用扩展
Pizza pizza = new ItalyPizza();

简单工厂

简单工厂不是一种设计模式，更像是一种编程习惯。

// 简单工厂 示例
public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("")) {
        }else if (type.equals("")) {
        }else if (type.equals("")) {
        }
        return pizza;
    }
}

工厂方法模式

工厂方法是抽象的，依赖子类来完成动作。必须返回一个产品。

abstract Product createProduct(String type);

工厂模式特点

1. 封装变化，将变化的部分独立出来进行封装
2. 不确定的推迟，利用多态，在不确定类的情况下，将类延迟到子类来决定具体的类
3. 封装变化，延迟处理，使得代码扩展性很强

   单例模式

   确保一个类只有一个实例，并提供全局访问带你。

最简单的一种实现，存在多线程问题

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

加 synchronized，存在性能问题

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

饿汉式，存在浪费资源的问题

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

懒汉式，双重锁检查

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