factory pattern

2019-01-30

参考文章：https://howtodoinjava.com/design-patterns/creational/implementing-factory-design-pattern-in-java/

1、什么情况下使用

工厂模式引入了类之间的低耦合类，是设计程序架构的时候最重要的原则。低耦合说的是应用程序中抽象实体代替具体类。它不仅是我们的架构更灵活，同时以更加不那么脆弱。

一张图胜过千言万语。让我们来看下怎样实现一个工厂。

avatar

上面这张类图描述了一个可以构建三种类型例如小的，轿车和豪华的车辆工厂的方案。构建一辆车需要很多步骤和附件最后组装。这些步骤可以在程序中作为方法，然后当创建特定的车辆调用。

我们在应用程序中创建车辆类型的实例的时候，不幸的是，我们需要暴露车辆组装的逻辑给外面，这是不好的。因为代码没有集中，所以我们改变车辆的程序是有阻碍的，改变似乎不可行。

2、工厂模式例子

2.1 对象类型

package designPatterns.creational.factory; 

public enum CarType { 

SMALL, SEDAN, LUXURY 

}

2.2 对象的实现

Car 是所有车辆实例的父类，包含了所有车辆类型的公共逻辑。

 public abstract class Car {
 
    public Car(CarType model) {
        this.model = model;
        arrangeParts();
    }
 
    private void arrangeParts() {
        // Do one time processing here
    }
 
    // Do subclass level processing in this method
    protected abstract void construct();
 
    private CarType model = null;
 
    public CarType getModel() {
        return model;
    }
 
    public void setModel(CarType model) {
        this.model = model;
    }
}

LuxuryCar 是车辆类型LUXURY 的具体实现。

public class LuxuryCar extends Car {
 
    LuxuryCar() {
        super(CarType.LUXURY);
        construct();
    }
 
    @Override
    protected void construct() {
        System.out.println("Building luxury car");
        // add accessories
    }
}

SmallCar 是车辆类型SMALL的具体实现。

public class SmallCar extends Car {
 
    SmallCar() {
        super(CarType.SMALL);
        construct();
    }
 
    @Override
    protected void construct() {
        System.out.println("Building small car");
        // add accessories
    }
}

SedanCar 是车辆类型 SEDAN的具体实现

public class SedanCar extends Car {
 
    SedanCar() {
        super(CarType.SEDAN);
        construct();
    }
 
    @Override
    protected void construct() {
        System.out.println("Building sedan car");
        // add accessories
    }
}

2.3 工厂创建对象

CarFactory.java是我们工厂模式的主要实现类。车辆实例只取决于它的类型。

public class CarFactory {
    public static Car buildCar(CarType model) {
        Car car = null;
        switch (model) {
        case SMALL:
            car = new SmallCar();
            break;
 
        case SEDAN:
            car = new SedanCar();
            break;
 
        case LUXURY:
            car = new LuxuryCar();
            break;
 
        default:
            // throw some exception
            break;
        }
        return car;
    }
}

2.4 测试工厂模式

public class TestFactoryPattern {
    public static void main(String[] args) {
        System.out.println(CarFactory.buildCar(CarType.SMALL));
        System.out.println(CarFactory.buildCar(CarType.SEDAN));
        System.out.println(CarFactory.buildCar(CarType.LUXURY));
    }
}

结果输出

Building small car
designPatterns.creational.factory.SmallCar@7c230be4
Building sedan car
designPatterns.creational.factory.SedanCar@60e1e567
Building luxury car
designPatterns.creational.factory.LuxuryCar@e9bfee2

3、工厂模式的好处

创建对象可以反复使用，不用写多余的代码。
创建一个对象需要信息或者资源，没有暴露包含的类
必须集中生成对象的生命周期管理，以确保应用程序内的一致行为。

4、jdk中的使用

工厂模式适合大部分对象复杂步骤的执行

jdk中的工厂模式

java.sql.DriverManager#getConnection()
java.net.URL#openConnection()
java.lang.Class#newInstance()
java.lang.Class#forName()