《个人软件开发流程》——毛锦媛

1.需求分析：

                   1. 根据用户输入的题目个数，产生含有三个数字，两种运算符的题目，并显示出来。

                   2. 根据生成的题目，进行计算，显示计算后的结果。

2. 具体设计：

  各个类的作用：     

        1. Game类：主界面类，显示给用户的。

         2. Subject类：题目类，主要作用：根据用户输入的个数产生题目、对所产生的所有进行计算。

         3. SubjectUtils类：Subject类的工具类，主要作用：产生随机运算符、产生四则运算题、根据传入的题目进行计算。

         4. Utils类：主界面类所用的工具类，主要作用：遍历数组、遍历集合。

         5. TestSubject类：对Subject类里面的方法进行测试。

3.核心代码：

Game类：    主界面

package game;

import java.util.List;
import java.util.Scanner;
import prctice.Subject;
import utils.Utils;

public class Game {
    public static void main(String[] args) {
        Subject subject = new Subject();
        System.out.println("尊敬的顾客，请输入要生成几道题目：");
        Scanner sc = new Scanner(System.in);
        int count = sc.nextInt();
        System.out.println("---------*生成的题目如下*-----------------");
        List<String> allExamp = subject.AllExamp(count);
        Utils.showList(allExamp);
        System.out.println("请输入你的答案：(一题一行):");
        String[] answer = Utils.retrunArray(count);
        for (int i = 0; i < answer.length; i++) {
            String ele = sc.next();
            answer[i]=ele;
        }
        System.out.println("您的答案是:");
        Utils.showArrayElement(answer);
        System.out.println();
        System.out.println("-----------*在线为您解答如下*----------");
        List<String> result = subject.result(allExamp);
        Utils.showList(result);

    }

}

Subject类：  随机产生四则运算的类

package prctice;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

import utils.SubjectUtils;

/**
 * 习题类 定义了生成习题的方法
 * 
 * @author Asus
 *
 */
public class Subject {
    private static String[] fu = { "+", "-", "*", "/" };

    /**
     * 功能1. 根据传入的个数来生成题目
     * 
     * @param List<String>
     */
    public List<String> AllExamp(int count) {
        List<String> examList = new ArrayList<String>();
        for (int i = 0; i < count; i++) {
            String create = SubjectUtils.create();
            examList.add(create);
        }
        return examList;
    }

    /**
     * 功能2.对生成的题目进行运算
     * 
     * @return List<String>
     */

    public List<String> result(List<String> list) {
        List<String> resultList = new ArrayList<String>();
        for (String s : list) {
            String newStr = s.substring(0, s.length() - 1);
            String d = SubjectUtils.count(newStr);
            resultList.add(d);
        }
        return resultList;
    }

}

SubjectUtils类：  Subject类的工具类

package utils;

import java.util.Random;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

import prctice.Subject;

/**
 * Subject类所用的工具类
 * 
 * @author Asus
 *
 */
public class SubjectUtils {
    private static String[] fu = { "+", "-", "*", "/" };

    // 方法一：随机产生运算符
    public static String createFu() {
        Random random = new Random();
        int index = random.nextInt(4);
        return fu[index];
    }

    // 方法二：用于产生四则三维运算题
    public static String create() {
        String ti = " ";
        // 1. 先产生第一位数字
        Random rand = new Random();
        int first = rand.nextInt(100) + 1;
        // 2.产生第二位数字
        int two = rand.nextInt(100) + 1;
        // 3.产生第三位数字
        int three = rand.nextInt(100) + 1;
        // 4.产生运算符
        String fu = SubjectUtils.createFu();
        String fu2 = SubjectUtils.createFu();
        if ((first < two) && fu.equals("-")) {
            ti = two + fu + first + fu2 + three + "=";
        } else if ((first < two) && fu.equals("/")) {
            ti = two + fu + first + fu2 + three + "=";
        } else {
            ti = first + fu + two + fu2 + three + "=";
        }

        return ti;

    }

