JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表啥意义？

Posted 2023-05-01

package com.fml.resource;
import javax.swing.Icon;
import javax.swing.JOptionPane;
public class CaiShuZi4JOptionPane
/**
* @param args
*/
public static void main(String[] args)
Icon icon = null;
boolean bl = false;
int put = 0;
int c = (int) (((Math.random())*100)+1); //获取一个1-100的随机数
System.out.println("你获取的随机数是："+c); //打印你的随机数字

String str1 = (String) JOptionPane.showInputDialog(null,"请输入你的猜测数字(1-100)：\\n","猜数字游戏",JOptionPane.PLAIN_MESSAGE,icon,null,"在这输入"); //第一次输入你的猜测数字

if(str1==null)
JOptionPane.showMessageDialog(null, "你已经取消了本次游戏"); //如果你点取消那么本次游戏结束
else
bl = num(str1); //判断是输入的是不是数字或者是整数
if(true==bl) //如果是数字的话进入与随机数比较的程序
System.out.println("你输入的数字是："+str1); //打印你输入的数字
put = Integer.valueOf(str1);

for(int i = 4;i > 0;i--) //i是你可以猜测的次数
if(put==c)
JOptionPane.showMessageDialog(null, "恭喜你猜对了，正确答案是:"+c+"。"); //如果你猜对了就直接结束循环
break;
else if(put>c) //如果输大了就让你再次从新输入
str1 = (String) JOptionPane.showInputDialog(null,"你的输入过大。你还有"+i+"次机会，请重新输入：\\n","猜数字游戏",JOptionPane.PLAIN_MESSAGE,icon,null,"在这输入");
if(str1==null)
JOptionPane.showMessageDialog(null, "你已经取消了本次输入");
break;
else
bl =num(str1);
if(true==bl)
put = Integer.valueOf(str1);
else
JOptionPane.showMessageDialog(null, "你的输入不正确，请重新输入");


else if(put<c) //如果你输小了也让你从新输入
str1 = (String) JOptionPane.showInputDialog(null,"你的输入过小。你还有"+i+"次机会，请重新输入：\\n","猜数字游戏",JOptionPane.PLAIN_MESSAGE,icon,null,"在这输入");
if(str1==null)
JOptionPane.showMessageDialog(null, "你已经取消了本次输入");
break;
else
bl =num(str1);
if(true==bl)
put = Integer.valueOf(str1);
else
JOptionPane.showMessageDialog(null, "你的输入不正确，请重新输入");






else if(bl==false) //这个 是你第一次如果填写的不是数字的话也会结束本次游戏
JOptionPane.showMessageDialog(null, "请您下次按要求填写。本次游戏结束");

if(true==bl && c!=put) //如果你i次都没猜对，那么就直接告诉你这个数十什么
JOptionPane.showMessageDialog(null, "很遗憾你没能猜对，这个数字是："+c+".");






public static boolean num(String value) //一个静态方法，判断你输入的是不是数字
try
Integer.parseInt(value);
return true;
catch (Exception e)
return false;

你先看看我的实例，最下面的一个就是捕获异常和进行处理的方法

在整个JAVA的异常处理中，实际上也是按照面向对象的方式进行处理，处理的步骤如下：

1、一旦产生异常，将会产生一个异常类的实例化对象。

2、在try语句中对这个异常对象进行捕获。

3、产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功，则执行catch语句中的代码。

Try 

         catch (…)    

          finally 

               ……

       

这个finally如果没有中途退出最后是一定会执行到的。

throws 是用在主类前面的，是让他的父类来处理这个异常。不在此类中处理

