"小明爸爸的四则运算" Android_版

程序一早就写完了，一直没时间写博客，时间也快截止了，还是来写了。

一，需求分析

初步计划是写一个简单的自动控制器给出n道简单的加减乘除的四则运算题目（含表达式和答案），为了方便使用及推广，使用平台android.编译平台eclipse.

用户给出需要的题目量n以及题目内数字个数m，程序取得需求生成n个题目类的实例对象，设置对象的属性数字个数为m，并生成四则运算表达式和答案

二，概要设计

算法方面无特殊，全是基本操作

三，详细设计及编码

安卓基本开发 + 基础程序设计

ActivityMain类

主界面没什么好说的。代码也没几行，获取基本的组件，设置属性，over

EquationActivity类

答题界面，通过主界面交互得到的数据创建适配器，动态显示题目列表

package com.magician.mathmagic.ui;

import android.app.ActionBar;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.ListView;

import com.magician.mathmagic.adapter.AdapterEquation;
import com.magician.mathmagic.controller.Intelligent;
import com.magician.mathmagic.model.Equation;

public class EquationActivity extends Activity {

    private ListView listEquation;
    private AdapterEquation adapterEquation;
    private Intelligent intelligent;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_equation);
        
        ActionBar actionBar = getActionBar();  
        actionBar.setDisplayHomeAsUpEnabled(true);  
        
        initView();
        initData();
    }
    
    private void initView() {

        listEquation = (ListView) findViewById(R.id.list_equation_equationlist);
    }
    
    private void initData() {

        int quantity, grade, numbers, bracket;
        
        Bundle bundle = getIntent().getExtras();
        quantity = bundle.getInt("quantity");
        grade = bundle.getInt("grade");
        numbers = bundle.getInt("numbers");
        bracket = bundle.getInt("bracket");
        
        intelligent = new Intelligent(quantity, grade, numbers, bracket);
        adapterEquation = new AdapterEquation(EquationActivity.this, intelligent);
        int i = 0;
        for (Equation equation : intelligent.getEquationList()) {
            i++;
            System.out.println(i + " " + equation.toString() + " " + equation.getAnswer());
        }
        listEquation.setAdapter(adapterEquation);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.equation, menu);
        return true;
    }

    @Override  
    public boolean onOptionsItemSelected(MenuItem item) {  
        switch (item.getItemId()) {  
        case android.R.id.home:  
            finish();
            return true;
        }
        return false;  
    }  
}

AdapterEquation类

自定义的列表适配器，通过界面层传输的数据给出相应的处理之后返回界面效果给界面层

主要是创建一个管理者对象管理四则运算。

/**************************************************************************************
*
* [Project]
*       MathMagic
* [Package]
*       com.magician.mathmagic.adapter
* [FileName]
*       AdapterEquation.java
* [Copyright]
*       Copyright 2014 brotherYang All Rights Reserved.
* [History]
*        @Version    :    1.0.0
*       @User        :     Administrator
*        @Time        :    2014-10-7 - 下午8:15:08
*        @Auther        :    brotherYang (include18883287887@gamil.com)
*        @Record        :    Create
*
**************************************************************************************/

package com.magician.mathmagic.adapter;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

import android.app.Activity;
import android.content.Context;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.magician.mathmagic.controller.Intelligent;
import com.magician.mathmagic.model.Equation;
import com.magician.mathmagic.ui.R;

public class AdapterEquation extends BaseAdapter{

    private LinkedList<Map<String, String>> aEquationItemData;
    private Map<String, String> aEditorValue;
    private Map<String, String> aAnswer;
     
    private Intelligent intelligent;
    private Equation equation;
    private LayoutInflater aInflater;
    private ViewHolder aHolder;
    private Activity aContext;
    
    public AdapterEquation (Context context, Intelligent intelligent) {
        this.intelligent = intelligent;
        this.aContext = (Activity) context;
        this.aInflater = (LayoutInflater) context
                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            
        init();
    }

    // 初始化
    private void init() {
        aEquationItemData = new LinkedList<Map<String,String>>();
        aEditorValue = new HashMap<String, String>();
        aAnswer = new HashMap<String, String>();
        aEditorValue.clear();
        aAnswer.clear();
        
        for (int i = 0; i < getCount(); i++) {
            aEquationItemData.add(i, null);
        }
    }
         
