（一）设计模式简单工厂模式（大话设计模式学习笔记）

一时失言乱红尘 2024-04-18 08:27 35阅读 0赞

**1、面向对象程序设计好处**

面向对象程序设计通过封装、继承、多态把程序的耦合度降低。

**①封装**： 将实现细节和属性隐藏，通过对外提供的公共接口控制属性的访问权限，防止该类的代码和数据被外部类定义的代码随机访问。通过封装，可以做到修改自己的代码，而不影响调用我们代码的程序。

**②继承**：以现有类为基础，复制它，然后通过添加和修改这个副本来创建一个新类。

**③多态**：多态也称作动态绑定、后期绑定或运行时绑定；通过将子类对象引用赋值给父类引用，然后在程序运行时再根据对象的类型进行方法绑定。

**2、设计模式好处**

使用设计模式使得程序更加灵活，容易修改，并且易于复用。

①可维护性（容易修改）：只修改需要改的地方，不影响其他功能的逻辑。

②复用：通过继承使用已有的类的属性或方法。

**3、简单工厂模式**

工厂类依据条件创建实现了不同功能的子类对象，然后返回一个指向了相应子类对象的父类引用。**好处：如果要添加新的功能，只需要创建一个实现了另外功能的新子类，对于原有代码，只需要修改抽象工厂的代码。**

**    *  ①抽像类中包含所有的方法声明（相似的功能）***

***      ②每一个子类对应一种具体的方法实现（功能实现）***

*③**工厂类负责所有子类对象的创建，并赋值给父类对像的引用，利用多态进行后期方法体的绑定。***

类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzM1MTg0NTc2_size_16_color_FFFFFF_t_70][]

简单工厂类：

public class SimpleFactory {
    
        public static Operation createOperation(String operater) {
            Operation operation = null;
            switch (operater) {
                case "+":
                    operation = new OperationAdd();
                    break;
                case "-":
                    operation = new OpertionSub();
                    break;
                case "*":
                    operation = new OperationMul();
                    break;
                case "/":
                    operation = new OperationDiv();
                    break;
            }
            return operation;
        }
    }

加减乘除四个子类：

//基类
    public abstract class Operation {
        protected double operationA = 0.0;
        protected double operationB = 0.0;
    
        public double getOperationA() {
            return operationA;
        }
    
        public void setOperationA(double operationA) {
            this.operationA = operationA;
        }
    
        public double getOperationB() {
            return operationB;
        }
    
        public void setOperationB(double operationB) {
            this.operationB = operationB;
        }
    
        public abstract double getResult() throws Exception;
    }
    
    
    
    
    
    
    
    //加法类
    public class OperationAdd extends Operation {
        @Override
        public double getResult() {
            return operationA + operationB;
        }
    }
    
    
    
    //减法类
    
    public class OpertionSub extends Operation {
        @Override
        public double getResult() {
            return operationA - operationB;
        }
    }
    
    
    
    
    
    //乘法类
    public class OperationMul extends Operation {
        @Override
        public double getResult() {
            return operationA * operationB;
        }
    }
    
    
    
    
    //除法类
    public class OperationDiv extends Operation {
        @Override
        public double getResult() throws Exception {
            if (operationB == 0.0) {
                throw new Exception("除数不能为零！");
            }
            return operationA / operationB;
        }
    }

客户端代码：

public class Main {
    
        public static void main(String[] args) {
    
            Operation operation = SimpleFactory.createOperation("+");
            operation.setOperationA(100);
            operation.setOperationB(150);
            try {
                System.out.println(operation.getResult());
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
    
        }
    }

对于类似计算器的设计中，通过使用简单工厂模式，能够灵活添加任意的计算子类（如：平方运算、求余运算等等），且在添加新功能的过程中对原有功能没有影响（不需要修改），只是需要修改工厂类，使其能够创建新子类对象。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzM1MTg0NTc2_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/c664369b69d24e97a07e1df2590d21d6.png