续.第一次冲刺之后.

第一次冲刺：

       每个员可以各自完成自己的分配好的模块

　　罗伟业：加减算术----乘除算式   返回一个完整正确（加减、乘除）的算式<考虑到低年级还没有完全掌握四则混合运算>

　　康取：四则混合运算算式  返回一个完整正确的混合四种运算的算式 <含分数>

　　陈键：四则混合+括号混合  返回一个完整正确的混合四种运算的算式  <含分数>

现在也基本达到了目标 .

基本能够达到预想效果< UI - 。-不堪入目 有待提高.>

在完成过程中想到了

----存储 一些默认设置 比如模式和难度的选择等等的数据
-----增加一个对题 错题的 比较.分数显示.
-----设置输入内容只能是数值 。不能是分数，保留三位小数.<规划输入格式>

package com.example.testc;
import java.math.BigDecimal;
import java.util.Random;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
public class MainActivity extends Activity {
    private Calculator calculator = new Calculator();
    private Double intemp ;    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void onclick(View v) {
        switch (v.getId()) {
        case R.id.createone:
            String a = createOperation();
            calculator.setExpression(a);     
            adjustResult( calculator.getResult() ,"1");
            System.out.println(a + "===" +intemp+ "====" + calculator.getResult());
            break;
        }
    }

    /** 比较答案的对错，精度为0.001 **/
    public boolean adjustResult(String CorrectResult, String userResult) {
        BigDecimal correctAnswer = new BigDecimal(CorrectResult);
        BigDecimal userAnswer = new BigDecimal(userResult);
        double cAnswer;  
        double uAnswer;         
        
          cAnswer = correctAnswer.doubleValue();
          uAnswer = userAnswer.doubleValue();
          int ax = (int) Math.round(cAnswer * 1000) ;
            cAnswer = ax /1000.0;
            intemp=cAnswer;
            if (Math.abs(cAnswer - uAnswer) < 0.001 )
                return true;
        return false;
    }

    public String createOperation() {
        Random seed = new Random();
        final String ADD = "+" + "";
        final String MINUS = "-" + "";
        final String MULTIPLY = "x" + "";
        final String DEVIDE = "/" + "";

        // 操作数的个数.而且最多为五个,默认三个操作数
        int number = 3;
        String datas[] = new String[5];
        String op[] = new String[5];

        /** 生成 操作数个数 **/
        int numberSeeder = seed.nextInt(4) + 1;

        if (numberSeeder == 1)
            number = 3;
        else if (numberSeeder == 2 || numberSeeder == 4)
            number = 4;
        else if (numberSeeder == 3)
            number = 5;

        /** 生成 操作数 跟 符号 **/
        for (int i = 0; i < number; i++) {
            int jud = seed.nextInt(100);
            if (jud < 20) {
                datas[i] = fraction();
            } else if (jud < 100) {
                datas[i] = integerCreater();
            }
            if (i<number-1) {
                /** 操作数的个数都是比符号的个数多一个 **/
                int judp= seed.nextInt(4) + 1;
                if (judp == 1)
                    op[i] = ADD;
                else if (judp == 2)
                    op[i] = MINUS;
                else if (judp == 3)
                    op[i] = MULTIPLY;
                else if (judp== 4)
                    op[i] = DEVIDE;
            }
        }
        return createBrackets(datas, op, number);
    }
    /** create an integer **/
    public String integerCreater() {
        Random seed = new Random();
        String data;
        data = String.valueOf(seed.nextInt(300) + 1);
        return data;
    }
    /** create a fraction **/
    public String fraction() {
        final String DEVIDE = "/" + "";
        final String leftear = "(" + "";
        final String rightear = ")" + "";
        int First = 1, second = 1;
        Random seeder = new Random();
        First = seeder.nextInt(20) + 1;// 分子
        second = seeder.nextInt(20) + 1;// 分母
        return leftear + First + DEVIDE + second + rightear;
    }

