简单工厂模式

最新推荐文章于 2025-05-26 21:02:41 发布

原创最新推荐文章于 2025-05-26 21:02:41 发布 · 300 阅读

0 ·

CC 4.0 BY-SA版权

大话设计模式专栏收录该内容

2 篇文章

订阅专栏

本文深入解析简单工厂模式的实质，通过实例代码展示了如何利用面向对象的封装、继承和多态特性实现灵活的运算符选择机制，并探讨了其优缺点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.简单工厂模式的实质

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
2.画上流程框图
3.面向对象三大特性

这里为什么再把继承、封装、多态搬到台面上来呢？因为工厂模式离不开他呀！这几个家伙太重要了！

封装：只要你把业务和判断逻辑分别写成方法就算是封装了，这样就是实现了可维护性和复用性，当你想修改业务时候就去修改业务的方法即可。
继承：子类继承父类，提高扩展性（当你想增加一个取余数运算时，加个子类即可）
多态：[同一个行为具有不同的表现形态]，当你明白了向上转型你就理解了工厂类(https://blog.youkuaiyun.com/qq_31655965/article/details/54746235)
4.贴上代码类
Operation类（父类）

package SimpleFactory;

public class Operation {
    private double numberA;
    private double numberB;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public double GetResult() {
        return 0;
    }
}

运算符类（子类：加减乘除）

package SimpleFactory;

public class Add extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        return getNumberA()+getNumberB();
    }

}

package SimpleFactory;

public class Sub extends Operation {

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        return getNumberA()-getNumberB();
    }

}

package SimpleFactory;

public class Mul extends Operation {

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        return getNumberA()*getNumberB();
    }


}

package SimpleFactory;

public class Div extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        if (getNumberB()==0) {
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return getNumberA()/getNumberB();
    }

}

OperationFactory类（工厂类）

package SimpleFactory;

public class OperationFactory {
    public static Operation creatrOperation(String operation) {
        Operation oper = null;
        switch (operation) {
        case "+":
            oper = new Add();
            break;
        case "-":
            oper = new Sub();
            break;
        case "*":
            oper = new Mul();
            break;
        case "/":
            oper = new Div();
            break;
        default:
            System.err.println("请按照要求输入运算符号！");
            break;
        }
        return oper;
    }
}

Service客户端类（测试类）

package SimpleFactory;

import org.junit.Test;

/**
 * 客户端类
 * @author Halo
 *
 */
public class Service {
    @Test
    public void testSimpleFactory() {
        Operation oper =null;
        oper = OperationFactory.creatrOperation("+");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("-");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("*");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("/");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

//      oper = OperationFactory.creatrOperation("swith里没有的运算符，如sqrt");
//      oper.setNumberA(1);
//      oper.setNumberB(2);
//      System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("/");
        oper.setNumberA(1);
        oper.setNumberB(0);
        System.out.println(oper.GetResult());
    }
}

5.浅析优劣

简单工厂模式，将变化的地方，用一个类表示，当需要使用，修改，删除这个变化的地方的时候，只需要创建，修改，删除指定类实例化对象即可。

优点：
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”的对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点：
由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求，这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利。

总之，
1. 维护性：维护时候只需要该类的实例就行了，简单粗暴！
2. 扩展性：需要增加其他的运算符时，只需要创建对应的类，再实例化，不过需要在工厂类中添加一段条件代码，表示何种条件下调用，这点不太友好！
3. 复用性：用多少次都ok，只要实例化对象即可。