工厂设计模式

工厂模式定义
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。本文从一个具体的例子逐步深入分析，来体会三种工厂模式的应用场景和利弊。

通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系

简单工厂模式

简单工厂模式创建汽车

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


/**
 *创建宝马汽车
 */
public class BaomaCar implements Car {
    public BaomaCar(){
        this.create();
    }
    @Override
    public void create() {
        System.out.println("create BaoMaCar");
    }
}


/**
 * 创建奔驰汽车
 */
public class BenchiCar implements Car {
    public BenchiCar(){
        this.create();
    }
    @Override
    public void create() {
        System.out.println("create BenChiCar");
    }
}

/**
 * 汽车工厂
 */
public class CarFactory {
    public Car Create(String type){
        if("Baoma".equals(type)){
            return new BaomaCar();
        }else if("Benchi".equals(type)){
            return new BenchiCar();
        }else{
            return null;
        }
    }
}

public class TestFactory {
    public static void main(String []args){
        CarFactory carFactory = new CarFactory();
        Car baomaCar = carFactory.Create("Baoma");
        Car benchiCar = carFactory.Create("Benchi");
    }

3.工厂方法模式(Factory Method)
和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂

也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。

工厂方法模式创建汽车

/**
 * 汽车工厂
 */
public interface AbstractFactory {

    Car createCar();
}

/**
 * 宝马汽车工厂
 */
public class BaomaFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new BaomaCar();
    }
}

/**
 * 奔驰汽车工厂
 */
public class BenchiFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new BenchiCar();
    }
}



public class TestFactory {
    public static void main(String []args){
        AbstractFactory baomaFactory = new BaomaFactory();
        baomaFactory.createCar();
        AbstractFactory benchiFactory = new BenchiFactory();
        benchiFactory.createCar();
    }
}

总结

简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中，根据参数的类型进行实例化，同时不存在抽象接口。而后者则增加了抽象工厂，通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品，这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则

4. 抽象工厂模式(Abstract Factory)
上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品Car，如果要生成另一种产品Engine，应该怎么表示呢？

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。

/**
 * 发动机
 */
public interface Engine {
    void create();
}

/**
 * 创建奔驰发动机
 */
public class BenchiEngine implements Engine {
    public BenchiEngine(){
        this.create();
    }
    @Override
    public void create() {
        System.out.println("create BenChiEngine");
    }
}

/**
 * 创建宝马发动机
 */
public class BaomaEngine implements Engine {
    public BaomaEngine(){
        this.create();
    }
    @Override
    public void create() {
        System.out.println("create BaomaEngine");
    }
}

/**
 * 奔驰工厂
 */
public class BenchiFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new BenchiCar();
    }

    @Override
    public Engine createEngine() {
        return new BenchiEngine();
    }
}

/**
 * 宝马工厂
 */
public class BaomaFactory implements AbstractFactory {
    @Override
    public Engine createEngine() {
        return new BaomaEngine();
    }

    @Override
    public Car createCar() {
        return new BaomaCar();
    }
}

public class TestFactory {
    public static void main(String []args){
        AbstractFactory baomaFactory = new BaomaFactory();
        baomaFactory.createCar();
        baomaFactory.createEngine();
        AbstractFactory benchiFactory = new BenchiFactory();
        benchiFactory.createCar();
        benchiFactory.createEngine();
    }
}

总结

抽象工厂模式是工厂方法模式的升级版，后者面向单个产品，而前者面向的的是一个产品族。根据官方定义：为创建一组相关/互相依赖的对象提供一个接口而无需指定它们的具体类。
比如一个汽车工厂要生成汽车，而每种汽车都发动机等一系列产品，这意味着每增加一款汽车就需要增加一个新的工厂来提供新产品的实现。这时候就可以使用抽象工厂模式来进行设计。抽象工厂模式适用于一系列产品族