设计模式:简单工厂模式

Posted longjin-java

tags:

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

描述


最近整理一些JAVA的基础的知识。

简单工厂模式,也就是说到底要实例化谁,将来会不会增加实例化的对象,比如计算算法的实现过程中,需要减加乘除得类,以后说不定还会增加开根运算等,所以应该考虑单独用一类来创造这个实力过程。

实现


为此我们就用简单工厂类实现加减乘除的算法计算。首先定义一个运算的接口。

public interface Operation {

    public double getResult();

}

定义好接口后,我们需要实现该接口,目前只实现加减乘除,所以需要四个实现类,在实现实现类之前,我们实现一个骨架抽象类,为了更灵活使用。

技术分享图片
public abstract class AbstractOper implements Operation{

    protected double numA;
    protected double numB;

    protected AbstractOper(double numA, double numB) {
        this.numA = numA;
        this.numB = numB;
    }
    //运算抽象类
    protected abstract double oper();
    //实现接口的获取运算结果的方法
    public double getResult() {
        return oper();
    }
}
View Code

然后开始编写实现类,首先加法运算实现类

public class AddOperation extends AbstractOper implements Operation {


    public AddOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper() {
        return numA+numB;
    }
}

减法实现类

public class SubOperation extends AbstractOper implements Operation {
    public SubOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper() {
        return numA-numB;
    }
}

乘法实现类

public class MulOperation extends AbstractOper implements Operation {
    public MulOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper() {
        return BigDecimal.valueOf(numA).multiply(BigDecimal.valueOf(numA)).doubleValue();
    }
}

除法实现类,这里要注意除数不为0问题

public class DivOperation extends AbstractOper implements Operation {
    public DivOperation(double numA, double numB) {
        super(numA, numB);
    }

    @Override
    protected double oper(){
        try {
            if(numB==0){
                throw new Exception("除数不能为0");//这里抛出异常
            }
        }catch (Exception e){
            System.out.println("除数不能为0");//我这为了方便就直接捕获了,可以直接抛出
            return 0;
        }
        return BigDecimal.valueOf(numA).divide(BigDecimal.valueOf(numB)).doubleValue();
    }
}

当四个算法运算类实现好,为了能够方便具体实现哪一个类,所以建立一个工厂类

技术分享图片
public class OperationFactory {

    public static Operation createOperation(String oper, double numA, double numB){
        Operation operation = null;
        switch (oper){
            case "+" :{
                operation = new AddOperation(numA,numB);
                break;
            }
            case "-" :{
                operation = new SubOperation(numA,numB);
                break;
            }
            case "*" :{
                operation = new MulOperation(numA,numB);
                break;
            }
            case "/" :{
                operation = new DivOperation(numA,numB);
                break;
            }

            default:{
                break;
            }
        }

        return operation;
    }
}
View Code

最后只要在客户端调用工厂类即可创建具体实例,否在全在客户端实现比较混乱也不利于维护

技术分享图片
public class OperTest {
    public static void main(String[] args) {
        System.out.print("输入numA:");
        Scanner scan = new Scanner(System.in);
        String readA = scan.nextLine();
        double numA = Double.parseDouble(readA);
        System.out.print("输入numB:");
        String readB = scan.nextLine();
        double numB = Double.parseDouble(readB);
        System.out.print("输入oper:");
        String operStr = scan.nextLine();
        //调用工厂类创建实例
        Operation oper = OperationFactory.createOperation(operStr,numA,numB);
        //调用获取结果的方法
        double reslut = oper.getResult();
        System.out.println("输入numA:"+numA+"输入numB:"+numB+"输出结果:"+reslut);
    }
}
View Code

总结


最终通过简单工厂实现了减加乘除得运算,好的程序离不开好的设计,虽然一个类也许就可以实现这泄功能,但那只是面向过程而非面向对象,通过以上写法用来满足类的单一原则,里氏原则,开闭原则,接口隔离,最少知道原则,以更好地实现松耦合。

 

 

 

 

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

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

设计模式之简单工厂模式

设计模式-简单工厂工厂方法模式抽象工厂模式详解

Delphi 设计模式:《HeadFirst设计模式》Delphi7代码---工厂模式之简单工厂

C#之三十八 简单工厂设计模式

设计模式之简单工厂模式