50道100以内的加减法口算习题及它的模块化改造

50道100以内的加减法口算习题及它的模块化改造
前言
一、未经过模块化设计的基础代码
- 1.代码示例
- 2.存在的问题
二、分解与模块化
- 1.分解思想
- 2.代码示例
三、选择与设计算法
- 1、习题与算式的分离
- 2、算式产生与其约束条件的分离
- 3、加减法算式的分离
四、模块化改造后的完整代码

前言

对50道100以内的加减法口算习题的代码进行模块化改造，使其运用模块化技术进行分解和细化，设由函数组成的、具有一定结构的程序来分离不同的专注点，管理和控制程序的复杂性，使其便亍维护、更新和扩展。

提示：以下是本篇文章正文内容

一、未经过模块化设计的基础代码

1.代码示例

/**/import java.util.Random;public class BinaryOperation_0 {public static void main(String[] args) {int m = 0, n = 0, value = 0;char o = '+';Random random = new Random();int ov = random.nextInt(2); // 0：加号； 1：减号for (int i = 0; i < 50; i++) {if(ov == 0) {o = '+';do {m = random.nextInt(101);n = random.nextInt(101);value = m + n;}while(value > 100);}else {o = '-';do {m = random.nextInt(101);n = random.nextInt(101);value = m - n;}while(value < 0);}System.out.println((i+1) + "\t:" + m + o + n + " = " + value);ov = random.nextInt(2);}}}

2.存在的问题

• 程序没有明确清晰的“算式”、“习题”的含义，没有使用相应的变量、数据结构等程序设计的
方式表达。

• 若干独立的功能集中在一个函数中丌利亍发现和修改程序中的错诨，也丌便扩充程序的功能。

• 程序修改后，每次都要重新设计一些检验的数据，运行程序、观察结果，判断修改过的程序是否正确，我们希望能保留下检测数据、运行结果及其判断，无须改变地反复使用。

• 编程缺乏觃范。

二、分解与模块化

1.分解思想

采用分解的策略对上一版程序进行重构，产生50道100以内的加减法算式习题

（1）增加一个打印说明 printHeader
（2）产生加减法算式，并存储在数组里 generateEquations()
（3）打印输出习题 printExercise
（4）打印计算结果 printCalculations

2.代码示例

代码如下：

import java.util.Random;public class BinaryOperation_1 {static String[] equs = new String[50];   //存储算式集合的数组static int[] results = new int[50];  // 存储计算结果的数组public static void main(String[] args) {printHeader();  //打印说明generateEquations();  // 产生加减法算式，并存储在数组里printExercise();  //打印输出习题printCalculations();  //打印计算结果}public static void printHeader() {System.out.println("----------------------------------------------");System.out.println("--程序输出50道100以内的加减法算式习题---");System.out.println("--每次运行可得到一套习题和答案---");System.out.println("----------------------------------------------");}public static void generateEquations() {int m = 0, n = 0, value = 0;char o = '+';Random random = new Random();int ov = random.nextInt(2); // 0：加号； 1：减号for (int i = 0; i < 50; i++) {if(ov == 0) {o = '+';do {m = random.nextInt(101);n = random.nextInt(101);value = m + n;}while(value > 100);}else {o = '-';do {m = random.nextInt(101);n = random.nextInt(101);value = m - n;}while(value < 0);}ov = random.nextInt(2);equs[i] = "" + m + o + n + " = ";results[i] = value;}}public static void printExercise() {for(int i = 0; i < equs.length; i++) {System.out.println((i+1) + ":\t" + equs[i]);}}public static void printCalculations() {System.out.println("\n-----以下是习题的答案-------");for(int i = 0; i < results.length; i++) {System.out.println((i+1) + ":\t" + results[i]);}}}

三、选择与设计算法

1、习题与算式的分离

概述：
把习题和算式明确地仍代码中抽出，并分别用合适的数据结构表示，有助于各自的设计和实现。而且，不仅一个程序的数据结构具有丌同的组合方式。如果把数据结构连同对它们的操作也都封装到一个模块——最简单的就是函数，那么，包含了数据与操作的这些函数可以作为程序的模块使用。可以提高程序的结构性和可维护性，如可以替换相同功能、不同实现的模块，而不影响程序的功能。

算式：

 /*** 产生一个加法算式*/public static int[] generateAnAddEquation(int add_max_value, int max_oprt_value) {int m, n, v;int e[] = new int[] {0,0,0,0};do {m = generateOperand(max_oprt_value);  // 产生一个不超过max_oprt_value的操作数n = generateOperand(max_oprt_value);  // 产生一个不超过max_oprt_value的操作数v = m + n;}while(v > add_max_value);e[0] = m; //第一个操作数e[1] = n; //第二个操作数e[2] = 0; //操作符：0--加法；1--减法e[3] = v; // 计算结果return e;}

习题：

/*** 产生加法算式习题集*/public static int[][] generateExerciseOfAdditionEquations(int equ_num, int add_max_value, int max_oprt_value){int m, n;  //操作数int e[];   // 算式     //[操作数1，操作数2，操作符，结果]int[][] exercise = new int[equ_num][4];  int e_index = 0; //目前习题中算式的个数for(int i = 0; i < equ_num; i++) {do {e = generateAnAddEquation(add_max_value, max_oprt_value); //产生一个加法算式}while(occursIn(e, exercise, e_index));  //判断算式e是否出现在习题exercise中exercise[e_index++] = e;   // 把算式e存放在习题exercise中，游标加1}return exercise;}

2、算式产生与其约束条件的分离

• 考虑到程序的可扩展性、可修改性，例如，允许不止一个加法或减法运算，或者将算式数值范围扩大到500、1000等。

• 分别定义运算数生成函数不约束条件检测函数，对满足一定条件的运算数才生成算式。

•满足100 以内整数”的条件不仅适合两个运算数，也适用于其结果。

代码如下：

final int EQUATION_NUM = 50;   // 习题中等式的数量final int ADD_MAX_VALUE = 100; // 加法算式约束：加法结果的最大值   .final int MAX_OPRT_VALUE = 99;  // 算式约束：操作数的最大值final int SUB_MIN_VALUE = 0;    //减法算式约束：减法结果的最小值final int NUM_PER_LINE = 5;    //打印格式：每行算式个数int[][] exercise;              // 习题集二维数组

3、加减法算式的分离

为了能够产生全加、全减和混合三种类型的习题，应当分别编写加法算式和减法算式函数，然后随机地选择这两种算式，就能生成混合运算的习题。

代码如下：

     /* 打印加法算式习题  */printHeader("--程序输出加法算式的习题--");  // 打印输出信息头exercise = generateExerciseOfAdditionEquations(EQUATION_NUM,ADD_MAX_VALUE,MAX_OPRT_VALUE);  // 产生加法算式习题formatAndDisplayExercise(exercise, NUM_PER_LINE); //打印习题/* 打印减法算式习题  */printHeader("--程序输出减法算式的习题--");  // 打印输出信息头exercise = generateExerciseOfSubtractionEquations(EQUATION_NUM,SUB_MIN_VALUE,MAX_OPRT_VALUE);  // 产生加法算式习题formatAndDisplayExercise(exercise, NUM_PER_LINE); //打印习题/* 打印加减法混合算式习题  */printHeader("--程序输出加减法混合算式的习题--");  // 打印输出信息头exercise = generateExerciseOfAddAndSubEquations(EQUATION_NUM,ADD_MAX_VALUE,SUB_MIN_VALUE,MAX_OPRT_VALUE);  // 产生加法算式习题formatAndDisplayExercise(exercise, NUM_PER_LINE); //打印习题

四、模块化改造后的完整代码

import java.util.Random;/*** 产生加法、减法、混合算式习题* （1）采用4元素一维数组存放算式，[操作数1，操作数2，操作符，结果]，操作符：0--加法；1--减法* （2）采用二维数组存放习题[equation_num][4]* （3）产生算式功能模块化* （4）打印功能模块化* @author lenovo**/public class ExerciseGenerator_task3 {public static void main(String[] args) {final int EQUATION_NUM = 50;   // 习题中等式的数量final int ADD_MAX_VALUE = 100; // 加法算式约束：加法结果的最大值   .final int MAX_OPRT_VALUE = 99;  // 算式约束：操作数的最大值final int SUB_MIN_VALUE = 0;    //减法算式约束：减法结果的最小值final int NUM_PER_LINE = 5;    //打印格式：每行算式个数int[][] exercise;              // 习题集二维数组/* 打印加法算式习题  */printHeader("--程序输出加法算式的习题--");  // 打印输出信息头exercise = generateExerciseOfAdditionEquations(EQUATION_NUM,ADD_MAX_VALUE,MAX_OPRT_VALUE);  // 产生加法算式习题formatAndDisplayExercise(exercise, NUM_PER_LINE); //打印习题/* 打印减法算式习题  */printHeader("--程序输出减法算式的习题--");  // 打印输出信息头exercise = generateExerciseOfSubtractionEquations(EQUATION_NUM,SUB_MIN_VALUE,MAX_OPRT_VALUE);  // 产生加法算式习题formatAndDisplayExercise(exercise, NUM_PER_LINE); //打印习题/* 打印加减法混合算式习题  */printHeader("--程序输出加减法混合算式的习题--");  // 打印输出信息头exercise = generateExerciseOfAddAndSubEquations(EQUATION_NUM,ADD_MAX_VALUE,SUB_MIN_VALUE,MAX_OPRT_VALUE);  // 产生加法算式习题formatAndDisplayExercise(exercise, NUM_PER_LINE); //打印习题}/*** 产生加法算式习题集* @param equ_num：习题集中算式的数量* @param add_max_value：加法结果的最大值* @param max_oprt_value：操作数的最大值* @return：返回习题二维数组[equation_num][4]*/public static int[][] generateExerciseOfAdditionEquations(int equ_num, int add_max_value, int max_oprt_value){int m, n;  //操作数int e[];   // 算式     //[操作数1，操作数2，操作符，结果]int[][] exercise = new int[equ_num][4];  int e_index = 0; //目前习题中算式的个数for(int i = 0; i < equ_num; i++) {do {e = generateAnAddEquation(add_max_value, max_oprt_value); //产生一个加法算式}while(occursIn(e, exercise, e_index));  //判断算式e是否出现在习题exercise中exercise[e_index++] = e;   // 把算式e存放在习题exercise中，游标加1}return exercise;}/*** 产生减法算式习题集* @param equ_num：习题集中算式的数量* @param sub_min_value：减法结果的最小值* @param max_oprt_value：操作数的最大值* @return:返回习题二维数组[equation_num][4]*/public static int[][] generateExerciseOfSubtractionEquations( int equ_num, int sub_min_value, int max_oprt_value){int m, n;  //操作数int e[];   // 算式     //[操作数1，操作数2，操作符，结果]int[][] exercise = new int[equ_num][4];  int e_index = 0; //目前习题中算式的个数for(int i = 0; i < equ_num; i++) {do {e = generateAnSubtractEquation(sub_min_value, max_oprt_value); //产生一个减法算式}while(occursIn(e, exercise, e_index));  //判断算式e是否出现在习题exercise中exercise[e_index++] = e;   // 把算式e存放在习题exercise中，游标加1}return exercise;}/*** 产生加减法算式习题集* @param equ_num：习题集中算式的数量* @param add_max_value：加法结果的最大值* @param sub_min_value：减法结果的最小值* @param max_oprt_value：操作数的最大值* @return：返回习题二维数组[equation_num][4]*/public static int[][] generateExerciseOfAddAndSubEquations(int equ_num, int add_max_value, int sub_min_value, int max_oprt_value){int m, n;  //操作数int e[];   // 算式     //[操作数1，操作数2，操作符，结果]int[][] exercise = new int[equ_num][4];  int e_index = 0; //目前习题中算式的个数int operator; //操作符（随机产生）Random random = new Random();for(int i = 0; i < equ_num; i++) {operator = random.nextInt(2); //0---加法；1---减法do {if(operator == 0) { //加法e = generateAnAddEquation(add_max_value, max_oprt_value); //产生一个加法算式}else {  //减法e = generateAnSubtractEquation(sub_min_value, max_oprt_value); //产生一个减法算式}}while(occursIn(e, exercise, e_index));  //判断算式e是否出现在习题exercise中exercise[e_index++] = e;   // 把算式e存放在习题exercise中，游标加1}return exercise;}/*** 产生一个加法算式* @param add_max_value：加法结果的最大值* @param max_oprt_value： 操作数的最大值* @return： 返回一个数组表示的算式[操作数1，操作数2，操作符，结果]，操作符：0--加法；1--减法*/public static int[] generateAnAddEquation(int add_max_value, int max_oprt_value) {int m, n, v;int e[] = new int[] {0,0,0,0};do {m = generateOperand(max_oprt_value);  // 产生一个不超过max_oprt_value的操作数n = generateOperand(max_oprt_value);  // 产生一个不超过max_oprt_value的操作数v = m + n;}while(v > add_max_value);e[0] = m; //第一个操作数e[1] = n; //第二个操作数e[2] = 0; //操作符：0--加法；1--减法e[3] = v; // 计算结果return e;}/*** 产生一个减法算式* @param sub_min_value：减法结果的最小值* @param max_oprt_value： 操作数的最大值* @return： 返回一个数组表示的算式[操作数1，操作数2，操作符，结果]，操作符：0--加法；1--减法*/public static int[] generateAnSubtractEquation(int sub_min_value, int max_oprt_value) {int m, n, v;int e[] = new int[] {0,0,0,0};do {m = generateOperand(max_oprt_value);  // 产生一个不超过max_oprt_value的操作数n = generateOperand(max_oprt_value);  // 产生一个不超过max_oprt_value的操作数v = m - n;}while(v < sub_min_value);e[0] = m; //第一个操作数e[1] = n; //第二个操作数e[2] = 1; //操作符：0--加法；1--减法e[3] = v; // 计算结果return e;}/*** 产生一个不超过 max_value的随机数* @param max_value* @return*/public static int generateOperand(int max_value) {Random random = new Random();return random.nextInt(max_value+1);}/*** 判断算式在习题中是否重复* @param eq： 算式[操作数1，操作数2，操作符，结果]* @param exercise：习题集二维数组* @param index：目前习题中算式的个数（游标）* @return：返回布尔值，重复返回1；不重复返回0.*/public static boolean occursIn(int[] eq, int[][] exercise, int index) {boolean found = false;for(int i = 0; i < index; i++) {if(isEqual(eq, exercise[i])) {found = true;break;}}return found;}/*** 判断两个算式是否相等* @param eq1：第一个算式  [操作数1，操作数2，操作符，结果]* @param eq2：第二个算式  [操作数1，操作数2，操作符，结果]* @return：如果相等，返回1；如果不相等，返回0*/public static boolean isEqual(int[] eq1, int[] eq2) {return (eq1[0] == eq2[0] && eq1[1] == eq2[1] && eq1[2] == eq2[2])|| (eq1[0] == eq2[1] && eq1[1] == eq2[0] && eq1[2] == eq2[2]);}/*** 按格式打印习题集* @param exercise： 习题集二维数组[equation_num][4]* @param num_per_line： 每行显示的算式个数*/public static void formatAndDisplayExercise(int[][] exercise, int num_per_line) {int i, m, n, o, v;int e[];  //算式数组[操作数1，操作数2，操作符，结果]for(i = 0; i < exercise.length; i++) {e = exercise[i];m = e[0];n = e[1];o = e[2];v = e[3];if(i % num_per_line == 0) {System.out.println();System.out.printf("%2d ~ %2d:    ", i+1, i+5);}if(o == 0) {  //加法算式,操作符：0--加法；1--减法System.out.printf("%2d + %2d = %3d    ", m, n, v);}else {System.out.printf("%2d - %2d = %3d    ", m, n, v);}}}/*** 打印输出提示信息* * @param str: 要打印的提示信息*/public static void printHeader(String str) {System.out.println("\n\n------------------------------------");System.out.println(str);System.out.println("------------------------------------");}}