大话设计模式之工厂方法模式

参考—->程杰大神的《大话设计模式》—org
记一下一遍以后重复看时有新的理解，メモ
小记—>
在UML绘图中 斜体表示抽象函数 若是接口会有interface标识

这次对应书中的例子的结构图

如果想后期增加功能时，如如图中的N次方的功能，需要更改的是写一个实现接口工厂的N次方工厂的类，然后添加一个继承抽象运算类的N次方类。
遵循 修改封闭 扩展开放 的原则。。。。
抽象类—->

package co.jp.li.operation;
/**
 * 抽象类是不能被实例化的。
 * 抽象类里面可以有抽象函数和具体的函数
 * 抽象函数必须在抽象类中
 * 声明功能抽象类
 * */
public abstract class Operation {

    private double numberA;
    private double numberB;

    /**
     * 利用构造参数进行赋值
     * */
    public Operation(double numberA, double numberB) {
        super();
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public abstract void getResult();
}

声明具体的功能的类继承抽象的功能类 重写抽象函数
加法和减法—>

package co.jp.li.operation;
/**
 * 声明具体的功能的类继承抽象的功能类 重写抽象函数
 * */
public class AddOperation extends Operation {

    private double numberA, numberB;

    Operation operation;
    public AddOperation(double numberA, double numberB) {
        super(numberA, numberB);
        // TODO Auto-generated constructor stub
        this.numberA = numberA;
        this.numberB = numberB;
    }

    @Override
    public void getResult() {
        // TODO Auto-generated method stub

        System.out.println("たす　は---->" + (numberA + numberB));
    }

}

package co.jp.li.operation;
/**
 * 声明具体的功能的类继承抽象的功能类 重写抽象函数
 * */
public class SubOperation extends Operation {

    private double numberA, numberB;

    public SubOperation(double numberA, double numberB) {
        super(numberA, numberB);
        // TODO Auto-generated constructor stub
        this.numberA = numberA;
        this.numberB = numberB;
    }

    @Override
    public void getResult() {
        // TODO Auto-generated method stub
        System.out.println("ひく　は---->" + (numberA - numberB));
    }

}

一个接口利用生产运算符号和参数赋值接口工厂—>

package co.jp.li.factory;

import co.jp.li.operation.Operation;
/**
 * 一个接口利用生产运算符号和参数赋值
 * */
public interface  IFactory {

     Operation CreateOperation(double numA,double NumB);
}

得到加减法的功能实例化的工厂—>

package co.jp.li.factory;

import co.jp.li.operation.AddOperation;
import co.jp.li.operation.Operation;
/**
 * 声明具体的功能的类工厂实现总的工厂的接口
 * */
public class AddFactory implements IFactory {


    public Operation CreateOperation(double numA,double numB) {

        return new AddOperation(numA,numB);
    }

}

package co.jp.li.factory;

import co.jp.li.operation.Operation;
import co.jp.li.operation.SubOperation;
/**
 * 声明具体的功能的类工厂实现总的工厂的接口
 * */
public class SubFactory implements IFactory {


    public Operation CreateOperation(double numA,double numB) {

        return new SubOperation(numA,numB);
    }
}

用户输入测试—>

package co.jp.li.courstom;

import co.jp.li.factory.IFactory;
import co.jp.li.factory.SubFactory;
import co.jp.li.operation.Operation;

public class TestClient {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /**
         * 实例化具体的功能的类工厂返回得到
         * 实现的接口总工长 用来得到具体的功能类
         * */
        IFactory iFactory = new SubFactory();
        /**
         *  创建调用得到具体的功能类返回抽象类的具体事例(其实抽象类是不能被实例化的这个地方
         *  只是得到了实现抽象类的功能类的具体事例)
         * */
        Operation operation = iFactory.CreateOperation(1.3, 1.0);
        operation.getResult();
    }

}

和简单的工厂进行相比的话，当增加一个功能时工厂方法模式没有违背
修改封闭 扩展开放的原则，简单工厂在增加新的功能时需要修改工厂类
什么switch 加case 等等，破坏了修改封闭。