工厂模式简介

工厂模式是我们日常开发工作中经常使用的设计模式，它属于创建型设计模式，我们常用的工厂模式有：简单工厂模式，工厂方法模式，抽象工厂模式 三种类型；下面我们一起来领略一下它们各自的特点。

简单工厂模式

简单工厂模式，又称为静态工厂模式；其核心是工厂类，包含了必要的处理逻辑，可以根据外界跟定的信息，返回指定的结果。参考以下示例：

Car

//定义Car
public interface Car {

    String getName();

}

//Jeep实现类
public class Jeep implements Car {

    @Override
    public String getName() {
        return "Jeep";
    }
}

//Truck实现类
public class Truck implements Car {

    @Override
    public String getName() {
        return "Truck";
    }
}

//Cooper实现类
public class Cooper implements Car {

    @Override
    public String getName() {
        return "Cooper";
    }
}

Factory

//Car 工厂类，根据传入的name，生产具体的Car
public class CarFactory {

    public Car getCar(String name) {
        switch (name) {
            case "Jeep":
                return new Jeep();
            case "Truck":
                return new Truck();
            case "Cooper":
                return new Cooper();
            default:
                throw new RuntimeException();
        }
    }
}

演示Demo

public class Demo {

    public static void main(String[] args) {
        CarFactory factory = new CarFactory();
        Car jeep = factory.getCar("Jeep");
        System.out.println(jeep.getName());
        Car truck = factory.getCar("Truck");
        System.out.println(truck.getName());
        Car cooper = factory.getCar("Cooper");
        System.out.println(cooper.getName());
    }
}

当然，简单工厂的缺点也很明显：

  • 增加新的产品，需要修改Factory的代码
  • 不存在所有Object都可以生产的工厂

工厂方法模式的出现，对这些缺点有了一定的克服。

工厂方法模式

工厂方法模式的特点是在工厂类中定义了创建产品的接口，而具体的实现交由子类工厂去实现；通过此种方式将变化封装了起来，遵守开闭原则，实现了可扩展；参看以下示例。

public interface CarFactory {
    // 定义了获取Car接口
    Car getCar();
}
//Jeep工厂类
public class JeepFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Jeep();
    }
}
//Cooper工厂类
public class CooperFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Cooper();
    }
}
//Truck工厂类
public class TruckFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Truck();
    }
}

演示Demo

public class Demo {

    public static void main(String[] args) {
        CarFactory jeepFactory = new JeepFactory();
        Car jeep = jeepFactory.getCar();
        System.out.println(jeep.getName());
        TruckFactory truckFactory = new TruckFactory();
        Car truck = truckFactory.getCar();
        System.out.println(truck.getName());
        CooperFactory cooperFactory = new CooperFactory();
        Car cooper = cooperFactory.getCar();
        System.out.println(cooper.getName());
    }
}

工厂方法模式是对简单工厂做了抽象，工厂方法模式是典型的模板模式的应用。通过代码，我们发现：工厂方法模式的较简单工厂而言实现比较复杂，对于可以形成产品族的情况较难处理。

其中针对对于可以形成产品族的情况较难处理这里情况，在抽象工厂模式中得到一定的处理。

抽象工厂模式

抽象工厂模式是为一系列相关的，或者有依赖关系的对象创建提供接口；我们可以参考一下代码：

我们在原有Car的逻辑上扩展了Window车窗

//定义Window
public interface Window {

    String getModel();
}
//小型车窗
public class SmallWindow implements Window {

    @Override
    public String getModel() {
        return "Small";
    }
}
//中型车窗
public class MidWindow implements Window {

    @Override
    public String getModel() {
        return "Mid";
    }
}
//大型车窗
public class BigWindow implements Window {

    @Override
    public String getModel() {
        return "Big";
    }
}

CarFactory升级

public interface CarFactory {
    //创建车窗
    Window createWindow();
    //创建车
    Car createCar();

}
//Jeep工厂
public class JeepFactory implements CarFactory {

    @Override
    public Window createWindow() {
        return new MidWindow();
    }

    @Override
    public Car createCar() {
        return new Jeep();
    }
}
//Truck工厂
public class TruckFactory implements CarFactory {

    @Override
    public Window createWindow() {
        return new BigWindow();
    }

    @Override
    public Car createCar() {
        return new Truck();
    }
}
//Cooper工厂
public class CooperFactory implements CarFactory {

    @Override
    public Window createWindow() {
        return new SmallWindow();
    }

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

Demo实例

public class Demo {

    public static void main(String[] args) {
        CarFactory jeepFactory = new JeepFactory();
        Window jeepWindow = jeepFactory.createWindow();
        System.out.println(jeepWindow.getModel());
        Car jeepCar = jeepFactory.createCar();
        System.out.println(jeepCar.getName());

        CarFactory truckFactory = new TruckFactory();
        Window truckWindow = truckFactory.createWindow();
        System.out.println(truckWindow.getModel());
        Car truckCar = truckFactory.createCar();
        System.out.println(truckCar.getName());

    }
}

相较于工厂方法模式，抽象工厂模式对产品族(相关联的对象)支持的较好，但是还是没有解决实现复杂的问题；而针对这一问题，我们可以通过与简单工厂的结合使用，或者与反射的结合使用来降低实现的复杂度。