工厂模式

工厂模式(Factory)：指将创建对象的过程交给特定的类来进行管理，对创建实例进行了封装。工厂模式包括工厂方法模式和抽象工厂模式，而简单工厂模式并未列入23中设计模式中。

• 简单工厂模式

//车标的枚举
public enum Logo {
    PORSCHE, MASERATI
}

public interface Car {
    //汽车move
    void move();
}

public class PorscheCar implements Car {
    @Override
    public void move() {
        System.out.println("保时捷飞驰而过");
    }
}

public class MaseratiCar implements Car {
    @Override
    public void move() {
        System.out.println("玛莎拉蒂紧随其后");
    }
}

public class CarFactory {
    public Car create(Logo logo){
        //根据车标的枚举类来创建对应的实例
        switch (logo.ordinal()){
            case 0:
                System.out.println("生产了一辆保时捷");
                return new PorscheCar();
            case 1:
                System.out.println("生产了一辆玛莎拉蒂");
                return new MaseratiCar();
            default:
                System.out.println("未找到车型!");
                return null;
        }
    }

    //单例模式构建工厂, 保证工厂不会被创建很多的实例
    private CarFactory() {}

    public static CarFactory getInstance(){
        return CarFactoryHolder.INSTANCE;
    }

    private static class CarFactoryHolder {
        public static final CarFactory INSTANCE = new CarFactory();
    }
}

//测试Demo
public class Main {
    public static void main(String[] args) {
        Car c1 = CarFactory.getInstance().create(Logo.PORSCHE);
        Car c2 = CarFactory.getInstance().create(Logo.MASERATI);
        c1.move();
        c2.move();

        /**
         * console:
         * 生产了一辆保时捷
         * 生产了一辆玛莎拉蒂
         * 保时捷飞驰而过
         * 玛莎拉蒂紧随其后
         */
    }
}

简单工厂模式的UML图：

该模式是构建一种具体的工厂(CarFactory)，将产品的创建交给工厂实现，但是每次新增一种产品，都需要对CarFactory进行修改，可扩展性不是很好。

 

• 工厂方法模式

public interface Car {
    //汽车move
    void move();
}

public class PorscheCar implements Car {
    @Override
    public void move() {
        System.out.println("保时捷飞驰而过");
    }
}

public class MaseratiCar implements Car {
    @Override
    public void move() {
        System.out.println("玛莎拉蒂紧随其后");
    }
}

//抽象出生产汽车的方法
public interface BaseCarFactory {
    Car create();
}

//保时捷的独有的工厂, 这个工产只生产保时捷
public class PorscheCarFactory implements BaseCarFactory {
    @Override
    public Car create() {
        System.out.println("生产了一辆保时捷");
        return new PorscheCar();
    }

    //单例
    private PorscheCarFactory() {}

    public static PorscheCarFactory getInstance(){
        return PorscheCarFactoryHolder.INSTANCE;
    }

    private static class PorscheCarFactoryHolder {
        public static final PorscheCarFactory INSTANCE = new PorscheCarFactory();
    }
}

//玛莎拉蒂的独有的工厂, 这个工产只生产玛莎拉蒂
public class MaseratiCarFactory implements BaseCarFactory {
    @Override
    public Car create() {
        System.out.println("生产了一辆玛莎拉蒂");
        return new MaseratiCar();
    }

    //单例
    private MaseratiCarFactory() {}

    public static MaseratiCarFactory getInstance(){
        return MaseratiCarFactoryHolder.INSTANCE;
    }

    private static class MaseratiCarFactoryHolder {
        public static final MaseratiCarFactory INSTANCE = new MaseratiCarFactory();
    }
}

//测试Demo
public class Main {
    public static void main(String[] args) {
        Car porsche = PorscheCarFactory.getInstance().create();
        Car maserati = MaseratiCarFactory.getInstance().create();
        porsche.move();
        maserati.move();

        /**
         * console:
         * 生产了一辆保时捷
         * 生产了一辆玛莎拉蒂
         * 保时捷飞驰而过
         * 玛莎拉蒂紧随其后
         */
    }
}

