熹熹大人
熹熹大人

简易计算器的设计_C#课程设计

以下内容可且仅可供参考，如有错误欢迎指正。

部分内容借鉴自百度

侵删致歉

位切换键盘的实现用了复杂的拖64给label的方法，此功能可以在自己计算机上的计算器里找到。

目录

一、设计简介

1.设计背景

2.开发工具及环境

二、需求分析

1.设计功能要求

2.其他要求

三、相关工作

1.设计基础

2.功能需求

四、设计原理

详见代码

五、源代码

1.界面

2. Form1.cs

3.Form2.cs

3.Program.cs

一、设计简介

1.设计背景

        伴随着日益升高的物质生活水平以及日常生活中对基本的计算需求的提高。如今，网络快速发展，对算数要求的需求日益增大，计算的效率和性能和人们的生活紧密相关。对此，使用c#语言开发出一个为人们生活带来便利的计算器，以期带来对数据计算的提高。该系统实现了对数的加、减、乘、除以及专业模式的运算。

2.开发工具及环境

1)   开发工具及介绍

        Microsoft Visual Studio（简称VS）。VS是美国微软公司的开发工具包系列产品。VS是一个基本完整的开发工具集，它包括了整个软件生命周期中所需要的大部分工具，如UML工具、代码管控工具、集成开发环境(IDE)等等。所写的目标代码适用于微软支持的所有平台，包括Microsoft Windows、Windows Mobile、Windows CE、.NET Framework、.Net Core、.NET Compact Framework和Microsoft Silverlight 及Windows Phone。

2)   开发环境

        window10系统、window11系统、Microsoft Visual Studio2019、2022。

二、需求分析

1.设计功能要求

1）实现加、减、乘、除、求开方、求倒数等。

2）实现进制之间的转换功能：十进制、二进制、十六进制、八进制。

2.其他要求

1）界面美观，功能丰富

2）开放平台：vs2010及以上

三、相关工作

1.设计基础

        使用Windows窗体应用程序，设计出美观丰富的用户界面（UI）以及相关代码编写设计程序而集成的一个简易的计算器，通过Windows窗体应用程序来添加控件，来组成所需要的运算和数字来达到简易模式以及专业模式。

2.功能需求

        图形化用户界面，设计的简易计算器，用户通过button按钮选择用户想要的算法、数字以及运算符号，进行简易模式以及专业模式。具体如下：

1）当进行简易模式的时候

  1. 鼠标单击“计算器”上的数字按钮（0、1、2、3、4、5、6、7、8、9、.）累次可以设置参与运算的数值。
  2. 鼠标单击“计算器”上的运算符号按钮（+、-、*、=、%）。
  3. 如果需要删除错误的数据，鼠标单击“计算器”上的Delete button按钮。
  4. 如果要清除历史就单击CE按钮。
  5. 此简易模式可以读取历史记录、清除历史记录、保存历史记录，以便于用户在旁边的空白处查看。

2）当进行专业模式的时候

  1. 鼠标单击“计算器”上面的数字按钮（button）（0、1、2、3、4、5、6、7、8、9、.、A、B、C、D、E、F、b、x、^、！、（））累次可以设置参与运算的数值。
  2. 鼠标单击“计算器”上的运算符号按钮（content）（+、-、*、=、%、）。
  3. 鼠标单击“计算器”，选择进制（二进制（前缀0b）、八进制（前缀0）、十进制、十六进制（0x））。
  4. 此简易模式也可以读取历史记录、清除历史记录、保存历史记录，展示在旁边的空白格中。
  5. 在专业模式下，还有含有64位数字的二进制，在数字上修改二进制，变可在下方得到相应的八进制、十进制、十六进制。

四、设计原理

详见代码

五、源代码

1.界面

Form1.cs[设计]

简易计算器的设计_C#课程设计_第1张图片

 Form2.cs[设计]

 简易计算器的设计_C#课程设计_第2张图片

2. 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.Windows.Forms;
using System.Text.RegularExpressions;
using System.IO;

