简单工厂/工厂方法/抽象工厂

1 简单工厂

根据参数由工厂类来创建对象

/**
 * 简单工厂
 * 目的：根据参数获取对象
 * 缺点：新增实现类时，需要修改代码，不好动态扩展（可参考工厂方法）
 */
public class SimpleFactoryDP {

    public final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }

    //抽象产品
    public interface Product {
        void show();
    }

    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    public static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }

    void test(){
        Product product = SimpleFactory.makeProduct(1);
        product.show();
    }

}

2 工厂方法

解决简单工厂不能动态扩展实现类（开闭原则）

/**
 *  工厂方法
 *  单个工厂提供单个实现类，方便扩展更多实现类
 *  目的：优化简单工厂不好扩展新的类。这里只需要新增工厂类既能扩展
 *  缺点：有时需要工厂类能够同时提供多个不同对象（可参考抽象工厂）
 */
public class FactoryMethodDP {
    //抽象产品：提供了产品的接口
    interface Product {
        public void show();
    }
    //具体产品1：实现抽象产品中的抽象方法
    class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品2：实现抽象产品中的抽象方法
    class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    //抽象工厂：提供了厂品的生成方法
    interface AbstractFactory {
        public Product newProduct();
    }
    //具体工厂1：实现了厂品的生成方法
    class ConcreteFactory1 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂1生成-->具体产品1...");
            return new ConcreteProduct1();
        }
    }
    //具体工厂2：实现了厂品的生成方法
    class ConcreteFactory2 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂2生成-->具体产品2...");
            return new ConcreteProduct2();
        }
    }

    void test() {
        AbstractFactory abstractFactory = new  ConcreteFactory1();
        abstractFactory.newProduct().show();
    }


}

3 抽象工厂

解决工厂方法 单个工厂不能同时创建多个不同的实现类

/**
 * 抽象工厂
 * 工厂可以产生多个不同对象，实现对象可以扩展，工厂类也可以动态组装
 */
public class AbstractFactoryDP {

    interface ProductA{
        void aEat();
    }
    class Aimpl1 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl1");
        }
    }
    class Aimpl2 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl2");
        }
    }

    interface ProductB{
        void bUse();
    }
    class Bimpl1 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl1");
        }
    }
    class Bimpl2 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl2");
        }
    }

    interface AbstractProductFactory{
        ProductA createA();
        ProductB createB();
    }

    class ProductFactoryImplA implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl1();
        }
        @Override
        public ProductB createB() {
            return new Bimpl1();
        }
    }

    class ProductFactoryImplB implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl2();
        }
        @Override
        public ProductB createB() {
            return new Bimpl2();
        }
    }

    void test(){
        AbstractProductFactory productFactory = new ProductFactoryImplA();
        ProductA productA = productFactory.createA();
        productA.aEat();
        ProductB productB = productFactory.createB();
        productB.bUse();
    }

}