简单工厂模式

简单工厂模式

• Factory（工厂角色）：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod()，它的返回类型为抽象产品类型Product
• Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象
• ConcreteProduct（具体产品角色）：它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法

示例1

1. 定义抽象类

public abstract class AbstractCar {

public void run() {
    System.out.println("汽车飞速行驶中...");
}

}

2. 定义实现子类

public class Audi extends AbstractCar {

@Override
public void run() {
    System.out.println("奥迪汽车飞速行驶中...");
}

}

public class BMW extends AbstractCar {

@Override
public void run() {
    System.out.println("宝马汽车飞速行驶中...");
}

}

3. 定义工厂类

public class CarFactory {

private static final String CAR_TYPE_BMW = "bmw";
private static final String CAR_TYPE_AUDI = "audi";

public static AbstractCar getCar(String type) {
    if (CAR_TYPE_BMW.equals(type)) {
        return new BMW();
    } else if (CAR_TYPE_AUDI.equals(type)) {
        return new Audi();
    } else {
        // 默认返回宝马汽车,避免NPE
        return new BMW();
    }
}

}

4. 测试类

public class Demo1Test {

public static void main(String[] args) {

    // 得到具体的汽车--宝马
    AbstractCar bwm = CarFactory.getCar("bwm");
    bwm.run();

    // 得到具体的汽车--奥迪
    AbstractCar audi = CarFactory.getCar("audi");
    audi.run();

    /*
        执行结果：
            宝马汽车飞速行驶中...
            奥迪汽车飞速行驶中...
     */

}

}

#### 示例2

    1. 定义接口

public interface IOperation {

double getResult(double a, double b);

}

2. 定义实现

public class AddOperation implements IOperation {

@Override
public double getResult(double a, double b) {
    return a + b;
}

}

public class SubOperation implements IOperation {

@Override
public double getResult(double a, double b) {
    return a - b;
}

}

3. 定义工厂类

public class OperationFactory {

private static final String OPERATION_TYPE_ADD = "add";
private static final String OPERATION_TYPE_SUB = "sub";

public static IOperation getOperation(String type) {
    switch (type) {
        case OPERATION_TYPE_ADD:
            return new AddOperation();
        case OPERATION_TYPE_SUB:
            return new SubOperation();
        default:
            return new AddOperation();
    }
}

}

4. 定义测试类

public class Demo2Test {
    public static void main(String[] args) {
        IOperation addOperation = OperationFactory.getOperation("add");
        double result1 = addOperation.getResult(1.0, 2.0);
        System.out.println("result1 = " + result1);

        IOperation subOperation = OperationFactory.getOperation("sub");
        double result2 = subOperation.getResult(10.0, 2.0);
        System.out.println("result2 = " + result2);

        /**
         * result1 = 3.0
         * result2 = 8.0
         */
    }
}
```

总结

优点：

• 工厂类包含必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的职责，而仅仅“消费”产品，简单工厂模式实现了对象创建和使用的分离
• 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以在一定程度减少使用者的记忆量

缺点：

• 由于工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响
• 引入新的工厂类，增加系统的复杂性
• 系统扩展困难，尤其是产品数量较多时，会造成工厂逻辑过于复杂，不利于扩展和维护
• 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构

适用场景：

• 产品数量较少时
• 客户端只知道需要传入的参数 ，不关心产品是如何创建出来时