单一原则+工厂模式

一个四则运算的优化

package com.single;

/**
 * @author: 肖德子裕
 * @date: 2018/9/26 11:27
 * @description: 单一设计原则
 */
public class Coluculator {
    private double numA=0;
    private double numB=0;

    public double getNumA() {
        return numA;
    }

    public void setNumA(double numA) {
        this.numA = numA;
    }

    public double getNumB() {
        return numB;
    }

    public void setNumB(double numB) {
        this.numB = numB;
    }

    public double getResult(){
        double result=0;
        return result;
    }
}
package com.single;

import com.single.calculate.OperationAdd;
import com.single.calculate.OperationDiv;
import com.single.calculate.OperationMul;
import com.single.calculate.OperationSub;

/**
 * @author: 肖德子裕
 * @date: 2018/9/26 11:57
 * @description: 工厂
 */
public class OperationFactory {
    public static Coluculator creatOperate(String operate){
        Coluculator coluculator=null;
        switch (operate){
            case "+":
                coluculator=new OperationAdd();
                break;
            case "-":
                coluculator=new OperationSub();
                break;
            case "*":
                coluculator=new OperationMul();
                break;
            case "/":
                coluculator=new OperationDiv();
                break;
                default:
                    throw new RuntimeException("运算符不合法");
        }
        return coluculator;
    }
}
package com.single.calculate;

import com.single.Coluculator;

/**
 * @author: 肖德子裕
 * @date: 2018/9/26 11:49
 * @description: 加法运算
 */
public class OperationAdd extends Coluculator {
    @Override
    public double getResult() {
       double result=0;
       return result=getNumA()+getNumB();
    }
}
package com.single.calculate;

import com.single.Coluculator;

/**
 * @author: 肖德子裕
 * @date: 2018/9/26 11:49
 * @description: 除法运算
 */
public class OperationDiv extends Coluculator {
    @Override
    public double getResult() {
       double result=0;
       if(getNumB()==0){
          throw new RuntimeException("分母不能为0");
       }
       return result=getNumA()/getNumB();
    }
}
package com.single;

import org.junit.Test;

/**
 * @author: 肖德子裕
 * @date: 2018/9/26 11:41
 * @description: 测试四则运算
 */
public class Main {
    @Test
    public void testAdd(){
        Coluculator coluculator=OperationFactory.creatOperate("+");
        coluculator.setNumA(20);
        coluculator.setNumB(20);
        double result=coluculator.getResult();
        System.out.println(result);
    }

    @Test
    public void testSub(){
        Coluculator coluculator=OperationFactory.creatOperate("-");
        coluculator.setNumA(40);
        coluculator.setNumB(20);
        double result=coluculator.getResult();
        System.out.println(result);
    }

    @Test
    public void testMul(){
        Coluculator coluculator=OperationFactory.creatOperate("*");
        coluculator.setNumA(40);
        coluculator.setNumB(20);
        double result=coluculator.getResult();
        System.out.println(result);
    }

    @Test
    public void testDiv(){
        Coluculator coluculator=OperationFactory.creatOperate("/");
        coluculator.setNumA(40);
        coluculator.setNumB(20);
        double result=coluculator.getResult();
        System.out.println(result);
    }
}

原文地址:https://www.cnblogs.com/xdzy/p/9718612.html

时间: 2024-10-30 07:03:02

单一原则+工厂模式的相关文章

设计模式 2/23 工厂模式(二)

先要给各位同学灌输一个思想,世间本无设计模式,用的人多了,自然就有了 没有太明显的优劣之分,只道是谁更适合 如果没法理解<<工厂>>,建议阅读上一篇 设计模式 2/23 工厂模式(一) ,毕竟是一个渐进明细的过程,急不来的 这一篇分享 工厂模式 回想一下简单工厂,我们把具体类的实例化工作放在一个工厂方法里面来执行. 同时故意在上一篇提到了开放-封闭原则. 仔细想象看看上一篇的代码,到底有没有遵守这个原则,或者说这个原则有没有被严格意义的遵守,或者说遵守的程度是多少. 如果我们要新增

设计模式之抽象工厂模式读后

