设计模式之单例模式和工厂模式（代码+举例）

开闭原则

• 对扩展开放，对修改关闭，尊虚开闭原则可以达到解耦的效果

工厂模式

• 工厂说白了就是创建对象的，我创建对象不需要在业务层new了，直接调用工厂的方法获取对象
• **解耦：**当我们想要添加新的实体类时，不需要改动工厂类和业务类，只添加实体类即可，这就是扩展了功能但没有修改源代码，因为你只是增加了一个新的类而已

1. 简单工厂模式(耦合度低)

顾客点咖啡案例 - 可以先看总结

工厂代码：

public class CoffeeFactory {
    public Coffee createCoffee(String type){
        Coffee coffee = null;
        if ("American".equals(type)){
            coffee = new AmericanCoffee();
        } else if ("latter".equals(type)){
            coffee = new LatterCoffee();
        }
        return coffee;
    }
}

业务层代码：

public class CoffeeStore {
    public Coffee orderCoffer(String type){
        CoffeeFactory coffeeFactory = new CoffeeFactory();
        Coffee coffee = coffeeFactory.createCoffee("latter");
        coffee.make();
        return coffee;
    }
}

顾客代码：

public class Customer {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee coffee = coffeeStore.orderCoffer("latter");
    }
}

**总结：**可以看到业务层解耦了，不用new对象了，但是工厂还是有耦合，如果我想增加橙C美式咖啡，还是需要改动factory这个类，我们最终的目的是只添加实体类，而工厂类和业务层代码不用动。

2. 静态工厂模式(同上)

• 静态工厂只是把工厂类中的createCoffee变成了静态方法，而业务层直接使用CoffeeFactory.createCoffee获取对象
• **总结：**这种模式本质上和简单工厂模式没什么区别

3. 工厂方法(无耦合)

• 代码改动：将Factory变成了抽象接口，具体的实现交给实现类，说白了你有几个类就增加几个FactroyCoffee。
  
  

业务层代码：

public class CoffeeStore {
    private CoffeeFactory coffeeFactory;
    public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }
    public Coffee orderCoffer(){
        Coffee coffee = coffeeFactory.createCoffee();
        coffee.make();
        return coffee;
    }
}

工厂方法代码：

// CoffeeFactory
public interface CoffeeFactory {

    public Coffee createCoffee();
}
// 具体实现例如 LatterFactory（拿铁咖啡）
public class LatterFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new LatterCoffee();
    }
}

• 总结：工厂方法实现了业务层的完全解耦，工厂层也没有耦合了，如果以后想要增加一个类，只需要创建实体类和工厂的实现类，然后实现CoffeeFactory接口，只增加了2个类，对源代码无修改
• 缺点：增加一个品种需要创建两个类，增加了系统复杂度，类爆炸

4. 抽象工厂模式

代码就不演示了~~ 核心思想就是工厂方法模式+抽象类
只不过将多个相似功能的Factory抽象到一个父类里面，例如咖啡店除了做咖啡还做甜品，2种咖啡2种甜品要创建4个类+4工厂+1个接口，我们可以把咖啡和甜品放到一个工厂里面，例如美式咖啡+美式甜品使用一个工厂，意式咖啡+意式甜品使用一个工厂，这样就创建4个类+2个工厂+1个接口

单例模式

1. 饿汉式

• 因为对象是随类加载(线程安全)而创建的，所以天生就是线程安全

class EHSingleton {
    // 饿汉式单例模式实现
    private EHSingleton(){}
    private static final EHSingleton instance = new EHSingleton();
    public static EHSingleton getInstance(){
        return instance;
    }
}

2. 懒汉式

1.1 线程不安全

class LHsingletion {
    // 懒汉式单例模式
    private LHsingletion(){}
    private static LHsingletion instance;
    public static LHsingletion getInstance(){
        if (instance == null){ // 可能发生线程安全问题
            instance = new LHsingletion();
        }
        return instance;
    }
}

1.2 Double Check 线程安全方式

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