【设计模式】工厂模式

作用

　　实现了创建者和调用者的分离

　　详细分类

　　　　简单工厂模式：

　　　　　　　用来生产同一等级结构中的任意产品（对于增加新的产品，需要球盖已有的代码）。

　　　　工厂方法模：

　　　　　　用来生产同一等级结构中的固定产品（支持增加任意产品）。　　

　　　　抽象工厂模式：

　　　　　　围绕一个超级工厂创建其他工厂。该超级工厂又称为其他共产的工厂。

　　　核心本质：

　　　　实例化对象不使用new，用工厂方法代替，例如我们平常会写 Factory调用哪个对象，不用new。

　　　　将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

需要满足OOP七大原则中的：

　　开闭原则：一个软件的实体应当对拓展开发，对修改关闭

　　依赖倒转原则：要针对接口编程，不要针对实现编程

　　迪米特原则：只与你直接的朋友通信，而避免和陌生人通信

代码案例：

简单工厂

现在的汽车有大量的需求，我们就把制造车子这个过程抽象成一个接口，由不同品牌制造商去实现他。假设现在有A品牌和B品牌实现了他。

接口

public interface Car {

    void name();
}

A品牌实现

public class Wuling implements Car{
    @Override
    public void name() {
　　　　//制造车子的步骤省略一万个步骤
        System.out.printf("五零红光");
    }
}

B品牌实现

public class Tesla implements Car{
    @Override
    public void name() {
　　　　
        System.out.printf("特斯拉");
    }
}

用户需要用车子时

public class Consumer {
    public static void main(String[] args) {
        Car car = new Wuling();//可能这里还需要传一堆参数，用户需要知道怎么去实现他，那么该怎么解决呢，可以进一步的再去封装一个工厂
        Car car2 = new Tesla();
        car.name();
        car2.name();
    }
}

CarFactory工厂

public class CarFactory {
    public static Car getCar(String  car){
        if(car.equals("五菱")){
            return new Wuling();
        }else  if (car.equals("特斯拉")){
            return new Tesla();
        }else{
            return null;
        }
    }
}

有了工厂之后，用户再需要去使用车子时，就不在需要知道他的实现细节了

public class Consumer {
    public static void main(String[] args) {
//        Car car = new Wuling();
//        Car car2 = new Tesla();

        Car car = CarFactory.getCar("五零红光");
        Car car2 = CarFactory.getCar("特斯拉");
        car.name();
        car2.name();

    }
}

但这样写的话还是有问题的，当出现一个新的品牌的时候，客户用怎么去用他呢？

假设大众也可以造车了

public class Dazhong implements Car{

    @Override
    public void name() {
        System.out.println("大众");
    }
}

如果要去用大众的，必须把CarFactoy给改了，那这样就违背了开闭原则。

如果不去看这个缺点的话，简单工厂模式已经介绍完了，简单工厂模式也成为静态工厂模式，应为他无法在进行扩展了。

模型

工厂方法模式

需要每一个品牌制造商都实现一个工厂

将工厂也抽象出来，让品牌制造商去实现他

//工厂方法模式
public interface CarFactory {

    Car getCar();
}

特斯拉实现工厂

public class TeslaFactoroy implements CarFactory {
    @Override
    public Car getCar() {
        return new Tesla();
    }
}


五零红光实现工厂

public class WulingFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Wuling();
    }
}

这时候如果有新的制造商进来就无需改变原本的工厂了，比如MoBai。

public class MoBai implements Car{
    @Override
    public void name() {
        System.out.printf("摩拜");
    }
}

再去实现它的工厂

public class MoBaiFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new MoBai();
    }
}

两种模式的对比

　　从结构复杂度，代码复杂度，编程复杂度，管理上的复杂度上来看，很明显简单工厂模式要好一些，但根据设计原则来看，还是工厂方法模式符合原则。

根据实际业务来讲，简单工厂模式使用的比较多。