namespace _1._2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        
        private static List temp = new List();
        private static long tempx = 0;
        private void Add(object sender, EventArgs e)
        {   //数字和符号的Click事件
            Button button = (Button)sender;
            textBox1.Text += button.Text;
        }
        private void Reset(object sender, EventArgs e)
        {   // CE的Click事件
            textBox1.Text = "";
        }
        private void Delete(object sender, EventArgs e)
        {   // ←的Click事件
            //移除最后一个字符
            if (textBox1.TextLength > 0)
                textBox1.Text = textBox1.Text.Remove(textBox1.TextLength - 1);
        }
        private void Equal(object sender, EventArgs e)
        {   // = 的Click事件，计算并显示
            //自动清除历史文件夹
            Cleanf();
            List zhonglist = ToList(textBox1.Text);
            List houlist = houzhui(zhonglist);
            List s = zhonglist;
            s.Add("=");
            s.Add(Calculate(houlist));
            string s1 = string.Join("", s);
            if (temp.Count > 9)//最多存十条记录
            {
                temp.RemoveAt(0);
            }
            temp.Add(s1);
            textBox2.Text = string.Join(",",temp);
            textBox1.Text = Calculate(houlist);
        }
        //中缀转List
        static List ToList(string s)
        {
            List ls = new List();//存放中缀表达式
            String str = "";               //拼接多位数、小数
            char c = ' ';                  //遍历输入的字符
            int i = 0;

            do
            {
                if((s[i] == '-' && i == 0) || (i > 0 && s[i] == '-' && !char.IsDigit(s[i - 1])))//在负数前加零方便后续计算
                {
                    ls.Add("0");
                }
                if (!char.IsDigit(c = s[i])&&c != '.') //如果c不是数字和'.'，就加入ls
                {
                    ls.Add(c.ToString());
                    i++;    //i后移
                }
                else//如果是数字，需要考虑多位数
                {
                    str = "";   //先将str清空
                    while (i < s.Length && (char.IsDigit(c = s[i]) || c == '.'))
                    {
                        str += c;
                        i++;
                    }
                    ls.Add(str);
                }
            } while (i < s.Length);
            return ls;
        }
        //中缀改后缀
        static List houzhui(List ls)
        {
            //定义两个栈,一个存临时结果，一个存运算符
            Stack operators = new Stack();
            
            List num = new List();

            //遍历 ls
            foreach (var item in ls)
            {
                Regex regex = new Regex("[+-]?\\d+.?\\d*");//整数和浮点数
                //如果是一个数，则加入num
                if (regex.Match(item).Length > 0)
                {
                    num.Add(item);
                }
                else if (item.Equals("("))//Equals:比较是否相同
                {
                    operators.Push(item);
                }
                else if (item.Equals(")"))
                {
                    //如果是右括号,则依次弹出operators栈顶的运算符,并压入num,直到遇到左括号为止,并将这对括号丢弃
                    while (!operators.Peek().Equals("("))//Peek()返回顶部对象
                    {
                        num.Add(operators.Pop());
                    }
                    operators.Pop();   //将 ( 弹出
                }
                else
                {
                    //当item 的 优先级小于或等于operators栈顶运算符，将operators栈顶的运算符弹出并加入到num中，再次转到operators与operators中新的栈顶运算符比较
                    while (operators.Count != 0 && compare(operators.Peek()) >= compare(item))
                    {
                        num.Add(operators.Pop());
                    }
                    //还需要将 item 压入栈
                    operators.Push(item);
                }
            }

            //将operators中剩余的运算符依次弹出并加入num
            while (operators.Count != 0)
            {
                num.Add(operators.Pop());
            }

            return num;  //按顺序输出就是对应的后缀表达式对应的List
        }
        //运算符优先级
        public static int compare(string operation)
        {
            int res = 0;
            switch (operation)
            {
                case "+":
                    res = 1;
                    break;
                case "-":
                    res = 1;
                    break;
                case "*":
                    res = 2;
                    break;
                case "/":
                    res = 2;
                    break;
                case "%":
                    res = 3;
                    break;
                case "^":
                    res = 4;
                    break;
                case "!":
                    res = 5;
                    break;
                default:
                    Console.WriteLine("不存在该运算符");
                    break;
            }
            return res;
        }
        //计算后缀表达式
        static string Calculate(List ls)
        {
            Regex regex = new Regex("[+-]?\\d+.?\\d*");
            //创建栈
            Stack stack = new Stack();
            //遍历 list
            foreach (var item in ls)
            {
                //使用正则表达式来取出数
                if (regex.Match(item).Length > 0) //如果是数字,就压入栈中
                {
                    stack.Push(regex.Match(item).Value);
                }
                else if (item.Equals("!"))//弹出一个数字进行计算
                {
                    int num1 = int.Parse(stack.Pop());
                    int res = leicheng(num1);
                    stack.Push(res.ToString());
                }
                else    //不是数就弹出两个数字进行计算
                {
                    double num2 = double.Parse(stack.Pop());
                    if (stack.Count == 0)
                    {
                        stack.Push("0");
                    }
                    double num1 = double.Parse(stack.Pop());
                    double res = 0;
                    if (item.Equals("+"))
                    {
                        res = num1 + num2;
                    }
                    else if (item.Equals("-"))
                    {
                        res = num1 - num2;
                    }
                    else if (item.Equals("*"))
                    {
                        res = num1 * num2;
                    }
                    else if (item.Equals("÷"))
                    {
                        res = num1 / num2;
                    }
                    else if (item.Equals("%"))
                    {
                        res = num1 % num2;
                    }
                    else if (item.Equals("^"))
                    {
                        res = Math.Pow(num1, num2);
                    }
                    else
                    {
                        throw new Exception("表达式有误");
                    }
                    stack.Push(res.ToString());
                }
            }

            //最后留在stack中的数据就是运算结果
            return stack.Pop();
        }
        //累乘
        private static int leicheng(int n)
        {
            if(n == 1)
            {
                return n;
            }
            else
            {
                return n * leicheng(n - 1);
            }
        }
        //进制转换
        //二进制的前缀为 0b
        //八进制的前缀为 0
        //十六进制的前缀为 0x
        private void jinzhi2(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            switch(s[0])
            {
                case '0':
                    switch (s[1])
                    {
                        case 'x'://十六转二
                            s = s.Substring(2);//去掉前缀
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 16), 2);//先转十再转二
                            break;
                        default://八转二
                            s = s.Substring(1);
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 8), 2);
                            break;
                    }
                    break;
                default://十转二
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s), 2);
                    break;
            }
        }
        private void jinzhi8(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            switch (s[0])
            {
                case '0':
                    switch (s[1])
                    {
                        case 'x'://十六转八
                            s = s.Substring(2);//去掉前缀
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 16), 8);//先转十再转八
                            break;
                        case 'b'://二转八
                            s = s.Substring(2);
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 2), 8);
                            break;
                    }
                    break;
                default://十转八
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s), 8);
                    break;
            }
        }
        private void jinzhi10(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            
            switch (s[1])
            {
                case 'x'://十六转十
                    s = s.Substring(2);//去掉前缀
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s, 16));
                    break;
                case 'b'://二转十
                    s = s.Substring(2);
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s, 2));
                    break;
                default://八转十
                    s = s.Substring(1);
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s, 8));
                    break;
            }
        }
        private void jinzhi16(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            switch (s[0])
            {
                case '0':
                    switch (s[1])
                    {
                        case 'b'://二转十六
                            s = s.Substring(2);//去掉前缀
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 2), 16); ;//先转十再转十六
                            break;
                        default://八转十六
                            s = s.Substring(1);
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 8), 16);
                            break;
                    }
                    break;
                default://十转十六
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s), 16);
                    break;
            }
        }
        private void Reset2(object sender, EventArgs e)
        {   // 清除历史记录的Click事件
            textBox2.Text = "";
            temp.Clear();
            Cleanf();
        }
        //清空历史记录文件
        private void Cleanf()
        {
            File.Delete("历史记录1.txt");
            FileStream f = File.Create("历史记录1.txt");
            f.Close();
        }
        //读取文件到历史记录
        private void Readf(object sender, EventArgs e)
        {   //读取历史记录的Click事件
            StreamReader sr = new StreamReader("历史记录1.txt");
            string s;
            if((s = sr.ReadLine()) != null)
            {
                String[] s1 = s.Split(',');
                List s2 = new List(s1);
                temp = s2;
                textBox2.Text = string.Join(",", temp);
            }
            sr.Close();
        }
        //打开文件，
        private void Openf(object sender, EventArgs e)
        {  //保存历史记录的Click事件
            StreamWriter sw = new StreamWriter("历史记录1.txt");
            sw.WriteLine(string.Join(",", temp));
            sw.Close();
        }

        //以下是位切换键盘设计代码，不会高级方法，拖了64个label控制0和1

        private void jisuan(string s,int n)
        {
            long t = 1;
            for(int i = 0;i < n - 1;i++)
            {
                t *= 2;
            }
            if(s == "0")
            {
                tempx -= t;
            }
            else
            {
                tempx += t;
            }

            label72.Text = Convert.ToString(tempx , 8);
            label73.Text = Convert.ToString(tempx);
            label74.Text = Convert.ToString(tempx, 16);
        }
        private void ex1(object sender, EventArgs e)
        {
            if(label1.Text == "0")
            {
                label1.Text = "1";
            }
            else
            {
                label1.Text = "0";
            }
            jisuan(label1.Text,1);
        }

        private void ex2(object sender, EventArgs e)
        {
            if (label2.Text == "0")
            {
                label2.Text = "1";
            }
            else
            {
                label2.Text = "0";
            }
            jisuan(label2.Text, 2);
        }

        private void ex3(object sender, EventArgs e)
        {
            if (label3.Text == "0")
            {
                label3.Text = "1";
            }
            else
            {
                label3.Text = "0";
            }
            jisuan(label3.Text, 3);
        }

        private void ex4(object sender, EventArgs e)
        {
            if (label4.Text == "0")
            {
                label4.Text = "1";
            }
            else
            {
                label4.Text = "0";
            }
            jisuan(label4.Text, 4);
        }

        private void ex5(object sender, EventArgs e)
        {
            if (label5.Text == "0")
            {
                label5.Text = "1";
            }
            else
            {
                label5.Text = "0";
            }
            jisuan(label5.Text, 5);
        }

        private void ex6(object sender, EventArgs e)
        {
            if (label6.Text == "0")
            {
                label6.Text = "1";
            }
            else
            {
                label6.Text = "0";
            }
            jisuan(label6.Text, 6);
        }

        private void ex7(object sender, EventArgs e)
        {
            if (label7.Text == "0")
            {
                label7.Text = "1";
            }
            else
            {
                label7.Text = "0";
            }
            jisuan(label7.Text, 7);
        }

        private void ex8(object sender, EventArgs e)
        {
            if (label8.Text == "0")
            {
                label8.Text = "1";
            }
            else
            {
                label8.Text = "0";
            }
            jisuan(label8.Text, 8);
        }

        private void ex9(object sender, EventArgs e)
        {
            if (label9.Text == "0")
            {
                label9.Text = "1";
            }
            else
            {
                label9.Text = "0";
            }
            jisuan(label9.Text, 9);
        }

        private void ex10(object sender, EventArgs e)
        {
            if (label10.Text == "0")
            {
                label10.Text = "1";
            }
            else
            {
                label10.Text = "0";
            }
            jisuan(label10.Text, 10);
        }

        private void ex11(object sender, EventArgs e)
        {
            if (label11.Text == "0")
            {
                label11.Text = "1";
            }
            else
            {
                label11.Text = "0";
            }
            jisuan(label11.Text, 11);
        }

        private void ex12(object sender, EventArgs e)
        {
            if (label12.Text == "0")
            {
                label12.Text = "1";
            }
            else
            {
                label12.Text = "0";
            }
            jisuan(label12.Text, 12);
        }

        private void ex13(object sender, EventArgs e)
        {
            if (label13.Text == "0")
            {
                label13.Text = "1";
            }
            else
            {
                label13.Text = "0";
            }
            jisuan(label13.Text, 13);
        }

        private void ex14(object sender, EventArgs e)
        {
            if (label14.Text == "0")
            {
                label14.Text = "1";
            }
            else
            {
                label14.Text = "0";
            }
            jisuan(label14.Text, 14);
        }

        private void ex15(object sender, EventArgs e)
        {
            if (label15.Text == "0")
            {
                label15.Text = "1";
            }
            else
            {
                label15.Text = "0";
            }
            jisuan(label15.Text, 15);
        }

        private void ex16(object sender, EventArgs e)
        {
            if (label16.Text == "0")
            {
                label16.Text = "1";
            }
            else
            {
                label16.Text = "0";
            }
            jisuan(label16.Text, 16);
        }

        private void ex17(object sender, EventArgs e)
        {
            if (label17.Text == "0")
            {
                label17.Text = "1";
            }
            else
            {
                label17.Text = "0";
            }
            jisuan(label17.Text, 17);
        }

        private void ex18(object sender, EventArgs e)
        {
            if (label18.Text == "0")
            {
                label18.Text = "1";
            }
            else
            {
                label18.Text = "0";
            }
            jisuan(label18.Text, 18);
        }

        private void ex19(object sender, EventArgs e)
        {
            if (label19.Text == "0")
            {
                label19.Text = "1";
            }
            else
            {
                label19.Text = "0";
            }
            jisuan(label19.Text, 19);
        }

        private void ex20(object sender, EventArgs e)
        {
            if (label20.Text == "0")
            {
                label20.Text = "1";
            }
            else
            {
                label20.Text = "0";
            }
            jisuan(label20.Text, 20);
        }

        private void ex21(object sender, EventArgs e)
        {
            if (label21.Text == "0")
            {
                label21.Text = "1";
            }
            else
            {
                label21.Text = "0";
            }
            jisuan(label21.Text, 21);
        }

        private void ex22(object sender, EventArgs e)
        {
            if (label22.Text == "0")
            {
                label22.Text = "1";
            }
            else
            {
                label22.Text = "0";
            }
            jisuan(label22.Text, 22);
        }

        private void ex23(object sender, EventArgs e)
        {
            if (label23.Text == "0")
            {
                label23.Text = "1";
            }
            else
            {
                label23.Text = "0";
            }
            jisuan(label23.Text, 23);
        }

        private void ex24(object sender, EventArgs e)
        {
            if (label24.Text == "0")
            {
                label24.Text = "1";
            }
            else
            {
                label24.Text = "0";
            }
            jisuan(label24.Text, 24);
        }

        private void ex25(object sender, EventArgs e)
        {
            if (label25.Text == "0")
            {
                label25.Text = "1";
            }
            else
            {
                label25.Text = "0";
            }
            jisuan(label25.Text, 25);
        }

        private void ex26(object sender, EventArgs e)
        {
            if (label26.Text == "0")
            {
                label26.Text = "1";
            }
            else
            {
                label26.Text = "0";
            }
            jisuan(label26.Text, 26);
        }

        private void ex27(object sender, EventArgs e)
        {
            if (label27.Text == "0")
            {
                label27.Text = "1";
            }
            else
            {
                label27.Text = "0";
            }
            jisuan(label27.Text, 27);
        }

        private void ex28(object sender, EventArgs e)
        {
            if (label28.Text == "0")
            {
                label28.Text = "1";
            }
            else
            {
                label28.Text = "0";
            }
            jisuan(label28.Text, 28);
        }

        private void ex29(object sender, EventArgs e)
        {
            if (label29.Text == "0")
            {
                label29.Text = "1";
            }
            else
            {
                label29.Text = "0";
            }
            jisuan(label29.Text, 29);
        }

        private void ex30(object sender, EventArgs e)
        {
            if (label30.Text == "0")
            {
                label30.Text = "1";
            }
            else
            {
                label30.Text = "0";
            }
            jisuan(label30.Text, 30);
        }

        private void ex31(object sender, EventArgs e)
        {
            if (label31.Text == "0")
            {
                label31.Text = "1";
            }
            else
            {
                label31.Text = "0";
            }
            jisuan(label31.Text, 31);
        }
        private void ex32(object sender, EventArgs e)
        {
            if (label32.Text == "0")
            {
                label32.Text = "1";
            }
            else
            {
                label32.Text = "0";
            }
            jisuan(label32.Text, 32);
        }
        private void ex33(object sender, EventArgs e)
        {
            if (label33.Text == "0")
            {
                label33.Text = "1";
            }
            else
            {
                label33.Text = "0";
            }
            jisuan(label33.Text, 33);
        }
        private void ex34(object sender, EventArgs e)
        {
            if (label34.Text == "0")
            {
                label34.Text = "1";
            }
            else
            {
                label34.Text = "0";
            }
            jisuan(label34.Text, 34);
        }
        private void ex35(object sender, EventArgs e)
        {
            if (label35.Text == "0")
            {
                label35.Text = "1";
            }
            else
            {
                label35.Text = "0";
            }
            jisuan(label35.Text, 35);
        }
        private void ex36(object sender, EventArgs e)
        {
            if (label36.Text == "0")
            {
                label36.Text = "1";
            }
            else
            {
                label36.Text = "0";
            }
            jisuan(label36.Text, 36);
        }
        private void ex37(object sender, EventArgs e)
        {
            if (label37.Text == "0")
            {
                label37.Text = "1";
            }
            else
            {
                label37.Text = "0";
            }
            jisuan(label37.Text, 37);
        }
        private void ex38(object sender, EventArgs e)
        {
            if (label38.Text == "0")
            {
                label38.Text = "1";
            }
            else
            {
                label38.Text = "0";
            }
            jisuan(label38.Text, 38);
        }
        private void ex39(object sender, EventArgs e)
        {
            if (label39.Text == "0")
            {
                label39.Text = "1";
            }
            else
            {
                label39.Text = "0";
            }
            jisuan(label39.Text, 39);
        }
        private void ex40(object sender, EventArgs e)
        {
            if (label40.Text == "0")
            {
                label40.Text = "1";
            }
            else
            {
                label40.Text = "0";
            }
            jisuan(label40.Text, 40);
        }
        private void ex41(object sender, EventArgs e)
        {
            if (label41.Text == "0")
            {
                label41.Text = "1";
            }
            else
            {
                label41.Text = "0";
            }
            jisuan(label41.Text, 41);
        }
        private void ex42(object sender, EventArgs e)
        {
            if (label42.Text == "0")
            {
                label42.Text = "1";
            }
            else
            {
                label42.Text = "0";
            }
            jisuan(label42.Text, 42);
        }
        private void ex43(object sender, EventArgs e)
        {
            if (label43.Text == "0")
            {
                label43.Text = "1";
            }
            else
            {
                label43.Text = "0";
            }
            jisuan(label43.Text, 43);
        }
        private void ex44(object sender, EventArgs e)
        {
            if (label44.Text == "0")
            {
                label44.Text = "1";
            }
            else
            {
                label44.Text = "0";
            }
            jisuan(label44.Text, 44);
        }
        private void ex45(object sender, EventArgs e)
        {
            if (label45.Text == "0")
            {
                label45.Text = "1";
            }
            else
            {
                label45.Text = "0";
            }
            jisuan(label45.Text, 45);
        }
        private void ex46(object sender, EventArgs e)
        {
            if (label46.Text == "0")
            {
                label46.Text = "1";
            }
            else
            {
                label46.Text = "0";
            }
            jisuan(label46.Text, 46);
        }
        private void ex47(object sender, EventArgs e)
        {
            if (label47.Text == "0")
            {
                label47.Text = "1";
            }
            else
            {
                label47.Text = "0";
            }
            jisuan(label47.Text, 47);
        }
        private void ex48(object sender, EventArgs e)
        {
            if (label48.Text == "0")
            {
                label48.Text = "1";
            }
            else
            {
                label48.Text = "0";
            }
            jisuan(label48.Text, 48);
        }
        private void ex49(object sender, EventArgs e)
        {
            if (label49.Text == "0")
            {
                label49.Text = "1";
            }
            else
            {
                label49.Text = "0";
            }
            jisuan(label49.Text, 9);
        }
        private void ex50(object sender, EventArgs e)
        {
            if (label50.Text == "0")
            {
                label50.Text = "1";
            }
            else
            {
                label50.Text = "0";
            }
            jisuan(label50.Text, 50);
        }
        private void ex51(object sender, EventArgs e)
        {
            if (label51.Text == "0")
            {
                label51.Text = "1";
            }
            else
            {
                label51.Text = "0";
            }
            jisuan(label51.Text, 51);
        }
        private void ex52(object sender, EventArgs e)
        {
            if (label52.Text == "0")
            {
                label52.Text = "1";
            }
            else
            {
                label52.Text = "0";
            }
            jisuan(label52.Text, 52);
        }
        private void ex53(object sender, EventArgs e)
        {
            if (label53.Text == "0")
            {
                label53.Text = "1";
            }
            else
            {
                label53.Text = "0";
            }
            jisuan(label53.Text, 53);
        }
        private void ex54(object sender, EventArgs e)
        {
            if (label54.Text == "0")
            {
                label54.Text = "1";
            }
            else
            {
                label54.Text = "0";
            }
            jisuan(label54.Text, 54);
        }
        private void ex55(object sender, EventArgs e)
        {
            if (label55.Text == "0")
            {
                label55.Text = "1";
            }
            else
            {
                label55.Text = "0";
            }
            jisuan(label55.Text, 55);
        }
        private void ex56(object sender, EventArgs e)
        {
            if (label56.Text == "0")
            {
                label56.Text = "1";
            }
            else
            {
                label56.Text = "0";
            }
            jisuan(label56.Text, 56);
        }
        private void ex57(object sender, EventArgs e)
        {
            if (label57.Text == "0")
            {
                label57.Text = "1";
            }
            else
            {
                label57.Text = "0";
            }
            jisuan(label57.Text, 57);
        }
        private void ex58(object sender, EventArgs e)
        {
            if (label58.Text == "0")
            {
                label58.Text = "1";
            }
            else
            {
                label58.Text = "0";
            }
            jisuan(label58.Text, 58);
        }
        private void ex59(object sender, EventArgs e)
        {
            if (label59.Text == "0")
            {
                label59.Text = "1";
            }
            else
            {
                label59.Text = "0";
            }
            jisuan(label59.Text, 59);
        }
        private void ex60(object sender, EventArgs e)
        {
            if (label60.Text == "0")
            {
                label60.Text = "1";
            }
            else
            {
                label60.Text = "0";
            }
            jisuan(label60.Text, 60);
        }
        private void ex61(object sender, EventArgs e)
        {
            if (label61.Text == "0")
            {
                label61.Text = "1";
            }
            else
            {
                label61.Text = "0";
            }
            jisuan(label61.Text, 61);
        }
        private void ex62(object sender, EventArgs e)
        {
            if (label62.Text == "0")
            {
                label62.Text = "1";
            }
            else
            {
                label62.Text = "0";
            }
            jisuan(label62.Text, 62);
        }
        private void ex63(object sender, EventArgs e)
        {
            if (label63.Text == "0")
            {
                label63.Text = "1";
            }
            else
            {
                label63.Text = "0";
            }
            jisuan(label63.Text, 63);
        }
        private void ex64(object sender, EventArgs e)
        {
            if (label64.Text == "0")
            {
                label64.Text = "1";
            }
            else
            {
                label64.Text = "0";
            }
            jisuan(label64.Text, 64);
        }

        private void label79_Click(object sender, EventArgs e)
        {
            System.Environment.Exit(0);
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {

        }
        //
    }
}

