devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android Studio实现简易计算器（带横竖屏，深色浅色模式，更该按钮颜色，selector，style的使用）_androidstudio 计算器代码 横屏

作者：盐析白兔 | 2024-03-27 15:50:52

赞

踩

androidstudio 计算器代码 横屏

目录

前言

运行结果：

运行截屏（p50e）

 apk文件

源码文件

 项目结构

总览

MainActivity.java

drawable

更改图标的方法：

blackbutton.xml

bluebuttons.xml

greybutton.xml

orangebuttons.xml

whitebutton.xml

layout

布局文件

 竖屏：

横屏：

values

        colors.xml

strings.xml

styles

浅色模式

深色模式

themes.xml

前言

        本文章以及之后文章的程序版本使用Android Studio 2022.3.1 Patch 1 版本编辑，使用语言为java，最低支持API 27 Android 8.1，构建工具版本如下：

运行结果：

        先粘贴运行结果和源码文件和apk链接（实机演示，使用模拟器和华为P30和P50E均可执行）本图片为P50E运行截屏

运行截屏（p50e）

        屏幕大小不会导致布局变形，不放视频了，akp可以直接下载使用看一看

 apk文件

i道i的计算器1.0版本apk文件icon-default.png?t=N7T8https://download.csdn.net/download/weixin_58196051/88393857

源码文件

i道i的计算器1.0版本源码文件，注意Android Studio版本，（更低版本能打开，但没有虚拟目录）icon-default.png?t=N7T8https://download.csdn.net/download/weixin_58196051/88393859

 项目结构

不要在意这个文件名为什么

总览

        这是1.0版本里面的编辑模式目录，主函数东西不多，大多都是重复的绑定而已，初学还是看看布局之类的。

这里只是一个记录，具体的建议打开源码看看

AndroidManifest.xml中都是自动生成的，这里只有一个窗口，也没新加注册，我们就不看了。

