设计模式之工厂模式

实际开发中有用到，这里再次做下复习忘记了~~~~~

1、简单工程模式

具备三个要素：工厂、产品抽象、实际产品

public class FactoryMain {
    public static void main(String[] args) {

        final Iproduct product = ProductFactory.createProduct("A");
        System.out.println("=================" + product.getName());
    }

}

//抽象产品接口
interface Iproduct {
    String getName();
}

//产品
class ProductA implements Iproduct {

    @Override
    public String getName() {
        return "Product A";
    }
}

//产品
class ProductB implements Iproduct {
    @Override
    public String getName() {
        return "Product B";
    }
}

//工厂
class ProductFactory {
    static Iproduct createProduct(String productName) {
        if ("A".equals(productName)) {
            return new ProductA();
        }
        if ("B".equals(productName)) {
            return new ProductB();
        }
        return null;
    }
}

有什么问题？？？

问题出在工厂！~~，如果新增加一种产品 C ,工程类是不是要重新代码改造？

那么如何才能不用动代码，如果增加一种产品类型的话，不用改动原来代码？

2、抽象工厂

public class FactoryMain2 {
    public static void main(String[] args) {
        IProductFactory factoryA = new ProductAFactory();
        factoryA.creatProduct();
        
        IProductFactory factoryB = new ProductBFactory();
        factoryB.creatProduct();
        
    }
}

interface IProductFactory {

    Iproduct creatProduct();
}

class ProductAFactory implements IProductFactory {
    @Override
    public Iproduct creatProduct() {
        return new ProductA();
    }
}

class ProductBFactory implements IProductFactory {
    @Override
    public Iproduct creatProduct() {
        return new ProductB();
    }
}

OK ,问题来了，如果增加第三种产品 C 怎么办呢？

只需要增加如下实现，而不需要修改以前代码

//增加产品 C
class ProductC implements Iproduct {

    @Override
    public String getName() {
        return "Product C";
    }
}
//增加C 工厂类
class ProductCFactory implements IProductFactory {
    @Override
    public Iproduct creatProduct() {
        return new ProductC();
    }
}
//修改调用方
  IProductFactory factoryC = new ProductCFactory();
        factoryC.creatProduct();

是不是么有对原来已有产品调用产生任何改动，符合 开闭原则（对于扩展是开放的，对于修改是关闭的）

那么还有个问题来了？不可以在抽象类总一次性定义所有产品簇吗？或者说，如果实际业务中增加产品簇很频繁？

3、抽象工厂模式

public class FactoryMain3 {
    public static void main(String[] args) {

        IabstractProductFactory factory = new AbstractProductFactory();
      
        final Iproduct productA = factory.createProductA();
        final Iproduct productB = factory.createProductB();


    }
}

interface IabstractProductFactory {

    Iproduct createProductA();

    Iproduct createProductB();

}

class AbstractProductFactory implements IabstractProductFactory{
    @Override
    public Iproduct createProductA() {
        return new ProductA();
    }

    @Override
    public Iproduct createProductB() {
        return new ProductB();
    }
}

总结

分析以上工厂方法如下：

1、简单工厂 提供不同产品生产，但是违反开闭原则

2、工厂模式遵循了 开闭原则，新增产品对原产品逻辑无侵入，但是如果增加不是一种产品，而是一大类产品，（Product 级别）则需要复制所有方法

3、抽象工厂模式，则提供了一次性创建整个产品簇的方法。

So . 还是根据实际业务中场景 选择适当的工厂模式