工厂设计模式

基本概念：为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

分为三类：

• 简单工厂模式Simple Factory：不利于产生系列产品；

• 工厂方法模式Factory Method：又称为多形性工厂；

• 抽象工厂模式Abstract Factory：又称为工具箱，产生产品族，但不利于产生新的产品；

一、简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

先来看看它的组成：

• 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

• 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

• 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

实例代码：

// 抽象产品
public abstract class Simple {
    public Simple() {
    }
}
class SimpleA extends Simple {
    public SimpleA() {
        super();
    }
}
class SimpleB extends Simple {
    public SimpleB() {
        super();
    }
}

//简单工厂模式
public class SimpleFactory {

    /*
    * 在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化
    * */

    public SimpleFactory() {
    }
    // 定义一个用于创建对象的接口
    public static Simple creator(int which) {
        switch (which) {
            case 1 -> {
                return new SimpleA();
            }
            case 2 -> {
                return new SimpleB();
            }
            default -> {
                return null;
            }
        }
    }
}

//测试
public class SimpleFactoryTest {
    public static void main(String[] args) {
        Simple simpleA = SimpleFactory.creator(1);
        Simple simpleB = SimpleFactory.creator(2);
    }
}

缺点：在普通工厂方法模式中，如果传递的数值出错，则不能正确创建对象

二、工厂方法模式

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

来看下它的组成：

• 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

• 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象

• 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

• 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

示例代码：

// 抽象产品接口
public  interface Movable {
    void run();
}
// 具体产品角色
class Car implements Movable {
    @Override
    public void run() {
        System.out.println("汽车在。。。。");
    }
}
// 具体产品角色
class Plane implements Movable {
    @Override
    public void run() {
        System.out.println("飞机在。。。。");
    }
}

//抽象工厂角色
public abstract class VehicleFactory {
    public VehicleFactory() {}

    abstract Movable creator();
    /*
    *工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
    *
    * */
}
// 具体工厂
class CarFactory extends VehicleFactory{
    @Override
    public Movable creator() {
        return new Car();
    }
}
// 具体工厂
class PlaneFactory extends VehicleFactory{
    @Override
    public Movable creator() {
        return new Plane();
    }
}

//测试
public class FactoryMethodTest {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.creator().run();

        PlaneFactory planeFactory = new PlaneFactory();
        planeFactory.creator().run();
    }
}

简单工厂和工厂方法模式的比较？

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。

反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

缺点：该工厂类负责创建所有实例，如果有新的类加入，需要不断的修改工厂类，不利于后期的维护

三、抽象工厂模式

在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

示例代码：

// 抽象产品
public interface Food {
    void printName();
}
// 具体产品角色
class Apple implements Food {
    @Override
    public void printName() {
        System.out.println("这是苹果");
    }
}
// 具体产品角色
class Banana implements Food {
    @Override
    public void printName() {
        System.out.println("这是香蕉");
    }
}

// 抽象产品
public interface Vehicle {
    void run();
}
// 具体产品角色
class BYDCar implements Vehicle {
    @Override
    public void run() {
        System.out.println("比亚迪在行驶");
    }
}
// 具体产品角色
class BWMCar implements Vehicle {
    @Override
    public void run() {
        System.out.println("宝马在行驶");
    }
}

// 抽象工厂
public abstract class AbstractFactory {

    /*
    * 在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
    * */

    abstract public Food createFood();
    abstract public Vehicle createVehicle();
}

// 具体工厂，其中Food,Vehicle是抽象类
class DefaultFactory extends AbstractFactory {
    @Override
    public Food createFood() {return new Apple();}

    @Override
    public Vehicle createVehicle() {return new BYDCar();}
}

// 具体工厂，其中Food,Vehicle是抽象类
class SecondFactory extends AbstractFactory {
    @Override
    public Food createFood() {
        return new Banana();
    }

    @Override
    public Vehicle createVehicle() {
        return new BWMCar();
    }
}

//测试
public class AbstractFactoryTest {
    public static void main(String[] args) {
        DefaultFactory factory = new DefaultFactory();
        factory.createFood().printName();
        factory.createVehicle().run();

        SecondFactory factory1 = new SecondFactory();
        factory1.createFood().printName();
        factory1.createVehicle().run();
    }
}

总结

• 简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。

• 工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。

• 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。