    @Override
    public int getCount() {
        return intelligent.getEquationList().size();
    }

    @Override
    public Object getItem(int position) {
        return intelligent.getEquationList().get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(final int position, View convertView, ViewGroup parent) {
        if (convertView == null) {
            convertView = aInflater.inflate(R.layout.list_item_equation, null);
            aHolder = new ViewHolder();
            
            aHolder.vBtonSubmit = (Button) convertView.findViewById(R.id.bton_equation_submit);
            aHolder.vTexvWitchOne = (TextView) convertView.findViewById(R.id.texv_equation_witchone);
            aHolder.vTexvEquation = (TextView) convertView.findViewById(R.id.texv_equation_content);
            aHolder.vEditYourAnswer = (EditText) convertView.findViewById(R.id.edit_equation_youranswer);
            aHolder.vTexvAnswer = (TextView) convertView.findViewById(R.id.texv_equation_rightanswer);
            aHolder.vEditYourAnswer.setTag(position);
            aHolder.vBtonSubmit.setTag(position);
            convertView.setTag(aHolder);
            convertView.setId(position);
            ClearHolder(aHolder);
        } else {
            aHolder = (ViewHolder) convertView.getTag();
            ClearHolder(aHolder);
            aHolder.vEditYourAnswer.setTag(position);
            aHolder.vBtonSubmit.setTag(position);
        }

        equation = intelligent.getEquationList().get(position);
        aHolder.vRightAnswer = (equation.getAnswer());
        aHolder.vTexvWitchOne.setText((position+1) + " : ");
        aHolder.vTexvEquation.setText(equation.toString()); 
        
        class ATextWatcher implements TextWatcher {
            public ATextWatcher(ViewHolder holder) {
                mHolder = holder;
            }

            private ViewHolder mHolder;

            @Override
            public void onTextChanged(CharSequence s, int start,
                    int before, int count) {
            }

            @Override
            public void beforeTextChanged(CharSequence s, int start,
                    int count, int after) {
            }

            @Override
            public void afterTextChanged(Editable s) {
                if (s != null && !"".equals(s.toString())) {
                    int position = (Integer) mHolder.vEditYourAnswer.getTag();
                    aEditorValue.put(String.valueOf(position), s.toString());
                    // 当EditText数据发生改变的时候存到data变量中
                }
            }
        }
        
        aHolder.vEditYourAnswer.addTextChangedListener(new ATextWatcher(aHolder));
        aHolder.vEditYourAnswer.setText(null == aEditorValue.get(String.valueOf(position)) ? "" : aEditorValue.get(String.valueOf(position)));
        aHolder.vTexvAnswer.setText(null == aEquationItemData.get(position) ? "" : aEquationItemData.get(position).get("answer"));
        aHolder.vBtonSubmit.setEnabled(!intelligent.getEquationList().get(position).isRight());
        aHolder.vBtonSubmit.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                
                // TODO Auto-generated method stub
                aHolder.vYourAnswer = aEditorValue.get(String.valueOf(position));
                aHolder.vRightAnswer = (intelligent.getEquationList()
                        .get(position).getAnswer());
                int tPosition = (Integer) v.getTag();

                if (null == (aHolder.vYourAnswer)) {
                    Toast.makeText(aContext, "题目 " + (tPosition+1) +" 答案为空！", Toast.LENGTH_SHORT).show();
                    return;
                }
                intelligent.getEquationList().get(tPosition).setAnswered(true);
                if (Double.valueOf(aHolder.vYourAnswer) == (aHolder.vRightAnswer)) {
                    
                    aAnswer = new HashMap<String, String>();
                    aAnswer.put("answer", "回答正确！");
                    aEquationItemData.remove(tPosition);
                    aEquationItemData.add(tPosition, aAnswer);
                    intelligent.getEquationList().get(tPosition).setRight(true);
                } else {
                    aAnswer = new HashMap<String, String>();
                    aAnswer.put("answer", "回答错误！正确答案是 : " + aHolder.vRightAnswer);
                    aEquationItemData.remove(tPosition);
                    aEquationItemData.add(tPosition, aAnswer);
                }
                notifyDataSetChanged();
            }
        });
        
        return convertView;
    }

    /**
     * 
     */
    private void ClearHolder(ViewHolder holder) {
        // TODO Auto-generated method stub
        holder.vTexvWitchOne.setText("");
        holder.vTexvEquation.setText("");
        holder.vTexvAnswer.setText("");
        holder.vEditYourAnswer.setText("");
    }

    public final class ViewHolder {
        public View vBaseView;
        public int vPosition;
        public TextView vTexvWitchOne;
        public TextView vTexvEquation;
        public TextView vTexvAnswer;
        public EditText vEditYourAnswer;
        public Button vBtonSubmit;
        
        public String vEquation;
        public String vYourAnswer;
        public double vRightAnswer;
    }
}

