软件构造实验2——模块化软件构造-重构

2020-11-18

实验 模块化软件构造2

一、实验目的

1、掌握模块化设计方法。

  1. 掌握模块分解原理和函数设计方法。
  2. 了解代码编写和文档撰写规范。

二、实验环境与实验要求

  1. JDK,Eclipse 或 idea(可选)
  2. 实验前做好上机实验的准备,针对实验内容,认真复习与本次实验有关的知识,完成实验内容的预习准备工作;
  3. 能认真独立完成各个功能模块的内容;
  4. 实验后做好实验总结,根据实验情况完成总结报告。

三、实验内容

  1. 在实验一的基础上改进设计,功能点如下:

(1)设计类 Equation,它代表一个有两个操作数(short),一个操作符(char)的算式。除了字段对应的 getter、setter,还应覆盖实现 equals 方法。并有抽象(abstract)方法 caculate。

(2)设计子类 AddEquation、SubEquation,它们继承 Equation。

(3)设计习题类 Exercise,它可以产生指定数目的算式,放入 Java 容器中(Vector 或者 HashSet)。要求随机(Random 类)产生的算式操作数及结果应在 0 到 100 内,习题中的算式不重复。

(4)设计打印类 Printer,可打印(标准输出)表头、习题、结果。Printer 是一个通用类,它可以按照指定的列数打印 Java 集合(容器)中的习题及结果

(5)设计 Main 类。读入数目 m 和 n。产生 m 个不重复的算式 Equation(加法或减法),放入 Excercise 中,使用 Printer 打印 Exercise 的习题,打印时每列 n 个算式。

  1. 将上述代码用 Java 语言实现。

java.util.Random 类的 API 文档:

https://www.matools.com/file/manual/jdk_api_1.8_google/index.html?java/util/Random.html

java.util.Vector 类的 API 文档:

https://www.matools.com/file/manual/jdk_api_1.8_google/index.html?java/util/Vector.html

java.util.HashSet 类的 API 文档:

https://www.matools.com/file/manual/jdk_api_1.8_google/index.html?java/util/HashSet.html

java.util.Scanner 类的 API 文档:

https://www.matools.com/file/manual/jdk_api_1.8_google/index.html?java/util/Scanner.html

https://blog.csdn.net/nakahara_chuya/article/details/104684575

关于 equals 方法:

https://blog.csdn.net/changshuchao/article/details/86714875

关于 Java 集合的遍历:

https://www.runoob.com/java/collection-iterator.html

注意事项:

(1)请在程序中加入必要的注释和说明;

(2)请采用规范一致的编程风格编写代码。

四、实验结果

要求:给出代码截图及运行结果;不要截取无关区域;可分块截取,每张截图文字给出文字说明;截图调整大小,以代码中文字与正文文本字体大小相近为宜。

思路:
一、首先要明确为何要创建子类 SubEqutation 和子类 AddEqutation ?
Equtation 属于抽象类,其包含了具有抽象方法 caculate,因此抽象类无法进行实例化,所以要通过子类实现抽象方法并且实例化即:

Equation eq=new AddEquation(left_operation,right_operation);

二、Equation 包含那几个模块?
2.1、定义了左操作数、右操作数、操作符以及对应的 get、set 方法
2.2、需要重写 toString 方法 从而能够将算术表达式打印出来
2.3、需要一个抽象方法 caculate 对表达式进行计算。
2.4、要有对应的构造函数

三、SubEquation、AddEquation 需要实现哪些方法?
3.1、定义变量 ans 记录答案以及对应的 get 方法
3.2、继承自父类 Equation 重写 caculate 方法
3.3、重写构造函数

四、如何实现产生随机数以及存储到 HashSet 中?
如果对 HashSet 不够了解可以转到本博客另外一个笔记中进行学习:链接
4.1、需要重写 Equation 中的 equals 以及 hashCode 方法:因为 HashSet 中存储的对象是 Equtation,所以我们要重新定义 HashSet 的判重规则,即 equals 方法,又因为 equals 方法是要通过 HashCode 的方法进行判重的,因此我们要重写这两个方法。

