23种设计模式之工厂模式

工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。

简单工厂模式

public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.makeProduct(Const.PRODUCT_A);
        productA.show();

        Product productB = SimpleFactory.makeProduct(Const.PRODUCT_B);
        productB.show();


    }
    //抽象产品
    public interface Product {
        void show();
    }
    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        @Override
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        @Override
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }
    final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
        static final int PRODUCT_C = 2;
    }
    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;
        }
    }
}

工厂方法模式

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af = new ConcreteFactory1();
            a = af.newProduct();
            a.show();
            
            
            
             Product b;
            AbstractFactory bf = new ConcreteFactory2();
            b = bf.newProduct();
            b.show();
            
            
            
            
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}

//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    @Override
    public void show() {
        System.out.println("具体产品1显示...");
    }
}

//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    @Override
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}

//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

注意：当需要生成的产品不多且不会增加，一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式。

抽象工厂模式

public class ElectricFactory {
    public static void main(String[] args) {
        AbstractElectricFactory haierFactory = new HaierFactory();
        AirConditioner ac = haierFactory.createAC();
        ac.show();


        AbstractElectricFactory tclFactory = new TCLFactory();
        Television tv = tclFactory.createTv();
        tv.show();
    }
}
// 抽象电器工厂
interface AbstractElectricFactory {
    public Television createTv();
    public AirConditioner createAC();
}

//抽象产品(电视)：提供了产品的接口
interface Television {
    public void show();
}
//抽象产品(空调)：提供了产品的接口
interface AirConditioner {
    public void show();
}

class HaierTelevision implements Television{

    @Override
    public void show() {
        System.out.println("海尔电视显示");
    }
}

class TCLTelevision implements Television{
    @Override
    public void show() {
        System.out.println("TCL电视显示");
    }
}
class HaierAirConditioner implements AirConditioner{

    @Override
    public void show() {
        System.out.println("海尔空调显示");
    }
}
class TCLAirConditioner implements AirConditioner{

    @Override
    public void show() {
        System.out.println("TCL空调显示");
    }
}


class HaierFactory implements AbstractElectricFactory{
    @Override
    public Television createTv() {
        System.out.println("海尔工厂生成");
        return new HaierTelevision();
    }

    @Override
    public AirConditioner createAC() {
        System.out.println("海尔工厂生成");
        return new HaierAirConditioner();
    }
}

class TCLFactory implements AbstractElectricFactory{
    @Override
    public Television createTv() {
        System.out.println("TCL工厂生成");
        return new TCLTelevision();
    }

    @Override
    public AirConditioner createAC() {
        System.out.println("TCL工厂生成");
        return new TCLAirConditioner();
    }
}

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。当抽象工厂的产品族只有一个的时候，抽象工厂降为工厂方法模式。
新增一个产品族时满足开闭原则，新增一个产品的时候不满足开闭原则。

参考资料：
1.http://c.biancheng.net/view/8385.html
2.http://c.biancheng.net/view/1348.html
3.http://c.biancheng.net/view/1351.html
代码地址：https://gitee.com/zhoujie1/design-mode-and-principle.git