3.Form2.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.IO;

namespace _1._2
{


    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        private static List temp = new List();

        private void button2_Click(object sender, EventArgs e)//CE按钮
        {
            textBox1.Text = "";
        }

        private void button5_Click(object sender, EventArgs e)
        {

        }

        private void Add(object sender, EventArgs e)
        {   //数字和符号的Click事件
            Button button = (Button)sender;
            textBox1.Text += button.Text;
        }

        private void button8_Click(object sender, EventArgs e)
        {

        }

        private void button3_Click(object sender, EventArgs e)//delect按钮
        {
            if (textBox1.TextLength > 0)
                textBox1.Text = textBox1.Text.Remove(textBox1.TextLength - 1);
        }

        private void button9_Click(object sender, EventArgs e)//“=”按钮
        {
            Cleanf();
            List zhonglist = ToList(textBox1.Text);
            List houlist = houzhui(zhonglist);
            List s = zhonglist;
            s.Add("=");
            s.Add(Calculate(houlist));
            string s1 = string.Join("", s);
            if (temp.Count > 9)//最多存十条记录
            {
                temp.RemoveAt(0);
            }
            temp.Add(s1);
            textBox2.Text = string.Join(",", temp);
            textBox1.Text = Calculate(houlist);
        }
        //中缀转List
        static List ToList(string s)
        {
            List ls = new List();//存放中缀表达式
            String str = "";               //拼接多位数、小数
            char c = ' ';                  //遍历输入的字符
            int i = 0;

            do
            {
                if ((s[i] == '-' && i == 0) || (i > 0 && s[i] == '-' && !char.IsDigit(s[i - 1])))//在负数前加零方便后续计算
                {
                    ls.Add("0");
                }
                if (!char.IsDigit(c = s[i]) && c != '.') //如果c不是数字和'.'，就加入ls
                {
                    ls.Add(c.ToString());
                    i++;    //i后移
                }
                else//如果是数字，需要考虑多位数
                {
                    str = "";   //先将str清空
                    while (i < s.Length && (char.IsDigit(c = s[i]) || c == '.'))
                    {
                        str += c;
                        i++;
                    }
                    ls.Add(str);
                }
            } while (i < s.Length);
            return ls;
        }
        static List houzhui(List ls)
        {
            //定义两个栈,一个存临时结果，一个存运算符
            Stack operators = new Stack();

            List num = new List();

            //遍历 ls
            foreach (var item in ls)
            {
                Regex regex = new Regex("[+-]?\\d+.?\\d*");//整数和浮点数
                //如果是一个数，则加入num
                if (regex.Match(item).Length > 0)
                {
                    num.Add(item);
                }
                else if (item.Equals("("))//Equals:比较是否相同
                {
                    operators.Push(item);
                }
                else if (item.Equals(")"))
                {
                    //如果是右括号,则依次弹出operators栈顶的运算符,并压入num,直到遇到左括号为止,并将这对括号丢弃
                    while (!operators.Peek().Equals("("))//Peek()返回顶部对象
                    {
                        num.Add(operators.Pop());
                    }
                    operators.Pop();   //将 ( 弹出
                }
                else
                {
                    //当item 的 优先级小于或等于operators栈顶运算符，将operators栈顶的运算符弹出并加入到num中，再次转到operators与operators中新的栈顶运算符比较
                    while (operators.Count != 0 && compare(operators.Peek()) >= compare(item))
                    {
                        num.Add(operators.Pop());
                    }
                    //还需要将 item 压入栈
                    operators.Push(item);
                }
            }

            //将operators中剩余的运算符依次弹出并加入num
            while (operators.Count != 0)
            {
                num.Add(operators.Pop());
            }

            return num;  //按顺序输出就是对应的后缀表达式对应的List
        }
        //运算符优先级
        public static int compare(string operation)
        {
            int res = 0;
            switch (operation)
            {
                case "+":
                    res = 1;
                    break;
                case "-":
                    res = 1;
                    break;
                case "^":
                    res = 3;
                    break;
                case "*":
                    res = 2;
                    break;
                case "÷":
                    res = 3;
                    break;
                case "%":
                    res = 4;
                    break;
                case "!":
                    res = 5;
                    break;
                default:
                    Console.WriteLine("不存在该运算符");
                    break;
            }
            return res;
        }
        //计算后缀表达式
        static string Calculate(List ls)
        {
            Regex regex = new Regex("[+-]?\\d+.?\\d*");
            //创建栈
            Stack stack = new Stack();
            //遍历 list
            foreach (var item in ls)
            {
                //使用正则表达式来取出数
                if (regex.Match(item).Length > 0) //如果是数字,就压入栈中
                {
                    stack.Push(regex.Match(item).Value);
                }
                else    //不是数就弹出两个数字进行计算
                {
                    double num2 = double.Parse(stack.Pop());
                    double num1 = double.Parse(stack.Pop());
                    double res = 0;
                    if (item.Equals("+"))
                    {
                        res = num1 + num2;
                    }
                    else if (item.Equals("-"))
                    {
                        res = num1 - num2;
                    }
                    else if (item.Equals("×"))
                    {
                        res = num1 * num2;
                    }
                    else if (item.Equals("÷"))
                    {
                        res = num1 / num2;
                    }
                    else if (item.Equals("%"))
                    {
                        res = num1 % num2;
                    }
                    else
                    {
                        throw new Exception("表达式有误");
                    }
                    stack.Push(res.ToString());
                }
            }

            //最后留在stack中的数据就是运算结果
            return stack.Pop();
        }
        private void Cleanf()
        {
            File.Delete("历史记录2.txt");
            FileStream f = File.Create("历史记录2.txt");
            f.Close();
        }

