软件构造实验05 软件重构与交付

会编程是什么样的感觉

已于 2024-02-28 23:11:53 修改

阅读量785

点赞数 25

分类专栏：软件构造文章标签： java 开发语言 intellij-idea 重构驱动开发

于 2024-02-28 22:18:59 首次发布

本文链接：https://blog.csdn.net/m0_63369249/article/details/136355888

版权

软件构造专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文介绍了使用Java和Junit进行软件重构实验，涉及混合算式重构，Java程序打包及运行，以及应用Test-DrivenDevelopment方法开发将阿拉伯数字转为中文大写的NumberToChinese类及其测试用例。

摘要由CSDN通过智能技术生成

一、前言

二、实验目的

三、实验内容

一、前言

软件构造的实验作业05，使用的编程语言为Java，测试工具为Junit，JDK为Java 1.8。本文的源码均放在了博主的主页，自行下载。

二、实验目的

1、熟悉软件重构常用的方法。

2、掌握java程序打包的方法与相关工具使用。

3、理解驱动测试开发的基本原理与步骤。

三、实验内容

1、根据教材190页6.3.2的案例，对生成混合算式的BinaryOperation类中的构造方法construct进行重构，增加乘法与除法运算。

新增乘法运算代码如下：

新增除法运算代码如下：

2、将程序HealthCalculator.java打包为jar文件，并在另一台电脑上尝试运行这个程序。其中素材HealthCalculator.java代码如下：

package exp6;
/*
提示：体重指数（BMI）是国际通用的衡量人体重的方法，
计算的方法是：BMI=体重（公斤）除以身高（米）平方。
我国专家认为，中国人属亚洲人种，最佳值应该是20-22，
BMI大于22.6为超重，BMI大于30为肥胖。
体重指数, 男性, 女性
过轻：低于20；低于19
适中：20-25； 19-24
过重：25-30； 24-29
肥胖：30-35； 29-34
非常肥胖, 高于35, 高于34
专家指出最理想的体重指数是22。
*/
import java.awt.*;
import javax.swing.*;
import javax.swing.plaf.basic.BasicOptionPaneUI.ButtonActionListener;
import java.awt.event.*;
@SuppressWarnings("serial")
public class HealthCalculator extends JFrame implements ActionListener{
    JTextField height,weight;
    JTextArea result;
    JButton calculate, clear;
    ButtonActionListener listener;
    public HealthCalculator() {
        setLayout(new FlowLayout());
        height = new JTextField(10);
        weight = new JTextField(10);
        weight.setText("输入体重（公斤）");
        height.setText("输入身高（cm）");
        add(height);
        add(weight);
        calculate = new JButton("计算");
        clear = new JButton("清零");
        add(calculate);
        add(clear);
        result = new JTextArea(6,24);
        add(result);
        calculate.addActionListener(this);
        clear.addActionListener(this);
    }
    public void actionPerformed(ActionEvent e) {
        JButton button=(JButton)e.getSource();
        if (button.getText() == "计算"){
            try{
                double h = Double.parseDouble(height.getText());
                double w = Double.parseDouble(weight.getText());
                int r=0;
                String showText;
                r = (int) (100*100*w/h/h);
                if(r<20){
                    result.append("BMI="+r+"\n"+"太轻了，要补充营养。");
                }else if(r<=25){
                    result.append("BMI="+r+"\n"+"恭喜你，标准体形！");
                }else {
                    result.append("BMI="+r+"\n"+"过于肥胖，要减重、加强锻炼。");
                }
                result.append("\n");
            }catch(Exception exp){
                result.setText("身高和体重只能是数字！");
            }
        }else {
            weight.setText("输入体重（公斤）");
            height.setText("输入身高（cm）");
        }
    }
    public static void main(String[] args)
    {
        HealthCalculator win= new HealthCalculator();
        win.setTitle("健康计算器");
        win.setSize(300,180);
        win.setVisible(true);
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );
    }
}

打包流程如下：

（1）首先将其打包成jar文件，选择文件---->项目结构---->工件，如下图所示：

（2）保存在out目录下：

（3）选中右击打开jar包所在目录：

（4）点击jar包所在文件路径，输入cmd，打开小黑框，执行以下命令：

java -jar 名字.jar

运行jar包，得到结果：

（5）后续仅双击程序就可以打开：