MainActivity.java

        主函数，这里获取了activity_main.xml中的各种控件引用，并添加了一些监听器之类的常规操作，最后用栈做的方法，中缀表达式转后缀表达式那一套，虽然有近千行，但很多是重复的，注释多看看就没问题，稍微值得注意的就是对onSaveInstanceState方法的重写，保存了一些数据防止在旋转时遗失，然后再在onCreate中读取出来。

  1. package com.example.calculatorddaa;
  2.  
  3.  
  4. import android.content.pm.ActivityInfo;
  5. import android.content.res.Configuration;
  6. import android.os.Bundle;
  7. import android.util.Log;
  8. import android.view.View;
  9. import android.widget.Button;
  10. import android.widget.EditText;
  11. import android.widget.HorizontalScrollView;
  12. import android.widget.TextView;
  13.  
  14. import androidx.annotation.NonNull;
  15. import androidx.appcompat.app.AppCompatActivity;
  16.  
  17. import java.text.NumberFormat;
  18. import java.util.ArrayList;
  19. import java.util.Stack;
  20.  
  21. public class MainActivity extends AppCompatActivity {
  22.     //变量定义
  23.     EditText editText;          //输入框：用于输入数字
  24.     TextView textView, textView_Now, textView_M;          //文本框：显示计算过程,第二个显示当前结果，第三个个显示是否存在记忆。
  25.     HorizontalScrollView horizonLayout_Last, horizonLayout_Now;
  26.     Button button_rotate;   // 按钮，旋转
  27.     Button[] number_buttons = new Button[10];               // 按钮：十个数字
  28.     Button button_add, button_sub, button_mul, button_div;     // 按钮：加减乘除
  29.     Button button_point, button_equal_To, button_C, button_CE;           // 按钮：小数点，等号，清空,退格
  30.     Button button_MR, button_Mup, button_Mdown, button_MC;     // 按钮：读取记忆,记忆加，记忆减，记忆删除
  31.     //下面是横屏按钮
  32.     Button button_left_parenthesis, button_right_parenthesis;// 两个括号
  33.     Button button_e, button_pi;//两个特殊变量
  34.     Button button_reciprocal, button_square, button_cubic_power, button_n_power;// 倒数，二次方，三次方，n次方,
  35.     Button button_square_root, button_cube_root, button_n_root;// 平方根，立方根,n次根
  36.     Button button_inv;// 切换一元运算符的按钮(反函数)
  37.     Button button_ln, button_log;//ln,log
  38.     Button button_sin, button_cos, button_tan;// 三角函数们
  39.     String str_t_digit = "", str_t_equation = "", str_t_Now = "";    // 临时字符串,临时保存输入的数字和表达式和上次结果信息
  40.     Double digit_t = 0.0; // 临时变量
  41.     Integer parenthesis_n = 0;  //未匹配的左括号数目，包含(,^(,三角函数(,ln(,log(
  42.     Boolean mark_inv = true;// 标记变量，标记inv的状态  true正，false反
  43.     ArrayList<Double> input_Double = new ArrayList<>(); // 储存用户输入的数字,用可变数组储存
  44.     ArrayList<String> input_String = new ArrayList<>(); // 储存用户输入的运算符,用可变数组储存
  45.     ArrayList<Boolean> input_Boolean = new ArrayList<>(); // 储存用户输入是否是数字,用可变数组储存，
  46.     //直接入栈的字符串
  47.     ArrayList<String> special_symbols = new ArrayList<String>();
  48.     Double memory = 0.0; //记忆
  49.     NumberFormat nf = NumberFormat.getInstance();//Double转String
  50.  
  51.     private final View.OnClickListener land_switch_onClickListener = new View.OnClickListener() {//横竖屏切换侦听器
  52.         @Override
  53.         public void onClick(View view) {//点击事件
  54.             try {
  55.                 // 获取当前屏幕的方向
  56.                 int currentOrientation = getResources().getConfiguration().orientation;
  57.                 // 根据当前屏幕方向切换屏幕方向
  58.                 if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE) {
  59.                     setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
  60.                 } else {
  61.                     setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  62.                 }
  63.             } catch (Exception e) {
  64.                 Log.e("land_switch", "error");
  65.             }
  66.         }
  67.     };
  68.     private final View.OnClickListener digit_onClickListener = new View.OnClickListener() {//数字侦听器，数字+小数点
  69.         @Override
  70.         public void onClick(View view) {//点击事件
  71.             Button button = (Button) view;   //把点击获得的id信息传递给button
  72.             try {
  73.                 if (!str_t_equation.equals("") && str_t_equation.charAt(str_t_equation.length() - 1) == ')') {//前面是）不让输入数字
  74.                     return;
  75.                 } else if (button.getId() == R.id.button_0) {//如果点击了按钮：“0”
  76.                     if (!(str_t_digit.equals("0"))) {    //之前不是只有一个0，才添0，防止000这样情况出现
  77.                         str_t_digit = str_t_digit + 0;
  78.                     }
  79.                 } else if (button.getId() == R.id.button_point) {
  80.                     if (str_t_digit.contains(".")) { //判断字符串中是否已包含小数点，如果有，就什么也不做
  81.                         return;
  82.                     } else { //如果没有小数点
  83.                         if (str_t_digit.equals("")) {//如果初时显示为空，就替换为"0."
  84.                             str_t_digit = "0.";
  85.                         } else {
  86.                             str_t_digit = str_t_digit + ".";
  87.                         }
  88.                     }
  89.                 } else { // 现在如果只有一个0，就删除0，
  90.                     if (str_t_digit.equals("0")) {
  91.                         str_t_digit = "";
  92.                     }//接下来是1~9的按钮
  93.                     if (button.getId() == R.id.button_1) {//如果点击了按钮：“1”
  94.                         str_t_digit = str_t_digit + 1;//变量末尾，添加一个“1”
  95.                     } else if (button.getId() == R.id.button_2) {//以此类推到9
  96.                         str_t_digit = str_t_digit + 2;
  97.                     } else if (button.getId() == R.id.button_3) {
  98.                         str_t_digit = str_t_digit + 3;
  99.                     } else if (button.getId() == R.id.button_4) {
  100.                         str_t_digit = str_t_digit + 4;
  101.                     } else if (button.getId() == R.id.button_5) {
  102.                         str_t_digit = str_t_digit + 5;
  103.                     } else if (button.getId() == R.id.button_6) {
  104.                         str_t_digit = str_t_digit + 6;
  105.                     } else if (button.getId() == R.id.button_7) {
  106.                         str_t_digit = str_t_digit + 7;
  107.                     } else if (button.getId() == R.id.button_8) {
  108.                         str_t_digit = str_t_digit + 8;
  109.                     } else if (button.getId() == R.id.button_9) {
  110.                         str_t_digit = str_t_digit + 9;
  111.                     } else {
  112.                         Log.e("digit", "error");
  113.                         return;
  114.                     }
  115.                 }
  116.                 editText.setText(str_t_digit);
  117.                 editText.setSelection(editText.getText().length());
  118.             } catch (Exception e) {
  119.                 Log.e("digit", "error");
  120.             }
  121.         }
  122.     };
  123.     private final View.OnClickListener operator_onClickListener = new View.OnClickListener() {//常用运算符侦听器，
  124.         @Override
  125.         public void onClick(View view) {//点击事件
  126.             Button button = (Button) view;   //把点击获得的id信息传递给button
  127.             try {
  128.                 //+,-,*,÷逻辑一样，除零之类的运算时再判断
  129.                 if (!str_t_digit.equals("")) {//有数字
  130.                     digit_t = Double.parseDouble(str_t_digit);// 字符串转数字
  131.                     input_Double.add(digit_t);// 入列
  132.                     //数字添加进表达式字符串
  133.                     str_t_equation += str_t_digit;
  134.                     str_t_digit = "";    //删除之前的数字字符串
  135.                     input_Boolean.add(true);//  入列了一个数字
  136.                     // 根据按钮入列运算符------------------------------
  137.                 } else {// 如果输入数字为空，多种情况，
  138.                     // 前面什么都没有，但是textView_Now不空
  139.                     if (str_t_equation.equals("") && !str_t_Now.equals("") && !str_t_Now.equals("错误")) {
  140.                         //将textView_Now内容当数字进来
  141.                         digit_t = Double.parseDouble(str_t_Now);// 字符串转数字
  142.                         input_Double.add(digit_t);// 入列
  143.                         //数字添加进表达式字符串
  144.                         str_t_equation += str_t_Now;
  145.                         input_Boolean.add(true);//  入列了一个数字
  146.                     } else if (str_t_equation.equals("") || str_t_equation.charAt(str_t_equation.length() - 1) == '(') {
  147.                         //前面什么都没有，或者是包含（的运算符(包含^(,三角函数，ln(,log(
  148.                         if (button.getId() == R.id.button_sub) {//是减号正常加入
  149.                             input_Double.add(0.0);//  入列了一个数字
  150.                             str_t_equation += "0";  // 运算符添加进表达式字符串
  151.                             input_Boolean.add(true);//  入列了一个数字
  152.                             input_String.add("-");  // 入列运算符
  153.                             input_Boolean.add(false);//  入列了一个运算符
  154.                             str_t_equation += "-";  // 运算符添加进表达式字符串
  155.                             editText.setText(str_t_digit);
  156.                             editText.setSelection(editText.getText().length());
  157.                             textView.setText(str_t_equation);
  158.                             horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  159.                             return;
  160.                         } else {// 其他符号不理睬
  161.                             Log.e("operator", "Blank in front");
  162.                             return;
  163.                         }
  164.                     } else {//不是空,不是（，那就是运算符或者数字了
  165.                         if ("+-*/".contains(String.valueOf(str_t_equation.charAt(str_t_equation.length() - 1)))) {//前面是+-*/之一
  166.                             input_String.remove(input_String.size() - 1);   // 删除这个运算符
  167.                             input_Boolean.remove(input_Boolean.size() - 1);
  168.                             str_t_equation = str_t_equation.substring(0, str_t_equation.length() - 1);  //表达式中删除这个运算符
  169.                             //根据运算符添加---------------------
  170.                         }
  171.                         // 是）和数字
  172.                         // 根据按钮入列运算符------------------------------
  173.                     }
  174.                 }
  175.                 if (button.getId() == R.id.button_add) {
  176.                     input_String.add("+");  // 入列运算符
  177.                     str_t_equation += "+";  // 运算符添加进表达式字符串
  178.                 } else if (button.getId() == R.id.button_sub) {
  179.                     input_String.add("-");  // 入列运算符
  180.                     str_t_equation += "-";  // 运算符添加进表达式字符串
  181.                 } else if (button.getId() == R.id.button_mul) {
  182.                     input_String.add("*");  // 入列运算符
  183.                     str_t_equation += "*";  // 运算符添加进表达式字符串
  184.                 } else if (button.getId() == R.id.button_div) {
  185.                     input_String.add("/");  // 入列运算符
  186.                     str_t_equation += "/";  // 运算符添加进表达式字符串
  187.                 } else {
  188.                     Log.e("operator", "error");
  189.                     return;
  190.                 }
  191.                 input_Boolean.add(false);//  入列了一个运算符
  192.                 editText.setText(str_t_digit);
  193.                 editText.setSelection(editText.getText().length());
  194.                 textView.setText(str_t_equation);
  195.                 horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  196.             } catch (Exception e) {
  197.                 Log.e("operator", "error");
  198.             }
  199.         }
  200.  
  201.     };
  202.     private final View.OnClickListener memory_onClickListener = new View.OnClickListener() {//四个记忆功能和e,pi这两个特殊变量
  203.         @Override
  204.         public void onClick(View view) {//点击事件
  205.             Button button = (Button) view;   //把点击获得的id信息传递给button
  206.             try {
  207.                 if (button.getId() == R.id.button_MC) {
  208.                     memory = 0.0;// 清空记忆
  209.                     textView_M.setText("");// 隐藏M标志
  210.                 } else if (!str_t_equation.equals("") && str_t_equation.charAt(str_t_equation.length() - 1) == ')') {//前面是）不让输入数字,也不让MR，e，pi
  211.                     //既然不让输入数字，就更不会出现M+，M-，但MC还能用
  212.                     return;
  213.                 } else if (button.getId() == R.id.button_MR) {
  214.                     if (!textView_M.getText().equals("")) {// 不是空
  215.                         str_t_digit = nf.format(memory);    //替换
  216.                     }
  217.                 } else if (button.getId() == R.id.button_Mup) {
  218.                     if (!str_t_digit.equals("")) {
  219.                         memory += Double.parseDouble(str_t_digit);
  220.                         if (memory != 0.0) {// 是空
  221.                             textView_M.setText("M");// 显示M标志
  222.                         } else {
  223.                             textView_M.setText("");
  224.                         }
  225.                     }
  226.                 } else if (button.getId() == R.id.button_Mdown) {
  227.                     if (!str_t_digit.equals("")) {
  228.                         memory -= Double.parseDouble(str_t_digit);
  229.                         if (memory != 0.0) {// 是空
  230.                             textView_M.setText("M");// 显示M标志
  231.                         } else {
  232.                             textView_M.setText("");
  233.                         }
  234.                     }
  235.                 } else if (button.getId() == R.id.button_e) {
  236.                     digit_t = Math.E;
  237.                     str_t_digit = nf.format(digit_t);
  238.                     ;    //替换
  239.                 } else if (button.getId() == R.id.button_pi) {
  240.                     digit_t = Math.PI;
  241.                     str_t_digit = nf.format(digit_t);
  242.                     ;    //替换
  243.                 } else {
  244.                     Log.e("memory", "error");
  245.                     return;
  246.                 }
  247.                 editText.setText(str_t_digit);
  248.                 editText.setSelection(editText.getText().length());
  249.             } catch (Exception e) {
  250.                 Log.e("memory", "error");
  251.             }
  252.         }
  253.     };
  254.  
  255.     private final View.OnClickListener parenthesis_onClickListener = new View.OnClickListener() {//括号侦听器，
  256.         @Override
  257.         public void onClick(View view) {//点击事件
  258.             Button button = (Button) view;   //把点击获得的id信息传递给button
  259.             try {
  260.                 if (button.getId() == R.id.button_left_parenthesis) {
  261.                     //左括号可以出现在非数字的右边，前面什么都没有也行，如果是数字或者)，前面添加一个乘号
  262.                     if (!input_Boolean.isEmpty() && (input_Boolean.get(input_Boolean.size() - 1) || str_t_equation.charAt(str_t_equation.length() - 1) == ')')) {// 前面有东西，且是数字或者)
  263.                         input_String.add("*");  // 入列运算符
  264.                         input_Boolean.add(false);//  入列了一个运算符
  265.                         str_t_equation += "*";  // 运算符添加进表达式字符串
  266.                     }
  267.                     input_String.add("(");  // 入列运算符
  268.                     parenthesis_n += 1;
  269.                     input_Boolean.add(false);//  入列了一个运算符
  270.                     str_t_equation += "(";  // 运算符添加进表达式字符串
  271.                     textView.setText(str_t_equation);
  272.                     horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  273.                 } else if (button.getId() == R.id.button_right_parenthesis) {
  274.                     //右括号可以出现在数字的右边，和右括号右边，如果没有右括号且当前没有输入数字，什么也不做
  275.                     if (parenthesis_n > 0) {//前面有左括号才能加右括号，
  276.                         if (!str_t_digit.equals("")) {//有数字
  277.                             digit_t = Double.parseDouble(str_t_digit);// 字符串转数字
  278.                             input_Double.add(digit_t);// 入列
  279.                             //数字添加进表达式字符串
  280.                             str_t_equation += str_t_digit;
  281.                             str_t_digit = "";    //删除之前的数字字符串
  282.                             input_Boolean.add(true);//  入列了一个数字
  283.                             editText.setText(str_t_digit);
  284.                             editText.setSelection(editText.getText().length());
  285.                         } else if (str_t_equation.charAt(str_t_equation.length() - 1) != ')') {
  286.                             return;//没括号就润
  287.                         }
  288.                         input_String.add(")");  // 入列运算符
  289.                         parenthesis_n -= 1;
  290.                         input_Boolean.add(false);//  入列了一个运算符
  291.                         str_t_equation += ")";  // 运算符添加进表达式字符串
  292.                         textView.setText(str_t_equation);
  293.                         horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  294.                     }
  295.                 } else {
  296.                     Log.e("parenthesis", "error");
  297.                 }
  298.             } catch (Exception e) {
  299.                 Log.e("parenthesis", "error");
  300.             }
  301.         }
  302.     };
  303.     private final View.OnClickListener index_onClickListener = new View.OnClickListener() {//指数的侦听器，
  304.         @Override
  305.         public void onClick(View view) {//点击事件
  306.             Button button = (Button) view;   //把点击获得的id信息传递给button
  307.             try {// 指数和常用运算符逻辑相似，
  308.                 if (!str_t_digit.equals("")) {//有数字
  309.                     digit_t = Double.parseDouble(str_t_digit);// 字符串转数字
  310.                     input_Double.add(digit_t);// 入列
  311.                     //数字添加进表达式字符串
  312.                     str_t_equation += str_t_digit;
  313.                     str_t_digit = "";    //删除之前的数字字符串
  314.                     input_Boolean.add(true);//  入列了一个数字
  315.                     // 根据按钮入列运算符------------------------------
  316.                 } else {// 如果输入数字为空，多种情况，
  317.                     //前面是+-*/就替换，是）和数字直接加上去,(和""不管
  318.                     // 前面什么都没有，但是textView_Now不空
  319.                     if (str_t_equation.equals("") && !str_t_Now.equals("") && !str_t_Now.equals("错误")) {
  320.                         //将textView_Now内容当数字进来
  321.                         digit_t = Double.parseDouble(str_t_Now);// 字符串转数字
  322.                         input_Double.add(digit_t);// 入列
  323.                         //数字添加进表达式字符串
  324.                         str_t_equation += str_t_Now;
  325.                         input_Boolean.add(true);//  入列了一个数字
  326.                     } else if (str_t_equation.equals("") || str_t_equation.charAt(str_t_equation.length() - 1) == '(') {
  327.                         return;
  328.                     } else {
  329.                         if ("+-*/".contains(String.valueOf(str_t_equation.charAt(str_t_equation.length() - 1)))) {//前面是+-*/之一
  330.                             input_String.remove(input_String.size() - 1);   // 删除这个运算符
  331.                             input_Boolean.remove(input_Boolean.size() - 1);
  332.                             str_t_equation = str_t_equation.substring(0, str_t_equation.length() - 1);  //表达式中删除这个运算符
  333.                             //根据运算符添加---------------------
  334.                         }
  335.                         // 是）和数字
  336.                         // 根据按钮入列运算符------------------------------
  337.                     }
  338.                 }
  339.                 //先添加^(,再根据里面内容加入其他东西
  340.                 input_String.add("^");  // 入列运算符
  341.                 input_Boolean.add(false);//  入列了一个运算符
  342.                 str_t_equation += "^";  // 运算符添加进表达式字符串
  343.                 input_String.add("(");  // 入列运算符
  344.                 input_Boolean.add(false);//  入列了一个运算符
  345.                 str_t_equation += "(";  // 运算符添加进表达式字符串
  346.                 parenthesis_n += 1;
  347.                 if (button.getId() == R.id.button_reciprocal) {
  348.                     input_Double.add(0.0);//  入列了一个数字
  349.                     str_t_equation += "0";  // 运算符添加进表达式字符串
  350.                     input_Boolean.add(true);//  入列了一个数字
  351.                     input_String.add("-");  // 入列运算符
  352.                     input_Boolean.add(false);//  入列了一个运算符
  353.                     str_t_equation += "-";  // 运算符添加进表达式字符串
  354.                     input_Double.add(1.0);//  入列了一个数字
  355.                     str_t_equation += "1";  // 运算符添加进表达式字符串
  356.                     input_Boolean.add(true);//  入列了一个数字
  357.                     input_String.add(")");  // 入列运算符
  358.                     input_Boolean.add(false);//  入列了一个运算符
  359.                     str_t_equation += ")";  // 运算符添加进表达式字符串
  360.                     parenthesis_n -= 1;
  361.                 } else if (button.getId() == R.id.button_square) {
  362.                     input_Double.add(2.0);//  入列了一个数字
  363.                     str_t_equation += "2";  // 运算符添加进表达式字符串
  364.                     input_Boolean.add(true);//  入列了一个数字
  365.                     input_String.add(")");  // 入列运算符
  366.                     input_Boolean.add(false);//  入列了一个运算符
  367.                     str_t_equation += ")";  // 运算符添加进表达式字符串
  368.                     parenthesis_n -= 1;
  369.                 } else if (button.getId() == R.id.button_cubic_power) {
  370.                     input_Double.add(3.0);//  入列了一个数字
  371.                     str_t_equation += "3";  // 运算符添加进表达式字符串
  372.                     input_Boolean.add(true);//  入列了一个数字
  373.                     input_String.add(")");  // 入列运算符
  374.                     input_Boolean.add(false);//  入列了一个运算符
  375.                     str_t_equation += ")";  // 运算符添加进表达式字符串
  376.                     parenthesis_n -= 1;
  377.                 } else if (button.getId() == R.id.button_n_power) {
  378.                     //n次自己输入
  379.                 } else if (button.getId() == R.id.button_square_root) {
  380.                     input_Double.add(1.0);//  入列了一个数字
  381.                     str_t_equation += "1";  // 运算符添加进表达式字符串
  382.                     input_Boolean.add(true);//  入列了一个数字
  383.                     input_String.add("/");  // 入列运算符
  384.                     input_Boolean.add(false);//  入列了一个运算符
  385.                     str_t_equation += "/";  // 运算符添加进表达式字符串
  386.                     input_Double.add(2.0);//  入列了一个数字
  387.                     str_t_equation += "2";  // 运算符添加进表达式字符串
  388.                     input_Boolean.add(true);//  入列了一个数字
  389.                     input_String.add(")");  // 入列运算符
  390.                     input_Boolean.add(false);//  入列了一个运算符
  391.                     str_t_equation += ")";  // 运算符添加进表达式字符串
  392.                     parenthesis_n -= 1;
  393.                 } else if (button.getId() == R.id.button_cube_root) {
  394.  
  395.                     input_Double.add(1.0);//  入列了一个数字
  396.                     str_t_equation += "1";  // 运算符添加进表达式字符串
  397.                     input_Boolean.add(true);//  入列了一个数字
  398.                     input_String.add("/");  // 入列运算符
  399.                     input_Boolean.add(false);//  入列了一个运算符
  400.                     str_t_equation += "/";  // 运算符添加进表达式字符串
  401.                     input_Double.add(3.0);//  入列了一个数字
  402.                     str_t_equation += "3";  // 运算符添加进表达式字符串
  403.                     input_Boolean.add(true);//  入列了一个数字
  404.                     input_String.add(")");  // 入列运算符
  405.                     input_Boolean.add(false);//  入列了一个运算符
  406.                     str_t_equation += ")";  // 运算符添加进表达式字符串
  407.                     parenthesis_n -= 1;
  408.                 } else if (button.getId() == R.id.button_n_root) {
  409.  
  410.                     input_Double.add(1.0);//  入列了一个数字
  411.                     str_t_equation += "1";  // 运算符添加进表达式字符串
  412.                     input_Boolean.add(true);//  入列了一个数字
  413.                     input_String.add("/");  // 入列运算符
  414.                     input_Boolean.add(false);//  入列了一个运算符
  415.                     str_t_equation += "/";  // 运算符添加进表达式字符串
  416.                 } else {
  417.                     Log.e("index", "error");
  418.                     return;
  419.                 }
  420.                 editText.setText(str_t_digit);
  421.                 editText.setSelection(editText.getText().length());
  422.                 textView.setText(str_t_equation);
  423.                 horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  424.             } catch (Exception e) {
  425.                 Log.e("index_onClickListener", "error");
  426.             }
  427.         }
  428.     };
  429.     private final View.OnClickListener unary_operator_onClickListener = new View.OnClickListener() {//一元运算符，包含ln，log三角函数，inv
  430.         @Override
  431.         public void onClick(View view) {//点击事件
  432.             Button button = (Button) view;   //把点击获得的id信息传递给button
  433.             try {//先整inv，//单目运算符逻辑和左括号相似（毕竟包含左括号）
  434.                 if (button.getId() == R.id.button_inv) {
  435.                     mark_inv = !mark_inv;
  436.                     if (mark_inv) {
  437.                         button_sin.setText(R.string.sin);
  438.                         button_cos.setText(R.string.cos);
  439.                         button_tan.setText(R.string.tan);
  440.                     } else {
  441.                         button_sin.setText(R.string.sin_);
  442.                         button_cos.setText(R.string.cos_);
  443.                         button_tan.setText(R.string.tan_);
  444.                     }
  445.                 } else {//可以出现在非数字的右边，前面什么都没有也行，如果是数字或者)，前面添加一个乘号
  446.                     if (!input_Boolean.isEmpty() && (input_Boolean.get(input_Boolean.size() - 1) || str_t_equation.charAt(str_t_equation.length() - 1) == ')')) {// 前面有东西，且是数字或者)
  447.                         input_String.add("*");  // 入列运算符
  448.                         input_Boolean.add(false);//  入列了一个运算符
  449.                         str_t_equation += "*";  // 运算符添加进表达式字符串
  450.                     }
  451.                     if (button.getId() == R.id.button_ln) {
  452.                         input_String.add("ln");  // 入列运算符
  453.                         str_t_equation += "ln";  // 运算符添加进表达式字符串
  454.                     } else if (button.getId() == R.id.button_log) {
  455.                         input_String.add("log");  // 入列运算符
  456.                         str_t_equation += "log";  // 运算符添加进表达式字符串
  457.                     } else if (button.getId() == R.id.button_sin) {
  458.                         if (mark_inv) {
  459.                             input_String.add("sin");  // 入列运算符
  460.                             str_t_equation += "sin";  // 运算符添加进表达式字符串
  461.                         } else {
  462.                             input_String.add("sin⁻¹");  // 入列运算符
  463.                             str_t_equation += "sin⁻¹";  // 运算符添加进表达式字符串
  464.                         }
  465.                     } else if (button.getId() == R.id.button_cos) {
  466.                         if (mark_inv) {
  467.                             input_String.add("cos");  // 入列运算符
  468.                             str_t_equation += "cos";  // 运算符添加进表达式字符串
  469.                         } else {
  470.                             input_String.add("cos⁻¹");  // 入列运算符
  471.                             str_t_equation += "cos⁻¹";  // 运算符添加进表达式字符串
  472.                         }
  473.                     } else if (button.getId() == R.id.button_tan) {
  474.                         if (mark_inv) {
  475.                             input_String.add("tan");  // 入列运算符
  476.                             str_t_equation += "tan";  // 运算符添加进表达式字符串
  477.                         } else {
  478.                             input_String.add("tan⁻¹");  // 入列运算符
  479.                             str_t_equation += "tan⁻¹";  // 运算符添加进表达式字符串
  480.                         }
  481.                     } else {
  482.                         Log.e("unary_operator", "error");
  483.                         return;
  484.                     }
  485.                     input_Boolean.add(false);//  入列了一个运算符
  486.                     //都要进来一个(
  487.                     input_String.add("(");  // 入列运算符
  488.                     parenthesis_n += 1;
  489.                     input_Boolean.add(false);//  入列了一个运算符
  490.                     str_t_equation += "(";  // 运算符添加进表达式字符串
  491.                     textView.setText(str_t_equation);
  492.                     horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  493.                 }
  494.             } catch (Exception e) {
  495.                 Log.e("unary_operator", "error");
  496.             }
  497.         }
  498.     };
  499.     private final View.OnClickListener delete_onClickListener = new View.OnClickListener() {//退位和清空侦听器，
  500.         @Override
  501.         public void onClick(View view) {//点击事件
  502.             Button button = (Button) view;   //把点击获得的id信息传递给button
  503.             try {
  504.                 if (button.getId() == R.id.button_C) {   // 清空，第一次删除数字，然后算式，最后上次结果
  505.                     if (!str_t_digit.equals("")) {    // 有数字
  506.                         str_t_digit = "";//清空数字
  507.                     } else if (!str_t_equation.equals("")) { //有表达式
  508.                         str_t_equation = "";// 清空表达式
  509.                         parenthesis_n = 0;
  510.                         input_String.clear();
  511.                         input_Double.clear();
  512.                         input_Boolean.clear();
  513.                     } else {
  514.                         str_t_Now = "";// 清空上次结果
  515.                     }
  516.                     editText.setText(str_t_digit);
  517.                     editText.setSelection(editText.getText().length());
  518.                     textView.setText(str_t_equation);
  519.                     textView_Now.setText(str_t_Now);
  520.                 } else if (button.getId() == R.id.button_CE) {   // 单纯的数字退格改为没数字退格表达式
  521.                     if (!str_t_digit.equals("")) {    // 有数字
  522.                         str_t_digit = str_t_digit.substring(0, str_t_digit.length() - 1);
  523.                         editText.setText(str_t_digit);
  524.                         editText.setSelection(editText.getText().length());
  525.                     } else {    //  退位表达式，出栈，注意特殊运算符的处理，括号的处理
  526.                         if (!input_Boolean.isEmpty()) {   // 表达式有东西才处理
  527.                             if (input_Boolean.get(input_Boolean.size() - 1)) {    // 最右边是数字,按目前设定不太可能出现这种情况
  528.                                 Log.e("delete", "需要弹出字符串。");
  529.                             } else {
  530.                                 String pop_string = input_String.get(input_String.size() - 1);  // 记录删除的运算符
  531.                                 input_String.remove(input_String.size() - 1);
  532.                                 input_Boolean.remove(input_Boolean.size() - 1);
  533.                                 str_t_equation = str_t_equation.substring(0, str_t_equation.lastIndexOf(pop_string));   // 字符串删除运算符
  534.                                 //(),常用运算符,特殊运算符
  535.                                 if (pop_string.equals("(")) {    //出来的是左括号，判断是左边否为特殊运算符
  536.                                     parenthesis_n -= 1;  //减少未匹配括号
  537.                                     if (!input_Boolean.isEmpty() && !input_Boolean.get(input_Boolean.size() - 1)) {
  538.                                         //前面有东西，并且是运算符，
  539.                                         if (special_symbols.contains(input_String.get(input_String.size() - 1))) {
  540.                                             //而且这个运算符还是特殊运算符
  541.                                             //删除这个特殊运算符
  542.                                             str_t_equation = str_t_equation.substring(0, str_t_equation.lastIndexOf(input_String.get(input_String.size() - 1)));   // 字符串删除特殊运算符
  543.                                             input_String.remove(input_String.size() - 1);
  544.                                             input_Boolean.remove(input_Boolean.size() - 1);
  545.                                         }
  546.                                         //左边还有可能是^（,的形式，也一起删了
  547.                                         else if (input_String.get(input_String.size() - 1).equals("^")) {
  548.                                             str_t_equation = str_t_equation.substring(0, str_t_equation.lastIndexOf(input_String.get(input_String.size() - 1)));   // 字符串删除^
  549.                                             input_String.remove(input_String.size() - 1);
  550.                                             input_Boolean.remove(input_Boolean.size() - 1);
  551.                                             //如果左边是数字一并删除数字
  552.                                             if (!input_Boolean.isEmpty() && input_Boolean.get(input_Boolean.size() - 1)) {
  553.                                                 input_Double.remove(input_Double.size() - 1);
  554.                                                 input_Boolean.remove(input_Boolean.size() - 1);
  555.                                                 if (!input_String.isEmpty()) {
  556.                                                     str_t_equation = str_t_equation.substring(0, str_t_equation.lastIndexOf(input_String.get(input_String.size() - 1)) + input_String.get(input_String.size() - 1).length());   // 字符串删除数字
  557.                                                 } else {    // 前面没东西了
  558.                                                     str_t_equation = "";    //清空
  559.                                                 }
  560.                                             }
  561.                                         }
  562.                                         // +(,-(等不用在意
  563.                                     }
  564.                                 } else {    // 那就是+-*/)
  565.                                     if (pop_string.equals(")")) {    //出来的是右括号，未匹配括号+1
  566.                                         parenthesis_n += 1;  //增加未匹配括号
  567.                                     }
  568.                                     //如果左边是数字一并删除数字
  569.                                     if (!input_Boolean.isEmpty() && input_Boolean.get(input_Boolean.size() - 1)) {
  570.                                         input_Double.remove(input_Double.size() - 1);
  571.                                         input_Boolean.remove(input_Boolean.size() - 1);
  572.                                         if (!input_String.isEmpty()) {
  573.                                             str_t_equation = str_t_equation.substring(0, str_t_equation.lastIndexOf(input_String.get(input_String.size() - 1)) + input_String.get(input_String.size() - 1).length());   // 字符串删除数字
  574.                                         } else {    // 前面没东西了
  575.                                             str_t_equation = "";    //清空
  576.                                         }
  577.                                     }
  578.                                 }
  579.                                 textView.setText(str_t_equation);
  580.                                 horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  581.                             }
  582.                         }
  583.                     }
  584.                 } else {
  585.                     Log.e("delete", "error");
  586.                 }
  587.             } catch (Exception e) {
  588.                 Log.e("delete", "big error");
  589.             }
  590.         }
  591.     };
  592.     private final View.OnClickListener equal_To_onClickListener = new View.OnClickListener() {//等于号侦听器
  593.         @Override
  594.         public void onClick(View view) {//点击事件
  595.             //看看算式最右边是不是除了）的运算符，是的话看看当前有没有数字，有的话加进表达式中
  596.             if (!input_Boolean.isEmpty()) {
  597.                 if (!input_Boolean.get(input_Boolean.size() - 1) && str_t_equation.charAt(str_t_equation.length() - 1) != ')') {
  598.                     //最右边是非）的运算符
  599.                     if (!str_t_digit.equals("")) {//有数字
  600.                         digit_t = Double.parseDouble(str_t_digit);// 字符串转数字
  601.                         input_Double.add(digit_t);// 入列
  602.                         //数字添加进表达式字符串
  603.                         str_t_equation += str_t_digit;
  604.                         str_t_digit = "";    //删除之前的数字字符串
  605.                         input_Boolean.add(true);//  入列了一个数字
  606.                     } else {//没数字就补个0吧
  607.                         digit_t = 0.0;// 字符串转数字
  608.                         input_Double.add(digit_t);// 入列
  609.                         //数字添加进表达式字符串
  610.                         str_t_equation += "0";
  611.                         input_Boolean.add(true);//  入列了一个数字
  612.                     }
  613.                 }
  614.                 if (parenthesis_n > 0) {// 看看当前有没有没写的），有的话加进表达式中，
  615.                     while (parenthesis_n > 0) {
  616.                         input_String.add(")");  // 入列运算符
  617.                         parenthesis_n -= 1;
  618.                         input_Boolean.add(false);//  入列了一个运算符
  619.                         str_t_equation += ")";  // 运算符添加进表达式字符串
  620.                     }
  621.                 }
  622.                 editText.setText(str_t_digit);
  623.                 editText.setSelection(editText.getText().length());
  624.                 textView.setText(str_t_equation);
  625.                 horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  626.                 str_t_Now = count_String();//计算算式
  627.             } else {//表达式什么都没有
  628.                 //直接结果0
  629.                 str_t_Now = "0";
  630.             }
  631.             textView_Now.setText(str_t_Now);
  632.             editText.setText(str_t_digit);
  633.             editText.setSelection(editText.getText().length());
  634.             textView.setText(str_t_equation);
  635.             horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  636.             //清空表达式
  637.             input_String.clear();
  638.             input_Double.clear();
  639.             input_Boolean.clear();
  640.             str_t_equation = "";
  641.             //暂时不需要重新显示，让用户看一会
  642.  
  643.         }
  644.  
  645.         public String count_String() {
  646.             // 对输入的字符串进行计算，如果有错误，返回”错误“，没有返回计算结果
  647.             try {//用栈计算
  648.                 Stack<Double> numStack = new Stack<>();//数字栈
  649.                 Stack<String> symbolStack = new Stack<>();//符号栈
  650.                 String str_pop;// 出栈的运算符
  651.                 int priority1, priority2;
  652.                 Double numeral1, numeral2;
  653.                 // 首尾添加#
  654.                 input_String.add(0, "#");
  655.                 input_Boolean.add(0, false);
  656.                 input_String.add("#");
  657.                 input_Boolean.add(false);
  658.  
  659.                 // 优先级是^>*=/>+=->(=)=单目>#,()和单目运算符特殊处理
  660.                 while (!input_Boolean.isEmpty()) {//没东西就停下
  661.                     if (input_Boolean.get(0)) {//数字直接入数字栈就行
  662.                         input_Boolean.remove(0);
  663.                         numStack.push(input_Double.remove(0));
  664.                     } else {//运算符开始看情况
  665.                         //(,三角函数，ln,log直接入，
  666.                         //按优先级来，优先级高的碰到优先级低的直接入栈，低的碰到高的就出栈计算，
  667.                         if (special_symbols.contains(input_String.get(0)) || "(".equals(input_String.get(0)) || symbolStack.empty()) {
  668.                             //是特殊字符串，或者栈为空，直接入栈
  669.                             input_Boolean.remove(0);
  670.                             symbolStack.push(input_String.remove(0));
  671.                         } else {
  672.                             priority1 = get_priority(input_String.get(0));
  673.                             priority2 = get_priority(symbolStack.peek());
  674.                             if (priority1 == -1 || priority2 == -1) {
  675.                                 Log.e("equal_To", "数字栈不足");
  676.                                 return "错误";
  677.                             }
  678.                             if (priority1 > priority2) {// 否则看看两者优先级
  679.                                 // 如果外面的优先级大，就入栈
  680.                                 input_Boolean.remove(0);
  681.                                 symbolStack.push(input_String.remove(0));
  682.                             } else {//否则，出栈看看
  683.                                 str_pop = symbolStack.pop();//出栈一个运算符
  684.                                 //根据出栈的运算符，判断要做的事情
  685.                                 if (str_pop.equals("(")) {//出来个左括号，后面只有可能是），不然有错误
  686.                                     if (input_String.get(0).equals(")")) {//是）就出栈，并看看前面是不是单目运算符
  687.                                         input_Boolean.remove(0);
  688.                                         input_String.remove(0);
  689.                                         if (special_symbols.contains(symbolStack.peek())) {//前面是特殊运算符
  690.                                             //获得特殊运算符
  691.                                             str_pop = symbolStack.pop();
  692.                                             //出栈一个元素，做出运算后再入栈
  693.                                             numeral1 = numStack.pop();
  694.                                             switch (str_pop) {
  695.                                                 case "ln":
  696.                                                     numStack.push(Math.log(numeral1));
  697.                                                     break;
  698.                                                 case "log":
  699.                                                     numStack.push(Math.log10(numeral1));
  700.                                                     break;
  701.                                                 case "sin":
  702.                                                     numStack.push(Math.sin(numeral1));
  703.                                                     break;
  704.                                                 case "cos":
  705.                                                     numStack.push(Math.cos(numeral1));
  706.                                                     break;
  707.                                                 case "tan":
  708.                                                     numStack.push(Math.tan(numeral1));
  709.                                                     break;
  710.                                                 case "sin⁻¹":
  711.                                                     numStack.push(Math.asin(numeral1));
  712.                                                     break;
  713.                                                 case "cos⁻¹":
  714.                                                     numStack.push(Math.acos(numeral1));
  715.                                                     break;
  716.                                                 case "tan⁻¹":
  717.                                                     numStack.push(Math.atan(numeral1));
  718.                                                     break;
  719.                                                 default:
  720.                                                     Log.e("equal_To", "左括号左边有其他运算符");
  721.                                                     return "错误";
  722.                                             }
  723.                                         }
  724.                                     } else {
  725.                                         Log.e("equal_To", "左括号出栈时，右边不是右括号");
  726.                                         return "错误";
  727.                                     }
  728.                                 } else if (str_pop.equals("#")) {//如果出来个#
  729.                                     input_Boolean.remove(0);// 后面只能一个#，出来吧
  730.                                     input_String.remove(0);// 如果算式正确，循环接下来就会结束
  731.                                 } else {//双目运算符，出来两个数
  732.                                     numeral2 = numStack.pop();//这里就不判断栈是否空了，如果空，会进入try错误处理
  733.                                     numeral1 = numStack.pop();
  734.                                     switch (str_pop) {
  735.                                         case "^":
  736.                                             numStack.push(Math.pow(numeral1, numeral2));
  737.                                             break;
  738.                                         case "+":
  739.                                             numStack.push(numeral1 + numeral2);
  740.                                             break;
  741.                                         case "-":
  742.                                             numStack.push(numeral1 - numeral2);
  743.                                             break;
  744.                                         case "*":
  745.                                             numStack.push(numeral1 * numeral2);
  746.                                             break;
  747.                                         case "/":
  748.                                             if (numeral2 == 0) {
  749.                                                 Log.e("equal_To", "除数为0");
  750.                                                 return "错误";
  751.                                             }
  752.                                             numStack.push(numeral1 / numeral2);
  753.                                             break;
  754.                                         default:
  755.                                             Log.e("equal_To", "非正常常用运算符");
  756.                                             return "错误";
  757.                                     }
  758.                                 }
  759.                             }
  760.                         }
  761.                     }
  762.                 }
  763.                 //循环结束，如果此时符号栈还有东西，或者数字栈多于一个数，就报错
  764.                 if (!symbolStack.empty() || numStack.size() > 1) {
  765.                     Log.e("equal_To", "循环结束后，栈内还有东西");
  766.                     while (!symbolStack.empty()) {
  767.                         Log.e("equal_To", "符号栈内东西有：" + symbolStack.pop());
  768.                     }
  769.                     while (!numStack.empty()) {
  770.                         Log.e("equal_To", "数字栈内东西有：" + numStack.pop().toString());
  771.                     }
  772.                     return "错误";
  773.                 } else {
  774.                     return nf.format(numStack.pop());
  775.                 }
  776.             } catch (Exception e) {
  777.                 Log.e("equal_To", "其他错误" + e.toString());
  778.                 return "错误";
  779.             }
  780.         }
  781.  
  782.         public int get_priority(String str) {// 返回优先级
  783.             switch (str) {
  784.                 case "^":
  785.                     return 4;
  786.                 case "*":
  787.                 case "/":
  788.                     return 3;
  789.                 case "+":
  790.                 case "-":
  791.                     return 2;
  792.                 case "(":
  793.                 case ")":
  794.                     return 1;
  795.                 case "#":
  796.                     return 0;
  797.                 default:
  798.                     return -1;
  799.             }
  800.         }
  801.     };
  802.  
  803.     // 被销毁前缓存一些数据,为了旋转后不出问题
  804.     @Override
  805.     protected void onSaveInstanceState(@NonNull Bundle outState) {
  806.         super.onSaveInstanceState(outState);
  807.         outState.putDouble("memory", memory);
  808.         outState.putInt("parenthesis_n", parenthesis_n);
  809.         outState.putString("str_t_digit", str_t_digit);
  810.         outState.putString("str_t_equation", str_t_equation);
  811.         outState.putString("str_t_Now", str_t_Now);
  812.         outState.putSerializable("input_Double", input_Double);
  813.         outState.putSerializable("input_String", input_String);
  814.         outState.putSerializable("input_Boolean", input_Boolean);
  815.     }
  816.  
  817.     //下面这个重写了父类的方法，会在程序启动时调用，
  818.     @Override
  819.     protected void onCreate(Bundle savedInstanceState) {
  820.         super.onCreate(savedInstanceState);     // 调用父类的onCreate()方法
  821.         setContentView(R.layout.activity_main); // 布局文件的位置
  822.         special_symbols.add("ln");
  823.         special_symbols.add("log");
  824.         special_symbols.add("sin");
  825.         special_symbols.add("cos");
  826.         special_symbols.add("tan");
  827.         special_symbols.add("sin⁻¹");
  828.         special_symbols.add("cos⁻¹");
  829.         special_symbols.add("tan⁻¹");
  830.         nf.setGroupingUsed(false);//不使用12,345,789这样的三位格式化
  831.         nf.setMaximumFractionDigits(16);// 最大保留16位小数
  832.         nf.setMinimumFractionDigits(0);// 最小保留16位小数
  833.         // 获取文本框引用
  834.         editText = findViewById(R.id.textView_Equation);
  835.         textView = findViewById(R.id.textView_Last);
  836.         textView_Now = findViewById(R.id.textView_Now);
  837.         //滚动控件引用
  838.         horizonLayout_Last = findViewById(R.id.horizonLayout_Last);
  839.         horizonLayout_Now = findViewById(R.id.horizonLayout_Now);
  840.         //文本框赋值会自动移动光标到最左边，记着移回最右边
  841.         // 上面带滚动条的把滚动条移到最右边
  842.         // 禁止弹出文本框，并且不允许长按，以防粘贴进奇奇怪怪的东西
  843.         editText.setShowSoftInputOnFocus(false);
  844.         editText.setLongClickable(false);
  845.         if (savedInstanceState != null) {
  846.             // 从保存的 Bundle 中恢复数据
  847.             memory = savedInstanceState.getDouble("memory");
  848.             parenthesis_n = savedInstanceState.getInt("parenthesis_n");
  849.             str_t_digit = savedInstanceState.getString("str_t_digit");
  850.             str_t_equation = savedInstanceState.getString("str_t_equation");
  851.             str_t_Now = savedInstanceState.getString("str_t_Now");
  852.             input_Double = (ArrayList<Double>) savedInstanceState.getSerializable("input_Double");
  853.             input_String = (ArrayList<String>) savedInstanceState.getSerializable("input_String");
  854.             input_Boolean = (ArrayList<Boolean>) savedInstanceState.getSerializable("input_Boolean");
  855.             horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  856.         }
  857.         textView.setText(str_t_equation);
  858.         horizonLayout_Last.fullScroll(View.FOCUS_RIGHT);// 滑动到最右边
  859.         textView_Now.setText(str_t_Now);
  860.         editText.setText(str_t_digit);
  861.         // 光标移动
  862.         editText.setSelection(editText.getText().length());
  863.         // 获取按钮引用
  864.         //旋转
  865.         button_rotate = findViewById(R.id.button_rotate);
  866.         // 数字
  867.         number_buttons[0] = findViewById(R.id.button_0);
  868.         number_buttons[1] = findViewById(R.id.button_1);
  869.         number_buttons[2] = findViewById(R.id.button_2);
  870.         number_buttons[3] = findViewById(R.id.button_3);
  871.         number_buttons[4] = findViewById(R.id.button_4);
  872.         number_buttons[5] = findViewById(R.id.button_5);
  873.         number_buttons[6] = findViewById(R.id.button_6);
  874.         number_buttons[7] = findViewById(R.id.button_7);
  875.         number_buttons[8] = findViewById(R.id.button_8);
  876.         number_buttons[9] = findViewById(R.id.button_9);
  877.         // 小数点
  878.         button_point = findViewById(R.id.button_point);
  879.         // 常用运算符
  880.         button_add = findViewById(R.id.button_add);
  881.         button_sub = findViewById(R.id.button_sub);
  882.         button_mul = findViewById(R.id.button_mul);
  883.         button_div = findViewById(R.id.button_div);
  884.         // 等于号
  885.         button_equal_To = findViewById(R.id.button_equal_To);
  886.         // 两个删除
  887.         button_C = findViewById(R.id.button_C);
  888.         button_CE = findViewById(R.id.button_CE);
  889.         // 记忆变量相关
  890.         textView_M = findViewById(R.id.textView_M);
  891.         if (memory == 0.0) {
  892.             textView_M.setText("");
  893.         }// 隐藏M标志
  894.         button_MC = findViewById(R.id.button_MC);
  895.         button_Mup = findViewById(R.id.button_Mup);
  896.         button_Mdown = findViewById(R.id.button_Mdown);
  897.         button_MR = findViewById(R.id.button_MR);
  898.         // 横屏运算符
  899.         // 两个括号
  900.         button_left_parenthesis = findViewById(R.id.button_left_parenthesis);
  901.         button_right_parenthesis = findViewById(R.id.button_right_parenthesis);
  902.         //两个特殊变量
  903.         button_e = findViewById(R.id.button_e);
  904.         button_pi = findViewById(R.id.button_pi);
  905.         // 倒数，二次方，三次方，n次方,
  906.         button_reciprocal = findViewById(R.id.button_reciprocal);
  907.         button_square = findViewById(R.id.button_square);
  908.         button_cubic_power = findViewById(R.id.button_cubic_power);
  909.         button_n_power = findViewById(R.id.button_n_power);
  910.         // 平方根，立方根,n次根
  911.         button_square_root = findViewById(R.id.button_square_root);
  912.         button_cube_root = findViewById(R.id.button_cube_root);
  913.         button_n_root = findViewById(R.id.button_n_root);
  914.         // 切换一元运算符的按钮(反函数)
  915.         button_inv = findViewById(R.id.button_inv);
  916.         //ln,log
  917.         button_ln = findViewById(R.id.button_ln);
  918.         button_log = findViewById(R.id.button_log);
  919.         // 三角函数们
  920.         button_sin = findViewById(R.id.button_sin);
  921.         button_cos = findViewById(R.id.button_cos);
  922.         button_tan = findViewById(R.id.button_tan);
  923.  
  924.         // 为按钮添加监听器
  925.         button_rotate.setOnClickListener(land_switch_onClickListener);
  926.         button_point.setOnClickListener(digit_onClickListener);
  927.         number_buttons[0].setOnClickListener(digit_onClickListener);
  928.         number_buttons[1].setOnClickListener(digit_onClickListener);
  929.         number_buttons[2].setOnClickListener(digit_onClickListener);
  930.         number_buttons[3].setOnClickListener(digit_onClickListener);
  931.         number_buttons[4].setOnClickListener(digit_onClickListener);
  932.         number_buttons[5].setOnClickListener(digit_onClickListener);
  933.         number_buttons[6].setOnClickListener(digit_onClickListener);
  934.         number_buttons[7].setOnClickListener(digit_onClickListener);
  935.         number_buttons[8].setOnClickListener(digit_onClickListener);
  936.         number_buttons[9].setOnClickListener(digit_onClickListener);
  937.         button_add.setOnClickListener(operator_onClickListener);
  938.         button_sub.setOnClickListener(operator_onClickListener);
  939.         button_mul.setOnClickListener(operator_onClickListener);
  940.         button_div.setOnClickListener(operator_onClickListener);
  941.         button_C.setOnClickListener(delete_onClickListener);
  942.         button_CE.setOnClickListener(delete_onClickListener);
  943.         button_equal_To.setOnClickListener(equal_To_onClickListener);
  944.         button_MC.setOnClickListener(memory_onClickListener);
  945.         button_Mup.setOnClickListener(memory_onClickListener);
  946.         button_Mdown.setOnClickListener(memory_onClickListener);
  947.         button_MR.setOnClickListener(memory_onClickListener);
  948.  
  949.         // 两个括号
  950.         button_left_parenthesis.setOnClickListener(parenthesis_onClickListener);
  951.         button_right_parenthesis.setOnClickListener(parenthesis_onClickListener);
  952.         //两个特殊变量
  953.         button_e.setOnClickListener(memory_onClickListener);
  954.         button_pi.setOnClickListener(memory_onClickListener);
  955.         // 倒数，二次方，三次方，n次方,
  956.         button_reciprocal.setOnClickListener(index_onClickListener);
  957.         button_square.setOnClickListener(index_onClickListener);
  958.         button_cubic_power.setOnClickListener(index_onClickListener);
  959.         button_n_power.setOnClickListener(index_onClickListener);
  960.         // 平方根，立方根,n次根
  961.         button_square_root.setOnClickListener(index_onClickListener);
  962.         button_cube_root.setOnClickListener(index_onClickListener);
  963.         button_n_root.setOnClickListener(index_onClickListener);
  964.         // 切换一元运算符的按钮(反函数)
  965.         button_inv.setOnClickListener(unary_operator_onClickListener);
  966.         //ln,log
  967.         button_ln.setOnClickListener(unary_operator_onClickListener);
  968.         button_log.setOnClickListener(unary_operator_onClickListener);
  969.         // 三角函数们
  970.         button_sin.setOnClickListener(unary_operator_onClickListener);
  971.         button_cos.setOnClickListener(unary_operator_onClickListener);
  972.         button_tan.setOnClickListener(unary_operator_onClickListener);
  973.     }
  974. }