        private void button22_Click(object sender, EventArgs e)//“读取历史”按钮
        {
            StreamReader sr = new StreamReader("历史记录2.txt");
            String s;
            if ((s = sr.ReadLine() )!= null)
            {
                String[] s1 = s.Split(',');
                List s2 = new List(s1);
                temp = s2;
                textBox2.Text = string.Join(",", temp);
            }
            sr.Close();
        }

        private void button23_Click(object sender, EventArgs e)//“清除历史记录”
        {
            textBox2.Text = "";
            temp.Clear();
            Cleanf();
        }

        private void button24_Click(object sender, EventArgs e)
        {
            StreamWriter sw = new StreamWriter("历史记录2.txt");
            sw.WriteLine(string.Join(",", temp));
            sw.Close();
        }

        private void label1_Click(object sender, EventArgs e)
        {
            System.Environment.Exit(0);
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {

        }
    }
    }

3.Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace _1._2
{
    static class Program
    {
        /// 
        /// 应用程序的主入口点。
        /// 
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            //跳转窗口


         Form2 EasyModel = new Form2();
         Form1 PerModel = new Form1(); 
         EasyModel.ShowDialog();
        for(int i=0;i<1;i++)
            {
                if (EasyModel.DialogResult == DialogResult.OK)
                {
                    PerModel.ShowDialog();
                }
                if (PerModel.DialogResult == DialogResult.Cancel)
                {
                    EasyModel.ShowDialog();
                    i = -1;
                }
             
            }
      

        }
    }
}