参考技术A 楼上已经把异常说得很清楚了 , 那么垃圾回收就由我来处理吧什么是垃圾回收？垃圾回收机制 正是JAVA与其他语言不同的如C/C++C/C++ 程序员意向都是 对象一定要被摧毁. 如果对象忘记摧毁那么就会造成内存泄露JAVA 程序员的意向却是 遗忘对象, 让编译器为我们解决这种事,让内存泄露永远不会发生哪些对象是垃圾回收线程回收的？指定的对象，既System.gc();JAVA的垃圾回收发生的时机是什么？答: 可能不会发生, 也可能永远不会发生 你可以这样认为 : 只要内存没有到耗尽的那一刻,那么垃圾回收就不会被启动 因为启动垃圾回收需要付出一定的效率代价,不启动的话 我们就不用付出这样一份高昂的代价. 简述Java的事件处理机制，并举例说明编写程序时对事件进行处理的主要步骤？ 事件源类：描述事件发生源的基本属性和行为。比如，按钮是很多事件发生的事件源，Java构造按钮类来描述按钮的形状，颜色等等属性以及在屏幕上绘制按钮等动作，当然也包括按钮按下等相关事件发生本身。同时，在事件发生时，事件源类还负责发出事件发生的通知。该行为通过事件源查找自己的事件监听者队列，并将事件信息通知队列中的监听者来文成。同时，事件源还在得到有关监听者信息时负责维护自己的监听者队列。事件类：描述某个事件的所有属性和相关动作。比如定义键盘事件类KeyEvent来描述键盘事件的所有信息，如键是否按下、是否释放、是否双击，以及相关键的信息，如键码，是否有组合键等等。事件监听者类，也就是关注事件的主体类：当事件发生后，该主体负责进行相关的事件处理，同时，它还负责通知相关的事件源，自己关注它的特定的事件，以便事件源在事件发生时能够通知该主体。事件监听者接口：事件发生后，事件源要将相关的信息通知对应的监听者。这要求必须在事件源和监听者之间定义一个标准的接口规范，以便完成这样的信息交换。监听者接口正是负责定义这样的接口规范。详情可以 http://blog.csdn.net/JianZhiZG/archive/2006/12/02/1427073.aspx 举例说明类、抽象类和接口之间的关系和区别？接口: 1. 接口中声明的变量全部为final 和static类型的，并且这个接口的作用在于定义一些值不能改变的变量。 2. 接口中只定义可供实现的抽象方法 3. 还有一种方式是上述两种方式的组合，如非必要一般会将这样一个接口定义拆分成两个接口定义抽象类:1. 如果一个类包含一个接口但是不完全实现接口定义的方法，那么该类必须定义成abstract型2. 抽象类的方法体中只定义抽象的方法类: 1. 类是具有相同特性和行为的对象集合 那么三种 含义 区别何在 由楼主自定了~ 参考技术B Java程序设计中，采用try……catch……finally语句结构和主动抛出异常语句throw等方法来实现。通过try……catch……finally语句可以捕获一个或多个异常，其基本格式是：
try
语句体
catch（异常错误类型变量名）
语句体
finally
语句体

上面语句中的异常对象是在Java运行时由系统抛出的。还可以使用throw语句明确抛出一个异常，其基本格式是：
throw异常对象
对异常进行处理时，将引起异常的语句添加到最近的try语句中，由catch进行识别和处理。如果异常发生时能确保有一段代码被执行，则应该使用finally子句。
throws子句声明可能会出现的异常。如果一个方法可能会出现异常，但是没有能力来处理这种异常，可以在方法的生命处用throws子句来声明抛出异常。
而throw语句用于抛出异常。throw语句用于抛出的对象必须是java.lang.Throwable类或其子类的实例。

Java基础异常处理关键字：try catch finally throw throws

　　嗨咯，大家晚上好，我的博客首篇开始了 ，我们一起加油吧！

都说java 语言是非常健壮性 如：垃圾回收机制、内存模型、异常处理，强类型转换、跨平台,等等，使得Java语言的受到青睐。今天我们先来聊聊java的异常处理机制try catch finally throw throws，平时我们貌似小瞧了这五个关键字。开发应用系统，良好异常的处理对系统后期的开发、维护、升级、用户的体验尤其重要。

