精华内容
下载资源
问答
  • 在Unity中搭建一个UI界面,添加必要的Button,用C#代码写的计算器的计算功能,可以实现加减乘除取余退格关闭等功能。
  • java:用Swing做一个普通计算器

    千次阅读 2019-05-28 13:42:21
    用Swing做一个普通计算器 由于上篇文章用的一个主类调用科学和普通计算器,现在补充一个普通的计算器 package Cacultor_1; import javax.swing.*; import javax.xml.soap.Text; import java.awt.*; import java....

    用Swing做一个普通计算器

    用swing做更加复杂的计算器
    https://blog.csdn.net/dark_souls/article/details/89672759

    由于上一篇文章用的一个主类调用科学和普通计算器,现在补充一个普通的计算器

    package Cacultor_1;
    
    import javax.swing.*;
    import javax.xml.soap.Text;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.security.Key;
    /**
    **@author 李正阳  
    **/
    public class CacultorL extends JFrame implements ActionListener{
        private final String keys[]={"%","√","x^2","1/x","CE","C","<-                 ","/","7","8","9","*","4","5","6","-","1","2","3","+","+/-","0",".","="};    //主要按钮
        private final String Rom[]={"MC","MR","M+","M-","MS","M"};
        private JButton Keys[]=new JButton[keys.length];    //创建按钮组
        private JButton rom[]=new JButton[Rom.length];
       static JMenuBar menuBar=new JMenuBar();
        JPanel CenterPanel=new JPanel();
        JPanel NorthPanel=new JPanel();
        JPanel SouthPanel=new JPanel();
        JTextField textField=new JTextField(17);//下文本域
        JTextField textFieldUp=new JTextField(17);//上文本域
        private double left;                          //计算中存左值
        private double right;                          //计算中存右值
        private double result;
        private String Result;
        private String temp="";
        private static int option;
        private static String temp1="";
        public static void main(String[] args) {
            CacultorL window=new CacultorL();        //设置Jframe窗口的基本配置
            window.setSize(500,300);
           window.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//添加最大化最小化组件
            window.pack();    //自适应大小
            window.setJMenuBar(menuBar);  //创建菜单
            window.setVisible(true);    //显示窗口
        }
       public CacultorL(){                         //构造函数初始化计算器
           JMenu fileItem=new JMenu("      功能菜单");         //菜单组件
           JMenuItem card1=new JMenuItem("           科学");
           JMenuItem card2=new JMenuItem("       文件处理");
           menuBar.add(fileItem);
           fileItem.add(card1);                
           fileItem.add(card2);
    
           SouthPanel.setLayout(new GridLayout(2,1));               //设置网格布局
           CenterPanel.setLayout(new GridLayout(6,4));
           NorthPanel.setLayout(new GridLayout(1,6));
           CenterPanel.setPreferredSize(new Dimension(400,300));//设置jpanel的大小
           NorthPanel.setPreferredSize(new Dimension(50,50));
           addRom(Rom);
           for(int i=0;i<keys.length;i++) {             //将按钮添加上监视器,放在面板上
               addKeys(keys[i],i);
           }
           SouthPanel.add(textFieldUp);               //添加上文本域
           SouthPanel.add(textField);                
           add(SouthPanel,BorderLayout.NORTH);
           add(CenterPanel,BorderLayout.SOUTH);
           add(NorthPanel,BorderLayout.CENTER);
           textField.setHorizontalAlignment(JTextField.RIGHT); //锁定成不可修改
           textField.setEditable(false);
           textFieldUp.setHorizontalAlignment(JTextField.RIGHT);
           textFieldUp.setEditable(false);
       }
      public void addKeys(String keys,int i){
             Keys[i]= new  JButton(keys);
             CenterPanel.add(Keys[i]);
             Keys[i].addActionListener(this);
      }
      public void addRom(String Rom[]){
          for(int i=0;i<Rom.length;i++){
              rom[i]= new  JButton(Rom[i]);
              NorthPanel.add(rom[i]);
          }
      }
        @Override
        public void actionPerformed(ActionEvent e) { //数字键盘的监视器
             if(e.getSource()==Keys[8]){
                 temp+="7";
                 temp1+="7";
                 textField.setText(temp);
    
             }else if(e.getSource()==Keys[9]){
                 temp1+="8";
                 temp+="8";
                 textField.setText(temp);
    
             }else if(e.getSource()==Keys[10]){
                 temp1+="9";
                 temp+="9";
                 textField.setText(temp);
    
             }else if(e.getSource()==Keys[12]){
                 temp1+="4";
                 temp+="4";
                 textField.setText(temp);
    
             }else if(e.getSource()==Keys[13]){
                 temp1+="5";
                 temp+="5";
                 textField.setText(temp);
    
             }else if(e.getSource()==Keys[14]){
                 temp1+="6";
                 temp+="6";
                 textField.setText(temp);
    
             }else if(e.getSource()==Keys[16]){
                 temp1+="1";
                 temp+="1";
                 textField.setText(temp);
             }
             else if(e.getSource()==Keys[17]){
                 temp1+="2";
                 temp+="2";
                 textField.setText(temp);
             }
             else if(e.getSource()==Keys[18]){
                 temp1+="3";
                 temp+="3";
                 textField.setText(temp);
             }
            if(e.getSource()==Keys[0]){
                left=Double.parseDouble(textField.getText());
                textField.setText("");
                temp="";
                temp1+="%";
                textFieldUp.setText(temp1);
                option=2;
            }else if(e.getSource()==Keys[23]){   //等于号方法
                if(option==1){
                    String Right=textField.getText();
                    right=Double.parseDouble(Right);
                    result=left+right;
                    Result=""+result;
                }else if (option==2){
                    right=Double.parseDouble(textField.getText());
                    result=left%right;
                    Result=""+result;
                }else if(option==3){
                    right=Double.parseDouble(textField.getText());
                    result=left/right;
                    Result=""+result;
                }else if(option==4){
                    right=Double.parseDouble(textField.getText());
                    result=left*right;
                    Result=""+result;
                }else if(option==5){
                    right=Double.parseDouble(textField.getText());
                    result=left-right;
                    Result=""+result;
                }
                textField.setText(Result);
            }else if (e.getSource()==Keys[1]){           //加减乘除等功能键的监视器方法
                left=Double.parseDouble(textField.getText());
                textField.setText("");
                temp="";
                result=Math.sqrt(left);
                Result=""+result;
                textFieldUp.setText(Result);
            }else if(e.getSource()==Keys[2]){
                left=Double.parseDouble(textField.getText());
                textField.setText("");
                temp="";
                result=left*left;
                Result=""+result;
                textFieldUp.setText(Result);
            }else if(e.getSource()==Keys[3]){
                left=Double.parseDouble(textField.getText());
                textField.setText("");
                temp="";
                result=1/left;
                Result=""+result;
                textFieldUp.setText(Result);
            }else if(e.getSource()==Keys[4]){
                textField.setText("");
                temp="";
                temp1="";
            }else if(e.getSource()==Keys[19]){
                left=Double.parseDouble(textField.getText());
                temp1+="+";
                textFieldUp.setText(temp1);
                textField.setText("");
                temp="";
                option=1;
            }else if(e.getSource()==Keys[5]){
                textField.setText("");
                temp="";
                temp1="";
            }else if(e.getSource()==Keys[6]){
                textField.setText("");
                temp="";
                temp1="";
            }else if(e.getSource()==Keys[7]){
                left=Double.parseDouble(textField.getText());
                temp1+="/";
                textFieldUp.setText(temp1);
                textField.setText("");
                temp="";
                option=3;
            }else if(e.getSource()==Keys[11]){
                left=Double.parseDouble(textField.getText());
                temp1+="*";
                textFieldUp.setText(temp1);
                textField.setText("");
                temp="";
                option=4;
            }else if(e.getSource()==Keys[15]){
                left=Double.parseDouble(textField.getText());
                temp1+="-";
                textFieldUp.setText(temp1);
                textField.setText("");
                temp="";
                option=5;
            }else if(e.getSource()==Keys[22]){
                temp1+=".";
                temp+=".";
                textField.setText(temp);
            }
        }
    
    
    
        class ROM implements ActionListener{//加减乘除的监视器
            @Override
            public void actionPerformed(ActionEvent e) {//未完成的计算器方法
                if(e.getSource()==Keys[0]){
    
                }
            }
        }
    
    
    }
    
    

    运行界面
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 普通计算器

    2013-03-18 19:47:14
    计算器,Java课程设计普通使用,基本功能全部实现
  • 同学做的一个计算器,可以下载来看看,适合初学者。
  • 这是大二上学期课设的一道题,我当时刚好学习了C#,C#窗体应用程序的界面代码和业务代码是分开的,这比...注意右侧的解决方案资源管理器中的文件,后面会一个一个粘上来~~~在看看运行时的效果吧: 如果了解C#窗体应

    这是大二上学期课设的一道题,我当时刚好学习了C#,C#窗体应用程序的界面代码和业务代码是分开的,这比其他同学使用的C++MFC要方便很多,分享给你,希望对你有帮助。阅读本文并加以实现的话,需要有一定的C#编程基础,当然,代码里面计算中缀表达式的方法还是值得一看的。
    在编辑区它是这样子的:
    这里写图片描述

    注意右侧的解决方案资源管理器中的文件,后面会一个一个粘上来~~~

    在看看运行时的效果吧:
    这里写图片描述

    如果了解C#窗体应用程序,实现起来应该是不会有问题的,我下面就开始贴代码了,敲黑板~~~我们的重点在栈和队列的应用

    (哇,还是上GitHub的地址吧,非代码的操作有点多——https://github.com/DongjinLiu/Csharp

    Form1.cs

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace 计算器的设计与实现CSharp
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
    
            string input="";
            /// <summary>
            /// 监听输入函数
            /// </summary>
            /// <param name="c">输入的字符</param>
            void Input(char c)
            {
                input += c;
            }
            /// <summary>
            /// 显示函数
            /// </summary>
            void ShowMessage()
            {
                txtBox.Text = input;
            }
    
            #region 监听输入
            private void btn1_Click(object sender, EventArgs e)
            {
                Input('1');
                ShowMessage();
            }
    
            private void btn2_Click(object sender, EventArgs e)
            {
                Input('2');
                ShowMessage();
            }
    
            private void btn3_Click(object sender, EventArgs e)
            {
                Input('3');
                ShowMessage();
            }
    
            private void btn4_Click(object sender, EventArgs e)
            {
                Input('4');
                ShowMessage();
            }
    
            private void btn5_Click(object sender, EventArgs e)
            {
                Input('5');
                ShowMessage();
            }
    
            private void btn6_Click(object sender, EventArgs e)
            {
                Input('6');
                ShowMessage();
            }
    
            private void btn7_Click(object sender, EventArgs e)
            {
                Input('7');
                ShowMessage();
            }
    
            private void btn8_Click(object sender, EventArgs e)
            {
                Input('8');
                ShowMessage();
            }
    
            private void btn9_Click(object sender, EventArgs e)
            {
                Input('9');
                ShowMessage();
            }
    
            private void btn0_Click(object sender, EventArgs e)
            {
                Input('0');
                ShowMessage();
            }
    
            private void btnAdd_Click(object sender, EventArgs e)
            {
                Input('+');
                ShowMessage();
            }
    
            private void btnSubtruct_Click(object sender, EventArgs e)
            {
                Input('-');
                ShowMessage();
            }
    
            private void btnRide_Click(object sender, EventArgs e)
            {
                Input('x');
                ShowMessage();
            }
    
            private void btnRemove_Click(object sender, EventArgs e)
            {
                Input('÷');
                ShowMessage();
            }
    
            private void btnDot_Click(object sender, EventArgs e)
            {
                Input('.');
                ShowMessage();
            }
    
            private void btnClear_Click(object sender, EventArgs e)
            {
                input = "";
                txtBox.Text = "";
                ShowMessage();
                txtBox.ReadOnly = false;
                btnEqual.Enabled = true;
            }
            #endregion
    
            /// <summary>
            /// 判断运算优先级
            /// </summary>
            /// <param name="sign"></param>
            /// <returns></returns>
            private int GetSignYouXianJi(char sign)  // get sign priority
            {
                switch (sign)
                {
                    case '+':
                    case '-':
                        return 1;
                    case 'x':
                    case '÷':
                        return 2;
                }
                return -1;
            }
    
            /// <summary>
            /// 分析后缀表达式
            /// </summary>
            /// <param name="obj">用户输入的信息</param>
            /// <returns></returns>
            private char HouZhuiBiaoDaShi(string obj)
            {
                if (obj == "+")
                {
                    return '+';
                }
                else if (obj == "-")
                {
                    return '-';
                }
                else if (obj == "x")
                {
                    return 'x';
                }
                else if (obj == "÷")
                {
                    return '÷';
                }
                else                
                {
                    return '0';
                }
            }
    
    
            /// <summary>
            /// 计算表达式的结果
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void btnEqual_Click(object sender, EventArgs e)
            {
                btnEqual.Enabled = false;//避免多次输入"="带来的异常
    
                Stack<double> tempStack = new Stack<double>();                  // 运算栈
                Queue<string> houZhuiBiaoDaShiQueue = new Queue<string>();     // 保存后缀表达式的队列
                Stack<char> signStack = new Stack<char>();                      // 运算符栈
    
                string tempStr = "";                                            // 临时记录输入的数字或小数点
                int objType;
                double tempDouble;
    
                try
                {
                    #region 中缀表达式转后缀表达式
                    for (int i = 0; i < input.Length; i++)
                    {
                        if (input[i] <= '9' && input[i] >= '0' || input[i] == '.')  //找出运算数
                        {
                            tempStr += input[i];
                        }
                        else
                        {
                            if (tempStr.Length > 0)             //如果符号前存在数字,则将数字添加到houZhuiBiaoDaShiQueue队尾
                            {
                                houZhuiBiaoDaShiQueue.Enqueue(tempStr);
                                tempStr = "";
                            }
                            if (signStack.Count == 0)           //运算符栈为空,该运算符直接入栈
                            {
                                signStack.Push(input[i]);
                            }
                            else                                //运算符栈不为空,需要判断运算符的优先级
                            {
                                #region 判断运算优先级
                                if (GetSignYouXianJi(input[i]) > GetSignYouXianJi(signStack.Peek()))
                                {
                                    signStack.Push(input[i]);
                                }
                                else
                                {
                                    while (true)
                                    {
                                        houZhuiBiaoDaShiQueue.Enqueue(Convert.ToString(signStack.Pop()));
                                        if (signStack.Count == 0 || GetSignYouXianJi(input[i]) > GetSignYouXianJi(signStack.Peek()))
                                            break;
                                    }
                                    signStack.Push(input[i]);
                                }
                                #endregion
                            }
                        }
                    }   // end for
    
                    if (tempStr.Length > 0)   //将最后一个运算数添加到houZhuiBiaoDaShiQueue队尾
                    {
                        houZhuiBiaoDaShiQueue.Enqueue(tempStr);
                        tempStr = "";
                    }
                    while (signStack.Count > 0)//将所有运算符依次添加到队尾,形成后缀表达式
                    {
                        houZhuiBiaoDaShiQueue.Enqueue(Convert.ToString(signStack.Pop()));
                    }
                    #endregion
    
                    signStack.Clear();
                    tempStr = "";
    
                    #region 计算后缀表达式
    
                    while (houZhuiBiaoDaShiQueue.Count > 0)
                    {
                        objType = HouZhuiBiaoDaShi(houZhuiBiaoDaShiQueue.Peek());
                        switch (objType)
                        {
                            case '0':                 // 如果是运算数,则直接入栈(并在后缀表达式队列中移除该运算数)
                                tempStack.Push(Convert.ToDouble(houZhuiBiaoDaShiQueue.Dequeue()));
                                break;
                            case '+':
                                houZhuiBiaoDaShiQueue.Dequeue();//在后缀表达式队列中移除该运算符
                                tempStack.Push(tempStack.Pop() + tempStack.Pop());
                                break;
                            case '-':
                                houZhuiBiaoDaShiQueue.Dequeue();
                                tempDouble = tempStack.Pop();//提取出减数
                                tempStack.Push(tempStack.Pop() - tempDouble);
                                break;
                            case 'x':
                                houZhuiBiaoDaShiQueue.Dequeue();
                                tempStack.Push(tempStack.Pop() * tempStack.Pop());
                                break;
                            case '÷':
                                houZhuiBiaoDaShiQueue.Dequeue();
                                tempDouble = tempStack.Pop();//提取出除数
                                if (tempDouble != 0)
                                {
                                    tempStack.Push(tempStack.Pop() / tempDouble);
                                }
                                else
                                {
                                    MessageBox.Show("Error: 0是被除数!");
                                }
                                break;
                            default:
                                MessageBox.Show("未知错误!");
                                break;
                        }
                    }
                    #endregion
    
                    input += "=" + Convert.ToString(tempStack.Pop());
    
                    ShowMessage();
                    txtBox.ReadOnly = true;
                }
                catch (Exception)
                {
                    MessageBox.Show("请输入正确的运算式!");
                    throw;
                }
            }
        }
    }
    

    当时我正好看了设计模式这本书,下面的代码有点走架构风,不过感觉也不影响理解

    Operation.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 计算器的设计与实现CSharp
    {
        public class Operation:Form1
        {
            public double NumberA { get; set; }
            public double NumberB { get; set; }
            public virtual double GetResult()
            {
                double result = 0;
                return result;
            }
    
        }
    }
    

    OperationAdd.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 计算器的设计与实现CSharp
    {
        public class OperationAdd : Operation
        {
            public override double GetResult()
            {
                return NumberA + NumberB;
            }
    
        }
    }
    

    OperationRemove.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 计算器的设计与实现CSharp
    {
       public class OperationRemove:Operation
        {
            public override double GetResult()
            {
                if (NumberB!=0.0)
                {
                    return NumberA / NumberB;
                }
                else
                {
                    return 0;
                }
            }
    
        }
    }
    

    OperationRide.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 计算器的设计与实现CSharp
    {
        public class OperationRide:Operation
        {
            public override double GetResult()
            {
                return NumberA * NumberB;
            }
    
        }
    }
    

    OperationSubtruct.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 计算器的设计与实现CSharp
    {
        public class OperationSubtruct : Operation
        {
            public override double GetResult()
            {
                return NumberA - NumberB;
            }
    
        }
    }
    
    
    

    自我感觉注释写得很清楚了,希望对你有帮助~~~

    GitHub源码https://github.com/DongjinLiu/Csharp

    展开全文
  • 一个计算器,可以进行一些基本的运算,高级的运算也有一点, 如使用期间有问题,欢迎提问!每周五准时回答
  • 一个比较普通计算器VB程序,仅有加减乘除,喝一些基本运算
  • c代码-普通计算器

    2021-07-16 13:22:35
    c代码-普通计算器
  • Java普通计算器

    2015-11-21 19:33:50
    一个可以具体使用的完整的图形化界面的Java计算器,代码实现也是很简单的,基本上新手用用很不错的
  • 一个用C#编写的小程序,计算器~逻辑比较复杂~做的可能不是很好~但是能够运行
  • 这是一个依据月份间隔计算房租的APP,同时提供计算器的功能。仅提供试用,学习交流。计算结果提供参考,不能保证计算结果正确性。本人能力有限,如遇Bug请联系解决。适用于Android 8及以上版本。计算器界面计算结果...
  • 山寨版windows普通计算器,简单的加减乘除,正负数据,开根号,取百分比%,回删,1/x,和MC,MR,MS,M+,M-等,注释齐全无需动脑子就能看懂,大学生交交作业的好帮手
  • calculator:制作普通计算器
  • C# 简易的计算器,可以切换普通及科学模式进行运算,十分适合初学者。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,541
精华内容 7,816
关键字:

下载一个普通计算器