ASP源码.NET源码PHP源码JSP源码JAVA源码DELPHI源码PB源码VC源码VB源码Android源码
当前位置:首页 >> 网络编程 >> 移动开发 >> Java设计模式篇(三)--简单工厂模式详解

Java设计模式篇(三)--简单工厂模式详解

来源:网络整理     时间:2018-10-31     关键词:

本篇文章主要介绍了" Java设计模式篇(三)--简单工厂模式详解",主要涉及到方面的内容,对于移动开发感兴趣的同学可以参考一下: 在说简单工厂模式之前,我们先来了解下活字印刷术。古时候没有现在这么现代化,都是先刻好印版,然后用印版将文章去印在纸上。每写一篇,都得刻一版,好累。毕昇,是个头脑...

在说简单工厂模式之前,我们先来了解下活字印刷术。

古时候没有现在这么现代化,都是先刻好印版,然后用印版将文章去印在纸上。每写一篇,都得刻一版,好累。

毕昇,是个头脑很灵活的工匠,他就在想,如果我把每个字都单独刻出来,你用的时候自己去组合,这样不就省事了,因此,一项伟大的发明就出现了---活字印刷术。

活字印刷术有4大特点:

第一,要改文章的字,只需要替换对应的字模就行,这是可维护。

第二,每个字模可以多次使用,这是可复用。

第三,如果文章中用到的字没有,可以新刻一个对应的字,这是可扩展。

第四,如果想改变文章的排版,只需要改变字模的方向就行,灵活性好。

我们在开发中,经常遇到用户改需求的时候,你是否很累?我们用了这么多年面向对象编程语言,多态,继承等降低了程序之间的耦合,但是一种好的组织形式是必不可少的,让你有章可循,这就是我们的设计模式。

在设计过程中,我们要将业务逻辑和系统逻辑分离开来,这样就不会因为业务需求的变动,而各种痛苦不堪。

我们先来一例,了解下简单工厂模式。

一、简单工厂模式

现在有一个需求,让你设计一个计算器。你怎么做?

首先我们知道,计算器中包含最基本的加减乘除,参与运算的是两个数值,一个运算符,一个结果,如1+1=2。

很多人说这个很简单,然后将一堆代码写在一个方法中,各种条件判断。如果我后期要新增或者修改呢?比如我要新增一个开根运算,你怎么办?继续在原有客户端方法中新增分支?要是改错了怎么办?系统立马就不能用了。这种的就是典型的紧耦合,典型的面向对象过程编程,我们要像毕昇学习,用活字印刷版的思路去做。

大多数人,碰到问题就直觉的按照计算机能够理解的逻辑去做开发,而没有真正的做到面向对象。

面向对象编程的三大特性:继承,封装,多态。封装,大多数人都有意识,可是多态这个利器却没有用起来。

我们说过,类是具有一组相同行为和属性的对象的抽象,分类的目的是为了封装。但是如果涉及到的类的

具有相同的行为,只是实现不一样,那就使用接口。如果涉及到的类具有相同的属性和行为,只是行为的实现不一样,那么就使用继承。

根据多态的特性,利用父类可以去代表子类,对外,可以统一使用父类去做操作。这里,我们的计算器操作需要两个数,行为相同实现不一样,因此可以使用继承实现多态。这样,我们的类图就有了。



我们先创建这几个类:

package com.zhaodf.pattern.simpleFactory;

public interface Operation {

    double getResult();
}
package com.zhaodf.pattern.simpleFactory;

public class OperationAdd implements Operation{
    private double numberA;
    private double numberB;

    public OperationAdd(double numberA,double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        return this.numberA+this.numberB;
    }

    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;
    }
}
package com.zhaodf.pattern.simpleFactory;

public class OperationDiv implements Operation{
    private double numberA;
    private double numberB;

    public OperationDiv(double numberA, double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        if(this.numberB==0){
            System.out.println("除数不能为0");
            return 0;
        }
        return this.numberA / this.numberB;
    }

    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;
    }
}
package com.zhaodf.pattern.simpleFactory;

public class OperationMul implements Operation{
    private double numberA;
    private double numberB;

    public OperationMul(double numberA, double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        return this.numberA * this.numberB;
    }

    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;
    }
}
package com.zhaodf.pattern.simpleFactory;

public class OperationSub implements Operation{
    private double numberA;
    private double numberB;

    public OperationSub(double numberA, double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        return this.numberA - this.numberB;
    }

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

 基本类创建完了,我们现在需要一个根据计算要求统一生产这些类的地方---工厂,并且,我们使用父类作为统一对外的窗口,使客户端调用过程透明。

我们的工厂类如下:

package com.zhaodf.pattern.simpleFactory;

public class OperationFactory{
    //我们用1-代表加法,2-代表减法,3-代表乘法,4-代表除法
    public static Operation createOperation(double numberA,double numberB,int operationType){
        Operation op = null;
        switch (operationType){
            case 1:
                op = new OperationAdd(numberA,numberB);
                break;
            case 2:
                op = new OperationSub(numberA,numberB);
                break;
            case 3:
                op = new OperationMul(numberA,numberB);
                break;
            case 4:
                op = new OperationDiv(numberA,numberB);
                break;
        }
        return op;
    }
}

客户端调用代码:

package com.zhaodf.pattern.simpleFactory;

public class TestOperation {
    public static void main(String[] args){
        double numberA = 1;
        double numberB = 2;
        Operation op = OperationFactory.createOperation(numberA,numberB,1);
        System.out.println(op.getResult());
    }
}

二、总结

简单工厂模式,将创建运算对象过程放在了工厂类中,并且使用面向对象编程的特性-多态,将运算对象的父类作为统一对外的窗口。这里也有个不好的地方,就是虽然简化了客户端的代码,但是工厂类中创建对象的分支也需要维护,后面我们讲到反射时,再来修改此处。

以上就介绍了 Java设计模式篇(三)--简单工厂模式详解,包括了方面的内容,希望对移动开发有兴趣的朋友有所帮助。

本文网址链接:http://www.codes51.com/article/detail_4595459.html

相关图片

相关文章