3、根据教材193-199页例6.3的步骤，通过设计测试用例来驱动开发类NumberToChinese.

其中测试驱动开发的含义如下：

“测试驱动开发”(Test-Driven Development，TDD)或“测试先行开发”，是一种不同于传统软件开发流程的新型的开发方法。
它要求在编写某个功能的代码前先编写测试代码，然后只编写使测试通过的功能代码，通过测试来推动整个软件的开发。
有助于编写简洁可用和高质量的代码，并加速开发过程。

测试驱动开发的基本过程如下：

(1)编写一个测试，检测待测程序是否满足一个(新增)功能。

(2)运行测试----由于还没有代码，甚至可能都不能通过编译!

(3)编写待测程序足够的代码，并通过编译。

(4)编写待测程序满足测试，直至测试通过。

(5)必要的话重构代码，用测试验证。
(6)重复上述步骤，直到更多的需求都编码实现并通过测试。

本次的目标就是写一个程序将阿拉伯数字转化为中文大写，结合测试驱动开发的思想，对其不断的进行迭代开发，编写各种各样，不同的测试类，不断解决新的问题，得到最后的程序如下。

NumberToChinese类

package exp6;

public class NumberToChinese {
    public String numberToChinese(int number) {
        if (Integer.MAX_VALUE < number || number < 0) {
            throw new RuntimeException(number + " 不在32位正整数范围");
        }
        String infor = "";
        if (number < 10) {
            infor += basicNumber(number);
        } else if (number < 100) {
            infor += tensNumber(number);
        } else if (number < 1000) {
            infor += hundredNumber(number);
        } else if (number < 10000) { //万以内数字
            infor += thousandsNumber(number);
            infor = infor.replaceAll("零+","零");
        } else if (number < 100000000) { //亿以内数字
            infor += wansNumber(number);
            infor = clearChineseZeros(infor);
        } else if (number <= Integer.MAX_VALUE) { //20亿以内数字
            int yis = number / 100000000;
            int rest = number - yis * 100000000;
            if (yis != 0) {
                infor += tensNumber(yis) + "亿";
            }
            else {
                infor += "零";
            }
            if (rest != 0) {
                infor += wansNumber(rest);
            }
            infor = clearChineseZeros(infor);
        }
        return infor;
    }
    private String clearChineseZeros(String infor) {
        infor = infor.replaceAll("零+","零");
        if (infor.indexOf("零") == 0) {
            infor = infor.substring(1);
        }
        return infor;
    }
    private String wansNumber(int number) {
        String infor = "";
        int wans = number / 10000;
        int rest = number - wans * 10000;
        if (wans != 0) {
            infor += thousandsNumber(wans) + "万";
        }
        else {
            infor += "零";
        }
        if (rest != 0) {
            infor += thousandsNumber(rest);
        }
        return infor;
    }
    private String thousandsNumber(int number) {
        String infor = "";
        int thousands = number / 1000;
        int rest = number - thousands * 1000;
        if (thousands != 0) {
            infor += basicNumber(thousands) + "仟";
        }
        else {
            infor += "零";
        }
        if (rest != 0) {
            infor += hundredNumber(rest);
        }
        return infor;
    }
    private String hundredNumber(int number) {
        String infor = "";
        int hundreds = number / 100;
        int rest = number - hundreds * 100;
        if (hundreds != 0) {
            infor += basicNumber(hundreds) + "佰";
        }
        else {
            infor += "零";
        }
        if (rest != 0) {
            infor += tensNumber(rest);
        }
        return infor;
    }
    private String tensNumber(int number) {
        String infor = "";
        int units = number % 10;  //个位数
        int tens = number / 10;  //十位数
        if (tens != 0) {
            infor += basicNumber(tens) + "拾";
        }
        else {
            infor += "零";
        }
        if (units != 0) {
            infor += basicNumber(units);
        }
        return infor;
    }
    public String basicNumber(int number) {
        String infor = "";
        switch (number) {
            case 0:infor += "零"; break;
            case 1:infor += "壹"; break;
            case 2:infor += "贰"; break;
            case 3:infor += "叁"; break;
            case 4:infor += "肆"; break;
            case 5:infor += "伍"; break;
            case 6:infor += "陆"; break;
            case 7:infor += "柒"; break;
            case 8:infor += "捌"; break;
            case 9:infor += "玖"; break;
        }
        return infor;
    }
}

