一（1）简单工厂模式

1 设计模式中经常用到程序设计中的封装，继承，多态的思想。不同的设计模式使代码更加灵活，容易扩展。

2 设计模式中一般都会存在父类的概念，父类一般是抽象类，内部维护的变量，用于子类继承；维护的抽象方法，用于子类去具体实现。

3 对于一个方案的模式设计，要首先抽象出父类，想出父类中要维护哪些子类都要用到的变量；维护哪些子类都要去实现的方法。

扩展性的体现：主要体现在多态的实现部分，比如增加新的需求，要求可以计算a的b次幂，不需要动加减乘除的具体实现代码（类），只需要增加新类，去实现幂运算，在工厂类中，增加一个case语句即可。

解耦合的体现：不同的加减乘除具体实现方法通过不同的类来实现，这样它们之间基本没关联，实现解耦合。

本例子应用简单工厂的设计模式，返回不同的加减乘除运算类的对象。

package com.biao.factory.simplefactory;

/*
 *0 简单工厂类：根据传递的不同参数，通过多态，创建不同的对象，进行不同的运算操作。
 *1 可扩展：比如增加新的开方运算，只需要增加一个具体的运算类OperationSqur即可，不用更改原有代码，此为可扩展。
 *2 封装：比如不同的具体的运算类对于加减乘除的不同方法进行了封装，这样使加减乘除运算之间的耦合度降低。
 *3 继承：父类中定义变量，以及方法；子类去继承父类，用父类的变量，重写父类的方法，实现具体的运算。
 *4 多态：简单工厂类中，通过传递的不同参数，去创建不同的对象
 */
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Operation operation = null;
        /*测试1*/
        operation = OperationFactory.createOperation("+");
        operation.numberA = 5;
        operation.numberB = 10;
        Double result = operation.getResult();
        System.out.println("result:"+result);
        /*测试2*/
        operation = OperationFactory.createOperation("/");
        operation.numberA = 15;
        operation.numberB = 3;
        Double result2 = operation.getResult();
        System.out.println("result:"+result2);
    }
}
/**
 * 1 内部维护两个操作数，用于进行运算
 * 2 内部维护一个返回结果的方法，用于子类重写,并返回子类特有的结果。
 * 3 这是一个父类。父类主要定义有哪些东西，具体如何操作，需要各个子类去实现。
 */
class Operation{
    public double numberA = 0;
    public double numberB = 0;
    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(){
        double result = 0d;
        return result;
    }
}
/**
 * 1 以下为具体的运算类，即加减乘除类。
 */
class OperationAdd extends Operation{
    public double getResult(){
        double result = 0d;
        result = numberA + numberB;
        return result;
    }
}
class OperationSub extends Operation{
    public double getResult(){
        double result = 0d;
        result = numberA - numberB;
        return result;
    }
}
class OperationMul extends Operation{
    public double getResult(){
        double result = 0d;
        result = numberA * numberB;
        return result;
    }
}
class OperationDiv extends Operation{
    public double getResult(){
        double result = 0d;
        if(numberB == 0){
            try {
                throw new Exception("除数为0");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else{
            result = numberA/numberB;
        }
        return result;
    }
}
/**
 * 1 以下为运算符工厂类，通过多态，生成不同的运算类。
 *
 */
class OperationFactory{
    public static Operation createOperation(String operate){
        Operation oper = null;
        switch (operate) {
        case "+":
            oper = new OperationAdd();
            break;
        case "-":
            oper = new OperationSub();
            break;
        case "*":
            oper = new OperationMul();
            break;
        case "/":
            oper = new OperationDiv();
            break;

        default:
            break;
        }
        return oper;
    }
}

如上demo的改进，改进运算操作的父类为一个抽象类，抽象类中维护两个操作数，用于进行计算，维护一个方法，用于返回计算结果。

代码如下：

package com.biao.factory.simplefactory.again;
/**
 * @改进：运算类更改为抽象类，抽象类中维护两个变量，（就是操作数，用于进行运算），还有一个抽象方法，
 *         用于子类继承重写，返回不同的运算结果。
 */
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Operation oper;
        /*测试1*/
        oper = OperationFactory.createOperation("+");
        oper.NumberA = 1;
        oper.NumberB = 6;
        System.out.println(oper.getResult());
        /*测试2*/
        oper = OperationFactory.createOperation("/");
        oper.NumberA = 42;
        oper.NumberB = 6;
        System.out.println(oper.getResult());
    }

}

/*此类进行了改进*/
abstract class Operation{
    public double NumberA;
    public double NumberB;
    public abstract double getResult();
}

/*具体运算类*/
class OpetationAdd extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return NumberA + NumberB;
    }
}
class OpetationSub extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return NumberA - NumberB;
    }
}
class OpetationMul extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return NumberA * NumberB;
    }
}
class OpetationDiv extends Operation{
    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        double result =0;
        if(NumberB == 0){
            try {
                throw new Exception("除数为0");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            result = NumberA/NumberB;
        }
        return result;
    }
}

/*运算工厂生成类*/
class OperationFactory{
    public static Operation createOperation(String operate){
        Operation oper = null;
        switch (operate) {
        case "+":
            oper = new OpetationAdd();
            break;
        case "-":
            oper = new OpetationSub();
            break;
        case "*":
            oper = new OpetationMul();
            break;
        case "/":
            oper = new OpetationDiv();
            break;
        default:
            break;
        }
        return oper;
    }
}