漫谈设计模式之：简单工厂、工厂方法、抽象工厂

简介

这三种设计模式都属于工厂设计模式，所谓的工厂，通俗来讲就是用来生产产品的地方。从代码角度来说，产品就是一个个具体的类的实例对象，工厂也是一个实例对象，用来生产这些实例产品。工厂模式要解决的问题就是如何实例化对象。

简单工厂

1. 优点
   工厂类承担创建所有产品的职责，只要有想创建的产品，都可以放到工厂类里面实现，简称“万能类”。
2. 缺点
   显而易见，只要新增一个产品，就会对工厂类进行修改；
   而且工厂类会随着产品种类的增多而变得庞大而且不易于管理维护；
   违反了设计模式中的“开闭原则”，即对修改关闭（新增了产品需要修改工厂类，违反），
   对扩展开放（没有扩展）。
3. 实例展示：

	private interface ICar {
        void move();
    }

    private static class Benz implements ICar {

        @Override
        public void move() {
            ToastUtil.showToast("Benz moved!");
        }
    }

    private static class BMW implements ICar {

        @Override
        public void move() {
            ToastUtil.showToast("BMW moved!");
        }
    }

	//简单工厂
    private static class SimpleFactory {
        public static ICar getCar(int carType) {
            switch (carType) {
                case 0:
                    return new Benz();
                case 1:
                    return new BMW();
            }
            return null;
        }
    }

	//开始生产
	ICar car1 = SimpleFactory.getCar(0);
    car1.move();

工厂方法

1. 优点
   弱化一个工厂类通吃的概念，将生产产品的职责交给各自的产品工厂去完成，也就是每一个产品都有一个工厂类，负责完成本身产品的生产。
   符合“开闭原则”，对修改关闭（无需修改工厂类），对拓展开放（新增产品对应的工厂类）。
2. 缺点
   相比简单工厂一个工厂类来说，工厂方法实现了多个工厂类，相对来说使用起来复杂一点。
   缺少形成产品族的功能，这个后续可在抽象工厂模式中解决。
3. 实例展示：

	private interface IFactory {
        ICar getCar();
    }
    
    private class BenzFactory implements IFactory{

        public ICar getCar() {
            return new Benz();
        }
    }

    private class BMWFactory implements IFactory{

        public ICar getCar() {
            return new BMW();
        }
    }
    //工厂方法
    IFactory factory = new BenzFactory();
    ICar car1 = factory.getCar();
    car1.move();
    
	IFactory factory = new BMWFactory();
    ICar car2 = factory.getCar();
    car2.move();

扩展：泛型实现工厂方法

public class CarFactory {
    public static ICar createCar(Class<? extends ICar> c) {
        try {
            return (ICar) c.newInstance();
        } catch (Exception e) {
            System.out.println("初始化失败");
        }
        return null;
    }
}

ICar bmw = CarFactory.createCar(BMW.class);
        if (bmw != null) {
            bmw.move();
        }

扩展：enum实现工厂方法

enum EnumCarFactory {
        Benz {
            @Override
            public ICar create() {
                return new Benz();
            }
        },
        BMW {
            @Override
            public ICar create() {
                return new BMW();
            }
        };

        public abstract ICar create();
    }

try {
            ICar ACar = EnumCarFactory.valueOf("Benz").create();
            ACar.move();
        } catch (Exception e) {
            System.out.println("初始化失败");
        }

抽象工厂

1. 优点
   抽象工厂是针对“产品族”概念拓展而来的。
   一个产品不止一个功能，比如我们为高端人群定制了一套出行方案，这个方案里面有配备的车辆，还有人群穿戴的衣服等，这些功能合在一起就成为了“人群”这个产品的功能。
   如果只是配备车辆，那就跟工厂方法模式一样，只有一个功能，这是极端情况。
   所谓的抽象指的是工厂不止生产某一具体产品，而是能扩展到生产一系列产品。
2. 实例展示：

	private interface IFactory {
        ICar getCar();
    }

    private interface IClothes {
        void wear();
    }

    private class Gucci implements IClothes {

        @Override
        public void wear() {
            ToastUtil.showToast("wear Gucci");
        }
    }

    private class Prada implements IClothes {

        @Override
        public void wear() {
            ToastUtil.showToast("wear Prada");
        }
    }

    public interface IAbsFactory {
        ICar getCar();
        IClothes getClothes();
    }
    
	private class Zhangsan implements IAbsFactory {

        @Override
        public ICar getCar() {
            return new Benz();
        }

        @Override
        public IClothes getClothes() {
            return new Gucci();
        }
    }

    private class Lisi implements IAbsFactory {

        @Override
        public ICar getCar() {
            return new BMW();
        }

        @Override
        public IClothes getClothes() {
            return new Prada();
        }
    }
	//抽象工厂
    IAbsFactory absFactory = new Zhangsan();
    ICar car = absFactory.getCar();
    car.move();
    IClothes clothes = absFactory.getClothes();
    clothes.wear();

git地址

https://github.com/ddnosh/AndroidQuick