用Android Studio制作一个简易的计算器，Android开发经验的有效总结

首先建立按钮（这只是单单的建议按钮，连接按钮的代码在底下）

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

private GridLayout gridlayout;

private EditText edit;

private TextView view;

private Button add;

private Button substact;

private Button multiply;

private Button divide;

private Button seven;

private Button eight;

private Button nine;

private Button left;

private Button four;

private Button five;

private Button six;

private Button right;

private Button three;

private Button two;

private Button one;

private Button Clean;

private Button dot;

private Button zero;

private Button equal;

}

然后把每个按钮和对应的数字符号对应起来

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

gridlayout = (GridLayout) findViewById(R.id.gridlayout);

edit = (EditText) findViewById(R.id.edit);

view = (TextView) findViewById(R.id.view);

add = (Button) findViewById(R.id.add);

substact = (Button) findViewById(R.id.substact);

multiply = (Button) findViewById(R.id.multiply);

divide = (Button) findViewById(R.id.divide);

seven = (Button) findViewById(R.id.seven);

eight = (Button) findViewById(R.id.eight);

nine = (Button) findViewById(R.id.nine);

left = (Button) findViewById(R.id.left);

four = (Button) findViewById(R.id.four);

five = (Button) findViewById(R.id.five);

six = (Button) findViewById(R.id.six);

right = (Button) findViewById(R.id.right);

three = (Button) findViewById(R.id.three);

two = (Button) findViewById(R.id.two);

one = (Button) findViewById(R.id.one);

Clean = (Button) findViewById(R.id.Clean);

dot = (Button) findViewById(R.id.dot);

zero = (Button) findViewById(R.id.zero);

equal = (Button) findViewById(R.id.equal);

edit.setOnClickListener(this);

view.setOnClickListener(this);

add.setOnClickListener(this);

multiply.setOnClickListener(this);

divide.setOnClickListener(this);

dot.setOnClickListener(this);

one.setOnClickListener(this);

two.setOnClickListener(this);

three.setOnClickListener(this);

four.setOnClickListener(this);

five.setOnClickListener(this);

six.setOnClickListener(this);

seven.setOnClickListener(this);

eight.setOnClickListener(this);

nine.setOnClickListener(this);

zero.setOnClickListener(this);

right.setOnClickListener(this);

Clean.setOnClickListener(this);

left.setOnClickListener(this);

equal.setOnClickListener(this);

substact.setOnClickListener(this);

}

记录上一个结果

private String lastresult;

判断当前是否进行计算

private boolean now;

点击按钮后会输出相对应的数字和符号（onClick）

@Override

public void onClick(View v) {

String text = edit.getText().toString();//获取当前文本编译框内容

String lasttext;

boolean clean = false;

Formulautil a = new Formulautil();

if (text.equals(“0”))

{

edit.setText("");

}

switch(v.getId())

{

case R.id.zero:

edit.setText(edit.getText() + “0”);

Clean.setText(“C”);

now = false;

break;

case R.id.one:

edit.setText(edit.getText() + “1”);

Clean.setText(“C”);

now = false;

break;

case R.id.two:

edit.setText(edit.getText() + “2”);

Clean.setText(“C”);

now = false;

break;

case R.id.three:

edit.setText(edit.getText() + “3”);

Clean.setText(“C”);

now = false;

break;

case R.id.four:

edit.setText(edit.getText() + “4”);

Clean.setText(“C”);

now = false;

break;

case R.id.five:

edit.setText(edit.getText() + “5”);

Clean.setText(“C”);

now = false;

break;

case R.id.six:

edit.setText(edit.getText() + “6”);

Clean.setText(“C”);

now = false;

break;

case R.id.seven:

edit.setText(edit.getText() + “7”);

Clean.setText(“C”);

now = false;

break;

case R.id.eight:

edit.setText(edit.getText() + “8”);

Clean.setText(“C”);

now = false;

break;

case R.id.nine:

edit.setText(edit.getText() + “9”);

Clean.setText(“C”);

now = false;

break;

case R.id.dot:

edit.setText(edit.getText() + “.”);

Clean.setText(“C”);

now = false;

break;

case R.id.right:

edit.setText(edit.getText() + “)”);

Clean.setText(“C”);

now = false;

break;

case R.id.left:

edit.setText(edit.getText() + “(”);

Clean.setText(“C”);

now = false;

break;

case R.id.add:

edit.setText(edit.getText() + “+”);

Clean.setText(“C”);

now = false;

break;

case R.id.substact:

edit.setText(edit.getText() + “-”);

Clean.setText(“C”);

now = false;

break;

case R.id.multiply:

edit.setText(edit.getText() + “×”);

Clean.setText(“C”);

now = false;

break;

case R.id.divide:

edit.setText(edit.getText() + “÷”);

Clean.setText(“C”);

now = false;

break;

case R.id.equal:

edit.setText(edit.getText() + “=”);

lasttext = edit.getText().toString();

String a1 = String.valueOf(a.caculate(lasttext));

view.setText(a1);

break;

//清楚操作，保留上一结果，引入计算部分

case R.id.Clean:

edit.setText(“0”);

Clean.setText(“C”);

now = true;

//归零操作，不保留上一次结果

}

}