4.2、输入 n、m-> 利用 Random 函数生成随机数-> 创建子类对象实例化 Equation 并存放到 HashCode 中-> 利用 Printer 类通过增强 for 的形式打印输出对应的信息

代码:

Equtation 类

package com.company;

import java.util.Objects;

public abstract  class Equation {
    private short left_operation;//左操作数
    private short right_operation;//右操作数
    private char op;//操作符

    //
    public Equation(short left_operation, short right_operation, char op) {
        this.right_operation=right_operation;
        this.left_operation=left_operation;
        this.op=op;
    }

    public char getOp() {
        return op;
    }

    public short getLeft_operation() {
        return left_operation;
    }

    public short getRight_operation() {
        return right_operation;
    }

    public void setLeft_operation(short left_operation) {
        this.left_operation = left_operation;
    }

    public void setOp(char op) {
        this.op = op;
    }

    public void setRight_operation(short right_operation) {
        this.right_operation = right_operation;
    }

    //重写toString方法
    @Override
    public String toString() {
        String s="";
        s+=" 算式表达式为:"+left_operation+" "+op+" "+right_operation+" = "+caculate();
        return s;
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Equation equation = (Equation) o;
        return left_operation == equation.left_operation &&
                right_operation == equation.right_operation &&
                op == equation.op;
    }

    @Override
    public int hashCode() {
        return Objects.hash(left_operation, right_operation, op);
    }
    //计算
    public abstract int caculate();
}

AddEquation 类

package com.company;

public class AddEquation extends Equation{
    private short ans;

    public AddEquation(short left_operation, short right_operation) {
        super(left_operation, right_operation, '+');
    }

    //重写计算方法
    @Override
    public int caculate() {
        short left_operation=getLeft_operation();
        short right_operation=getRight_operation();
        char op=super.getOp();
        this.ans= (short) (left_operation+right_operation);
        return  ans;
    }

    public short getAns() {
        return ans;
    }
}

SubEquation 类

package com.company;

public  class SubEquation extends Equation{
    private short ans;

    public SubEquation(short left_operation, short right_operation) {
        super(left_operation, right_operation, '-');
    }

    @Override
    public int caculate() {
        short left_operation=getLeft_operation();
        short right_operation=getRight_operation();
        char op=getOp();
        this.ans= (short) (left_operation-right_operation);
        return ans;
    }

    public short getAns() {
        return ans;
    }
}

Printer 类

package com.company;

import java.util.HashSet;

public class Printer {
    public void print(HashSet<Equation>  eq, int n) {
        int i=0;
        //增强for实现遍历
        for(Equation item:eq){
            System.out.printf(item.toString());
            i++;
            if(i%n==0) System.out.println();//每当有n个算术表达式的时候换行
        }
    }
}

Exercise

package com.company;

import java.util.*;

public class Exercise {
    public static void main(String[] args) {

        //创建集合对象存放算式
        HashSet<Equation>  equations = new HashSet<Equation>();

        //输入
        Scanner sc=new Scanner(System.in);
        int n,m;
        m=sc.nextInt();
        n=sc.nextInt();
        //创建随机数对象
        Random r=new Random();

        //产生1-m个算术表达式
        while(equations.size()<m) {
            short left_operation;
            short right_operation;
            char op;
            left_operation=(short)(r.nextInt(100) + 1);
            right_operation= (short) (r.nextInt(100)+1);
            int num = r.nextInt(2);//0为+ 1位-
           // System.out.println(left_operation+" "+right_operation+" "+num );
            if(num==0) op='+';
            else op='-';
            if(op=='+'){
                Equation eq=new AddEquation(left_operation,right_operation);
                if(eq.caculate()>=0&&eq.caculate()<=100) equations.add(eq);
            }
            else {
                Equation eq=new SubEquation(left_operation,right_operation);
                if(eq.caculate()>=0&&eq.caculate()<=100) equations.add(eq);
            }
        }
       // System.out.println("yes");
        //打印输出
        Printer pt=new Printer();
        pt.print(equations,n);


    }
}

运行截图:

image.png


标题:软件构造实验2——模块化软件构造-重构
作者:xiaob0
地址:https://xiaobo.net.cn/articles/2020/11/18/1605677498751.html