Intelligent类

管理者，适配器传输的数据给出相应的动作，创建四则运算方程式

    /**
     * 方程式集合
     */
    private LinkedList<Equation> equationList;
    
    /**
     * 初始化题目数量
     */
    private int quantity;
    
    /**
     * 构造方程式
     */
    public Intelligent(int quantity, int grade, int numbers, int bracket) {
        // TODO Auto-generated constructor stub
        this.quantity = quantity;
        
        equationList = new LinkedList<Equation>();
        for (int i = 0; i < quantity; i++) {
            equationList.addLast(new Equation(grade, numbers, bracket));
        }
    }

Equation类

方程式，通过初始化各属性生成四则运算表达式以及答案。

/**************************************************************************************
 *
 * [Project]
 *       MathMagic
 * [Package]
 *       com.magician.mathmagic.model
 * [FileName]
 *       Equation.java
 * [Copyright]
 *       Copyright 2014 brotherYang All Rights Reserved.
 * [History]
 *        @Version    :    1.0.0
 *       @User        :     Administrator
 *        @Time        :    2014-10-7 - 下午7:22:16
 *        @Auther        :    brotherYang (include18883287887@gamil.com)
 *        @Record        :    Create
 *
 **************************************************************************************/

package com.magician.mathmagic.model;

import java.text.DecimalFormat;
import java.util.LinkedList;
import java.util.Random;

public class Equation {

    /**
     * 用于存放数的列表
     */
    private LinkedList<String> numberList;

    /**
     * 用于存放計算符号的列表
     */
    private LinkedList<String> arithmeticList;

    private LinkedList<String> calculateList;

    /**
     * 初始化题目难度 - 年级（1-6）
     */
    private int grade;

    /**
     * 初始化几个数字 - 个数（2-3）
     */
    private int numbers;

    /**
     * 初始化是否有括号
     */
    private int bracket;
    
    /**
     * 初始化括号数量
     */
    private int numBracket;

    /**
     * 算法 - （ " + ", " - ", " * ", " / "）
     */
    public static class Arithmetic {

        public static final int plus = 0;
        public static final int minus = 1;
        public static final int multiply = 2;
        public static final int divide = 3;
        public static final int bracket = 0;
        public static final int nobracket = 1;
        public static final int randombracket = 2;
        public static final int[] maxnumber = { 10, 30, 60, 100, 500, 1000 };
        public static final double wrongnumber = -2147483647;
    };

    /**
     * 方程式的答案
     */
    private double answer;

    /**
     * 方程式的字符串
     */
    private StringBuilder stringEquation;

    /**
     * 是否回答
     */
    private boolean isAnswered;

    /**
     * 是否回答正确
     */
    private boolean isRight;

    /**
     * @param grade
     * @param numbers
     * @param isBracket
     */
    public Equation(int grade, int numbers, int bracket) {
        this.grade = grade;
        this.numbers = numbers;
        this.bracket = bracket;

        if (bracket == Arithmetic.randombracket) {
            bracket = new Random().nextInt(2);
        }
        
        if (bracket == Arithmetic.nobracket) {
            numBracket = 0;
        } else {
            numBracket = new Random().nextInt(numbers - 1);
        }
        
        isAnswered = false;
        isRight = false;
        numberList = new LinkedList<String>();
        arithmeticList = new LinkedList<String>();
        calculateList = new LinkedList<String>();
        answer = Arithmetic.wrongnumber;
        stringEquation = new StringBuilder();

        for (int i = 0; i < numbers; i++) {
            numberList.add(String.valueOf((new Random()
                    .nextInt(Arithmetic.maxnumber[3]) + 1)));
            stringEquation.append(numberList.get(i) + " ");
            if (i < numbers - 1) {
                arithmeticList.add(generateArithmetic());
                stringEquation.append(arithmeticList.get(i) + " ");
            }
        }

        calculateAnswer();
    }