完成了连接部分，就是最核心的计算部分

3，计算部分（Formulautil.java）

import java.util.Stack;

import java.math.BigDecimal;

public class Formulautil {

/**大致思路是利用栈的出栈入栈压栈来处理一个运算式的先后级排序，进行相映的运算.*/

//数字栈：用于存储表达式中的各个数字

private Stack numberStack = null;

//符号栈：用于存储运算符和括号

private Stack symbolStack = null;

private int scale;//除法时出现循环小数保留精度

public Formulautil(int scale) {

super();

this.scale = scale;

}

public Formulautil() {

this(32);

}

/**从外面把字符串传递进来！！！*/

public BigDecimal caculate(String numStr) {

//判断算数表示是否结束，也就是判断结尾有木有=号！没有给加上！

//equals方法：值的比较

//charAt方法：检索方法

if (numStr.length() > 1

&& !"=".equals(numStr.charAt(numStr.length() - 1) + “”)) {

numStr += “=”;

}

//检查表达式是否是正确的！利用Standard方法(自定义)

if (!isStandard(numStr)) {

String isstandardtext;

isstandardtext = “出错”;

return null;

}

// 初始化栈

if (numberStack == null) {

numberStack = new Stack();

}

numberStack.clear();

if (symbolStack == null) {

symbolStack = new Stack();

}

symbolStack.clear();

/**！！！！！！！！！！核 心！！！！！！！！！！！！*/

//创建一个StringBuffer，用来放多位的数字

StringBuffer temp = new StringBuffer();

// 从表达式的第一个字符开始处理

for (int i = 0; i < numStr.length(); i++) {

// 获取一个字符

char ch = numStr.charAt(i);

// 若当前字符是数字

if (isNumber(ch)) {

// 加入到数字缓存中

temp.append(ch);

} else { // 非数字的情况

// 将数字缓存转为字符串

String tempStr = temp.toString();

if (!tempStr.isEmpty()) {

BigDecimal num = new BigDecimal(tempStr);

// 将数字压栈

numberStack.push(num);

// 重置数字缓存

temp = new StringBuffer();

}

// 判断运算符的优先级，若当前优先级低于栈顶的优先级，则先把计算前面计算出来

while (!comparePri(ch) && !symbolStack.empty()) {

// 出栈，取出数字，后进先出

BigDecimal b = numberStack.pop();

BigDecimal a = numberStack.pop();

// 取出运算符进行相应运算，并把结果压栈进行下一次运算

switch ((char) symbolStack.pop()) {

case ‘+’:

numberStack.push(a.add(b));

break;

case ‘-’:

numberStack.push(a.subtract(b));

break;

case ‘×’:

numberStack.push(a.multiply(b));

break;

case ‘÷’:

try {

numberStack.push(a.divide(b));

} catch (java.lang.ArithmeticException e) {

// 进行除法出现无限循环小数时，就会抛异常，此处设置精度重新计算

numberStack.push(a.divide(b, this.scale,

BigDecimal.ROUND_HALF_EVEN));

}

break;

default:

break;

}

} // while循环结束

if (ch != ‘=’) {

// 符号入栈

symbolStack.push(new Character(ch));

// 去括号

if (ch == ‘)’) {

symbolStack.pop();

symbolStack.pop();

}

}

}

} // for循环结束

// 返回计算结果

return numberStack.pop();

}