    /** brackets block 操作数据数组 、 操作符 、 个数 **/
    public String createBrackets(String datas[], String operator[], int number) {
        final String leftear = "(" + "";
        final String rightear = ")" + "";
        Random seeder = new Random();
        String bracketOperation = null;
        switch (number) {
        case 3:
            if (seeder.nextInt() / 2 == 0)
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + datas[2];
            else
                bracketOperation = datas[0] + operator[0] + leftear + datas[1]
                        + operator[1] + datas[2] + rightear;
            break;
        case 4:
            int temp = seeder.nextInt(21) + 1;
            temp = temp % 7 + 1;
            switch (temp) {
            case 1:// (a+b)x(a+b)
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + leftear + datas[2]
                        + operator[2] + datas[3] + rightear;
                break;
            case 2:// ((a+b)+b)+b
                bracketOperation = leftear + leftear + datas[0] + operator[0]
                        + datas[1] + rightear + operator[1] + datas[2]
                        + rightear + operator[2] + datas[3];
                break;
            case 3:// (a+(a+b))+b
                bracketOperation = leftear + datas[0] + operator[0] + leftear
                        + datas[1] + operator[1] + datas[2] + rightear
                        + rightear + operator[2] + datas[3];
                break;
            case 4:// (a+b)+a+b
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + datas[2] + operator[2]
                        + datas[3];
                break;
            case 5:// a+b+(a+b)
                bracketOperation = datas[0] + operator[0] + datas[1]
                        + operator[1] + leftear + datas[2] + operator[2]
                        + datas[3] + rightear;
                break;
            case 6:// a+(a+b)+b
                bracketOperation = datas[0] + operator[0] + leftear + datas[1]
                        + operator[1] + datas[2] + rightear + operator[2]
                        + datas[3];
                break;
            case 7:// (a+b+c)+a
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + operator[1] + datas[2] + rightear + operator[2]
                        + datas[3];
                break;
            }
            break;
        case 5:
            int dicision = seeder.nextInt(33) + 1;
            dicision = dicision % 9 + 1;
            switch (dicision) {
            case 1:// (a+(a+b))+a+b
                bracketOperation = leftear + datas[0] + operator[0] + leftear
                        + datas[1] + operator[1] + datas[2] + rightear
                        + rightear + operator[2] + datas[3] + operator[3]
                        + datas[4];
                break;
            case 2:// ((a+b)+a)+a+a
                bracketOperation = leftear + leftear + datas[0] + operator[0]
                        + datas[1] + rightear + operator[1] + datas[2]
                        + rightear + operator[2] + datas[3] + operator[3]
                        + datas[4];
                break;
            case 3:// (a+b)x(a+b)+a
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + leftear + datas[2]
                        + operator[2] + datas[3] + rightear + operator[3]
                        + datas[4];
                break;
            case 4:// (a+b)x(a+b+a)
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + leftear + datas[2]
                        + operator[2] + datas[3] + operator[3] + datas[4]
                        + rightear;
                break;
            case 5:// (a+b)x(a+b+c)
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + leftear + datas[2]
                        + operator[2] + datas[3] + operator[3] + datas[4]
                        + rightear;
                break;
            case 6:// (a+b)+a+(a+b)
                bracketOperation = leftear + datas[0] + operator[0] + datas[1]
                        + rightear + operator[1] + datas[2] + operator[2]
                        + leftear + datas[3] + operator[3] + datas[4]
                        + rightear;
                break;
            case 7:// ((a+b)+a)X(a+b)
                bracketOperation = leftear + leftear + datas[0] + operator[0]
                        + datas[1] + rightear + operator[1] + datas[2]
                        + rightear + operator[2] + leftear + datas[3]
                        + operator[3] + datas[4] + rightear;
                break;
            case 8:// (((a+b)+c)+d)+e
                bracketOperation = leftear + leftear + leftear + datas[0]
                        + operator[0] + datas[1] + rightear + operator[1]
                        + datas[2] + rightear + operator[2] + datas[3]
                        + rightear + operator[3] + datas[4];
                break;
            case 9:// a+(a+b+c)+e
                bracketOperation = datas[0] + operator[0] + leftear + datas[1]
                        + operator[1] + datas[2] + operator[2] + datas[3]
                        + rightear + operator[3] + datas[4];
                break;
            }
            break;
        }
        return bracketOperation;
    }

}