    /**
     * 
     */
    private String generateArithmetic() {
        // TODO Auto-generated method stub

        int intArithmetic = new Random().nextInt(4);

        switch (intArithmetic) {
        case Arithmetic.plus:
            return "+";
        case Arithmetic.minus:
            return "-";
        case Arithmetic.multiply:
            return "*";
        case Arithmetic.divide:
            return "/";
        default:
            return null;
        }
    }

    /**
     * (non-Javadoc)
     * 
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return stringEquation.toString();
    }

    /**
     * 
     */
    private void calculateAnswer() {
        // TODO Auto-generated method stub

        for (int i = 0; i < numberList.size(); i++) {
            calculateList.addLast(numberList.get(i));
            while (i < arithmeticList.size()) {
                if (arithmeticList.get(i).equals("*")) {
                    calculateList.addLast(String.valueOf(Double
                            .valueOf(calculateList.removeLast())
                            * Double.valueOf(numberList.remove(i + 1))));
                    arithmeticList.remove(i);
                } else if (arithmeticList.get(i).equals("/")) {
                    calculateList.addLast(String.valueOf(Double
                            .valueOf(calculateList.removeLast())
                            / Double.valueOf(numberList.remove(i + 1))));
                    arithmeticList.remove(i);
                } else {
                    calculateList.addLast(arithmeticList.get(i));
                    break;
                }
            }
        }

        for (String it : calculateList) {
            System.out.println(" content " + it);
        }
        
        while (!calculateList.isEmpty()) {
            if (answer == Arithmetic.wrongnumber) {
                answer = Double.valueOf(calculateList.removeFirst());
                continue;
            }
            String cString = calculateList.removeFirst();
            if (cString.equals("+")) {
                answer += Double.valueOf(calculateList.removeFirst());
                continue;
            } else if (cString.equals("-")) {
                answer -= Double.valueOf(calculateList.removeFirst());
                continue;
            } else {
                System.out.println("Error!");
            }
        }
        
        // 转换保留最后2为小数
        DecimalFormat df = new DecimalFormat(".##");
        answer = Double.valueOf(df.format(answer));
    }

    /**
     * @return the numbers
     */
    public int getNumbers() {
        return numbers;
    }

    /**
     * @param numbers
     *            the numbers to set
     */
    public void setNumbers(int numbers) {
        this.numbers = numbers;
    }

    /**
     * @return the grade
     */
    public int getGrade() {
        return grade;
    }

    /**
     * @param grade
     *            the grade to set
     */
    public void setGrade(int grade) {
        this.grade = grade;
    }

    /**
     * @return the isBracket
     */
    public int getBracket() {
        return bracket;
    }

    /**
     * @param isBracket
     *            the isBracket to set
     */
    public void setBracket(int bracket) {
        this.bracket = bracket;
    }

    /**
     * @return the answer
     */
    public double getAnswer() {
        return answer;
    }

    /**
     * @param answer
     *            the answer to set
     */
    public void setAnswer(double answer) {
        this.answer = answer;
    }

    /**
     * @return the isAnswered
     */
    public boolean isAnswered() {
        return isAnswered;
    }

    /**
     * @param isAnswered
     *            the isAnswered to set
     */
    public void setAnswered(boolean isAnswered) {
        this.isAnswered = isAnswered;
    }

    /**
     * @return the isRight
     */
    public boolean isRight() {
        return isRight;
    }

    /**
     * @param isRight
     *            the isRight to set
     */
    public void setRight(boolean isRight) {
        this.isRight = isRight;
    }
}

四，测试及性能测试

 经过测试，界面不友好，人机交互不友好，存在逻辑上的小bug.

基本操作无误，可以使用。

性能测试

 

 也算是一个性能分析吧，不过也看不出什么来

五，总结

这只是一次小小的软件工程的作业，但里面收获的真的很多，有软件设计的基本流程的进一步巩固，android平台快速开发的经验，代码规范性，软件设计的思想等等，收获颇丰，期待下一次实战。

软件地址：

http://121.42.29.54/upload/MathMagic.apk

百度云盘：

http://pan.baidu.com/s/1bntShm3