工厂模式

一、工厂模式的本质
1.实例化对象，用工厂方法代替new操作。
2.将选择实现类、创建对象统一管理和控制。从而将调用者和实现类解耦。
二、简单工厂模式
用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有的代码。）
1.定义汽车接口

public interface Car {
    void run();
}

2.定义具体汽车型号

public class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("Bmw is running!");
    }
}

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("Benz is running!");
    }
}

3.定义汽车工厂

public class CarFactory {
    public static Car creatCar(String type){
        if ("BMW".equals(type)){
            return new Bmw();
        }else if ("Benz".equals(type)){
            return new Benz();
        }else {
            return null;
        }
    }
}

4.客户端调用

public class Client {
    public static void main(String[] args) {
        Car c1 = CarFactory.creatCar("BMW");
        Car c2 = CarFactory.creatCar("Benz");
        c1.run();
        c2.run();
    }
}

三、工厂方法模式
用来生产同一等级结构中的固定产品。（支持增加任意产品。）
1.定义汽车接口

public interface Car {
    void run();
}

2.定义具体汽车型号

public class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("Bmw is running!");
    }
}

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("Benz is running!");
    }
}

3.定义汽车工厂

public interface CarFactory {
    Car createCar();
}

4.定义具体型号汽车的工厂

public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

public class BmwFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Bmw();
    }
}

5.客户端调用

public class Client {
    public static void main(String[] args) {
        Car car1 = new BenzFactory().createCar();
        Car car2 = new BmwFactory().createCar();
        car1.run();
        car2.run();
    }
}

工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个工厂类，工厂方法模式有一组实现了相同接口的工厂类。实现了开闭原则，对扩展开放，对修改关闭。
四、抽象工厂模式
用来生产不同产品族的全部产品。（对于增加新的产品无能为力，但是支持增加产品族。）
模拟生成汽车零件，高端工厂生成高端零件，低端工厂生产低端零件。
1.定义零部件接口以及实现
发动机接口

public interface Engine {
    void run();
    void start();
}

高端发动机

class luxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("噪音小，马力足");
    }

    @Override
    public void start() {
        System.out.println("起步快");
    }
}

低端发动机

class lowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("噪音大，马力小");
    }

    @Override
    public void start() {
        System.out.println("起步慢");
    }
}

座椅接口

public interface Seat {
    void massage();
}

高端座椅

class luxurySeat implements Seat{
    @Override
    public void massage() {
        System.out.println("高端座椅");
    }
}

低端座椅

class lowSeat implements Seat{
    @Override
    public void massage() {
        System.out.println("普通座椅");
    }
}

2.定义汽车工厂接口

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();   
}

高端汽车工厂

class luxuryCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new luxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new luxurySeat();
    }
}

低端汽车工厂

class lowCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new lowEngine();
    }

    @Override
    public Seat createSeat() {
        return new lowSeat();
    }
}

3.客户端调用

public class Client {
    public static void main(String[] args) {
        CarFactory factory = new luxuryCarFactory();
        //通过高端汽车工厂创建高端引擎
        Engine engine = factory.createEngine();
        engine.run();
        engine.start();
    }
}

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
五、通过枚举实现工厂模式
同样生成两种类型的车
定义枚举类型汽车工厂

public enum ECarFactory {
    BENZ {
        @Override
        public Car createCAR() {
            return new Benz();
        }
    },BMW {
        @Override
        public Car createCAR() {
            return new Bmw();
        }
    };


    public abstract Car createCAR();
}

客户端调用

public class Client {
    public static void main(String[] args) {
        Car car1 = ECarFactory.BENZ.createCAR();
        Car car2 = ECarFactory.BMW.createCAR();
        car1.run();
        car2.run();
    }
}

六、总结
简单工厂模式（静态工厂模式）：在某种程度上不符合设计原则，但是在实际中用的最多。
工厂方法模式：满足设计原则，在不修改现有代码的前提下，通过增加新的工厂类增加新的产品。
抽象工厂模式：不可以新增单个的产品，但可以增加产品族。
枚举方式实现工厂模式：1.避免错误调用的发生。2.性能好,使用便捷。3.降低类间的耦合。