设计模式 - 简单工厂模式

文章目录

---

前言

大家好,今天给大家介绍一下23种常见设计模式中的一种 - 工厂模式

---

1 . 问题引入

请用C++、Java、C#或 VB.NET任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符 号，得到结果。

下面的代码实现默认认为两个操作数为Integer类型, 为了简单起见, 不引入泛型

2 . Version1

public class Version1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入数字A: ");
        int A = sc.nextInt();
        System.out.print("请输入你要执行的操作(+,-,*,/): ");
        String str = sc.next();
        System.out.print("请输入数字B: ");
        int B = sc.nextInt();

        if("+".equals(str)){
            System.out.println(A+B);
        }else if("-".equals(str)){
            System.out.println(A-B);
        }else if("*".equals(str)){
            System.out.println(A*B);
        }else if("/".equals(str)){
            System.out.println(A/B);
        }
    }
}

代码问题分析

上述代码对于初学者来说能写出来我想再正常不过了,哈哈, 我们来针对上述三点改进一下,命名还是按照A,B吧,毕竟又不是真的计算器。

3 . Version2 

public class Version2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        try{
            System.out.print("请输入数字A: ");
            int A = sc.nextInt();
            System.out.print("请输入你要执行的操作(+,-,*,/): ");
            String str = sc.next();
            System.out.print("请输入数字B: ");
            int B = sc.nextInt();
            int ret = 0;

            switch (str){
                case "+":
                    ret = A+B;
                    break;
                case "-":
                    ret = A-B;
                    break;
                case "*":
                    ret = A*B;
                    break;
                case "/":
                    if(B!=0) {
                        ret = A/B;
                        break;
                    }
                    else throw new RuntimeException("除数为0");
                default:
                    throw new RuntimeException("没有该运算符!");
            }
            System.out.println("结果为: "+ret);
        }catch(Exception e){
            System.out.print("您的输入有误!: ");
            e.printStackTrace();
        }
    }
}

现在在看这段代码,是不是感觉没啥毛病了!  如果你没有学过面向对象编程,我没什么可说的,但是Java是面向对象编程的语言啊!  面向对象的三大特征是啥?

1. 封装：封装是指将数据和行为（方法）封装在一个类中，并对外部隐藏对象的内部实现细节，只提供公共的访问方式。这样可以保护数据不被直接访问和修改，提高代码的安全性和可维护性。

2. 继承：继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，子类可以复用父类的代码，并且可以在不改变父类的情况下进行扩展和修改。通过继承可以建立类之间的层次关系，提高代码的可复用性和扩展性。

3. 多态：多态是指同一个方法在不同的对象上有不同的行为表现。在面向对象编程中，多态可以通过继承和接口实现。多态性可以提高代码的灵活性和可扩展性，使代码更易于维护和扩展。

一个都没用到,哈哈,这肯定是不行的,还得再改进一下!

那么如何改进呢?  先来考虑封装, 是不是可以把操作逻辑和业务逻辑单独封装为一个类?

4. Version3

package FactoryModel.Option3;

import java.util.Scanner;

/**
 * 业务代码 和 计算代码实现分离! - 封装!
 */
public class Version3 {
    public static void main(String[] args) {
        try(Scanner sc = new Scanner(System.in)){
            System.out.print("请输入数字A: ");
            int A = sc.nextInt();
            System.out.print("请输入你要执行的操作(+,-,*,/): ");
            String str = sc.next();
            System.out.print("请输入数字B: ");
            int B = sc.nextInt();
            if(B!=0) System.out.println(Operation.getResult(A,B,str));
            else throw new RuntimeException();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 孺鸟可教也，写得不错，这样就完全把业务和界面分离了。
 * 如果你现在要我写一个Windows应用程
 * 序的计算器，我就可以复用这个运算类（Operation）了
 */
class Operation{
    public static int getResult(int A,int B, String oper){
        int ret = 0;
        switch (oper){
            case "+":
                ret = A+B;
                break;
            case "-":
                ret = A-B;
                break;
            case "*":
                ret = A*B;
                break;
            case "/":
                ret = A/B;
        }
        return ret;
    }
}

现在如果我希望增加一个开根（sqrt）运算，你如何改？

那只需要改Operation类就行了，在switch中加一个分支就行了

问题是你要加一个平方根运算，却需要让加减乘除的运算都得来参与编译，如果你一不小心，把加法运算改成了减法，这岂不是大大的糟糕。况且改代码这件事情不符合 开放 - 封闭原则

开放 - 封闭原则（Open-Closed Principle）是面向对象设计原则之一，提出者是Bertrand Meyer。该原则指出一个软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。换句话说，一个软件实体应该通过扩展来实现新功能，而不是通过修改已有的代码来实现。

具体来说，开放 - 封闭原则要求在系统需要变化时，应该通过添加新的代码来扩展功能，而不是修改已有的代码。这样可以保持系统的稳定性，减少对已有代码的影响，同时也更容易实现代码的复用和维护。

遵循开放 - 封闭原则可以使代码更加灵活、可扩展和可维护，同时也有利于降低系统的耦合度，提高代码的可复用性。这一原则在面向对象设计中扮演着重要的角色，帮助我们设计出更加稳定和易扩展的软件系统。

这个时候就该,继承登场了!

5 . Version4

public abstract class Operation {
    protected Integer A;
    protected Integer B;

    public Integer getA() {
        return A;
    }

    public void setA(Integer a) {
        A = a;
    }

    public Integer getB() {
        return B;
    }

    public void setB(Integer b) {
        B = b;
    }

    public abstract Integer getResult();
}

class OperationAdd extends Operation{
    @Override
    public Integer getResult() {
        return A+B;
    }
}

class OperationDiv extends Operation{
    @Override
    public Integer getResult() {
        return A/B;
    }
}


class OperationMul extends Operation{
    @Override
    public Integer getResult() {
        return A*B;
    }
}

class OperationSub extends Operation{
    @Override
    public Integer getResult() {
        return A-B;
    }
}

这个时候如果我们再额外添加运算是不是就变得很简单了,只需要增加一个类,继承Operation即可!

6 . 简单工厂模式

简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，属于工厂模式的一种。在简单工厂模式中，有一个工厂类负责根据客户端的需求创建相应的产品对象，而客户端无需知道具体产品的创建细节，只需要通过工厂类来获取所需的产品对象。

/**
 * 简单工厂模式
 */

public class OperationFactory {
    public static Operation createOperate(String oper){
        Operation operation = null;
        try{
            switch (oper){
                case "+":
                    operation = new OperationAdd(); // 多态
                    break;
                case "-":
                    operation = new OperationSub(); // 多态
                    break;
                case "*":
                    operation = new OperationMul(); // 多态
                    break;
                case "/":
                    operation = new OperationDiv(); // 多态
                    break;
                default:
                    throw new RuntimeException();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return operation;
    }

    public static void main(String[] args) {
        Operation operate = OperationFactory.createOperate("+");
        operate.setA(10);
        operate.setB(20);
        System.out.println(operate.getResult());
    }
}

---

总结

以上就是这篇博客的主要内容了,大家多多理解,下一篇博客见!