设计模式----简单工厂模式

/**
 * 总结来说就是先写一个抽象的父类
 * 然后用具体的子类继承这个父类 重写父类中关键的抽象的方法
 * 利用简单工厂类去生产出具体的子类，简单工厂里面的方法是静态方法，可以通过类名调用
 * 在主函数中，用多态的方法，声明抽象父类的引用，去实例化简单工厂中的子类，然后这个对象就造好了，再进行操作即可。
 *
 */

/**
 * 抽象的运算符
 *
 * 以及它的四个子类
 *
 */

public abstract class Operation {
    private double _numberA = 0;
    private double _numberB = 0;

    public double get_numberA() {
        return _numberA;
    }

    public void set_numberA(double _numberA) {
        this._numberA = _numberA;
    }

    public double get_numberB() {
        return _numberB;
    }

    public void set_numberB(double _numberB) {
        this._numberB = _numberB;
    }

    public abstract double GetResult();
}

class OperationAdd extends Operation{

    @Override
    public double GetResult(){
        return get_numberA()+get_numberB();
    }
}

class OperationSub extends Operation{

    @Override
    public double GetResult(){
        return get_numberA()-get_numberB();
    }
}

class OperationMul extends Operation{

    @Override
    public double GetResult(){
        return get_numberA()*get_numberB();
    }
}

class OperationDiv extends Operation{

    @Override
    public double GetResult(){
      try {
          return get_numberA()/get_numberB();
      }
      catch (NumberFormatException e)
      {
          System.out.println("除数不能为0！");
      }
      return get_numberA()/get_numberB();

    }
}

/**
 *
 * 简单工厂模式，生产出操作符
 *
 * 用的是静态方法 这样就不用造对象了
 */

public class OperationFactory {
    public static Operation createOperation(String operator)
    {
        Operation oper = null;

        switch(operator)
        {
            case "+": oper = new OperationAdd(); break;
            case "-": oper = new OperationSub(); break;
            case "*": oper = new OperationMul(); break;
            case "/": oper = new OperationDiv(); break;
        }
        return oper;
    }
}

/**
 * 对程序的终极追求：可维护、可复用、可拓展、灵活性好
 * 编程有一原则：用尽可能的方法去避免重复
 *
 * 紧耦合 VS 松耦合
 */


public class ProgramTest {
    public static void main(String[] args) {

        Operation oper = OperationFactory.createOperation("+");  //体现了多态性，因为左边是Operation的引用，而右边是生产出了它的子类

        oper.set_numberA(1);
        oper.set_numberB(2);

        System.out.println(oper.GetResult());

    }
}