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

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

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

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

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

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

 

2、设计模式好处

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

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

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

 

 

 

3、简单工厂模式

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

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

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

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

类图：

 

 

简单工厂类：

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

    }
}

 

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