原文地址 : 抽象工厂模式 抽象工厂模式算是工厂相关模式的终极形态 定义: 为创建一组相关或相互依赖的对象提供一个接口, 而且无需指定他们的具体类 跟工厂模式的区别就是 工厂也有个接口规范 在jdk的源码中就有一个不太明显的抽象工厂模式: 那就是List接口, 它在iterable的基础上, 扩展一个创建产品的方法 其中的iterator() 与listIterator() 尽管后者是前者的子类 但是两者的功能是不一样的 Iterator是只能向后移动的迭代器 ListIerator是能够前后移

php面向对象单例模式、工厂模式及6大原则

一.单例模式目的:为了控制对象的数量(只能够有一个,相当于类的计划生育)做法1.将类的构造函数做成私有的2.在类里面做了一个公有的函数来造对象3.将该函数变为静态的4.在函数里面加控制 class Ren { public $name; static public $dx; //静态成员变量用来存储该对象 private function __construct() //把构造函数设置为私有,类的外部就不能用new造对象了 { } static function DuiXiang() //做一个

php部分---面向对象,设计模式(单例模式、工厂模式)、oop六大原则;

一.单例模式目的:为了控制对象的数量(只能够有一个,相当于类的计划生育)做法1.将类的构造函数做成私有的2.在类里面做了一个公有的函数来造对象3.将该函数变为静态的4.在函数里面加控制 class Ren { public $name; static public $dx; //静态成员变量用来存储该对象 private function __construct() //把构造函数设置为私有,类的外部就不能用new造对象了 { } static function DuiXiang() //做一个

工厂模式-依赖倒置原则

老板:阿飞啊,我们公司最近接了个项目,你看着设计一下,我给你说下需求.项目组长阿飞:好啊,什么需求?老板:我们找了一个合作的商铺,他们要设计一套面包销售系统.主要功能,根据用户选择的面包种类来下订单,面包目前有奶油口味面包和苹果口味面包,所有面包的制作流程都是---搅拌,搓圆,加工,烘烤.项目组长阿飞:好的,我去想想怎么设计.项目组长阿飞:小三啊,我给你个任务,----,听懂了吗?阿三:听懂了,飞哥.项目组长阿飞:嗯嗯,好的,这个任务就交给你了,我要去处理点事情,我相信你.阿三:...三天过后.

设计模式 2/23 工厂模式

工厂模式是最常用的设计模式之一,用好了,代码优雅,可维护性高,对系统设计会上一个台阶 为什么这么说,因为工厂模式可以牵扯出抽象工厂模式,也有大家都会聊到的简单工厂模式 我们要了解一点,23中设计模式中,不包含简单工厂模式,之所以大家会去聊这个,四个字,渐进明细 通过对简单工厂模式的了解,我们引入工厂这个词,不然一个写代码的,天天给他讲工厂,工厂,工厂,西厂,东厂,会晕 同时,通过逐步的深入,从简单工厂,到工厂模式,再到抽象工厂,渐进明细的过程,逐步深入的理解,比较优劣,择优而为我们所用. 试想我

Java设计模式—工厂方法模式&amp;抽象工厂模式

工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式.       工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在工厂方法模式中,抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义:Creator为抽象创建 类,也就是抽象工厂,具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的. 工厂方法模式的扩展方式有很多种,下边是工厂方法模式一个比较实用的源代码: 抽象产品类: pub

大话设计模式:抽象工厂模式

抽象方法模式:提供一个创建一系列相关或互相依赖对象的接口,而无需指定他们具体的类. 三种模式的对比:   简单工厂模式 工厂模式 抽象工厂模式 产品 可以有多个但是都属于同一类, 同一等级.都继承产品抽象类. 可以有多个但是都属于同一类,同一等级. 都继承产品抽象类. 可以有不同种类的产品,每类有多中 具体产品: 抽象产品 只能有一个 只能有一个; 多个抽象产品类:每个抽象产品类可 以派生多种具体产品: 抽象工厂类   只能有一个,可以派生出多个具体工厂类: 只有一个,可派生出多个具体工厂类:

设计模式(一)——简单工厂模式

嵌入式linux 设计模式(一)--简单工厂模式 一.简单工厂模式简介 1.简单工厂模式 简单工厂模式(Factory Method Pattern)是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例. 简单工厂模式的UML类图 工厂角色(Creator):是简单工厂模式的核心,由它负责创建所有的类的内部逻辑.工厂类必须能够被