大话设计模式-工厂方法模式(大鸟和小菜java版)

工厂方法模式：工厂方法模式（FACTORY METHOD）是一种常用的类创建型设计模式,此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品
工厂方法模式是简单工厂模式的衍生。
还是大鸟和小菜的例子，写加减乘除基本运算

先定义一个抽象类，然后让加减乘除类继承这个抽象类，还要注意除数不能为0，需要抛一个异常

package 设计模式.工厂方法模式;
//定义一个抽象类
public abstract class Operation {
//    包含两个变量
    public double number1;
    public double number2;
//为两个变量添加set和get方法已备不时之需
    public double getNumber1() {
        return number1;
    }

    public void setNumber1(double number1) {
        this.number1 = number1;
    }

    public double getNumber2() {
        return number2;
    }

    public void setNumber2(double number2) {
        this.number2 = number2;
    }
//    定义一个抽象方法，继承该抽象类时，必须重写抽象方法 抛出异常
    public abstract double getRes() throws Exception;
}

//这个是加法类
class OAdd extends Operation{

    @Override
    public double getRes() {
        return number1+number2;
    }
}

//减法类
class OSub extends Operation{

    @Override
    public double getRes() {
        return number1 - number2;
    }
}

//乘法类
class OMul extends Operation{

    @Override
    public double getRes() {
        return number1 * number2;
    }
}

//除法类
class ODiv extends Operation {

    @Override
    public double getRes() throws Exception {
//        如果除数为0的话，则就抛出一个异常
        if(number2 == 0){
            throw new Exception("除数不能为0");
        }
        return number1/number2;
    }
}

定义一个工厂接口

package 设计模式.工厂方法模式;
//定义一个工厂接口，里面定义一个Operation的方法
public interface Factory {
    public Operation cOperation();
}

定义具体的工厂加减乘除代码

package 设计模式.工厂方法模式;
//加法工厂实现工厂接口，顺便重写接口里的方法
public class AddFactory implements Factory{

    @Override
    public Operation cOperation() {
        return new OAdd();
    }
}

//减法工厂
class SubFactory implements Factory{

    @Override
    public Operation cOperation() {
        return new OSub();
    }
}

//乘法工厂
class MulFactory implements Factory{

    @Override
    public Operation cOperation() {
        return new OMul();
    }
}

//除法工厂
class DivFactory implements Factory{

    @Override
    public Operation cOperation() {
        return new ODiv();
    }
}

最后就是测试主类啦
别忘了try…catch异常

package 设计模式.工厂方法模式;
//测试类
public class Test {
    public static void main(String[] args) {
//        使用多态，new出加法工厂对象，进行操作
        Factory f = new AddFactory();
//        实现方法
        Operation o = f.cOperation();
//        为其赋值
        o.number1 = 2;
        o.number2 = 3;
//        处理异常
        try {
            System.out.println(o.getRes());
        } catch (Exception e) {
            e.printStackTrace();
        }
// 下面的和上面是一样的，把加减乘除列出
        Factory f1 = new SubFactory();
        Operation o1 = f1.cOperation();
        o1.number1 = 4;
        o1.number2 = 5;
        try {
            System.out.println(o1.getRes());
        } catch (Exception e) {
            e.printStackTrace();
        }

        Factory f2 = new MulFactory();
        Operation o2 = f2.cOperation();
        o2.number1 = 1;
        o2.number2 = 2;
        try {
            System.out.println(o2.getRes());
        } catch (Exception e) {
            e.printStackTrace();
        }

        Factory f3 = new DivFactory();
        Operation o3 = f3.cOperation();
        o3.number1 = 1;
        o3.number2 = 0;
        try {
            System.out.println(o3.getRes());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上就是工厂方法模式啦。。
参考大佬的文章：https://blog.csdn.net/yixiang1989/article/details/38514189
最后附上运行结果