设计模式之——工厂设计模式

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式分为简单工厂模式，工厂方法模式和 抽象工厂模式 ，它们都属于设计模式中的创建型模式。其
主要功能都是帮助我们把对象的实例化部分抽取了出来，目的是降低系统中代码耦合度，并且增强了系
统的扩展性。

应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

简单工厂模式的应用：

简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负
责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且
产品较多时，工厂方法代码将会非常复杂。

该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，其UML类图如下：

代码实现：

public  abstract  class Car {

    public abstract void run();


    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

}

public  class Benz extends Car {

    @Override
    public void run() {
        System.out.println(this.getColor()+"的奔驰在跑");
    }
}

public  class Bmw extends Car {
    @Override
    public void run() {
        System.out.println(this.getColor()+"的宝马在跑");
    }
}

public class Car_factory {
    public static Car createFactory(String color,String Type){
        if ("Benz".equals(Type)){
           Car car =  new Benz();
           car.setColor(color);
           return car;
        }else if ("Bmw".equals(Type)){
            Car car =  new Bmw();
            car.setColor(color);
            return car;
        }
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        Car factory = createFactory("red", "Benz");
        factory.run();

    }
}

工厂方法模式

我们说过java开发中要遵循开闭原则，如果将来有一天我想增加一个新的车，那么必须修改
CarFactory，就不太灵活。解决方案是使用工厂方法模式。

我们为每一个车都构建成一个工厂：

先抽象一个工厂接口

public interface Factory {
    /**
     * 统一的创建方法
     * @return
     */
    Car create();

}

然后针对每一个产品构建一个工厂方法

public class BmwFactory implements Factory{
    @Override
    public Car create() {
        return new Bmw();
    }
}

public class BikeFactory implements Factory {

    @Override
    public Car create() {
        return new Bike();
    }
}

public class BenzFactory implements Factory{
    @Override
    public Car create() {
        return new Benz();
    }
}

应用场景

public class Client {
    public static void main(String[] args) {
        Factory benzFactory = new BenzFactory();
        Car benz = benzFactory.create();
        benz.run();


        Factory bikeFactory = new BikeFactory();
        Car Bike = benzFactory.create();
        Bike.run();
    }
}

好处
此模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作延
迟到其工厂子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体
的工厂子类去创建。当系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类
和其对应的工厂子类，使系统的扩展性变得很好，符合面向对象编程的开闭原则。

缺点
工厂方法模式虽然扩展性好，但是增加了编码难度，大量增加了类的数量，所以怎么选择还是看实际的
需求。