NumberToChineseTest类

package exp6;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

public class NumberToChineseTest {
    NumberToChinese nc;
    @Before
    public void setUp() throws Exception {nc = new NumberToChinese();}
    @Test
    public void testNumberToChineseOne() {
        assertEquals(nc.numberToChinese(1), "壹");
    }
    @Test
    public void testNumberToChineseTwo() {
        assertEquals(nc.numberToChinese(2), "贰");
    }
    @Test
    public void testNumberToChineseZero() {
        assertEquals(nc.numberToChinese(0), "零");
    }
    @Test
    public void testNumberToChineseNine() {
        assertEquals(nc.numberToChinese(9), "玖");
    }
    @Test
    public void testNumberToChinese10() {
        assertEquals(nc.numberToChinese(10), "壹拾");
    }
    @Test
    public void testNumberToChinese11() {
        assertEquals(nc.numberToChinese(11), "壹拾壹");
    }
    @Test
    public void testNumberToChinese19() {
        assertEquals(nc.numberToChinese(19), "壹拾玖");
    }
    @Test
    public void testNumberToChinese99() {
        assertEquals(nc.numberToChinese(99), "玖拾玖");
    }
    @Test
    public void testNumberToChinese999() {
        assertEquals(nc.numberToChinese(999), "玖佰玖拾玖");
    }
    @Test
    public void testNumberToChinese100() {
        assertEquals(nc.numberToChinese(100), "壹佰");
    }
    @Test
    public void testNumberToChinese888() {
        assertEquals(nc.numberToChinese(888), "捌佰捌拾捌");
    }
    @Test
    public void testNumberToChinese101() {
        assertEquals(nc.numberToChinese(101), "壹佰零壹");
    }
    @Test
    public void testNumberToChinese1234() {
        assertEquals(nc.numberToChinese(1234), "壹仟贰佰叁拾肆");
    }
    @Test
    public void testNumberToChinese1008() {
        assertEquals(nc.numberToChinese(1008), "壹仟零捌");
    }
    @Test
    public void testNumberToChinese8000() {
        assertEquals(nc.numberToChinese(8000), "捌仟");
    }
    @Test
    public void testNumberToChinese6600() {
        assertEquals(nc.numberToChinese(6600), "陆仟陆佰");
    }
    @Test
    public void testNumberToChinese4090() {
        assertEquals(nc.numberToChinese(4090), "肆仟零玖拾");
    }
    @Test
    public void testNumberToChinese23456() {
        assertEquals(nc.numberToChinese(23456), "贰万叁仟肆佰伍拾陆");
    }
    @Test
    public void testNumberToChinese11111() {
        assertEquals(nc.numberToChinese(11111), "壹万壹仟壹佰壹拾壹");
    }
    @Test
    public void testNumberToChinese90098() {
        assertEquals(nc.numberToChinese(90098), "玖万零玖拾捌");
    }
    @Test
    public void testNumberToChinese80808() {
        assertEquals(nc.numberToChinese(80808), "捌万零捌佰零捌");
    }
    @Test
    public void testNumberToChinese600006() {
        assertEquals(nc.numberToChinese(600006), "陆拾万零陆");
    }
    @Test
    public void testNumberToChinese123456() {
        assertEquals(nc.numberToChinese(123456), "壹拾贰万叁仟肆佰伍拾陆");
    }
    @Test
    public void testNumberToChinese1234567() {
        assertEquals(nc.numberToChinese(1234567), "壹佰贰拾叁万肆仟伍佰陆拾柒");
    }
    @Test
    public void testNumberToChinese90000009() {
        assertEquals(nc.numberToChinese(90000009), "玖仟万零玖");
    }
    @Test
    public void testNumberToChinese100000000() {
        assertEquals(nc.numberToChinese(100000000), "壹亿");
    }
    @Test
    public void testNumberToChinese2147483647() {
        assertEquals(nc.numberToChinese(2147483647), "贰拾壹亿肆仟柒佰肆拾捌万叁仟陆佰肆拾柒");
    }
    @Test(expected = RuntimeException.class)
    public void testNumberToChinese_1() {
        assertEquals(nc.numberToChinese(-1), "-1 不在32位正整数范围");
    }
}

运行结果如下：