异常有个非常重要的特征，从出现异常的位置 到 最顶端的main方法 如果你一直没catch到它，最终jvm会帮你抛出异常信息，糟糕的是该线程断掉，后续代码也不再执行,从此无声无息的消失在jvm这片汪洋大海。前面我公司的一个项目前端ajax请求control做支付，由于control的catch里面抛出了一个空指针，导致前端页面卡住不动了，解决方案：由于control层一般是顶层最好catch到任何有可能出现异常的地方，其他非顶层还可以继续throw 或者throws往上抛。还有就是最好为每个ajax设置超时时间。

 

先简单介绍下throw 跟throws：

throw ：在方法体内抛出一个异常,实际存在的异常对象，一般用是自己扩展的异常实例，throws是放在方法名后面，表示该方法如果出现异常 ， 我不想处理或者处理不了，交给调用者处理，可以thow抛出一个运行时异常(unchecked)如ClassNotFoundException，NumberFromartException,   也可以throws或throw+try或throw+throws 处理一个checked异常如:IOExcepion,SocketException、继承exception类之类的异常, 。区别是checked异常必须处理(要么try，要么throws继续往上抛，否则编译是通不过的)，而运行时异常可以不处理，一直不处理的后果是出现异常后jvm报出异常信息然后线程断掉。 throw 跟throws关键字一般情况不建议在代码中使用，推荐所有异常就地解决。知道用就行了，不做过多的讲解。

try的组合规则：1, try{}catch(){}  2,try{}catch(){}finally{}  3,try{}finally{}    ，1跟2的方式 catch可以有多个

 

朋友，吃几颗栗子：

1，无try组合  

public class CatchExecuteJustOne {
　　public void methodOne(){
　　　　System.out.println("into methodOne method");
　　　　int one=1/0;
　　　　System.out.println("end methodOne method"); //不会输出  没有try组合，报错后线程已经断掉
}
　　public static void main(String[] args) {
　　　　CatchExecuteJustOneS cejo = new CatchExecuteJustOneS();
　　　　cejo.methodOne();

　　　　System.out.println("end  main method"); //不会输出  没有try组合 报错线程已经断掉
　　}
}

输出：

Into methodOne method
Exception in thread "main" java.lang.ArithmeticException: / by zero
at priv.lilei.exception.example_1.CatchExecuteJustOneS.methodOne(CatchExecuteJustOneS.java:6)
at priv.lilei.exception.example_1.CatchExecuteJustOne.main(CatchExecuteJustOne.java:19)

 

2.1,有try组合案例1

public class CatchExecuteJustOne {
　　public void methodOne(){
　　　　System.out.println("into methodOne method");
　　try{
　　　　int one=1/0;
　　}catch(Exception e){
　　　　System.out.println("methodOne try到");
　　}
　　System.out.println("end methodOne method");
}

　　public static void main(String[] args) {
　　　　CatchExecuteJustOne cejo = new CatchExecuteJustOne();
　　　　cejo.methodOne();
　　　　System.out.println("end main method");
　　}
}

 输出：

into methodOne method
methodOne try到
end methodOne method
end main method

2.2，有try组合案例2

public class CatchExecuteJustOne {
public void methodOne(){
　　System.out.println("into methodOne method");
　　int one=1/0;
　　System.out.println("end methodOne method"); //不会执行线程上面报错断掉直接抛出了
}

public static void main(String[] args) {
　　try{
　　　　CatchExecuteJustOne cejo = new CatchExecuteJustOne();
　　　　cejo.methodOne();
　　}catch(Exception exception){
　　　　System.out.println("into main method catch"); //会执行 try到上面方法报的异常
　　}
　　　　System.out.println("end main method"); //会执行 try到上面方法报的异常
　}
}

输出：

into methodOne method
into main method catch
end main method

 

