设计模式-工厂模式

工厂模式-计算器的设计

大话设计模式中的代码是C++写的，我用Java将其写出来
并记录工厂模式的思想

-1. 紧耦合和松耦合

1. 使得要改的东西，只需更改要改的地方-----可维护
2. 这些东西并非用完就扔，可以重复使用-----可复用
3. 若要增加字，只需加入即可--------------可扩展
4. 如若要改变样式，只需移动--------------灵活性高

面向对象的好处：
通过封装、继承、多态把程序耦合度降低，使程序更加灵活，容易修改，并且容易复用。

松耦合和紧耦合
比如设计一个计算器-加入加减乘除几个功能，现在再增加一个开平方根的功能，怎么做？如果按照面向过程将需要在函数的参数值上做改动，除非将加减乘除分开，每个功能封装成独立的一个。那么新增加的也是独立的一个。

计算器代码示例如下
运算类：包括加减乘除和其父类，父类中包含两个参数

运算类
package shejimoshi.simplefactory;

public class Operation {
    private double numA=0;
    private double numB = 0;

    public Operation(double numA, double numB) {
        this.numA = numA;
        this.numB = numB;
    }
    public Operation(){}

    public double getNumA() {
        return numA;
    }

    public void setNumA(double numA) {
        this.numA = numA;
    }

    public double getNumB() {
        return numB;
    }

    public void setNumB(double numB) {
        this.numB = numB;
    }

    public  double getResult(){
        double result = 0;
        return  result;
    }
}

//加减乘处类
class OperationAdd extends Operation{

    @Override
    public double getResult() {
        double result = 0;
        result = this.getNumA()+this.getNumB();
        return result;
    }
}

//加减乘处类
class OperationSub extends Operation{

    @Override
    public double getResult() {
        double result = 0;
        result = this.getNumA()-this.getNumB();
        return result;
    }
}

//加减乘处类
class OperationMul extends Operation{

    @Override
    public double getResult() {
        double result = 0;
        result = this.getNumA()*this.getNumB();
        return result;
    }
}

//除法类
class OperationDiv extends Operation{

    @Override
    public double getResult() {
        double result = 0;
        if (this.getNumB()==0)
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
                e.printStackTrace();
            }
        result = this.getNumA()/this.getNumB();
        return result;
    }
}

简单工厂类–负责创建对应的运算类的类

可以创建不同的类
package shejimoshi.simplefactory;

public class OperationFactory {

    public Operation opea = null;

    public OperationFactory(Operation opea) {
        this.opea = opea;
    }

    public  Operation createOperate(String operator){



        switch (operator){

            case "+":
                opea = new OperationAdd();
                break;
            case "-":
                opea = new OperationSub();
                break;
            case "*":
                opea = new OperationMul();
                break;
            case "/":
                opea = new OperationDiv();
                break;
        }
        return opea;
    }
}

测试类

直接在其中声明一个创建类的实例，设定值，然后进行计算
package shejimoshi.simplefactory;

/**
 * Created by 96599 on 2019/10/17.
 */
public class Client {


    public static void main(String[] args) {
        Operation opre = new Operation(2,3);


        Operation res = new OperationFactory(opre).createOperate("*");
        res.setNumA(3);
        res.setNumB(4);

        System.out.print(res.getResult());
    }
}

该模式的类结构图为

聚合关系：弱拥有，体现的是A可以包含B，但B对象不是A对象的一部分 表示：空心菱形+实线箭头 比如：雁群可以包含大雁，但是大雁不一定是这个雁群的。

合成关系：强拥有关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。 比如 鸟拥有翅膀 表示：实心菱形+箭头

关联关系：表示：实心箭头 当一个类知道另一个类时，可以用关联关系。 比如：企鹅需要了解气候规律。

依赖关系： 虚线箭头。 比如：动物依赖食物和水等。