工厂方法模式的UML图：

该模式是构建一种抽象工厂(BaseCarFactory)，一种抽象产品(Car)，将具体对象的创建交给具体的工厂，每个工厂只负责生产指定类型的产品，当新增一种新产品时，例如生产宝马，那么只需要构建宝马的生产工厂即可，原来代码无需变动，具有一定的可扩展性。但工厂方法模式也有局限性，即所添加的产品是一个系列的，此处范例则都要是Car；若需要新增一个产品Plane，使用工厂方法则需要再复制一份上面的代码出来，专门处理Plane。

 

• 抽象工厂模式

//第一种抽象产品 Car
public abstract class Car {
    abstract void move();
}

public class Porsche extends Car {
    @Override
    void move() {
        System.out.println("保时捷飞驰而过");
    }
}

public class Maserati extends Car {
    @Override
    void move() {
        System.out.println("玛莎拉蒂紧随其后");
    }
}

//第二种抽象产品 Coffee
public abstract class Coffee {
    abstract void drink();
}

public class LatteMacchiato extends Coffee {
    @Override
    void drink() {
        System.out.println("品尝拿铁玛奇朵");
    }
}

public class Cappuccino extends Coffee {
    @Override
    void drink() {
        System.out.println("品尝卡布奇诺");
    }
}

//抽象工厂：该工厂负责构造，创建各种抽象产品的方法
public abstract class BaseFactory {
    abstract Car createCar();
    abstract Coffee drinkCoffee();
}

//德国人的工厂(具体工厂)：他们会生产保时捷，会喝拿铁玛奇朵
public class GermanFactory extends BaseFactory {
    @Override
    Car createCar() {
        System.out.println("生产一辆保时捷");
        return new Porsche();
    }

    @Override
    Coffee drinkCoffee() {
        System.out.println("德国人喝咖啡");
        return new LatteMacchiato();
    }

    //单例
    private GermanFactory() {}

    public static GermanFactory getInstance(){
        return GermanFactoryHolder.INSTANCE;
    }

    private static class GermanFactoryHolder {
        public static final GermanFactory INSTANCE = new GermanFactory();
    }
}

//意大利人的工厂(具体工厂)：他们会生产玛莎拉蒂，会喝卡布奇诺
public class ItalianFactory extends BaseFactory {
    @Override
    Car createCar() {
        System.out.println("生产一辆玛莎拉蒂");
        return new Maserati();
    }

    @Override
    Coffee drinkCoffee() {
        System.out.println("意大利人喝咖啡");
        return new Cappuccino();
    }

    //单例
    private ItalianFactory() {}

    public static ItalianFactory getInstance(){
        return ItalianFactoryHolder.INSTANCE;
    }

    private static class ItalianFactoryHolder {
        public static final ItalianFactory INSTANCE = new ItalianFactory();
    }
}

//测试Demo
public class Main {
    public static void main(String[] args) {
        BaseFactory bf1 = GermanFactory.getInstance();
        bf1.createCar().move();
        bf1.drinkCoffee().drink();

        BaseFactory bf2 = ItalianFactory.getInstance();
        bf2.createCar().move();
        bf2.drinkCoffee().drink();

        /**
         * console:
         * 生产一辆保时捷
         * 保时捷飞驰而过
         * 德国人喝咖啡
         * 品尝拿铁玛奇朵
         * 生产一辆玛莎拉蒂
         * 玛莎拉蒂紧随其后
         * 意大利人喝咖啡
         * 品尝卡布奇诺
         */
    }
}

抽象工厂模式的UML图：

抽象工厂模式中有四个角色：抽象工厂、具体工厂、抽象产品、具体产品。抽象工厂可以解决多个产品作为一组进行创建的应用，对改变一个应用的具体工厂非常方便，仅仅需要改变具体工厂的不同产品配置即可，而对于新增一组产品的扩展，也是非常方便。