你可能感兴趣的:(课程设计,c#)

  • C#中的PLINQ和LINQ的效率对比 搬砖的诗人Z C#c#linq开发语言
    PLINQ（ParallelLINQ）和LINQ（LanguageIntegratedQuery）都是.NET框架中的功能，用于对集合进行查询和操作。它们之间的主要区别在于并行处理能力。LINQ:LINQ是一种用于在.NET应用程序中进行数据查询和操作的语言集成功能。它提供了一种统一的方式来查询各种数据源，如集合、数组、XML、数据库等。LINQ是在单线程环境中执行查询操作的，因此对于大型数据集或
  • 程序员开发技术整理 laizhixue 学习前端框架
    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
  • C#学习笔记 2301_79022588 学习笔记
    一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
  • C# CsvHelper 使用 GeGe&YoYo 工具类c#开发语言
    C#CsvHelper使用1.简介CsvHelper是一个用于读写CSV文件的.NET库。极其快速，灵活且易于使用。CsvHelper建立在.NETStandard2.0之上，几乎可以在任何地方运行。Github地址：https://github.com/joshclose/csvhelper2.模块3.读取测试类publicclassFoo{publicintID{get;set;}public
  • C#杨辉三角形 wenchm c#算法数据结构
    目录1.杨辉三角形定义2.用数组实现10层的杨辉三角形3.使用List泛型链表集合设计10层的杨辉三角形（1）代码解释：（2）算法中求余的作用4.使用List泛型链表集合设计10层的等腰的杨辉三角形1.杨辉三角形定义杨辉三角是一个由数字排列成的三角形数表，其最本质的特征是它的两条边都是由数字1组成的，而其余的数则等于它上方的两个数之和。杨辉三角有两种常用的表示形式。2.用数组实现10层的杨辉三角形
  • C#使用ASP.NET Core Razor Pages构建网站（二） 林祖师 C#c#asp.net开发语言
    上一篇文章讲了HTTP协议的基本概念、客户端Web开发技术以及ASP.NETCore框架的关键特点和创建项目方法链接：C#使用ASP.NETCoreRazorPages构建网站（一）接下来继续了解ASP.NETCoreRazorPages构建网站的后续内容了解RazorPagesRazorPages允许开发人员轻松地将HTML标记和C#代码混合在一起，这是使用.cshtml扩展名的原因。默认情况下
  • c#IQueryable和IEnumberable的区别 彭小彭~ c#基础c#
    IQueryable和IEnumerable是C#中处理集合的两个重要接口，常用于LINQ查询。它们有一些关键区别，适用于不同的场景：1.执行查询的位置IEnumerable:当你对一个IEnumerable序列使用LINQ操作时，这些操作是在本地内存中执行的。如果IEnumerable表示数据库中的数据（例如，使用EntityFramework时），那么整个数据集首先会被加载到内存中，然后再应用
  • 游戏客户客户端面经 Unity游戏开发 游戏游戏开发求职程序员
    C#和C++的类的区别C#List添加100个Obj和100int内存是怎么变化的重载和重写的区别，重载是怎么实现的重写是怎么实现的？虚函数表是类的还是对象的用过哪些C++的STLVector底层是怎么实现的Vector添加一百次数据内存是怎么变化Map的底层，红黑树的查询和插入的时间复杂程度，Unordermap的底层实现是什么List的底层是怎么实现的场景里面有6个玩家扮演贪吃蛇进行3v3，场
  • c# 与c++类型对应关系 让您看见未来 c++c#c#开发语言
    c#c++ubytecharshortshortint32int32_tlongint64_tfloatfloatdoubledoubleIntPt,[]void*
  • APP UI自动化测试思路总结 程序员老鹰 ui测试工具开发语言软件测试经验分享程序人生程序员
    首先想要说明一下，APP自动化测试可能很多公司不用，但也是大部分自动化测试工程师、高级测试工程师岗位招聘信息上要求的，所以为了更好的待遇，我们还是需要花时间去掌握的，毕竟谁也不会跟钱过不去。接下来，一起总结一下APPUI自动化测试的思路吧。一，开发语言选择通常用于自动化测试的编程语言有：Python、Java、Javascript、Ruby、C#、PHP等。一般我们会选择自己熟悉的编程语言来编写自
  • C#关键字 namespace xklcy C#关键字c#开发语言
    namespace关键字用于声明包含一组相关对象的作用域。可以使用命名空间来组织代码元素并创建全局唯一类型。在命名空间中，可以声明零个或多个以下类型：class类interface接口struct结构体enum枚举delegate委托namespace可以声明嵌套的命名空间（文件范围的命名空间声明除外）以下示例显示如何在嵌套命名空间中调用静态方法。namespaceSomeNameSpace{pu
  • moba客户端开发面经 Unity游戏开发 面试游戏开发unity
    1、Lua：元表是什么，怎么实现对象继承2、OPP是什么3、mvc结构4、C#:list和array区别和使用场景5、项目：（1）ui框架类设计，ui层级管理怎么做，对象初始化内存占用这样做高，资源是怎么加载的（2）背包数据室怎么加载的，mvc怎么使用的，怎么性能优化的（3）ui的一些优化方式，动静分离，不使用透明，排序减少batch6、帧同步和状态同步介绍：（1）用什么协议，这俩什么区别（2）网
  • KMP算法（java、C#） 以明志、 c#算法java
    文章目录kmp中的nextVal（代码用next数组表示）获取匹配成功的主串下标程序入口（示例）kmp中的nextVal（代码用next数组表示）namespaceTestmain{publicclassGetNext{int[]next;publicint[]getNextArray(char[]ch){next=newint[ch.Length];inti=0,j=-1;next[0]=-1;
  • C#面：throw 和throw ex 的区别 那个那个鱼 C#面试题c#开发语言c#.net
    throw关键字：用于抛出当前异常，并保留原始的异常堆栈信息。当使用throw关键字时，当前异常的堆栈信息将被保留，这对于调试和追踪异常非常有用。例如：try{//一些可能引发异常的代码}catch(Exceptionex){//处理异常throw;//重新抛出当前异常，保留原始的异常堆栈信息}throwex关键字：也用于抛出当前异常，但会重置异常的堆栈信息。当使用throwex关键字时，当前异常
  • 二、C#选择排序算法 哒哒咦哒哒·· c#排序算法数据结构算法
    简介选择排序算法的基本思想是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。选择排序（SelectionSort）原理介绍选择排序（SelectionSort）是一种简单的排序算法，其实现原理如下：遍历待排序数组，从第一个元素开始。假设当前遍历的元素为最
  • C#、ASP、ASP.NET、.NET、ASP.NET CORE区别、ASP.NET Core其概念和特点、ASP.NET Core个人心得体会 lijingguang C#c#
    C#是一种面向对象的编程语言，主要用于开发跨平台的应用程序。它是.NET框架的一部分，并且可以在.NET平台上运行。ASP（ActiveServerPages）是一种用于构建动态Web页面的技术，使用VBScript或JScript作为服务器端脚本语言。它是早期的Microsoft技术，现已逐渐过时。ASP.NET是微软推出的下一代Web应用程序开发技术，它提供了更强大、更高效的功能和工具。ASP
  • 诊所信息管理系统C语言课程设计 black_codemaker Cc语言课程设计开发语言
    1、问题描述完成小型诊所的简单信息管理程序，掌握类的设计以及继承和派生的应用。2、功能要求设计人类（Person类）和医生类（Doctor类），在此基础上，通过增加患者和账单，使它们公用于表示一家诊所的信息管理。（1）在一条医生记录中，包括医生的专业说明（specialty），如内科医生（surgeon）、儿科医生（pediatrician）、产科医生（obstetrician）及全科医生（gen
  • C#编写LINQ查询 林祖师 C#c#linq开发语言
    虽然在前面的文章里编写了一些LINQ查询，但是没有解释LINQ是如何工作的，现在，我们花点时间来正确的理解它们。LINQ有多个组成部分，有些是必须的，而有些是可选的。扩展方法：包括Where、Select、OrderBy等。这些扩展方法使得对集合和数据源进行查询操作变得更加直观和易于理解。表达式：在LINQ中，表达式通常指Lambda表达式，即匿名函数。Lambda表达式允许我们在LINQ查询中编
  • C#常见的.Net类型（二） 林祖师 C#c#.net开发语言
    目录一、在集合中存储多个对象理解集合的选择1.列表2.字典3.堆栈4.队列5.集二、使用Span、索引和范围Span索引范围处理类型和属性1.特性2.创建自定义特性3.反射一、在集合中存储多个对象处理集合的常见类型类型描述List动态大小的数组，可以按索引访问Dictionary键值对集合，根据键进行快速查找Queue先进先出的队列集合Stack后进先出的栈集合HashSet不包含重复元素的集合L
  • C#使用Entity Framework Core处理数据库（三） 林祖师 C#c#开发语言学习
    EntityFrameworkCore（EFCore）是一个轻量级、跨平台的对象关系映射（ORM）框架，用于在.NET应用程序中处理数据库操作。它提供了一种将数据库中的数据映射到.NET对象模型的方法，使开发人员可以使用面向对象的方式进行数据库操作，而无需直接编写SQL语句。上一篇文章讲了在C#中EFCore查询和加载模式：C#使用EntityFrameworkCore处理数据库（二）接下来讲讲使
  • C# Path 类 周杰伦fans 学习C#的笔记c#
    在C#中，Path类位于System.IO命名空间中，提供了一组用于操作和处理文件路径的静态方法。Path类可以用于处理文件名、目录名和路径等相关操作。下面是一些Path类常用的方法和示例说明：Path.Combine：用于组合多个字符串片段来创建一个有效的路径字符串。stringdirectory="C:\\Users";stringfilename="file.txt";stringfullP
  • C#学习汇总 林祖师 C#c#学习开发语言
    C#学习汇总1.C#编程基础C#语法C#使用变量2.控制程序流程和转换类型C#控制台应用程序C#选择语句和迭代语句C#类型转换3.编写函数C#编写函数4.使用面向对象C#构建类库C#在字段中存储数据C#写入和调用方法C#使用属性和索引器控制访问5.实现接口和继承类C#接口和泛型C#学习继承6.使用常见的.NET类型C#常见的.Net类型（一）C#常见的.Net类型（二）7.处理文件、流C#处理文件
  • Uni-app开发Canvas当子组件示例，点点绘制图形 他在时间门外 uni-appjavascript前端
    前言使用Uni-app实现封装一个Canvas渲染的子组件，实现通过传入两点绘制一条完整的路程具体逻辑看我发的后端和数据库设计C#根据两点名称，寻找两短路程的最优解，【有数据库设计，完整代码】即使不了解具体逻辑，该文章同样可以帮助想要实现使用Canvas当子组件，以及点点绘制图形问题的疑惑注意事项问题一：在使用canvas开发时为什么图形没有渲染1.注意画布的尺寸canvas标签默认宽度300px
  • C# 的一些好用的语法糖介绍 搬砖的诗人Z C#c#windows开发语言
    C#中有很多语法糖（Syntacticsugar），它们是一些语言特性，使得编写代码更加简洁、易读、更具表现力。Lambda表达式：Lambda表达式允许你编写简洁的匿名函数。例如：Funcadd=(a,b)=>a+b;自动属性：简化了属性的定义。编译器会自动创建私有字段并生成getter和setter方法。publicintAge{get;set;}集合初始化器：允许你初始化集合类型，使得代码更
  • C#在字段中存储数据 林祖师 C#c#开发语言
    定义字段在C#中，定义字段需要指定字段的类型和名称。字段是类或结构体的成员变量，用于存储数据。以下是一个简单的示例：publicclassMyClass{publicstringname;}可以对字段使用任何类型，包括数组和集合。使用enum类型存储值可以使用enum类型来存储一组相关的值。enum类型是一种枚举类型，它允许你为一组相关的值赋予有意义的名称。以下是一个简单的示例：publicenu
  • C#(C Sharp)学习笔记_变量常量与作用域【十二】 tiamo_16 C#学习笔记c#学习
    变量变量是用来存储数据值的标识符。你可以将变量视为内存中的一个位置，这个位置可以保存不同类型的数据。同时，变量也被称作为类中的成员变量在C#中声明变量时，你需要指定变量的类型，这告诉编译器你打算在变量中存储什么类型的数据。常量在C#中，常量（也称为字面量或常量值）是一种在编译时确定并在程序执行期间不可更改的值。常量可以是任何基本数据类型（如整数、浮点数、字符等）的值，也可以是字符串、枚举类型或引用
  • c# 的ref 和out ISDF-工软未来 C#c#开发语言
    在C#中，ref和out是用于方法参数的关键字，它们都允许在方法调用中对参数进行修改。ref关键字用于传递参数的引用。当使用ref关键字声明一个参数时，实际上是在告诉编译器此参数在调用方法之前必须被赋值。ref参数传递的是参数的引用地址，方法内部对引用地址的修改将影响到方法外部的参数值。函数内部可以赋值，也可以不赋值，但是调用之前必须初始化给值。publicvoidModifyValue(refi
  • Github 2024-03-09 开源项目日报Top10 老孙正经胡说 github开源Github趋势分析开源项目PythonGolang
    根据GithubTrendings的统计，今日(2024-03-09统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Python项目3HTML项目1CSS项目1Swift项目1C#项目1C++项目1JupyterNotebook项目1TypeScript项目1JavaScript项目1Ryujinx:任天堂Switch模拟器创建周期：2223天开发语言：C#协议类
  • C#--StreamWriter和StreamReader对象及常用函数 海绵波波107 C#c#数据库服务器
    目录StreamReaderReadLine()Split（）StreamWriterWriteLine（）Flush()Close()StreamReaderStreamReader是C#中用于从流（如文件、内存流等）中读取文本数据的类。它提供了多种方法来读取不同类型的数据。以下是一些StreamReader类的常用方法：StreamReader(Stream):构造函数，创建一个新的Strea
  • C#控制台应用程序 林祖师 C#c#开发语言
    C#控制台应用程序时基于文本的，在命令行中运行。它们通常执行需要编写的脚本的简单任务，例如编译文件或加密配置文件的一部分。一、向用户显示输出控制台应用程序执行的两个最常见的任务是写入和读取数据，前者使用WriteLine、Write方法来输出数据。使用编号的位置参数进行格式化生成格式化字符串的一种方式是使用编号的位置参数。WriteLine、Writede的方法就支持这一特性，对于不支持这一特性的
  • jvm调优总结（从基本概念 到 深度优化） oloz javajvmjdk虚拟机应用服务器
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html   Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 【Scala十六】Scala核心十：柯里化函数 bit1129 scala
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
  • HashMap dalan_123 java
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构     在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 周凡杨 java更新swingJTextArea
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。 问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
  • servlet或struts的Action处理ajax请求 g21121 servlet
    其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
  • FineReport的公式编辑框的语法简介 老A不折腾 finereport公式总结
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 简单的说下自己感觉的公式要注意的几个地方：   1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
  • linux mysql 数据库乱码的解决办法 墙头上一根草 linuxmysql数据库乱码
    linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写   修改/etc/my.cnf 具体的修改内容如下:   [client] default-character-set=utf8   [mysqld] datadir=/var/lib/mysql socket=/va
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
    ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
  • mysql 基准测试之sysbench annan211 基准测试mysql基准测试MySQL测试sysbench
    1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz  cd sysbench-0.5  chmod +x autogen.sh  ./autogen.sh  ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
  • sql的复杂查询使用案列与技巧 百合不是茶 oraclesql函数数据分页合并查询
      本片博客使用的数据库表是oracle中的scott用户表;          -------------------  自然连接查询           查询 smith 的上司(两种方法) &
  • 深入学习Thread类 bijian1013 javathread多线程java多线程
    一．             线程的名字 下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 同时，Thr
  • JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 javafastjsonnet.sf.json
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 一.fastjson实例 JsonUtil.java package com.study; impor
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成   在 【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
    #!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
  • nginx三种获取用户真实ip的方法 ronin47
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 实例环境： 用户IP 120.22.11.11
  • java-判断二叉树是不是平衡 bylijinnan java
    参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtilsBeanUtils
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
  • [金融与信息安全]最简单的数据结构最安全 comsci 数据结构
          现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？        从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
  • vi区段删除 Cwind linuxvi区段删除
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。   vi概述    引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。   vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号 非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
  • 清除tomcat缓存的方法总结 dashuaifu tomcat缓存
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 出现这种现象的原因主要是tomcat缓存的原因。 解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
  • 不要盲目的在项目中使用LESS CSS dcj3sjt126com Webless
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 　　比如它的引用功能 ? .rounded_corners{     
  • [入门]更上一层楼 dcj3sjt126com PHPyii2
    更上一层楼 通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 本章将介绍一些有助于更好使用 Yii 的资源：
  • Apache HttpClient使用详解 eksliang httpclienthttp协议
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
  • zxing二维码扫描功能 gundumw100 androidzxing
    经常要用到二维码扫描功能 现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
  • 纯HTML+CSS带说明的黄色导航菜单 ini htmlWebhtml5csshovertree
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航   在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果：   <!DOCTYPE html > <html > <head> <title>HoverTree
  • fastjson初始化对性能的影响 kane_xie fastjson序列化
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。   网上的说法：   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
  • 基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/     funct
  • java 计时器应用 tangqi609567707 javatimer
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int
  • erlang输出调用栈信息 wudixiaotie erlang
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 也可以用这个函数：erlang:get_s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他