简单工厂模式

最新推荐文章于 2024-09-27 00:45:01 发布

宇意

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量93

点赞数

分类专栏： # 设计模式文章标签： java 设计模式

本文链接：https://blog.csdn.net/u010992900/article/details/103286790

版权

设计模式专栏收录该内容

25 篇文章 0 订阅

订阅专栏

简单工厂模式

在这里插入图片描述

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

示例1

定义抽象类

public abstract class AbstractCar {

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

定义实现子类

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

public class BMW extends AbstractCar {

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

定义工厂类

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();
       }
   }

}

测试类

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);
}

定义实现

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;
    }
}

定义工厂类

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();
        }
    }
}

定义测试类

    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
             */
        }
    }

总结

优点：

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

缺点：