文本计算器(加入异常处理)

最新推荐文章于 2023-03-11 20:24:01 发布
最新推荐文章于 2023-03-11 20:24:01 发布
阅读量2k 收藏 2
点赞数
分类专栏： Java 文章标签： string character exception import null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sqrt5/article/details/7600489
版权

之前的文本计算器不能提示错误，并且输入错误的时候可能导致程序卡死，之前还不太会异常处理，这个版本加入了异常处理，能简单的分析错误原因，下面是源码，请多指教：


import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
public class TxtCalculator implements ActionListener
{
	JFrame f;
	JPanel pTxt = new JPanel();
	JTextField txt;
	JPanel pShow = new JPanel();
	JTextArea show;
	JMenu mEdit;
	JMenu mView;
	JMenu mHelp;
	JMenuItem mSave;
	JMenuItem mClear;
	JMenuItem mHelpItem;
	JMenuItem mAbout;
	static JButton start;
	String strAll[][]=new String[100][100];
	public TxtCalculator()
	{	
		f = new JFrame("文本计算器");
		JMenuBar mBar = new JMenuBar();
		mBar.setOpaque(true);
		mEdit = new JMenu("编辑");
		mSave = new JMenuItem("保存历史");
		mSave.addActionListener(this);
		mEdit.add(mSave);
		mClear = new JMenuItem("清空历史");
		mClear.addActionListener(this);
		mEdit.add(mClear);
		mHelp = new JMenu("帮助");
		mHelpItem = new JMenuItem("帮助主题");
		mHelpItem.addActionListener(this);
		mHelp.add(mHelpItem);
		mAbout = new JMenuItem("关于计算器");
		mAbout.addActionListener(this);
		mHelp.add(mAbout);
		mBar.add(mEdit);
		mBar.add(mHelp);
		f.setJMenuBar(mBar);
		txt = new JTextField();
		pTxt.setLayout(new BorderLayout());
		pShow.setLayout(new BorderLayout());
		start = new JButton("开始计算");
		start.setForeground(Color.blue);
		txt.addKeyListener(new KeyListener()
		{
			public void keyPressed(KeyEvent e)
			{
				int keyCode = e.getKeyCode();
				if (keyCode == KeyEvent.VK_ENTER)
				{
					System.out.println("系统管理员：用户按下了回车键");
					start.doClick();
				}
			}
			public void keyReleased(KeyEvent args) {}
			public void keyTyped(KeyEvent args) {}
		});
		start.addActionListener(this);
		show = new JTextArea("");
		show.setLineWrap(true);
		show.setEditable(false);
		txt.requestFocus();
		pTxt.add(txt,BorderLayout.CENTER);
		pTxt.add(new JScrollPane(start),BorderLayout.EAST);
		pShow.add(pTxt,BorderLayout.NORTH);
		JScrollPane show2=new JScrollPane(show);
		pShow.add(show2,BorderLayout.CENTER);
		f.add(pShow);
		f.setSize(new Dimension(300,270));
		Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
		Dimension fra=f.getSize();
		f.setLocation((screenSize.width-fra.width)/2,(screenSize.height-fra.height)/2);
		f.setResizable(false);
		f.setVisible(true);
		f.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.out.println("系统管理员：用户已经关闭软件！");
				System.exit(0);
			}
		});
	}
	public void actionPerformed(ActionEvent e)
	{
		String s = e.getActionCommand();
		if(s.equals("保存历史"))
		{
			System.out.println("系统管理员：用户按下了“保存历史”菜单");
			try
			{
				FileWriter txtWriter=new FileWriter("History.txt");
				BufferedWriter writer=new BufferedWriter(txtWriter);		
				String S=show.getText();
				S="/*文本计算器*/\r\n/*制作人：Sqrt5*/\r\n/*欢迎交流使用！*/\r\n/*E-mail:2.236068@gmail.com*/\r\n/*这是文本计算器的保存文件，可以根据您的需要在这里面保存记录*/\r\n\r\n"+S;
				writer.write(S);
				writer.close();
				System.out.println("系统管理员：历史History.txt已经保存到CLASS文件根目录！");
				JOptionPane.showMessageDialog(null,"历史History.txt已经保存到CLASS文件根目录！","提示",JOptionPane.WARNING_MESSAGE);
				Runtime.getRuntime().exec("cmd /c start .\\");
			}catch(IOException ee){}
		}
		else if(s.equals("清空历史"))
		{
			show.setText("");
			System.out.println("系统管理员：用户按下了“清空历史”菜单");
		}
		else if(s.equals("帮助主题"))
		{
			System.out.println("系统管理员：用户按下了“帮助主题”菜单");
			JOptionPane.showMessageDialog(null,"输入表达式即可，只支持有理数和括号\"(\"、\")\"，输入\"help\"可以查看更多信息","帮助主题",JOptionPane.WARNING_MESSAGE);
		}
		else if(s.equals("关于计算器"))
		{
			System.out.println("系统管理员：用户按下了“关于计算器”菜单");
			JOptionPane.showMessageDialog(null,"Sqrt5制作，欢迎使用","关于计算器",JOptionPane.WARNING_MESSAGE);
		}
		else if(s.equals("开始计算"))
		{
			System.out.println("系统管理员：用户按下了“开始计算”按钮");
			String exp=txt.getText().trim();
			if(exp.compareTo("clear")==0)
			{
				txt.setText("");
				show.setText("");
				System.out.println("系统管理员：高级用户输入了clear命令");
				return;
			}
			if(exp.compareTo("help")==0)
			{
				txt.setText("");
				show.append("此程序为文本计算器，输入一串公式可以根据优先级、括号等顺序计算出结果，暂时只能支持\"+\"、\"-\"、\"*\"、\"/\"四种运算，能识别括号。\r\n");
				show.append("作者：\tSqrt5\r\n");
				show.append("E-mail：\t2.236068@gmail.com\r\n");
				show.append("此产品最终解释权为作者所有！\r\n");
				show.append("简单命令提示：\r\n");
				show.append("save->保存历史\t");show.append("clear->清空历史\r\n");
				show.append("help->帮助\t");show.append("shutdown->关闭文本计算器\r\n");
				System.out.println("系统管理员：高级用户输入了help命令");
				return;
			}
			if(exp.compareTo("save")==0)
			{
				System.out.println("系统管理员：高级用户输入了save命令");
				txt.setText("");
				try
				{
					FileWriter txtWriter=new FileWriter("History.txt");
					BufferedWriter writer=new BufferedWriter(txtWriter);		
					String S=show.getText();
					S="/*文本计算器*/\r\n/*制作人：Sqrt5*/\r\n/*欢迎交流使用！*/\r\n/*E-mail:2.236068@gmail.com*/\r\n/*这是文本计算器的保存文件，可以根据您的需要在这里面保存记录*/\r\n\r\n"+S;
					writer.write(S);
					writer.close();
					System.out.println("系统管理员：历史History.txt已经保存到CLASS文件根目录！");
					show.append("历史History.txt已经保存到CLASS文件根目录！\r\n");
					Runtime.getRuntime().exec("cmd /c start .\\");
				}catch(IOException ee){}
				return;
			}
			if(exp.compareTo("shutdown")==0)
			{
				System.out.println("系统管理员：高级用户输入了shutdown命令");
				System.exit(0);
			}
			
			for(int i=0;i<exp.length()-1;i++)
			{
				if(exp.charAt(i)=='('&&exp.charAt(i+1)==')')
				{
					txt.setText("");
					show.append("括号中没有内容！请重新输入！\r\n");
					System.out.println("系统管理员：括号中没有内容");
					return;
				}
			}
			int count=0;
			boolean isBlank=false;
			for(int i=0;i<exp.length();i++)
			{
					
				if(exp.charAt(i)=='(')count++;
				if(exp.charAt(i)==')')count--;
				if(exp.charAt(i)==' ')
				{
					count=1;
					isBlank=true;
				}
			}
			if(count!=0)
			{
				txt.setText("");
				if(isBlank)
				{
					show.append("公式中不能出现空格！请重新输入！\r\n");
					System.out.println("系统管理员：公式中出现了空格");
				}
				else
				{
					show.append("公式中左右括号数要相等！请重新输入！\r\n");
					System.out.println("系统管理员：公式中左右括号数不相等");
				}
				return;
			}
			int strLength[]=new int[1000];
			for(int i=0;i<100;i++)
			{
				for(int j=0;j<100;j++)
				{
					strAll[i][j]=null;
				}
			}
			String expBr;
			expBr=SeparateAllString("#"+exp+"#",strLength);
			SeparateString("#"+expBr+"#",strAll[99]);
			for(int k=0;k<100;k++)
			{
				if(strAll[99][k]==null)
				{
					strLength[99]=k;
					break;
				}
			}
			txt.setText(""); 
			if(exp.compareTo("")!=0)
			{	
				String stemp;
				stemp="";
				try
				{
					stemp=doubleTrans(CalculatorAlgorithm(strAll[99],strLength[99]));
				}
				catch(Exception err)
				{
					txt.setText("");
					show.append("公式输入错误！请重新输入！\r\n");
					System.out.println("系统管理员：公式输入错误");
					return;
				}
				if(stemp.compareTo("Infinity")==0)
				{
					stemp="+∞";
					show.append(exp+"="+stemp+"\r\n");
					System.out.println(exp+"="+stemp);
				}
				else if(stemp.compareTo("-Infinity")==0)
				{
					stemp="-∞";
					show.append(exp+"="+stemp+"\r\n");
					System.out.println(exp+"="+stemp);
				}
				else
				{
					show.append(exp+"="+stemp+"\r\n");
					System.out.println(exp+"="+stemp);
				}	
			}
			txt.requestFocus();
		}
	}
	String doubleTrans(double d)
	{
  		if(Math.round(d)-d==0)
  		{
			return String.valueOf((long)d);
		}
		return String.valueOf(d);
	}
	double CalculatorAlgorithm(String str[],int strLength) throws Exception
	{
		if(strLength==3)
		{
			double n;
			n=Double.parseDouble(str[1]);
			return n;
		}
		Stack stkNum=new Stack();
		Stack stkOp=new Stack();
		Stack stkNumTaken=new Stack();
		Stack stkOpTaken=new Stack();
		double operateNum1=0.0,operateNum2=0.0;
		int pOp=0,cOp=0;
		boolean LastFirst=false;
		String ptempOp,ctempOp;
		String FirstOp,EndOp;
		int pPriority=0,cPriority=0;
		for(int i=strLength-1;i>=0;i--)
		{
			if(str[i].charAt(str[i].length()-1)>='0'&&str[i].charAt(str[i].length()-1)<='9')
			{
				double n;
				n=Double.parseDouble(str[i]);
				stkNum.push(n);
			}
			else stkOp.push(str[i]+"");
		}
		FirstOp=(String)stkOp.pop();
		while(!stkOp.empty())
		{
			if(!stkOpTaken.empty()&&!LastFirst)
			{
				operateNum1=(Double)stkNumTaken.pop();
				ptempOp=(String)stkOpTaken.pop();
			}
			else
			{
				operateNum1=(Double)stkNum.pop();
				ptempOp=(String)stkOp.pop();
			}
			if(ptempOp.compareTo("+")==0)
			{
				pPriority=20;
				pOp=1;
			}
			else if(ptempOp.compareTo("-")==0)
			{
				pPriority=20;
				pOp=2;
			}
			else if(ptempOp.compareTo("*")==0)
			{
				pPriority=50;
				pOp=3;
			}
			else if(ptempOp.compareTo("/")==0)
			{
				pPriority=50;
				pOp=4;
			}
			else if(ptempOp.compareTo("#")==0)
			{
				pPriority=1;
				pOp=0;
			}
			if(!stkOpTaken.empty()&&!LastFirst)
			{
				operateNum2=(Double)stkNumTaken.pop();
				ctempOp=(String)stkOpTaken.pop();
			}
			else
			{
				operateNum2=(Double)stkNum.pop();
				ctempOp=(String)stkOp.pop();
				LastFirst=false;
			}
			if(ctempOp.compareTo("+")==0)
			{
				cPriority=20;
				cOp=1;
			}
			else if(ctempOp.compareTo("-")==0)
			{
				cPriority=20;
				cOp=2;
			}
			else if(ctempOp.compareTo("*")==0)
			{
				cPriority=50;
				cOp=3;
			}
			else if(ctempOp.compareTo("/")==0)
			{
				cPriority=50;
				cOp=4;
			}
			else if(ctempOp.compareTo("#")==0)
			{
				cPriority=1;
				cOp=0;
			}
			if(pPriority>=cPriority)
			{
				
				switch(pOp)
				{
				case 1:
					operateNum2=operateNum1+operateNum2;break;
				case 2:
					operateNum2=operateNum1-operateNum2;break;
				case 3:
					operateNum2=operateNum1*operateNum2;break;
				case 4:
					operateNum2=operateNum1/operateNum2;break;
				}
			}
			else
			{
				stkNumTaken.push(operateNum1);
				stkOpTaken.push(ptempOp+"");
				LastFirst=true;
			}
			stkNum.push(operateNum2);
			stkOp.push(ctempOp+"");
			if(stkOpTaken.empty()&&ctempOp.compareTo("#")==0)break;
		}
		double m=0.0;
		m=(Double)stkNum.pop();
		return m;	
	}
	void SeparateString(String s,String str[])
	{
		int i;
		int j;
		boolean bSNum;
		boolean bSOp;
		boolean bSLFunc;
		boolean bSRFunc;
		boolean bSBra;
		boolean bSNumF;
		boolean bSOpF;
		boolean bSLFuncF;
		boolean bSRFuncF;
		boolean bSBraF;
		boolean bSEnd;
		boolean bSEndF;
		str[0]=""+s.charAt(0);
		j=0;
		for(i=1;i<s.length();i++)
		{
			bSEndF=(s.charAt(i-1)=='#');
			bSEnd=(s.charAt(i)=='#');
			bSNumF=(s.charAt(i-1)>='0'&&s.charAt(i-1)<='9')||(s.charAt(i-1)=='.')||(s.charAt(i-1)=='-');
			bSNum=(s.charAt(i)>='0'&&s.charAt(i)<='9')||(s.charAt(i)=='.')||(s.charAt(i)=='-');
			bSOpF=((s.charAt(i-1)=='+')||(s.charAt(i-1)=='*')||(s.charAt(i-1)=='/'));
			bSOp=((s.charAt(i)=='+')||(s.charAt(i)=='*')||(s.charAt(i)=='/'));
			bSLFuncF=(s.charAt(i-1)>='a'&&s.charAt(i-1)<='z');
			bSLFunc=(s.charAt(i)>='a'&&s.charAt(i)<='z');
			bSRFuncF=((s.charAt(i-1)=='!'));
			bSRFunc=((s.charAt(i)=='!'));
			bSBraF=((s.charAt(i-1)=='(')||(s.charAt(i-1)==')'));
			bSBra=((s.charAt(i)=='(')||(s.charAt(i)==')'));
			if(bSNumF&&bSNum)
			{
				if(
					(s.charAt(i-1)>='0'&&s.charAt(i-1)<='9'||(s.charAt(i-1)=='.')||(s.charAt(i-1)=='-'))
					&&
					s.charAt(i)=='-'
					&&
					(s.charAt(i+1)>='0'&&s.charAt(i+1)<='9'||(s.charAt(i+1)=='.')||(s.charAt(i+1)=='-'))
					)
					j++;
				if((s.charAt(i-2)>='0'&&s.charAt(i-2)<='9')&&s.charAt(i-1)=='-'&&(s.charAt(i)>='0'&&s.charAt(i)<='9'))
					j++;
			}
			else if(bSOpF&&bSOp){}
			else if(bSLFuncF&&bSLFunc){}
			else if(bSRFuncF&&bSRFunc){}
			else if(bSBraF&&bSBra){}
			else if(bSEndF&&bSEnd){}
			else j++;
			if(str[j]!=null)str[j]=str[j]+s.charAt(i);
			else str[j]=""+s.charAt(i);
		}
	}
	String SeparateAllString(String s,int strLength[])
	{
		String str[]=new String[1000];
		Stack stkString=new Stack();
		Stack stkStringTaken=new Stack();
		int i=1;
		int count=1;
		while(s.charAt(i)!='#')
		{
			stkString.push(s.charAt(i));
			i++;
		}
		i=0;
		while(count!=0)
		{
			count=0;
			while(!stkString.empty())
			{
				
				char temp;
				
				temp=(Character)stkString.pop();
				stkStringTaken.push(temp);
				if(temp==')')count++;
				if(temp=='(')
				{
					count--;
					stkStringTaken.pop();
					while((Character)stkStringTaken.peek()!=')')
					{
						if(str[i]!=null)str[i]=str[i]+(Character)stkStringTaken.pop();
						else str[i]=""+(Character)stkStringTaken.pop();
					}
					
					stkStringTaken.pop();
					SeparateString("#"+str[i]+"#",strAll[i]);	
					for(int j=0;j<100;j++)
					{
						if(strAll[i][j]==null)
						{
							strLength[i]=j;
							break;
						}
					}
					String swap;
					swap="";
					try
					{
						swap=""+CalculatorAlgorithm(strAll[i],strLength[i]);
					}
					catch(Exception err)
					{
						txt.setText("");
						show.append("不可预知错误！请重新输入！\r\n");
						System.out.println("系统管理员：不可预知错误");
						return "0";
					}
					for(int iii=swap.length()-1;iii>=0;iii--)
						stkStringTaken.push(swap.charAt(iii));
					i++;
				}
			}
			while(!stkString.empty())stkString.pop();
			while(!stkStringTaken.empty())
			{
				char swap;
				swap=(Character)stkStringTaken.pop();
				if(swap=='('&&swap==')')count++;
				stkString.push(swap);
			}
		}
		s="";
		while(!stkString.empty())
			s=(Character)stkString.pop()+s;
		return s;
	}
	public static void main(String[] args)
	{
		new TxtCalculator();
	}
}
Sqrt5
关注
专栏目录
JAVA大作业计算器，支持括号，异常处理
12-22
JAVA大作业计算器，支持括号，异常处理
异常处理-简单的除法运算器
10-23
2. 两个加数分别输入2和3，调试并修改程序，得出结果 3. 两个加数分别输入字符a和b，调试并修改程序，在结果文本框中输出相应的异常提示，如图3所示。 图3 格式化异常 4. 两个加数分别输入123456789876543和1，调试并修改程序，在结果文本框中输出相应的异常提示。 5. 两个加数分别输入123和0，调试并修改程序，尝试用finally处理该异常。 6. 定义一个自己的异常MyException，并在TxtOp1或者TxtOp2为空的时候，抛出该异常。利用catch语句将该异常捕捉。
java计算器输入异常_java程序计算器带括号和异常处理的
weixin_35779370的博客
03-04 381
import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*;import java.awt.List;import javax.script.ScriptEngine;import javax.script.ScriptEngineManager;import javax.scr...
计算机组成原理：计算机究竟是如何处理异常的
OceanStar的博客
11-11 983
异常：硬件、系统和应用的组合拳 一提到计算机当中的异常（Exception），可能你的第一反应就是 C++ 或者 Java 中的Exception。不过我们今天讲的，并不是这些软件开发过程中遇到的“软件异常”，而是和硬件、系统相关的“硬件异常”。 尽管，这里我把这些硬件和系统相关的异常，叫作“硬件异常”。但是，实际上，这些异常，既有来自硬件的，也有来自软件层面的。 比如，我们在硬件层面，当加法器进行两个数相加的时候，会遇到算术溢出；或者，玩游戏的时候，按下键盘发送了一个信号给CPU，CPU要去执行现有流程之
算数的异常处理 --- （Java版）
m0_52725750的博客
05-12 1302
注：这里主要是讲解 try{}catch(){}的使用 1.为什么要讲异常，比如：当我们在进行除法运算的时候，我们规定的是分母是不能为0的，当我们面向对象的时候，如果有用户输入了 0，那么很有可能就会导致我们的系统崩溃。 2.我们通常的解决方法就是加判断语句但是这明显的效率并不高，比如：我们输入了中文，而我们算数只能是数字，所以我们无法简单第判断所有的错误，如何才能有较高的效率呢，我们Java中用了try{}catch(){}语句出来解决了我们的问题。 代码： public class d
计算器设计和文本读取源码
06-04
这需要我们在代码中加入适当的错误检测和异常处理机制。 5. **文本读取**：如果涉及从文件读取或写入计算表达式，那么需要熟悉C++的标准输入输出流（iostream）库，以及文件操作相关的函数，如`fstream`。 6. **UI...
用ASP.NET实现一个简单的计算器(适合入门者) .rar_.net 计算器_asp计算器_计算器
09-23
ASP.NET 是微软公司开发的一种用于...6. 错误处理和异常处理机制。 7. 应用程序的部署和测试。 这是一个很好的起点，可以帮助初学者建立起对ASP.NET开发的基础理解，为进一步学习更复杂的Web应用程序打下坚实的基础。
C#实现Winform版计算器
09-02
需要注意的是，代码中没有处理除数为零的情况，实际应用中应该加入适当的错误处理机制，以防止出现运行时异常。此外，完整的计算器还需要实现更多的功能，比如括号、优先级、清除输入等。可以扩展Form1类，添加更多...
java_calculator2.rar_java 计算器_java 计算器
09-23
开发者可能在设计时加入了独特的功能或者优化，使得这个计算器在用户体验、计算能力或者代码结构上有所创新。 【标签】"java__计算器 java_计算器"进一步强调了该程序是用Java语言编写的一个计算器应用。Java是一种...
Python3.6基于正则实现的计算器示例【无优化简单注释版】
09-20
上述代码没有直接涉及错误处理，但在实际的计算器实现中，应当加入对异常情况的处理，比如处理除以零的情况，以及处理输入不合法时的错误提示。 综上所述，上述代码提供了一个简单且功能完整的基于正则表达式的...
面向对象程序设计-模板与异常处理实验报告
01-15
北京信息科技大学信息管理学院信息安全专业C++课程实验报告
面向对象程序设计-实验5异常处理.doc )
05-23
面向对象程序设计-实验5异常处理.doc )
python实现计算器
06-09
python实现界面设计，实现两个整数的加减乘数 简易的计算器，适合初学者
面向对象【异常处理】
qq_48336929的博客
07-31 441
面向对象（三）异常处理 在学习面向对象这一阶段过程中，为了方便记忆和理清思路，画了一个思维导图，一遍能够较快的形成知识框架。 1、异常（一） 1.1、什么是异常? Java运行期间发生的问题就是异常。 1.2、异常和错误的区别 异常： 程序发生异常时通常可以有针对性的处理方式。 错误： 程序发生错误，一般不会有针对性的处理方式。错误往往都是系统级别的问题，都是JVM所在系统发生并反馈给JVM的，无法针对处理，只能修正代码。 1.3、异常发生的原因 用户的非法操作； 程序员编写代码时的不恰当设计； 来自于
IT第二十天 - 面向对象编程思想、抽象类、异常处理、程序操作日志记录、本周总结 ★★★...
weixin_30877227的博客
08-25 113
IT第二十天 上午 面向对象编程思想 1.组装电脑的设计： (1)电脑的组成：显示器+机箱 (2)机箱的组成：电源+主板+硬盘 (3)主板所包含的部件：cpu+内存+PCI接口+usb接口 (4)PCI接口：显卡+声卡 (5)USB接口：U盘 2.人的描述： (1)人按肤色分：黄人+黑人+白人；人按年龄分：老年人+青...
java计算器输入异常,java 计算器
weixin_36063465的博客
03-16 188
Java codepublic class Arith{//默认除法运算精度private static final int DEF_DIV_SCALE = 10;//构造器私有，让这个类不能实例化private Arith() {}//加法运算public static double add(double v1,double v2){BigDecimal b1 = BigDecimal.v...
Java学习笔记：异常处理
imag1n3的博客
03-11 400
Java学习笔记：异常处理
java实验：带异常类的计算器
m0_72471315的博客
11-01 1333
以上就是关于异常类的计算器的内容了，可以更好的理解异常类的使用和运用。
C++的异常处理机制(一)
simon曦的博客
01-06 765
目录目录 前言 异常处理机制 异常处理的基本思想 C的异常处理的实现 异常基本语法 代码举例 栈解旋 异常接口说明 总结前言在使用Qt的过程中，对于信号与槽，感觉定义返回值来判断程序出错好像没有用。我感觉信号与槽就是相当于中断处理程序似的，当信号发出的时候，会中断当前指向的程序，而转去执行槽函数，这样正文就无法执行了，相当于事件循环卡住了(主题偏了，不知道理解的对不对)。主要想如果在槽函数中有异常发
python加法计算器异常处理
最新发布
05-23
Python加法计算器异常处理的方法主要是使用try-except语句来捕获可能出现的异常。在进行加法计算时，可能会出现以下异常： 1. 输入的不是数字类型 2. 除数为0 针对这些异常，我们可以在try语句块中进行计算，如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值