    // 方法三：对生成的题目进行计算，并以字符串的结果进行返回
    public static String count(String s) {
        ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript");
        Object o_res;
        String res = null;
        try {
            o_res = jse.eval(s);
            String string = o_res.toString();
            if (string.equals(".")) {
                int indexOf = string.indexOf(".");
                String res2 = string.substring(0, indexOf);
                if (res2.equals(".")) {
                    int i2 = res.indexOf(".");
                    res = res2.substring(0, i2);
                } else {
                    res = res2;
                }
            } else {
                res = string;
            }
        } catch (ScriptException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return res;
    }

}

Utils类： Main（）方法的工具类

package utils;

import java.util.List;

/**
 * main测试所用的工具类
 * 
 * @author Asus
 *
 */
public class Utils {
    /**
     * 功能 1 ： 根据用户输入的数，创建对应长度的数组
     */
    public static String[] retrunArray(int length) {
        return new String[length];
    }

    /**
     * 功能2： 根据用户传入的答案数组，遍历输出
     */
    public static void showArrayElement(String[] userArray) {
        System.out.print("[  ");
        for (int i = 0; i < userArray.length; i++) {
            System.out.print(userArray[i]);
            System.out.print(",");
        }
        System.out.print("  ]");
    }

    /**
     * 功能3 ： 根据用户传入的集合，进行遍历
     */
    public static void showList(List<String> userList) {
        for (String s : userList) {
            System.out.println(s);
        }
    }
}

TestSubject类：测试Subject类中的方法

package test;

import java.util.List;
import org.junit.Test;
import prctice.Subject;
import utils.SubjectUtils;

/**
 * 测试编写的四则运算程序
 * 
 * @author Asus
 *
 */
public class TestSubject {
    private Subject subject = new Subject();

    @Test
    // 测试运算符
    public void testFu() {
        String fu = SubjectUtils.createFu();
        String fu2 = SubjectUtils.createFu();
        System.out.println(fu + "->" + fu2);
    }

    // 测试生成表达式
    @Test
    public void testShow() {
        List<String> show = subject.AllExamp(2);
        for (String s : show) {
            System.out.println(s);
        }

    }

    // 测试计算方法
    @Test
    public void testCount() {
        String count = SubjectUtils.count("45+(48/3)+7.8");
        System.out.println(count);
    }

    /**
     * 测试两种方法： 1.生成题目的方法 2.计算结果的方法
     */
    @Test
    public void testResult() {
        List<String> allExamp = subject.AllExamp(5);
        System.out.println("-------------*生成的题目：*--------------");
        for (String s : allExamp) {
            System.out.println(s);
        }
        System.out.println("对应的结果");
        List<String> result = subject.result(allExamp);
        for (String i : result) {
            System.out.println(i);
        }
    }

}

测试结果：    所有方法都已经通过了测试。

 

4.项目的运行结果：

5. PSP（个人软件开发流程）

PSP阶段	预估时间(分钟)	实际时间(分钟)
计划	15	20
明确需求和其他相关因素，估计每个阶段的时间和成本	15	20
开发	370	430
需求分析	20	25
生成设计文档	20	20
设计复审(和同事审核设计文档)	20	25
代码规范(为目前的开发制定合适的规范)	10	15
具体设计	20	25
具体编码	260	270
代码复审	20	25
测试(自测、修改代码、提交修改)	20	25
报告	35	40
测试报告	10	10
计算工作量	10	10
事后总结，并提出过程改进计划	15	20

所查阅的资料：

   　　1.指定范围的随机数如何生成

 　　　 2.Object如何转为String类型

　　　 3.如何对以字符串形式的四则运算式子进行拆分计算

6. 小总结：

1. 具体设计较浪费时间，不断进行了重构，理解了代码是由重构得来的。
2. Java的好多知识都忘记了，需要查好多资料。eg:生成指定范围的字符串。
3. 单元测试能降低集成测试的成本。我每写一个方法后，我都会对其进行测试，根据测试结果判断是哪出了问题，提高了解决问题的能力。
4. 代码编写完成后，考虑可扩展问题，发现没有任何思路，还是自己学的少，学的浅。所以，自己更要对知识学的深入，要对其进行建构，多多扩展知识，还要多写代码，不能光学理论，实践最重要，能加深我们对知识的理解。
5. 遇到一个项目时，只能想到一种做法，这说明自己设计模式没好好学，我将从现在起，去把设计模式的几个原则以及找几个喜欢的设计模式学习一下。
6. 这一次是我自己独立完成一个项目，很有成就感，觉得态度决定一切，你只要想把一件事情干好，什么困难都不会难倒你。