设计模式学习梳理-工厂相关模式

简单工厂模式

简单工厂模式比较简单，主要思想是由工厂在运行时决定创建哪一种具体的产品，其中涉及到的角色由工厂，产品接口，具体产品
示例如下：

public class SubA implements Base {
    @Override
    public void info() {
        System.out.println("我是一个subA");
    }
}
public class SubB  implements Base{
    @Override
    public void info() {
        System.out.println("我是一个subB");
    }
}

public interface Base {
    void info();
}

从上述实现可以看出，简单工厂模式中，如果要新增一个产品，需要修改工厂类的方法实现，违背了开闭原则（对修改关闭，对扩展开放）
适用场景：项目规模较小，产品体系比较稳定即不需要修改工厂类

工厂方法模式

工厂方法模式对工厂进行进一步的抽象，创建一个工厂接口，将实际的创建产品的方法的在工厂类中实现，所以工厂方法模式中由四个角色：工厂接口，工厂类，产品接口，产品类；这样当需要增加新的产品类型时，只需要增加一个新的工厂类实现工厂接口，一个新的产品类实现产品接口，而不像简单工厂模式一样，需要修改工厂类的代码增加诸如ifelse的逻辑。
示例如下：
在上述简单工厂模式的基础上，修改工厂类为接口SimpleFactory，新增两个工厂实现类SimpleFactoryA,SimpleFactoryB

public interface SimpleFactory {
     Base createProduct();
}
public class SimpleFactoryA implements SimpleFactory{
    @Override
    public   Base createProduct(){
       return new SubA();
    }
}
public class SimpleFactoryB implements SimpleFactory {
   @Override
    public Base createProduct(){
       return new SubB();
    }
}

抽象工厂模式

抽象工厂模式是工厂方法模式的一种扩展，与工厂方法模式不同的是，抽象产品不再是一个，而是一系列相关的抽象产品，首先定义两个抽象产品接口

public interface BaseA {
    void info();
}
//新增一个抽象产品接口
public interface BaseB{
    void info();
}

定义产品的实现类，每个产品有两个实现类

public class SubA implements BaseA {
    @Override
    public void info() {
        System.out.println("我是一个Base系列 0号");
    }
}
public class SubA1 implements BaseA {
    @Override
    public void info() {
        System.out.println("我是一个base系列 1号");
    }
}
public class SubB  implements BaseB{
    @Override
    public void info() {
        System.out.println("我是一个base1系列 0号");
    }
}
public class SubB1 implements BaseB{
    @Override
    public void info() {
        System.out.println("我是一个base1系列 1号");
    }
}

工厂接口新增一个产品系列的方法

public interface SimpleFactory {
     BaseA createProductA();
     //新增一个产品B的创建方法
     BaseB createProductB();
}
public class SimpleFactory0 implements SimpleFactory{
    @Override
    public   BaseA createProductA(){
       return new SubA();
    }

    @Override
    public BaseB createProductB() {
        return new SubB();
    }
}
public class SimpleFactory1 implements SimpleFactory {
   @Override
    public BaseA createProductA(){
       return new SubA1();
    }

    @Override
    public BaseB createProductB() {
        return new SubB1();
    }
}

与工厂方法模式相比，多了一个抽象产品SubB，工厂接口里增加了一个createProductB的方法
总结：
从简单工厂模式到工厂方法模式，是对工厂进行抽象，增加了一个工厂接口，满足了开闭原则，使得新增一个产品时，不需要修改工厂类的代码，只需要新增一个工厂实现类
从工厂方法模式到抽象工厂模式，是新增了系列产品，每个系列产品可以有多个实现，并且在工厂方法中新增了一个系列产品的创建方法，这样工厂可以创建多个系列类型的产品