drawable

        drawable中，设置的几个blackbutton之类的，以button或buttons结尾命名的文件是selector，其中是不同颜色的圆角按钮的定义，将设定好的selector用作按钮的背景就可以整出异形按钮了，这里使用的都是圆角按钮。那两个ic打头的本来是初始自带的图标但我更改了图标，所以没什么用了。

更改图标的方法：

        首先把你想整的图片粘贴进drawable目录，虽然是虚拟目录，但能直接粘贴进去。

        使用快捷键Ctrl+Shift+A，会弹出搜索框，输入im选择第一个，就是那个带安卓图标的Image Asset。

 然后把前景替换就行，第二个是背景，我直接设成白色了，图片是我自己画的，怕被拉去要钱。过一段时间整一个个人logo。

 

 具体的在网上查查Image Asset的使用之类的。设置完了就会虚拟目录就会多一个mipmap

blackbutton.xml

这几个按钮的xml都大同小异，看一个剩下的就不用看了，只是改改颜色而已，建议去看看布局。里面的@color/***都是在colors.xml中定义的，八位16进制颜色和6位16进制颜色都可以。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
  3.     <!--按下样式-->
  4.     <item android:state_pressed="true">
  5.         <shape android:shape="rectangle">
  6.             <corners android:radius="50dp"><!--角大小--></corners>
  7.             <solid android:color="@color/c_light_background" ><!--按钮颜色--></solid>
  8.             <stroke android:width="1dp"
  9.                 android:color="@color/c_light_button"><!--边框大小和颜色--></stroke>
  10.         </shape>
  11.     </item>
  12.     <!--平常样式-->
  13.     <item android:state_pressed="false">
  14.         <shape android:shape="rectangle"><!--长方形按钮-->
  15.             <corners android:radius="50dp"><!--角大小--></corners>
  16.             <solid android:color="@color/c_light_button" ><!--按钮颜色--></solid>
  17.             <stroke android:width="1dp"
  18.                 android:color="@color/c_light_button"><!--边框大小和颜色--></stroke>
  19.         </shape>
  20.     </item>
  21. </selector>

bluebuttons.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
  3.     <!--按下样式-->
  4.     <item android:state_pressed="true">
  5.         <shape android:shape="rectangle">
  6.             <corners android:radius="50dp"><!--角大小--></corners>
  7.             <solid android:color="@color/c_blue_" ><!--按钮颜色--></solid>
  8.             <stroke android:width="1dp"
  9.                 android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  10.         </shape>
  11.     </item>
  12.     <!--平常样式-->
  13.     <item android:state_pressed="false">
  14.         <shape android:shape="rectangle"><!--长方形按钮-->
  15.             <corners android:radius="50dp"><!--角大小--></corners>
  16.             <solid android:color="@color/c_blue" ><!--按钮颜色--></solid>
  17.             <stroke android:width="1dp"
  18.                 android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  19.         </shape>
  20.     </item>
  21. </selector>

greybutton.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
  3.     <!--按下样式-->
  4.     <item android:state_pressed="true">
  5.         <shape android:shape="rectangle">
  6.             <corners android:radius="50dp"><!--角大小--></corners>
  7.             <solid android:color="@color/c_dark_grey" ><!--按钮颜色--></solid>
  8.             <stroke android:width="1dp"
  9.                 android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  10.         </shape>
  11.     </item>
  12.     <!--平常样式-->
  13.     <item android:state_pressed="false">
  14.         <shape android:shape="rectangle"><!--长方形按钮-->
  15.             <corners android:radius="50dp"><!--角大小--></corners>
  16.             <solid android:color="@color/c_grey" ><!--按钮颜色--></solid>
  17.             <stroke android:width="1dp"
  18.                 android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  19.         </shape>
  20.     </item>
  21. </selector>

orangebuttons.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
  3.     <!--按下样式-->
  4.     <item android:state_pressed="true">
  5.         <shape android:shape="rectangle">
  6.             <corners android:radius="50dp"><!--角大小--></corners>
  7.             <solid android:color="@color/c_orange_" ><!--按钮颜色--></solid>
  8.             <stroke android:width="1dp"
  9.                 android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  10.         </shape>
  11.     </item>
  12.     <!--平常样式-->
  13.     <item android:state_pressed="false">
  14.         <shape android:shape="rectangle"><!--长方形按钮-->
  15.             <corners android:radius="50dp"><!--角大小--></corners>
  16.             <solid android:color="@color/c_orange" ><!--按钮颜色--></solid>
  17.             <stroke android:width="1dp"
  18.                 android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  19.         </shape>
  20.     </item>
  21. </selector>

whitebutton.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <selector xmlns:android="http://schemas.android.com/apk/res/android">
  3.     <!--按下样式-->
  4.     <item android:state_pressed="true">
  5.         <shape android:shape="rectangle">
  6.             <corners android:radius="50dp"><!--角大小--></corners>
  7.             <solid android:color="@color/c_grey"><!--按钮颜色--></solid>
  8.             <stroke android:width="1dp" android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  9.         </shape>
  10.     </item>
  11.     <!--平常样式-->
  12.     <item android:state_pressed="false">
  13.         <shape android:shape="rectangle"><!--长方形按钮-->
  14.             <corners android:radius="50dp"><!--角大小--></corners>
  15.             <solid android:color="@color/c_white"><!--按钮颜色--></solid>
  16.             <stroke android:width="1dp" android:color="@color/c_dark_grey"><!--边框大小和颜色--></stroke>
  17.         </shape>
  18.     </item>
  19. </selector>

layout

布局文件

布局文件，一个竖屏，一个横屏，横屏刚开始没有，你换成系统目录视图，在layout-land创建就行

 竖屏：

本来使用的网格布局，后来发现p30上显示有问题，换成约束布局了，约束布局就别敲代码了，可视化整的方便些，就是可能会有些卡。约束布局也是大同小异，稍微值得注意的就是这里使用了一些横向滚动容器来装文本控件。使用style来统一设定。

  1. <?xml version="1.0" encoding="utf-8"?><!---->
  2. <!--这是竖屏布局
  3. 最大4列，10行,长宽全占满
  4. -->
  5. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
  6.     xmlns:app="http://schemas.android.com/apk/res-auto"
  7.     xmlns:tools="http://schemas.android.com/tools"
  8.     style="@style/layoutStyle"
  9.     android:layout_width="match_parent"
  10.     android:layout_height="match_parent"
  11.     tools:context=".MainActivity">
  12.  
  13.     <!--第0行有M标志，切换横竖屏的按钮-->
  14.  
  15.     <TextView
  16.         android:id="@+id/textView_M"
  17.         style="@style/lastTextBoxStyle"
  18.         android:text="@string/M"
  19.         app:layout_constraintBottom_toTopOf="@+id/horizonLayout_Last"
  20.         app:layout_constraintHeight_percent="0.05"
  21.         app:layout_constraintStart_toStartOf="parent"
  22.         app:layout_constraintTop_toTopOf="parent"
  23.         app:layout_constraintWidth_percent="0.1" />
  24.  
  25.     <!--占位用-->
  26.  
  27.     <ImageButton
  28.         style="@style/lastTextBoxStyle"
  29.         app:layout_constraintBottom_toTopOf="@+id/horizonLayout_Last"
  30.         app:layout_constraintEnd_toStartOf="@+id/button_rotate"
  31.         app:layout_constraintStart_toEndOf="@+id/textView_M"
  32.         app:layout_constraintTop_toTopOf="parent" />
  33.  
  34.     <Button
  35.         android:id="@+id/button_rotate"
  36.         style="@style/lastTextBoxStyle"
  37.         android:text="@string/rotate"
  38.         app:layout_constraintBottom_toTopOf="@+id/horizonLayout_Last"
  39.         app:layout_constraintEnd_toEndOf="parent"
  40.         app:layout_constraintHeight_percent="0.05"
  41.         app:layout_constraintTop_toTopOf="parent"
  42.         app:layout_constraintWidth_percent="0.1" />
  43.     <!--第1行是上回的结果，叫文本框——上次,
  44. 后来设计有变，改为储存表达式的文本
  45. 初始没文本，在第1行，在第0列，占4列，占1行，
  46. 为了水平滚动，加了滚动容器
  47. -->
  48.     <HorizontalScrollView
  49.         android:id="@+id/horizonLayout_Last"
  50.         style="@style/lastTextBoxStyle"
  51.         android:layout_width="match_parent"
  52.         android:scrollbars="vertical"
  53.         app:layout_constraintEnd_toEndOf="parent"
  54.         app:layout_constraintHeight_percent="0.08"
  55.         app:layout_constraintStart_toStartOf="parent"
  56.         app:layout_constraintTop_toBottomOf="@+id/button_rotate"
  57.         app:layout_constraintWidth_percent="1">
  58.  
  59.         <TextView
  60.             android:id="@+id/textView_Last"
  61.             style="@style/lastTextBoxStyle"
  62.             android:layout_width="wrap_content"
  63.             android:layout_height="match_parent"
  64.             android:layout_gravity="end"
  65.             android:gravity="end"
  66.             android:maxLines="1"
  67.             android:scrollbars="vertical"
  68.             android:text=""
  69.             android:textSize="24sp"
  70.             app:layout_constraintEnd_toEndOf="parent"
  71.             app:layout_constraintStart_toStartOf="parent" />
  72.     </HorizontalScrollView>
  73.  
  74.     <!--第2行是算式，叫文本框——方程
  75. 初始没文本，粗体，在第2行，在第0列，占4列，占1行，
  76. gravity="end"：文本靠右,只显示一行文本，不换行
  77. -->
  78.  
  79.     <!--当前结果
  80. 初始没文本，在第3行，在第0列，占4列，占1行，
  81. gravity="end"：文本靠右-->
  82.  
  83.     <!--第4行 分别是MR，M+，M-,MC，四个按钮-->
  84.     <EditText
  85.         android:id="@+id/textView_Equation"
  86.         style="@style/editTextBoxStyle"
  87.         android:focusableInTouchMode="false"
  88.         android:gravity="right"
  89.         android:marqueeRepeatLimit="marquee_forever"
  90.         android:singleLine="true"
  91.         android:text=""
  92.         android:textSize="50sp"
  93.         app:layout_constraintEnd_toEndOf="parent"
  94.         app:layout_constraintHeight_percent="0.15"
  95.         app:layout_constraintHorizontal_bias="0.0"
  96.         app:layout_constraintStart_toStartOf="parent"
  97.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Last"
  98.         app:layout_constraintWidth_percent="1" />
  99.  
  100.     <HorizontalScrollView
  101.         android:id="@+id/horizonLayout_Now"
  102.         style="@style/lastTextBoxStyle"
  103.         android:scrollbars="vertical"
  104.         app:layout_constraintEnd_toEndOf="parent"
  105.         app:layout_constraintHeight_percent="0.08"
  106.         app:layout_constraintStart_toStartOf="parent"
  107.         app:layout_constraintTop_toBottomOf="@+id/textView_Equation"
  108.         app:layout_constraintWidth_percent="1">
  109.  
  110.         <TextView
  111.             android:id="@+id/textView_Now"
  112.             style="@style/lastTextBoxStyle"
  113.             android:layout_width="wrap_content"
  114.             android:layout_height="match_parent"
  115.             android:layout_gravity="end"
  116.             android:gravity="end"
  117.             android:maxLines="1"
  118.             android:scrollbars="vertical"
  119.             android:text=""
  120.             android:textSize="20sp"
  121.             app:layout_constraintEnd_toEndOf="parent"
  122.             app:layout_constraintStart_toStartOf="parent" />
  123.  
  124.     </HorizontalScrollView>
  125.  
  126.     <Button
  127.         android:id="@+id/button_MR"
  128.         style="@style/normalButtonStyle"
  129.         android:text="@string/MR"
  130.         android:textSize="25sp"
  131.         app:layout_constraintBottom_toTopOf="@+id/button_C"
  132.         app:layout_constraintEnd_toStartOf="@+id/button_Mup"
  133.         app:layout_constraintHeight_percent="0.1"
  134.         app:layout_constraintStart_toStartOf="parent"
  135.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  136.         app:layout_constraintWidth_percent="0.22" />
  137.  
  138.     <Button
  139.         android:id="@+id/button_Mup"
  140.         style="@style/normalButtonStyle"
  141.         android:text="@string/Mup"
  142.         android:textSize="25sp"
  143.         app:layout_constraintBottom_toTopOf="@+id/button_div"
  144.         app:layout_constraintEnd_toStartOf="@+id/button_Mdown"
  145.         app:layout_constraintHeight_percent="0.1"
  146.         app:layout_constraintStart_toEndOf="@+id/button_MR"
  147.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  148.         app:layout_constraintWidth_percent="0.22" />
  149.  
  150.     <Button
  151.         android:id="@+id/button_Mdown"
  152.         style="@style/normalButtonStyle"
  153.         android:text="@string/Mdown"
  154.         android:textSize="25sp"
  155.         app:layout_constraintBottom_toTopOf="@+id/button_mul"
  156.         app:layout_constraintEnd_toStartOf="@+id/button_MC"
  157.         app:layout_constraintHeight_percent="0.1"
  158.         app:layout_constraintStart_toEndOf="@+id/button_Mup"
  159.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  160.         app:layout_constraintWidth_percent="0.22" />
  161.  
  162.     <Button
  163.         android:id="@+id/button_MC"
  164.         style="@style/deleteButtonStyle"
  165.         android:text="@string/MC"
  166.         android:textSize="25sp"
  167.         app:layout_constraintBottom_toTopOf="@+id/button_CE"
  168.         app:layout_constraintEnd_toEndOf="parent"
  169.         app:layout_constraintHeight_percent="0.1"
  170.         app:layout_constraintStart_toEndOf="@+id/button_Mdown"
  171.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  172.         app:layout_constraintWidth_percent="0.22" />
  173.     <!--第5行 分别是C，/，*,CE，四个按钮-->
  174.  
  175.     <Button
  176.         android:id="@+id/button_C"
  177.         style="@style/specialButtonsStyle"
  178.         android:text="@string/C"
  179.         android:textSize="25sp"
  180.         app:layout_constraintBottom_toTopOf="@+id/button_7"
  181.         app:layout_constraintEnd_toStartOf="@+id/button_div"
  182.         app:layout_constraintHeight_percent="0.1"
  183.         app:layout_constraintStart_toStartOf="parent"
  184.         app:layout_constraintTop_toBottomOf="@+id/button_MR"
  185.         app:layout_constraintWidth_percent="0.22" />
  186.  
  187.     <Button
  188.         android:id="@+id/button_div"
  189.         style="@style/specialButtonsStyle"
  190.         android:text="@string/div"
  191.         android:textSize="25sp"
  192.         app:layout_constraintBottom_toTopOf="@+id/button_8"
  193.         app:layout_constraintEnd_toStartOf="@+id/button_mul"
  194.         app:layout_constraintHeight_percent="0.1"
  195.         app:layout_constraintStart_toEndOf="@+id/button_C"
  196.         app:layout_constraintTop_toBottomOf="@+id/button_Mup"
  197.         app:layout_constraintWidth_percent="0.22" />
  198.  
  199.     <Button
  200.         android:id="@+id/button_mul"
  201.         style="@style/specialButtonsStyle"
  202.         android:text="@string/mul"
  203.         android:textSize="25sp"
  204.         app:layout_constraintBottom_toTopOf="@+id/button_8"
  205.         app:layout_constraintEnd_toStartOf="@+id/button_CE"
  206.         app:layout_constraintHeight_percent="0.1"
  207.         app:layout_constraintStart_toEndOf="@+id/button_div"
  208.         app:layout_constraintTop_toBottomOf="@+id/button_Mdown"
  209.         app:layout_constraintWidth_percent="0.22" />
  210.  
  211.     <Button
  212.         android:id="@+id/button_CE"
  213.         style="@style/deleteButtonStyle"
  214.         android:text="@string/CE"
  215.         android:textSize="25sp"
  216.         app:layout_constraintBottom_toTopOf="@+id/button_sub"
  217.         app:layout_constraintEnd_toEndOf="parent"
  218.         app:layout_constraintHeight_percent="0.1"
  219.         app:layout_constraintStart_toEndOf="@+id/button_mul"
  220.         app:layout_constraintTop_toBottomOf="@+id/button_MC"
  221.         app:layout_constraintWidth_percent="0.22" />
  222.     <!--剩下4行的第3列 分别是-，+，=,三个按钮，等于占两列-->
  223.  
  224.     <Button
  225.         android:id="@+id/button_sub"
  226.         style="@style/specialButtonsStyle"
  227.         android:text="@string/sub"
  228.         android:textSize="25sp"
  229.         app:layout_constraintBottom_toTopOf="@+id/button_add"
  230.         app:layout_constraintEnd_toEndOf="parent"
  231.         app:layout_constraintHeight_percent="0.1"
  232.         app:layout_constraintStart_toEndOf="@+id/button_9"
  233.         app:layout_constraintTop_toBottomOf="@+id/button_CE"
  234.         app:layout_constraintWidth_percent="0.22" />
  235.  
  236.     <Button
  237.         android:id="@+id/button_add"
  238.         style="@style/specialButtonsStyle"
  239.         android:text="@string/add"
  240.         android:textSize="25sp"
  241.         app:layout_constraintBottom_toTopOf="@+id/button_equal_To"
  242.         app:layout_constraintEnd_toEndOf="parent"
  243.         app:layout_constraintHeight_percent="0.1"
  244.         app:layout_constraintStart_toEndOf="@+id/button_6"
  245.         app:layout_constraintTop_toBottomOf="@+id/button_sub"
  246.         app:layout_constraintWidth_percent="0.22" />
  247.  
  248.     <!--10个数字和小数点，其中0占两列-->
  249.  
  250.     <Button
  251.         android:id="@+id/button_equal_To"
  252.         style="@style/equaltoButtonStyle"
  253.         android:text="@string/equal_To"
  254.         android:textSize="25sp"
  255.         app:layout_constraintBottom_toBottomOf="parent"
  256.         app:layout_constraintEnd_toEndOf="parent"
  257.         app:layout_constraintHeight_percent="0.21"
  258.         app:layout_constraintStart_toEndOf="@+id/button_3"
  259.         app:layout_constraintTop_toBottomOf="@+id/button_add"
  260.         app:layout_constraintWidth_percent="0.22" />
  261.  
  262.     <Button
  263.         android:id="@+id/button_point"
  264.         style="@style/digitButtonStyle"
  265.         android:text="@string/point"
  266.         android:textSize="25sp"
  267.         app:layout_constraintBottom_toBottomOf="parent"
  268.         app:layout_constraintEnd_toStartOf="@+id/button_equal_To"
  269.         app:layout_constraintHeight_percent="0.1"
  270.         app:layout_constraintStart_toEndOf="@+id/button_0"
  271.         app:layout_constraintTop_toBottomOf="@+id/button_3"
  272.         app:layout_constraintWidth_percent="0.22" />
  273.  
  274.     <Button
  275.         android:id="@+id/button_0"
  276.         style="@style/digitButtonStyle"
  277.         android:text="@string/_0"
  278.         android:textSize="25sp"
  279.         app:layout_constraintBottom_toBottomOf="parent"
  280.         app:layout_constraintEnd_toStartOf="@+id/button_point"
  281.         app:layout_constraintHeight_percent="0.1"
  282.         app:layout_constraintStart_toStartOf="parent"
  283.         app:layout_constraintTop_toBottomOf="@+id/button_2"
  284.         app:layout_constraintWidth_percent="0.47" />
  285.  
  286.     <Button
  287.         android:id="@+id/button_1"
  288.         style="@style/digitButtonStyle"
  289.         android:text="@string/_1"
  290.         android:textSize="25sp"
  291.         app:layout_constraintBottom_toTopOf="@+id/button_0"
  292.         app:layout_constraintEnd_toStartOf="@+id/button_2"
  293.         app:layout_constraintHeight_percent="0.1"
  294.         app:layout_constraintStart_toStartOf="parent"
  295.         app:layout_constraintTop_toBottomOf="@+id/button_4"
  296.         app:layout_constraintWidth_percent="0.22" />
  297.  
  298.     <Button
  299.         android:id="@+id/button_2"
  300.         style="@style/digitButtonStyle"
  301.         android:text="@string/_2"
  302.         android:textSize="25sp"
  303.         app:layout_constraintBottom_toTopOf="@+id/button_0"
  304.         app:layout_constraintEnd_toStartOf="@+id/button_3"
  305.         app:layout_constraintHeight_percent="0.1"
  306.         app:layout_constraintStart_toEndOf="@+id/button_1"
  307.         app:layout_constraintTop_toBottomOf="@+id/button_5"
  308.         app:layout_constraintWidth_percent="0.22" />
  309.  
  310.     <Button
  311.         android:id="@+id/button_3"
  312.         style="@style/digitButtonStyle"
  313.         android:text="@string/_3"
  314.         android:textSize="25sp"
  315.         app:layout_constraintBottom_toTopOf="@+id/button_point"
  316.         app:layout_constraintEnd_toStartOf="@+id/button_equal_To"
  317.         app:layout_constraintHeight_percent="0.1"
  318.         app:layout_constraintStart_toEndOf="@+id/button_2"
  319.         app:layout_constraintTop_toBottomOf="@+id/button_5"
  320.         app:layout_constraintWidth_percent="0.22" />
  321.  
  322.     <Button
  323.         android:id="@+id/button_4"
  324.         style="@style/digitButtonStyle"
  325.         android:text="@string/_4"
  326.         android:textSize="25sp"
  327.         app:layout_constraintBottom_toTopOf="@+id/button_1"
  328.         app:layout_constraintEnd_toStartOf="@+id/button_5"
  329.         app:layout_constraintHeight_percent="0.1"
  330.         app:layout_constraintStart_toStartOf="parent"
  331.         app:layout_constraintTop_toBottomOf="@+id/button_7"
  332.         app:layout_constraintWidth_percent="0.22" />
  333.  
  334.     <Button
  335.         android:id="@+id/button_5"
  336.         style="@style/digitButtonStyle"
  337.         android:text="@string/_5"
  338.         android:textSize="25sp"
  339.         app:layout_constraintBottom_toTopOf="@+id/button_2"
  340.         app:layout_constraintEnd_toStartOf="@+id/button_6"
  341.         app:layout_constraintHeight_percent="0.1"
  342.         app:layout_constraintStart_toEndOf="@+id/button_4"
  343.         app:layout_constraintTop_toBottomOf="@+id/button_8"
  344.         app:layout_constraintWidth_percent="0.22" />
  345.  
  346.     <Button
  347.         android:id="@+id/button_6"
  348.         style="@style/digitButtonStyle"
  349.         android:text="@string/_6"
  350.         android:textSize="25sp"
  351.         app:layout_constraintBottom_toTopOf="@+id/button_3"
  352.         app:layout_constraintEnd_toStartOf="@+id/button_add"
  353.         app:layout_constraintHeight_percent="0.1"
  354.         app:layout_constraintStart_toEndOf="@+id/button_5"
  355.         app:layout_constraintTop_toBottomOf="@+id/button_9"
  356.         app:layout_constraintWidth_percent="0.22" />
  357.  
  358.     <Button
  359.         android:id="@+id/button_7"
  360.         style="@style/digitButtonStyle"
  361.         android:text="@string/_7"
  362.         android:textSize="25sp"
  363.         app:layout_constraintBottom_toTopOf="@+id/button_4"
  364.         app:layout_constraintEnd_toStartOf="@+id/button_8"
  365.         app:layout_constraintHeight_percent="0.1"
  366.         app:layout_constraintStart_toStartOf="parent"
  367.         app:layout_constraintTop_toBottomOf="@+id/button_C"
  368.         app:layout_constraintWidth_percent="0.22" />
  369.  
  370.     <Button
  371.         android:id="@+id/button_8"
  372.         style="@style/digitButtonStyle"
  373.         android:text="@string/_8"
  374.         android:textSize="25sp"
  375.         app:layout_constraintBottom_toTopOf="@+id/button_5"
  376.         app:layout_constraintEnd_toStartOf="@+id/button_9"
  377.         app:layout_constraintHeight_percent="0.1"
  378.         app:layout_constraintStart_toEndOf="@+id/button_7"
  379.         app:layout_constraintTop_toBottomOf="@+id/button_div"
  380.         app:layout_constraintWidth_percent="0.22" />
  381.  
  382.     <Button
  383.         android:id="@+id/button_9"
  384.         style="@style/digitButtonStyle"
  385.         android:text="@string/_9"
  386.         android:textSize="25sp"
  387.         app:layout_constraintBottom_toTopOf="@+id/button_6"
  388.         app:layout_constraintEnd_toStartOf="@+id/button_sub"
  389.         app:layout_constraintHeight_percent="0.1"
  390.         app:layout_constraintStart_toEndOf="@+id/button_8"
  391.         app:layout_constraintTop_toBottomOf="@+id/button_mul"
  392.         app:layout_constraintWidth_percent="0.22" />
  393.  
  394.     <!--坑是一个接着一个，先是改按钮颜色，这倒没啥，改个主题，但改了主题还想用圆角按钮，
  395.     又整了selector文件。不想一个一个设置，用style，style的问题，
  396.     style设置在themes中，这里预览能正确显示，但运行不能。这个确实是自己不知道用法，当时不知道需要新建xml文件。
  397.     当时布局大概完成了，开始整java文件，本来想用js库，类似eval算个字符串，发现倒包不太行，
  398.     又看说这不安全，想一想，自己写个处理算法吧，就一个后缀表达式之类的。就先把按钮侦听器写了，其余的先放了放。
  399.     整横屏时又发现，诶？怎么老调不对，这模拟器怎么不能正确显示？又发现，诶？
  400.     我P30怎么连竖屏都不能正常显示，发现网格布局GridLayout屏幕小的话就不太对劲，
  401.     换！又约束的方式重写布局，多大点事，缝缝补补修好了，别说p30，手表大小的屏幕都能上，
  402.     解决完开始写横屏，嘿，你猜怎么着？屏幕一转，我变量呢？空了？改一下onSaveInstanceState
  403.     发现滚动条无法自动滚动到最右边，初步估计是修改字符串后，会改变控件长度，滚动容器参数没有更新，还以为是之前的长度
  404.     然后试图对MR之类的进行修改，不使用科学计数法，试了几种方法，想看看手机上现有的实现，一试，嘿
  405.     他们也没搞。然后就是添加约束条件，各种比如右括号左边不能直接添加数字，怕到时候栈运算出问题所有-1整个0-1之类的
  407.     -->
  408.     <!--下面是新加的功能-->
  409.     <!--左右括号-->
  410.  
  411.     <!--各种x的幂次方-->
  412.  
  413.     <Button
  414.         android:id="@+id/button_left_parenthesis"
  415.         style="@style/normalButtonStyle"
  416.         android:visibility="gone" />
  417.  
  418.     <Button
  419.         android:id="@+id/button_right_parenthesis"
  420.         style="@style/normalButtonStyle"
  421.         android:visibility="gone" />
  422.  
  423.     <Button
  424.         android:id="@+id/button_reciprocal"
  425.         style="@style/normalButtonStyle"
  426.         android:visibility="gone" />
  427.  
  428.     <Button
  429.         android:id="@+id/button_square"
  430.         style="@style/normalButtonStyle"
  431.         android:visibility="gone" />
  432.  
  433.     <Button
  434.         android:id="@+id/button_cubic_power"
  435.         style="@style/normalButtonStyle"
  436.         android:visibility="gone" />
  437.  
  438.     <Button
  439.         android:id="@+id/button_n_power"
  440.         style="@style/normalButtonStyle"
  441.         android:visibility="gone" />
  442.  
  443.     <Button
  444.         android:id="@+id/button_square_root"
  445.         style="@style/normalButtonStyle"
  446.         android:visibility="gone" />
  447.  
  448.     <Button
  449.         android:id="@+id/button_cube_root"
  450.         style="@style/normalButtonStyle"
  451.         android:visibility="gone" />
  452.  
  453.     <!--e按钮-->
  454.     <!--ln和log-->
  455.  
  456.     <!--三角函数们-->
  457.  
  458.     <Button
  459.         android:id="@+id/button_n_root"
  460.         style="@style/normalButtonStyle"
  461.         android:visibility="gone" />
  462.  
  463.     <Button
  464.         android:id="@+id/button_e"
  465.         style="@style/normalButtonStyle"
  466.         android:visibility="gone" />
  467.  
  468.     <Button
  469.         android:id="@+id/button_ln"
  470.         style="@style/normalButtonStyle"
  471.         android:visibility="gone" />
  472.  
  473.     <Button
  474.         android:id="@+id/button_log"
  475.         style="@style/normalButtonStyle"
  476.         android:visibility="gone" />
  477.  
  478.     <Button
  479.         android:id="@+id/button_sin"
  480.         style="@style/normalButtonStyle"
  481.         android:visibility="gone" />
  482.  
  483.     <!--变换按钮-->
  484.  
  485.     <Button
  486.         android:id="@+id/button_cos"
  487.         style="@style/normalButtonStyle"
  488.         android:visibility="gone" />
  489.  
  490.     <Button
  491.         android:id="@+id/button_tan"
  492.         style="@style/normalButtonStyle"
  493.         android:visibility="gone" />
  494.  
  495.     <Button
  496.         android:id="@+id/button_idaoi"
  497.         style="@style/normalButtonStyle"
  498.         android:visibility="gone" />
  499.  
  500.     <Button
  501.         android:id="@+id/button_pi"
  502.         style="@style/normalButtonStyle"
  503.         android:visibility="gone" />
  504.  
  505.     <Button
  506.         android:id="@+id/button_inv"
  507.         style="@style/normalButtonStyle"
  508.         android:visibility="gone" />
  509. </androidx.constraintlayout.widget.ConstraintLayout>

横屏：
  1. <?xml version="1.0" encoding="utf-8"?><!--这是横屏布局
  2. 最大7列，10行,长宽全占满
  3. -->
  4. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
  5.     xmlns:app="http://schemas.android.com/apk/res-auto"
  6.     xmlns:tools="http://schemas.android.com/tools"
  7.     style="@style/layoutStyle"
  8.     android:layout_width="match_parent"
  9.     android:layout_height="match_parent"
  10.     tools:context=".MainActivity">
  11.  
  12.     <!--这一部分和前面一样，就是改了一下第一行，和部分参数和部分绑定控制
  13.     要看新加的功能移步372行-->
  14.     <!--第0行有M标志，切换横竖屏的按钮-->
  15.     <!--中间是上回的结果，叫文本框——上次,
  16.     后来设计有变，改为储存表达式的文本
  17.     初始没文本，在第1行，在第0列，占4列，占1行，
  18.     为了水平滚动，加了滚动容器
  19.     -->
  20.     <TextView
  21.         android:id="@+id/textView_M"
  22.         style="@style/lastTextBoxStyle"
  23.         android:text="@string/M"
  24.         app:layout_constraintBottom_toTopOf="@+id/textView_Equation"
  25.         app:layout_constraintEnd_toStartOf="@+id/horizonLayout_Last"
  26.         app:layout_constraintHeight_percent="0.1 "
  27.         app:layout_constraintStart_toStartOf="parent"
  28.         app:layout_constraintTop_toTopOf="parent"
  29.         app:layout_constraintWidth_percent="0.1 " />
  30.  
  31.     <HorizontalScrollView
  32.         android:id="@+id/horizonLayout_Last"
  33.         style="@style/lastTextBoxStyle"
  34.         android:scrollbars="vertical"
  35.         app:layout_constraintEnd_toStartOf="@+id/button_rotate"
  36.         app:layout_constraintHeight_percent="0.1 "
  37.         app:layout_constraintStart_toEndOf="@+id/textView_M"
  38.         app:layout_constraintTop_toTopOf="parent"
  39.         app:layout_constraintWidth_percent="0.8">
  40.  
  41.         <TextView
  42.             android:id="@+id/textView_Last"
  43.             style="@style/lastTextBoxStyle"
  44.             android:layout_width="wrap_content"
  45.             android:layout_height="match_parent"
  46.             android:layout_gravity="end"
  47.             android:gravity="end"
  48.             android:maxLines="1"
  49.             android:scrollbars="vertical"
  50.             android:text=""
  51.             android:textSize="24sp"
  52.             app:layout_constraintEnd_toEndOf="parent"
  53.             app:layout_constraintStart_toStartOf="parent" />
  54.     </HorizontalScrollView>
  55.  
  56.     <Button
  57.         android:id="@+id/button_rotate"
  58.         style="@style/lastTextBoxStyle"
  59.         android:text="@string/rotate"
  60.         app:layout_constraintBottom_toTopOf="@+id/textView_Equation"
  61.         app:layout_constraintEnd_toEndOf="parent"
  62.         app:layout_constraintHeight_percent="0.1 "
  63.         app:layout_constraintStart_toEndOf="@+id/horizonLayout_Last"
  64.         app:layout_constraintTop_toTopOf="parent"
  65.         app:layout_constraintWidth_percent="0.1 " />
  66.  
  67.  
  68.     <!--第2行是算式，叫文本框——方程
  69. 初始没文本，粗体，在第2行，在第0列，占4列，占1行，
  70. gravity="end"：文本靠右,只显示一行文本，不换行
  71. -->
  72.  
  73.     <EditText
  74.         android:id="@+id/textView_Equation"
  75.         style="@style/editTextBoxStyle"
  76.         android:focusableInTouchMode="false"
  77.         android:gravity="right"
  78.         android:marqueeRepeatLimit="marquee_forever"
  79.         android:singleLine="true"
  80.         android:text=""
  81.         android:textSize="50sp"
  82.         app:layout_constraintEnd_toEndOf="parent"
  83.         app:layout_constraintHeight_percent="0.2"
  84.         app:layout_constraintStart_toStartOf="parent"
  85.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Last"
  86.         app:layout_constraintWidth_percent="1" />
  87.     <!--当前结果
  88. 初始没文本，在第3行，在第0列，占4列，占1行，
  89. gravity="end"：文本靠右-->
  90.     <HorizontalScrollView
  91.         android:id="@+id/horizonLayout_Now"
  92.         style="@style/lastTextBoxStyle"
  93.         android:scrollbars="vertical"
  94.         app:layout_constraintEnd_toEndOf="parent"
  95.         app:layout_constraintHeight_percent="0.1 "
  96.         app:layout_constraintStart_toStartOf="parent"
  97.         app:layout_constraintTop_toBottomOf="@+id/textView_Equation"
  98.         app:layout_constraintWidth_percent="1">
  99.  
  100.         <TextView
  101.             android:id="@+id/textView_Now"
  102.             style="@style/lastTextBoxStyle"
  103.             android:layout_width="wrap_content"
  104.             android:layout_height="match_parent"
  105.             android:layout_gravity="end"
  106.             android:gravity="end"
  107.             android:maxLines="1"
  108.             android:scrollbars="vertical"
  109.             android:text=""
  110.             android:textSize="24sp"
  111.             app:layout_constraintEnd_toEndOf="parent"
  112.             app:layout_constraintStart_toStartOf="parent" />
  113.  
  114.     </HorizontalScrollView>
  115.     <!--第4行 分别是MR，M+，M-,MC，四个按钮-->
  116.     <Button
  117.         android:id="@+id/button_MR"
  118.         style="@style/normalButtonStyle"
  119.         android:text="@string/MR"
  120.         android:textSize="21sp"
  121.         app:layout_constraintBottom_toTopOf="@+id/button_C"
  122.         app:layout_constraintEnd_toStartOf="@+id/button_Mup"
  123.         app:layout_constraintHeight_percent="0.08"
  124.         app:layout_constraintStart_toEndOf="@+id/button_reciprocal"
  125.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  126.         app:layout_constraintWidth_percent="0.13" />
  127.  
  128.     <Button
  129.         android:id="@+id/button_Mup"
  130.         style="@style/normalButtonStyle"
  131.         android:text="@string/Mup"
  132.         android:textSize="21sp"
  133.         app:layout_constraintBottom_toTopOf="@+id/button_div"
  134.         app:layout_constraintEnd_toStartOf="@+id/button_Mdown"
  135.         app:layout_constraintHeight_percent="0.08"
  136.         app:layout_constraintStart_toEndOf="@+id/button_MR"
  137.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  138.         app:layout_constraintWidth_percent="0.13" />
  139.  
  140.     <Button
  141.         android:id="@+id/button_Mdown"
  142.         style="@style/normalButtonStyle"
  143.         android:text="@string/Mdown"
  144.         android:textSize="21sp"
  145.         app:layout_constraintBottom_toTopOf="@+id/button_mul"
  146.         app:layout_constraintEnd_toStartOf="@+id/button_MC"
  147.         app:layout_constraintHeight_percent="0.08"
  148.         app:layout_constraintStart_toEndOf="@+id/button_Mup"
  149.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  150.         app:layout_constraintWidth_percent="0.13" />
  151.  
  152.     <!--第5行 分别是C，/，*,CE，四个按钮-->
  153.  
  154.     <Button
  155.         android:id="@+id/button_MC"
  156.         style="@style/deleteButtonStyle"
  157.         android:text="@string/MC"
  158.         android:textSize="21sp"
  159.         app:layout_constraintBottom_toTopOf="@+id/button_CE"
  160.         app:layout_constraintEnd_toEndOf="parent"
  161.         app:layout_constraintHeight_percent="0.08"
  162.         app:layout_constraintStart_toEndOf="@+id/button_Mdown"
  163.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  164.         app:layout_constraintWidth_percent="0.13" />
  165.  
  166.     <Button
  167.         android:id="@+id/button_C"
  168.         style="@style/specialButtonsStyle"
  169.         android:text="@string/C"
  170.         android:textSize="21sp"
  171.         app:layout_constraintBottom_toTopOf="@+id/button_7"
  172.         app:layout_constraintEnd_toStartOf="@+id/button_div"
  173.         app:layout_constraintHeight_percent="0.08"
  174.         app:layout_constraintStart_toEndOf="@+id/button_n_power"
  175.         app:layout_constraintTop_toBottomOf="@+id/button_MR"
  176.         app:layout_constraintWidth_percent="0.13" />
  177.  
  178.     <Button
  179.         android:id="@+id/button_div"
  180.         style="@style/specialButtonsStyle"
  181.         android:text="@string/div"
  182.         android:textSize="21sp"
  183.         app:layout_constraintBottom_toTopOf="@+id/button_8"
  184.         app:layout_constraintEnd_toStartOf="@+id/button_mul"
  185.         app:layout_constraintHeight_percent="0.08"
  186.         app:layout_constraintStart_toEndOf="@+id/button_C"
  187.         app:layout_constraintTop_toBottomOf="@+id/button_Mup"
  188.         app:layout_constraintWidth_percent="0.13" />
  189.  
  190.     <Button
  191.         android:id="@+id/button_mul"
  192.         style="@style/specialButtonsStyle"
  193.         android:text="@string/mul"
  194.         android:textSize="21sp"
  195.         app:layout_constraintBottom_toTopOf="@+id/button_9"
  196.         app:layout_constraintEnd_toStartOf="@+id/button_CE"
  197.         app:layout_constraintHeight_percent="0.08"
  198.         app:layout_constraintStart_toEndOf="@+id/button_div"
  199.         app:layout_constraintTop_toBottomOf="@+id/button_Mdown"
  200.         app:layout_constraintWidth_percent="0.13" />
  201.  
  202.     <Button
  203.         android:id="@+id/button_CE"
  204.         style="@style/deleteButtonStyle"
  205.         android:text="@string/CE"
  206.         android:textSize="21sp"
  207.         app:layout_constraintBottom_toTopOf="@+id/button_sub"
  208.         app:layout_constraintEnd_toEndOf="parent"
  209.         app:layout_constraintHeight_percent="0.08"
  210.         app:layout_constraintStart_toEndOf="@+id/button_mul"
  211.         app:layout_constraintTop_toBottomOf="@+id/button_MC"
  212.         app:layout_constraintWidth_percent="0.13" />
  213.     <!--剩下4行的第3列 分别是-，+，=,三个按钮，等于占两列-->
  214.  
  215.     <Button
  216.         android:id="@+id/button_sub"
  217.         style="@style/specialButtonsStyle"
  218.         android:text="@string/sub"
  219.         android:textSize="21sp"
  220.         app:layout_constraintBottom_toTopOf="@+id/button_add"
  221.         app:layout_constraintEnd_toEndOf="parent"
  222.         app:layout_constraintHeight_percent="0.08"
  223.         app:layout_constraintStart_toEndOf="@+id/button_9"
  224.         app:layout_constraintTop_toBottomOf="@+id/button_CE"
  225.         app:layout_constraintWidth_percent="0.13" />
  226.  
  227.     <Button
  228.         android:id="@+id/button_add"
  229.         style="@style/specialButtonsStyle"
  230.         android:text="@string/add"
  231.         android:textSize="21sp"
  232.         app:layout_constraintBottom_toTopOf="@+id/button_equal_To"
  233.         app:layout_constraintEnd_toEndOf="parent"
  234.         app:layout_constraintHeight_percent="0.08"
  235.         app:layout_constraintStart_toEndOf="@+id/button_6"
  236.         app:layout_constraintTop_toBottomOf="@+id/button_sub"
  237.         app:layout_constraintWidth_percent="0.13" />
  238.  
  239.     <!--10个数字和小数点，其中0占两列-->
  240.  
  241.     <Button
  242.         android:id="@+id/button_equal_To"
  243.         style="@style/equaltoButtonStyle"
  244.         android:text="@string/equal_To"
  245.         android:textSize="21sp"
  246.         app:layout_constraintBottom_toBottomOf="parent"
  247.         app:layout_constraintEnd_toEndOf="parent"
  248.         app:layout_constraintHeight_percent="0.18"
  249.         app:layout_constraintStart_toEndOf="@+id/button_3"
  250.         app:layout_constraintTop_toBottomOf="@+id/button_add"
  251.         app:layout_constraintWidth_percent="0.13" />
  252.  
  253.     <Button
  254.         android:id="@+id/button_point"
  255.         style="@style/digitButtonStyle"
  256.         android:text="@string/point"
  257.         android:textSize="21sp"
  258.         app:layout_constraintBottom_toBottomOf="parent"
  259.         app:layout_constraintEnd_toStartOf="@+id/button_equal_To"
  260.         app:layout_constraintHeight_percent="0.08"
  261.         app:layout_constraintStart_toEndOf="@+id/button_0"
  262.         app:layout_constraintTop_toBottomOf="@+id/button_3"
  263.         app:layout_constraintWidth_percent="0.13" />
  264.  
  265.     <Button
  266.         android:id="@+id/button_0"
  267.         style="@style/digitButtonStyle"
  268.         android:text="@string/_0"
  269.         android:textSize="21sp"
  270.         app:layout_constraintBottom_toBottomOf="parent"
  271.         app:layout_constraintEnd_toStartOf="@+id/button_point"
  272.         app:layout_constraintHeight_percent="0.08"
  273.         app:layout_constraintStart_toEndOf="@+id/button_pi"
  274.         app:layout_constraintTop_toBottomOf="@+id/button_2"
  275.         app:layout_constraintWidth_percent="0.28" />
  276.  
  277.     <Button
  278.         android:id="@+id/button_1"
  279.         style="@style/digitButtonStyle"
  280.         android:text="@string/_1"
  281.         android:textSize="21sp"
  282.         app:layout_constraintBottom_toTopOf="@+id/button_0"
  283.         app:layout_constraintEnd_toStartOf="@+id/button_2"
  284.         app:layout_constraintHeight_percent="0.08"
  285.         app:layout_constraintStart_toEndOf="@+id/button_tan"
  286.         app:layout_constraintTop_toBottomOf="@+id/button_4"
  287.         app:layout_constraintWidth_percent="0.13" />
  288.  
  289.     <Button
  290.         android:id="@+id/button_2"
  291.         style="@style/digitButtonStyle"
  292.         android:text="@string/_2"
  293.         android:textSize="21sp"
  294.         app:layout_constraintBottom_toTopOf="@+id/button_0"
  295.         app:layout_constraintEnd_toStartOf="@+id/button_3"
  296.         app:layout_constraintHeight_percent="0.08"
  297.         app:layout_constraintStart_toEndOf="@+id/button_1"
  298.         app:layout_constraintTop_toBottomOf="@+id/button_5"
  299.         app:layout_constraintWidth_percent="0.13" />
  300.  
  301.     <Button
  302.         android:id="@+id/button_3"
  303.         style="@style/digitButtonStyle"
  304.         android:text="@string/_3"
  305.         android:textSize="21sp"
  306.         app:layout_constraintBottom_toTopOf="@+id/button_point"
  307.  
  308.         app:layout_constraintEnd_toStartOf="@+id/button_equal_To"
  309.         app:layout_constraintHeight_percent="0.08"
  310.         app:layout_constraintStart_toEndOf="@+id/button_2"
  311.         app:layout_constraintTop_toBottomOf="@+id/button_6"
  312.         app:layout_constraintWidth_percent="0.13" />
  313.  
  314.     <Button
  315.         android:id="@+id/button_4"
  316.         style="@style/digitButtonStyle"
  317.         android:text="@string/_4"
  318.         android:textSize="21sp"
  319.         app:layout_constraintBottom_toTopOf="@+id/button_1"
  320.         app:layout_constraintEnd_toStartOf="@+id/button_5"
  321.         app:layout_constraintHeight_percent="0.08"
  322.         app:layout_constraintStart_toEndOf="@+id/button_log"
  323.         app:layout_constraintTop_toBottomOf="@+id/button_7"
  324.         app:layout_constraintWidth_percent="0.13" />
  325.  
  326.     <Button
  327.         android:id="@+id/button_5"
  328.         style="@style/digitButtonStyle"
  329.         android:text="@string/_5"
  330.         android:textSize="21sp"
  331.         app:layout_constraintBottom_toTopOf="@+id/button_2"
  332.         app:layout_constraintEnd_toStartOf="@+id/button_6"
  333.         app:layout_constraintHeight_percent="0.08"
  334.         app:layout_constraintStart_toEndOf="@+id/button_4"
  335.         app:layout_constraintTop_toBottomOf="@+id/button_8"
  336.         app:layout_constraintWidth_percent="0.13" />
  337.  
  338.     <Button
  339.         android:id="@+id/button_6"
  340.         style="@style/digitButtonStyle"
  341.         android:text="@string/_6"
  342.         android:textSize="21sp"
  343.         app:layout_constraintBottom_toTopOf="@+id/button_3"
  344.         app:layout_constraintEnd_toStartOf="@+id/button_add"
  345.         app:layout_constraintHeight_percent="0.08"
  346.         app:layout_constraintStart_toEndOf="@+id/button_5"
  347.         app:layout_constraintTop_toBottomOf="@+id/button_9"
  348.         app:layout_constraintWidth_percent="0.13" />
  349.  
  350.     <Button
  351.         android:id="@+id/button_7"
  352.         style="@style/digitButtonStyle"
  353.         android:text="@string/_7"
  354.         android:textSize="21sp"
  355.         app:layout_constraintBottom_toTopOf="@+id/button_4"
  356.         app:layout_constraintEnd_toStartOf="@+id/button_8"
  357.         app:layout_constraintHeight_percent="0.08"
  358.         app:layout_constraintStart_toEndOf="@+id/button_n_root"
  359.         app:layout_constraintTop_toBottomOf="@+id/button_C"
  360.         app:layout_constraintWidth_percent="0.13" />
  361.  
  362.     <Button
  363.         android:id="@+id/button_8"
  364.         style="@style/digitButtonStyle"
  365.         android:text="@string/_8"
  366.         android:textSize="21sp"
  367.         app:layout_constraintBottom_toTopOf="@+id/button_5"
  368.         app:layout_constraintEnd_toStartOf="@+id/button_9"
  369.         app:layout_constraintHeight_percent="0.08"
  370.         app:layout_constraintStart_toEndOf="@+id/button_7"
  371.         app:layout_constraintTop_toBottomOf="@+id/button_div"
  372.         app:layout_constraintWidth_percent="0.13" />
  373.  
  374.     <Button
  375.         android:id="@+id/button_9"
  376.         style="@style/digitButtonStyle"
  377.         android:text="@string/_9"
  378.         android:textSize="21sp"
  379.         app:layout_constraintBottom_toTopOf="@+id/button_6"
  380.         app:layout_constraintEnd_toStartOf="@+id/button_sub"
  381.         app:layout_constraintHeight_percent="0.08"
  382.         app:layout_constraintStart_toEndOf="@+id/button_8"
  383.         app:layout_constraintTop_toBottomOf="@+id/button_mul"
  384.         app:layout_constraintWidth_percent="0.13" />
  385.     <!--下面是新加的功能-->
  386.     <!--左右括号-->
  387.  
  388.     <!--各种x的幂次方-->
  389.  
  390.     <Button
  391.         android:id="@+id/button_left_parenthesis"
  392.         style="@style/normalButtonStyle"
  393.         android:text="@string/left_parenthesis"
  394.         android:textSize="21sp"
  395.         app:layout_constraintBottom_toTopOf="@+id/button_square"
  396.         app:layout_constraintEnd_toStartOf="@+id/button_right_parenthesis"
  397.         app:layout_constraintHeight_percent="0.08"
  398.         app:layout_constraintStart_toStartOf="parent"
  399.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  400.         app:layout_constraintWidth_percent="0.13" />
  401.  
  402.     <Button
  403.         android:id="@+id/button_right_parenthesis"
  404.         style="@style/normalButtonStyle"
  405.         android:text="@string/right_parenthesis"
  406.         android:textSize="21sp"
  407.         app:layout_constraintBottom_toTopOf="@+id/button_cubic_power"
  408.         app:layout_constraintEnd_toStartOf="@+id/button_reciprocal"
  409.         app:layout_constraintHeight_percent="0.08"
  410.         app:layout_constraintStart_toEndOf="@+id/button_left_parenthesis"
  411.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  412.         app:layout_constraintWidth_percent="0.13" />
  413.  
  414.     <Button
  415.         android:id="@+id/button_reciprocal"
  416.         style="@style/normalButtonStyle"
  417.         android:text="@string/reciprocal"
  418.         android:textAllCaps="false"
  419.         android:textSize="21sp"
  420.         app:layout_constraintBottom_toTopOf="@+id/button_n_power"
  421.         app:layout_constraintEnd_toStartOf="@+id/button_MR"
  422.         app:layout_constraintHeight_percent="0.08"
  423.         app:layout_constraintStart_toEndOf="@+id/button_right_parenthesis"
  424.         app:layout_constraintTop_toBottomOf="@+id/horizonLayout_Now"
  425.         app:layout_constraintWidth_percent="0.13" />
  426.  
  427.     <Button
  428.         android:id="@+id/button_square"
  429.         style="@style/normalButtonStyle"
  430.         android:text="@string/square"
  431.         android:textAllCaps="false"
  432.         android:textSize="21sp"
  433.         app:layout_constraintBottom_toTopOf="@+id/button_square_root"
  434.         app:layout_constraintEnd_toStartOf="@+id/button_cubic_power"
  435.         app:layout_constraintHeight_percent="0.08"
  436.         app:layout_constraintStart_toStartOf="parent"
  437.         app:layout_constraintTop_toBottomOf="@+id/button_left_parenthesis"
  438.         app:layout_constraintWidth_percent="0.13" />
  439.  
  440.     <Button
  441.         android:id="@+id/button_cubic_power"
  442.         style="@style/normalButtonStyle"
  443.         android:text="@string/cubic_power"
  444.         android:textAllCaps="false"
  445.         android:textSize="21sp"
  446.         app:layout_constraintBottom_toTopOf="@+id/button_cube_root"
  447.         app:layout_constraintEnd_toStartOf="@+id/button_n_power"
  448.         app:layout_constraintHeight_percent="0.08"
  449.         app:layout_constraintStart_toEndOf="@+id/button_square"
  450.         app:layout_constraintTop_toBottomOf="@+id/button_right_parenthesis"
  451.         app:layout_constraintWidth_percent="0.13" />
  452.  
  453.     <Button
  454.         android:id="@+id/button_n_power"
  455.         style="@style/normalButtonStyle"
  456.         android:text="@string/n_power"
  457.         android:textAllCaps="false"
  458.         android:textSize="21sp"
  459.         app:layout_constraintBottom_toTopOf="@+id/button_n_root"
  460.         app:layout_constraintEnd_toStartOf="@+id/button_C"
  461.         app:layout_constraintHeight_percent="0.08"
  462.         app:layout_constraintStart_toEndOf="@+id/button_cubic_power"
  463.         app:layout_constraintTop_toBottomOf="@+id/button_reciprocal"
  464.         app:layout_constraintWidth_percent="0.13" />
  465.  
  466.     <Button
  467.         android:id="@+id/button_square_root"
  468.         style="@style/normalButtonStyle"
  469.         android:text="@string/square_root"
  470.         android:textAllCaps="false"
  471.         android:textSize="21sp"
  472.         app:layout_constraintBottom_toTopOf="@+id/button_e"
  473.         app:layout_constraintEnd_toStartOf="@+id/button_cube_root"
  474.         app:layout_constraintHeight_percent="0.08"
  475.         app:layout_constraintStart_toStartOf="parent"
  476.         app:layout_constraintTop_toBottomOf="@+id/button_square"
  477.         app:layout_constraintWidth_percent="0.13" />
  478.  
  479.     <Button
  480.         android:id="@+id/button_cube_root"
  481.         style="@style/normalButtonStyle"
  482.         android:text="@string/cube_root"
  483.         android:textAllCaps="false"
  484.         android:textSize="21sp"
  485.         app:layout_constraintBottom_toTopOf="@+id/button_ln"
  486.         app:layout_constraintEnd_toStartOf="@+id/button_n_root"
  487.         app:layout_constraintHeight_percent="0.08"
  488.         app:layout_constraintStart_toEndOf="@+id/button_square_root"
  489.         app:layout_constraintTop_toBottomOf="@+id/button_cubic_power"
  490.         app:layout_constraintWidth_percent="0.13" />
  491.  
  492.     <!--e按钮-->
  493.     <!--ln和log-->
  494.  
  495.     <!--三角函数们-->
  496.  
  497.     <Button
  498.         android:id="@+id/button_n_root"
  499.         style="@style/normalButtonStyle"
  500.         android:text="@string/n_root"
  501.         android:textAllCaps="false"
  502.         android:textSize="21sp"
  503.         app:layout_constraintBottom_toTopOf="@+id/button_log"
  504.         app:layout_constraintEnd_toStartOf="@+id/button_7"
  505.         app:layout_constraintHeight_percent="0.08"
  506.         app:layout_constraintStart_toEndOf="@+id/button_cube_root"
  507.         app:layout_constraintTop_toBottomOf="@+id/button_n_power"
  508.         app:layout_constraintWidth_percent="0.13" />
  509.  
  510.     <Button
  511.         android:id="@+id/button_e"
  512.         style="@style/normalButtonStyle"
  513.         android:text="@string/e"
  514.         android:textAllCaps="false"
  515.         android:textSize="21sp"
  516.         app:layout_constraintBottom_toTopOf="@+id/button_sin"
  517.         app:layout_constraintEnd_toStartOf="@+id/button_ln"
  518.         app:layout_constraintHeight_percent="0.08"
  519.         app:layout_constraintStart_toStartOf="parent"
  520.         app:layout_constraintTop_toBottomOf="@+id/button_square_root"
  521.         app:layout_constraintWidth_percent="0.13" />
  522.  
  523.     <Button
  524.         android:id="@+id/button_ln"
  525.         style="@style/normalButtonStyle"
  526.         android:text="@string/ln"
  527.         android:textAllCaps="false"
  528.         android:textSize="21sp"
  529.         app:layout_constraintBottom_toTopOf="@+id/button_cos"
  530.         app:layout_constraintEnd_toStartOf="@+id/button_log"
  531.         app:layout_constraintHeight_percent="0.08"
  532.         app:layout_constraintStart_toEndOf="@+id/button_e"
  533.         app:layout_constraintTop_toBottomOf="@+id/button_cube_root"
  534.         app:layout_constraintWidth_percent="0.13" />
  535.  
  536.     <Button
  537.         android:id="@+id/button_log"
  538.         style="@style/normalButtonStyle"
  539.         android:text="@string/log"
  540.         android:textAllCaps="false"
  541.         android:textSize="21sp"
  542.         app:layout_constraintBottom_toTopOf="@+id/button_tan"
  543.         app:layout_constraintEnd_toStartOf="@+id/button_4"
  544.         app:layout_constraintHeight_percent="0.08"
  545.         app:layout_constraintStart_toEndOf="@+id/button_ln"
  546.         app:layout_constraintTop_toBottomOf="@+id/button_n_root"
  547.         app:layout_constraintWidth_percent="0.13" />
  548.  
  549.     <Button
  550.         android:id="@+id/button_sin"
  551.         style="@style/normalButtonStyle"
  552.         android:text="@string/sin"
  553.         android:textAllCaps="false"
  554.         android:textSize="21sp"
  555.         app:layout_constraintBottom_toTopOf="@+id/button_inv"
  556.         app:layout_constraintEnd_toStartOf="@+id/button_cos"
  557.         app:layout_constraintHeight_percent="0.08"
  558.         app:layout_constraintStart_toStartOf="parent"
  559.         app:layout_constraintTop_toBottomOf="@+id/button_e"
  560.         app:layout_constraintWidth_percent="0.13" />
  561.  
  562.     <!--变换按钮-->
  563.  
  564.     <Button
  565.         android:id="@+id/button_cos"
  566.         style="@style/normalButtonStyle"
  567.         android:text="@string/cos"
  568.         android:textAllCaps="false"
  569.         android:textSize="21sp"
  570.         app:layout_constraintBottom_toTopOf="@+id/button_idaoi"
  571.         app:layout_constraintEnd_toStartOf="@+id/button_tan"
  572.         app:layout_constraintHeight_percent="0.08"
  573.         app:layout_constraintStart_toEndOf="@+id/button_sin"
  574.         app:layout_constraintTop_toBottomOf="@+id/button_ln"
  575.         app:layout_constraintWidth_percent="0.13" />
  576.  
  577.     <Button
  578.         android:id="@+id/button_tan"
  579.         style="@style/normalButtonStyle"
  580.         android:text="@string/tan"
  581.         android:textAllCaps="false"
  582.         android:textSize="21sp"
  583.         app:layout_constraintBottom_toTopOf="@+id/button_pi"
  584.         app:layout_constraintEnd_toStartOf="@+id/button_1"
  585.         app:layout_constraintHeight_percent="0.08"
  586.         app:layout_constraintStart_toEndOf="@+id/button_cos"
  587.         app:layout_constraintTop_toBottomOf="@+id/button_log"
  588.         app:layout_constraintWidth_percent="0.13" />
  589.  
  590.     <Button
  591.         android:id="@+id/button_idaoi"
  592.         style="@style/normalButtonStyle"
  593.         android:text="@string/idaoi"
  594.         android:textAllCaps="false"
  595.         android:textSize="21sp"
  596.         app:layout_constraintBottom_toBottomOf="parent"
  597.         app:layout_constraintEnd_toStartOf="@+id/button_pi"
  598.         app:layout_constraintHeight_percent="0.08"
  599.         app:layout_constraintStart_toEndOf="@+id/button_inv"
  600.         app:layout_constraintTop_toBottomOf="@+id/button_cos"
  601.         app:layout_constraintWidth_percent="0.13" />
  602.  
  603.     <Button
  604.         android:id="@+id/button_pi"
  605.         style="@style/normalButtonStyle"
  606.         android:text="@string/pi"
  607.         android:textAllCaps="false"
  608.         android:textSize="21sp"
  609.         app:layout_constraintBottom_toBottomOf="parent"
  610.         app:layout_constraintEnd_toStartOf="@+id/button_1"
  611.         app:layout_constraintHeight_percent="0.08"
  612.         app:layout_constraintStart_toEndOf="@+id/button_idaoi"
  613.         app:layout_constraintTop_toBottomOf="@+id/button_tan"
  614.         app:layout_constraintWidth_percent="0.13" />
  615.  
  616.     <Button
  617.         android:id="@+id/button_inv"
  618.         style="@style/normalButtonStyle"
  619.         android:text="@string/square_inv"
  620.         android:textAllCaps="false"
  621.         android:textSize="21sp"
  622.         app:layout_constraintBottom_toBottomOf="parent"
  623.         app:layout_constraintEnd_toStartOf="@+id/button_idaoi"
  624.         app:layout_constraintHeight_percent="0.08"
  625.         app:layout_constraintStart_toStartOf="parent"
  626.         app:layout_constraintTop_toBottomOf="@+id/button_sin"
  627.         app:layout_constraintWidth_percent="0.13" />
  628.  
  629.  
  630. </androidx.constraintlayout.widget.ConstraintLayout>

我该最后粘贴代码的，越写越卡了。

values

        colors.xml

        一些颜色的定义，获得16进制颜色有很多方法，我用的是画图3D来取色，你也可以用它打开图片，然后直接选中图片的颜色。后续版本我会添加多页面，可能会添加相应功能（画大饼，大概率不写）

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <resources>
  3.     <!--这个文件来定义设定的颜色-->
  4.     <color name="black">#FF000000</color>
  5.     <color name="white">#FFFFFFFF</color>
  6.     <color name="c_black">#000000</color>
  7.     <color name="c_light_background">#303030</color>
  8.     <color name="c_light_button">#404040</color>
  9.     <color name="c_white">#FFFFFF</color>
  10.     <color name="c_blue">#506EF0</color>
  11.     <color name="c_blue_">#2A40C0</color>
  12.     <color name="c_orange">#FFBB40</color>
  13.     <color name="c_orange_">#FFA400</color>
  14.     <color name="c_light_grey">#EAEAEE</color>
  15.     <color name="c_grey">#CDCDD2</color>
  16.     <color name="c_dark_grey">#9696A0</color>
  17.  
  18. </resources>
strings.xml

定义字符串的，其中，第一个name="app_name"这个，设定的是应用的名字，就是图标下面显示的名字。

  1. <resources>
  2.     <!--这个文件来定义设定的字符串-->
  3.     <string name="app_name">i道i的计算器</string>
  4.     <string name="idaoi">i道i</string>
  5.  
  6.     <string name="M">M</string>
  7.     <string name="MR">MR</string>
  8.     <string name="Mup">M+</string>
  9.     <string name="Mdown">M-</string>
  10.     <string name="MC">MC</string>
  11.  
  12.     <string name="add">+</string>
  13.     <string name="sub">-</string>
  14.     <string name="mul">×</string>
  15.     <string name="div">÷</string>
  16.  
  17.     <string name="C">C</string>
  18.     <string name="CE">退格</string>
  19.     <string name="point">.</string>
  20.     <string name="equal_To">=</string>
  21.  
  22.     <string name="_0">0</string>
  23.     <string name="_1">1</string>
  24.     <string name="_2">2</string>
  25.     <string name="_3">3</string>
  26.     <string name="_4">4</string>
  27.     <string name="_5">5</string>
  28.     <string name="_6">6</string>
  29.     <string name="_7">7</string>
  30.     <string name="_8">8</string>
  31.     <string name="_9">9</string>
  32.  
  33.     <string name="rotate">⇵</string>
  34.     <string name="error">错误</string>
  35.     <string name="NULL">NULL</string>
  36.  
  37.  
  38.     <string name="e">e</string>
  39.     <string name="pi">π</string>
  40.  
  41.     <string name="left_parenthesis">(</string>
  42.     <string name="right_parenthesis">)</string>
  43.     <string name="reciprocal">1/x</string>
  44.     <string name="square">x²</string>
  45.     <string name="cubic_power">x³</string>
  46.     <string name="n_power">xⁿ</string>
  47.  
  48.     <string name="square_root">²√</string>
  49.     <string name="cube_root">³√</string>
  50.     <string name="n_root">ⁿ√</string>
  51.  
  52.     <string name="square_inv">Inv</string>
  53.     <string name="ln">ln</string>
  54.     <string name="log">log</string>
  55.     <string name="e_root">eⁿ</string>
  56.     <string name="ten_power">10ⁿ</string>
  57.  
  58.  
  59.     <string name="sin">sin</string>
  60.     <string name="cos">cos</string>
  61.     <string name="tan">tan</string>
  62.     <string name="sin_">sin⁻¹</string>
  63.     <string name="cos_">cos⁻¹</string>
  64.     <string name="tan_">tan⁻¹</string>
  65. </resources>
styles

当你创建多个styles.xml文件时，虚拟目录这里才会给你整个文件夹包起来，项目目录如下：

带-night是暗色模式使用的，就是你手机上的深色模式，如果深色模式文件夹里有就会用深色模式文件夹里的，没有就用浅色模式中的东西。

styles.xml初始是不自带的，你需要自己创建。

浅色模式

说起来也是大同小异，这东西相当于设定一个模板，然后你就在布局中套用这个模板就行。跟类一样，甚至可以继承。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <resources>
  3.     <!--布局-->
  4.     <style name="layoutStyle">
  5.         <item name="android:background">@color/c_light_grey</item>
  6.         <item name="android:textColor">@color/c_dark_grey</item>
  7.         <item name="android:layout_width">0dp</item>
  8.         <item name="android:layout_height">0dp</item>
  9.     </style>
  10.     <!--上次文本框-->
  11.     <style name="lastTextBoxStyle">
  12.         <item name="android:background">@color/c_white</item>
  13.         <item name="android:textColor">@color/c_dark_grey</item>
  14.         <item name="android:layout_width">0dp</item>
  15.         <item name="android:layout_height">0dp</item>
  16.     </style>
  17.     <!--文本框-->
  18.     <style name="editTextBoxStyle">
  19.         <item name="android:textStyle">bold</item>
  20.         <item name="android:background">@color/c_white</item>
  21.         <item name="android:textColor">@color/c_black</item>
  22.         <item name="android:layout_width">0dp</item>
  23.         <item name="android:layout_height">0dp</item>
  24.     </style>
  25.     <!--数字按钮,数字按钮的颜色
  26.     白背景，黑文字-->
  27.     <style name="digitButtonStyle">
  28.         <item name="android:background">@drawable/whitebutton</item>
  29.         <item name="android:textColor">@color/c_black</item>
  30.         <item name="android:layout_width">0dp</item>
  31.         <item name="android:layout_height">0dp</item>
  32.  
  33.     </style>
  34.     <!--普通按钮，普通功能的颜色
  35.     灰色背景，黑文字-->
  36.     <style name="normalButtonStyle">
  37.         <item name="android:background">@drawable/greybutton</item>
  38.         <item name="android:textColor">@color/c_black</item>
  39.         <item name="android:layout_width">0dp</item>
  40.         <item name="android:layout_height">0dp</item>
  41.  
  42.     </style>
  43.     <!--特殊按钮，常用功能的颜色
  44.     灰色背景，蓝色文字-->
  45.     <style name="specialButtonsStyle">
  46.         <item name="android:background">@drawable/greybutton</item>
  47.         <item name="android:textColor">@color/c_blue</item>
  48.         <item name="android:layout_width">0dp</item>
  49.         <item name="android:layout_height">0dp</item>
  50.  
  51.     </style>
  52.     <!--删除按钮，CE和C的颜色
  53.     橙色背景，白色文字-->
  54.     <style name="deleteButtonStyle">
  55.         <item name="android:background">@drawable/orangebuttons</item>
  56.         <item name="android:textColor">@color/c_white</item>
  57.         <item name="android:layout_width">0dp</item>
  58.         <item name="android:layout_height">0dp</item>
  59.  
  60.     </style>
  61.     <!--等于按钮，蓝色背景，白色文字-->
  62.     <style name="equaltoButtonStyle">
  63.         <item name="android:background">@drawable/bluebuttons</item>
  64.         <item name="android:textColor">@color/c_white</item>
  65.         <item name="android:layout_width">0dp</item>
  66.         <item name="android:layout_height">0dp</item>
  67.  
  68.     </style>
  69. </resources>
深色模式
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <resources>
  3.     <!--布局-->
  4.     <style name="layoutStyle">
  5.         <item name="android:background">@color/c_light_background</item>
  6.         <item name="android:textColor">@color/c_grey</item>
  7.         <item name="android:layout_width">0dp</item>
  8.         <item name="android:layout_height">0dp</item>
  9.     </style>
  10.     <!--上次文本框-->
  11.     <style name="lastTextBoxStyle">
  12.         <item name="android:background">@color/c_black</item>
  13.         <item name="android:textColor">@color/c_dark_grey</item>
  14.         <item name="android:layout_width">0dp</item>
  15.         <item name="android:layout_height">0dp</item>
  16.     </style>
  17.     <!--文本框-->
  18.     <style name="editTextBoxStyle">
  19.         <item name="android:textStyle">bold</item>
  20.         <item name="android:background">@color/c_black</item>
  21.         <item name="android:textColor">@color/c_light_grey</item>
  22.         <item name="android:layout_width">0dp</item>
  23.         <item name="android:layout_height">0dp</item>
  24.     </style>
  25.     <!--数字按钮,数字按钮的颜色
  26.     黑背景，白文字-->
  27.     <style name="digitButtonStyle">
  28.         <item name="android:background">@drawable/blackbutton</item>
  29.         <item name="android:textColor">@color/c_white</item>
  30.         <item name="android:layout_width">0dp</item>
  31.         <item name="android:layout_height">0dp</item>
  32.  
  33.     </style>
  34.     <!--普通按钮，普通功能的颜色
  35.     黑背景，灰文字-->
  36.     <style name="normalButtonStyle">
  37.         <item name="android:background">@drawable/blackbutton</item>
  38.         <item name="android:textColor">@color/c_grey</item>
  39.         <item name="android:layout_width">0dp</item>
  40.         <item name="android:layout_height">0dp</item>
  41.  
  42.     </style>
  43.     <!--特殊按钮，常用功能的颜色
  44.     黑背景，蓝色文字-->
  45.     <style name="specialButtonsStyle">
  46.         <item name="android:background">@drawable/blackbutton</item>
  47.         <item name="android:textColor">@color/c_blue</item>
  48.         <item name="android:layout_width">0dp</item>
  49.         <item name="android:layout_height">0dp</item>
  50.  
  51.     </style>
  52.     <!--删除按钮，CE和C的颜色
  53.     橙色背景，白色文字-->
  54.     <style name="deleteButtonStyle">
  55.         <item name="android:background">@drawable/orangebuttons</item>
  56.         <item name="android:textColor">@color/c_white</item>
  57.         <item name="android:layout_width">0dp</item>
  58.         <item name="android:layout_height">0dp</item>
  59.  
  60.     </style>
  61.     <!--等于按钮，蓝色背景，白色文字-->
  62.     <style name="equaltoButtonStyle">
  63.         <item name="android:background">@drawable/bluebuttons</item>
  64.         <item name="android:textColor">@color/c_white</item>
  65.         <item name="android:layout_width">0dp</item>
  66.         <item name="android:layout_height">0dp</item>
  67.  
  68.     </style>
  69. </resources>
themes.xml

我这设置的两个都一样的，改了一下主题，就是第一个parent后面的东西。其实就是默认style继承的东西。其他的自动生成没动

  1. <resources xmlns:tools="http://schemas.android.com/tools">
  2.     <!-- Base application theme. -->
  3.     <style name="Base.Theme.Calculatorddaa" parent="Theme.MaterialComponents.NoActionBar.Bridge">
  4.         <!-- Customize your light theme here. -->
  5.         <!-- <item name="colorPrimary">@color/my_light_primary</item> -->
  6.     </style>
  7.  
  8.     <style name="Theme.Calculatorddaa" parent="Base.Theme.Calculatorddaa" >
  9.     </style>
  10.  
  11. </resources>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/325240?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号