一简单工厂模式

Posted 国境之南时代

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了一简单工厂模式相关的知识,希望对你有一定的参考价值。

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;
    }
}

 

以上是关于一简单工厂模式的主要内容,如果未能解决你的问题,请参考以下文章

PHP面向对象之选择工厂和更新工厂

设计模式学习——简单工厂模式工厂模式抽象工厂模式

一工厂模式

设计模式之工厂模式

简单工厂模式\工厂方法模式

《疯狂学习之Java设计模式之简单工厂模式》