/**=检查算数表达式是否合格======*/

private boolean isStandard(String numStr) {

// 表达式不能为空

if (numStr == null || numStr.isEmpty())

return false;

// 用来保存括号，检查左右括号是否匹配

Stack stack = new Stack();

// 用来标记’='符号是否存在多个

boolean b = false;

for (int i = 0; i < numStr.length(); i++) {

char n = numStr.charAt(i);

// 判断字符是否合法

if (!(isNumber(n) || “(”.equals(n + “”) || “)”.equals(n + “”)

|| “+”.equals(n + “”) || “-”.equals(n + “”)

|| “×”.equals(n + “”) || “÷”.equals(n + “”) || “=”.equals(n

• “”))) {

return false;

}

// 将左括号压栈，用来给后面的右括号进行匹配

if ("(".equals(n + “”)) {

stack.pus
h(n);

}

if (")".equals(n + “”)) { // 匹配括号

if (stack.isEmpty() || !"(".equals((char) stack.pop() + “”)) // 括号是否匹配

return false;

}

// 检查是否有多个’='号

if ("=".equals(n + “”)) {

if (b)

return false;

b = true;

}

}

// 可能会有缺少右括号的情况

if (!stack.isEmpty())

return false;

// 检查’='号是否不在末尾

if (!("=".equals(numStr.charAt(numStr.length() - 1) + “”)))

return false;

return true;

}

/**=判断是否是0-9的数字========*/

private boolean isNumber(char num) {

if ((num >= ‘0’ && num <= ‘9’) || num == ‘.’)

return true;

return false;

}

/**====比较优先级，如果当前运算符比栈顶元素运算符优先级高则返回true,否则返回false*/

private boolean comparePri(char symbol) {

// 空栈返回ture

if (symbolStack.empty()) {

return true;

}

/*

我设计得这个计算器加减乘除，lg，ln，括号，三角函数，正常得优先级就是有括号先算括号，然后再乘除，在加减

第一级：（

第二级： × ÷ sin cos tan lg ln

第三级： + -

第四级：）

*/

// 查看堆栈顶部的对象

char top = (char) symbolStack.peek();

if (top == ‘(’) {

return true;

}

// 比较优先级

switch (symbol) {

case ‘(’: // 优先级最高

return true;

// 优先级比’+‘和’-'高

case ‘×’: {

if (top == ‘+’ || top == ‘-’)

return true;

else

return false;

}

// 优先级比’+‘和’-'高

case ‘÷’:

if (top == ‘+’ || top == ‘-’)

return true;

else

return false;

case ‘+’:

return false;

case ‘-’:

return false;

// 优先级最低

case ‘)’:

return false;

// 结束符

case ‘=’:

return false;

default:

break;

}

return true;

}

如果当前运算符比栈顶元素运算符优先级高则返回true,否则返回false==========*/

private boolean comparePri(char symbol) {

// 空栈返回ture

if (symbolStack.empty()) {

return true;

}

/*

我设计得这个计算器加减乘除，lg，ln，括号，三角函数，正常得优先级就是有括号先算括号，然后再乘除，在加减

第一级：（

第二级： × ÷ sin cos tan lg ln

第三级： + -

第四级：）

*/

// 查看堆栈顶部的对象

char top = (char) symbolStack.peek();

if (top == ‘(’) {

return true;

}

// 比较优先级

switch (symbol) {

case ‘(’: // 优先级最高

return true;

// 优先级比’+‘和’-'高

case ‘×’: {

if (top == ‘+’ || top == ‘-’)

return true;

else

return false;

}

// 优先级比’+‘和’-'高

case ‘÷’:

if (top == ‘+’ || top == ‘-’)

return true;

else

return false;

case ‘+’:

return false;

case ‘-’:

return false;

// 优先级最低

case ‘)’:

return false;

// 结束符

case ‘=’:

return false;

default:

break;

}

return true;

}