2.3，有try案例组合3    异常只会被最近捕捉到它的catch 一次。像switch case 跟if() if else(){} if()else if{} 语法一样

 

public class CatchExecuteJustOne {
public void methodOne(){
System.out.println("into methodOne method");
try{
int one=1/0;
}catch(ArithmeticException e){
System.out.println("catch 1");
}catch (Exception e) {
System.out.println("catch 2");//不会执行 已经执行了上一个catch 1
}
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();

try {
cejo.methodOne();
} catch (Exception e) {
System.out.println("man catch");//不会执行已经执行了catch 1
}

System.out.println("end main method");
}
}

输出：

into methodOne method
catch 1
end main method

2.4 有try组合案例4,  try{}finally{}组合，finally没中有返回值得时候线程会断掉，但在finally中有返回值时候线程不会断掉只是后续代码不会执行， 这种组合建议少用。

 //没返回值

public class CatchExecuteJustOne {
　　public void methodOne(){  //没返回值
　　　　System.out.println("into methodOne method");
　　try{
　　　　int one=1/0;
　　}finally{
　　　　System.out.println("into methodOne finally");
　　}
　　　　System.out.println("end methodOne method"); //不会执行线程上面报错断掉直接抛出了
}

public static void main(String[] args) {
　　CatchExecuteJustOne cejo = new CatchExecuteJustOne();
　　cejo.methodOne();
　　System.out.println("end main method");//不会执行线程上面报错断掉直接抛出了
　　}
}

没返回值的输出：

into methodOne method
Exception in thread "main" into methodOne finally
java.lang.ArithmeticException: / by zero
at priv.lilei.exception.example_1.CatchExecuteJustOne.methodOne(CatchExecuteJustOne.java:14)
at priv.lilei.exception.example_1.CatchExecuteJustOne.main(CatchExecuteJustOne.java:23)

有返回值：

public class CatchExecuteJustOne {
public String methodOne(){
System.out.println("into methodOne method");
try{
System.out.println("1");
int one=1/0;
System.out.println("2");//不会执行线程上面报错断掉直接抛出了
}finally{
System.out.println("into methodOne finally");//会输出
return "1";
}
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
cejo.methodOne();
System.out.println("end main method");//会执行 因为上面有try到并且方法有返回值
}
}

有返回值的输出：

into methodOne method
1
into methodOne finally
end main method

 

2.5，带finally的组合  finally永远被执行，有返回值得情况在返回之前执行,  除非出现特别暴力的行为如 system.exit(0); 或者断掉了，或者内存溢出了等Error错误。

return 组合

2.5.1 下面两个案例  在没有异常 跟有异常的情况  ，在catch跟finally 中给变量再次赋值   存在差异。没有异常再次赋值失败，而有异常再次赋值成功。

 

1 没有异常的情况 

public class CatchExecuteJustOne {
public String methodOne(){
String a="";
System.out.println("into methodOne method");
try{
a="a";
return a;
}catch(ArithmeticException e){
System.out.println("catch 1");
}finally {
System.out.println(1);
a="a2";        //不报错的情况   不会赋值给a;
System.out.println(2);
}
System.out.println(3); //不会执行 上面return a方法已经返回了
return a;
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
System.out.println(cejo.methodOne());
}
}

try中return 没有异常的情况的输出：

into methodOne method
1
2
a

2 有异常的情况

public class CatchExecuteJustOne {
public String methodOne(){
String a="";
System.out.println("into methodOne method");
try{
a="a";
int i=1/0;
return a;
}catch(ArithmeticException e){
System.out.println("catch 1");
}finally {
System.out.println(1);
a="a2";   //有异常会重新赋值给a 变量
System.out.println(2);
}
System.out.println(3); //会输出 捕捉到了异常没有从上面第一个return a返回 而是从下面这个return返回
return a;
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
System.out.println(cejo.methodOne());
}
}

try中return 有异常的情况输出：

into methodOne method
catch 1
1
2
3
a2