标签：处理异常 打开 try 有关 point 处理 产生 img lock
编写程序时，要在出现可能出现错误的时候加上检测的代码，如判断分母为0，数据为空，过多的 if-else分支导致程序代码加长，臃肿，可读性差，因此采用异常处理机制。
Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅， 并易于维护。
Java 程序的执行过程中出现异常，会生成一个异常类对象，该异常对象将被提交给 Java 运行时系统，这个过程称为抛出（throw）异常。一旦抛出对象以后，其后的代码就不再执行。
可以理解为异常的处理方式：① try-catch-finally; ② throws;
（1）由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出；
（2）由开发人员手动创建：Exception exception = new ClassCastException；——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样；
（1）当程序运行到某一句时，发生了异常，那么程序会先停下来；
（2）程序会在这句代码处，查看原因，生成一个合理“异常对象”，然后“抛”出；
（3）JVM 会检测这句代码的外围，是否有 try...catch 结构，可以“捕获”它；
（4）如果可以捕获，那么程序在处理完异常后，继续下面的运行，不会崩溃；
（5）如果不能捕获，那么会把这个异常继续抛给“上级”，如果“上级”能处理，那么程序从“上级"处理完的代码后面继续运行；
（6） 如果上级也不能处理，那么继续往上抛，一直到达JVM，那么就“崩溃”；
① 如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。 如果异常没有在调用者方法中处理， 它继续被抛给这个调
方法的上层方法。 这个过程将一直继续下去， 直到异常被处理。这一过程称为捕获(catch)异常。
② 如果一个异常回到main()方法， 并且main()也不处理， 则程序运行终止。
③ 程序员通常只能处理Exception， 而对Error无能为力。
（1）如果捕获的是 RuntimeException 类或它的子类，这些类的异常特点是：即使没有使用 try 和 catch 捕获，Java 自己也能捕获，并且编译通过，（但运行时会发生异常使得程序运行终止）
（2）如果抛出的异常是 IOException 等类型的非运行时异常，则必须捕获，否则编译错误，也就是说，必须处理编译时异常，将异常进行捕捉，转化为运行时异常；
捕获异常的第一步是用 try{} 语句块选定捕获异常的范围，将可能出现的异常的代码放在 try 语句块中；
在 catch 语句块中是对 异常对象 进行处理的代码。每个 try 语句块可以伴随一个或多个 catch 语句，用于处理可能产生的不同类型的异常对象。
如果明确知道产生的是何种异常，可以用该异常类作为 catch 的参数；也可以用其父类作为 catch 的参数；
比 如 ： 可 以 用 ArithmeticException 类 作 为 参 数 的 地 方 ， 就 可 以 用RuntimeException类作为参数， 或者用所有异常的父类Exception类作为参数。但不能是与ArithmeticException类无关的异常， 如NullPointerException（ catch中的语句将不会执行） 。
与其他对象一样，可以访问一个异常对象的成员变量或调用它的方法。
getMessage() 获取异常信息，返回字符串；
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
（1）捕获异常的最后一步是通过 finally 语句为异常处理提供一个统一的出口，使得在控制流转到程序的其他部分以前，能够对程序的状态作统一的管理；
（2）不论在 try 代码块中是否发生了异常事件，catch 语句是否执行，catch 语句是否有异常，catch 语句中是否有 return，finally 块中的语句都会被执行。
（3）finally 语句和 catch 语句是任选的；
try{
...... //可能产生异常的代码
}
catch( ExceptionName1 e ){
...... //当产生ExceptionName1型异常时的处置措施
}
catch( ExceptionName2 e ){
...... //当产生ExceptionName2型异常时的处置措施
} [
finally{
...... //无论是否发生异常， 都无条件执行的语句
} ]
try：该代码块中编写可能产生异常的代码
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
注意：
（1）try和catch都不能单独使用,必须连用。
（2）try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
（3）如果try中产生了异常,那么就会执行 catch 中的异常处理逻辑,执行完毕 catch 中的处理逻辑,继续执行try...catch之后的代码；
如果 catch 无法捕获 try 中发生的异常，那么就会导致当前方法结束，并把异常对象抛出给调用者，如果调用者可以处理，那么从调用者处理代码的后面继续运行，否则继续向上抛出，最终达到 JVM；
如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码
从上到下依次判断，一旦有一个满足了，后面就不看了。
建议：如果多个catch中的异常类型有大小包含关系，那么小的在上，大的在下，如果没有大小包含关系，顺序随意。
Demo：
1 public class TryCatchDemo {
2 public static void main(String[] args) {
3 try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。
4 read("b.txt");
5 } catch (FileNotFoundException e) {// 括号中需要定义什么呢？
6 //try中抛出的是什么异常，在括号中就定义什么异常类型
7 System.out.println(e);
8 }
9 System.out.println("over");
10 }
11 /*
12 当前的这个方法中 有异常 有编译期异常
13 */
14 public static void read(String path) throws FileNotFoundException {
15 if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
16 // 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
17 throw new FileNotFoundException("文件不存在");
18 }
19 }
20 }
扩展：Throwable类中定义了一些获取异常信息的方法（异常对象常用的方法）
public String getMessage() :获取异常的简短描述信息,原因(提示给用户的时候,就提示错误原因）
public String toString() :获取异常的类型和异常详细描述信息(不用)。
public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台，JVM打印异常对象,默认此方法,打印的异常信息是最全面的
Tips：包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace
Demo：
System.out.println(e.getMessage())；
System.out.println(e.toString());
System.out.println(e);
finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
必须执行的代码：在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),都得在使用完之后,最终关闭打开的资源或断开连接等操作。
语法格式：
try{
可能产生异常的代码
}catch(定义一个异常的变量,用来接收try中抛出的异常对象){
异常的处理逻辑,异常异常对象之后,怎么处理异常对象
//记录日志/打印异常信息/继续抛出异常
}
...
catch(异常类名 变量名){
}finally{
无论是否出现异常都会执行
}
注意：
（1）finally不能单独使用,必须和try一起使用
（2）finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)
Demo：
1 public static void main(String[] args) {
2 try {
3 //可能会产生异常的代码
4 readFile("c:\\a.tx");
5 } catch (IOException e) {
6 //异常的处理逻辑
7 e.printStackTrace();
8 } finally {
9 //无论是否出现异常,都会执行
10 System.out.println("资源释放");
11 }
12 }
13
14 /*
15 如果传递的路径,不是.txt结尾
16 那么就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
17
18 */
19 public static void readFile(String fileName) throws IOException {
20
21 if(!fileName.endsWith(".txt")){
22 throw new IOException("文件的后缀名不对");
23 }
24
25 System.out.println("路径没有问题,读取文件");
26 }
Tips：当只有在 try 或者 catch 中调用退出 JVM 的相关方法（System.exit(0);）,此时finally才不会执行,否则finally永远会执行。
（1）不管try中是否发生异常，也不管catch是否可以捕获异常，也无论try或catch中是否有return。 finally中的代码都必须执行；
（2）如果finally中有return，就从finally块的的return回去。
（3）如果finally中没有return，那么先把try或catch中该执行的执行完（包括把返回值的结果放到要带回调用处的操作数栈的位置），在return结束当前方法之前，先走一下finally，然后回去结束当前方法；
结论：如果 finally 中没有 return，finally 中的代码不影响返回值；
Demo1:
1 public static void main(String[] args) {
2 String str = getNum(1);
3 System.out.println(str);
4 }
5
6 public static String getNum(int a){
7 try{
8 System.out.println(a/0);
9 if(a > 0){
10 return "正数";
11 }else if(a < 0){
12 return "负数";
13 }else{
14 return "零";
15 }
16 }catch(Exception e){
17 return "异常";
18 }finally{
19 return "最终";
20 }
21 }
运行结果：
最终
Demo2:
1 public static void main(String[] args) {
2 String str = getNum(1);
3 System.out.println(str);
4 }
5
6 public static String getNum(int a){
7 try{
8 System.out.println(a/0);
9 if(a > 0){
10 return "正数";
11 }else if(a < 0){
12 return "负数";
13 }else{
14 return "零";
15 }
16 }catch(Exception e){
17 System.out.println("exception");
18 return "异常";
19 }finally{
20 System.out.println("finally");
21 }
22 }
运行结果：
exception
finally
异常
Demo3:
1 public static void main(String[] args) {
2 int num = getNum(4);
3 System.out.println(num);//0
4 }
5
6 public static int getNum(int a){
7 int result = 10;
8 try{
9 System.out.println(a/0);
10 if(a > 0){
11 result = 20;
12 return result;
13 }else if(a < 0){
14 result = -20;
15 return result;
16 }else{
17 return result;
18 }
19 }catch(Exception e){
20 System.out.println("exception");
21 result = 0;
22 return result; //从这里返回，result=0
23 }finally{
24 result = 30;
25 System.out.println("finally");
26 // return result;//如果有这句，结果就变成30
27 }
28 }
运行结果：
exception
finally
0
Demo4:
1 public class Test {
2 {
3 System.out.println("b");
4 }
5 static{
6 System.out.println("a");
7 }
8 TestExer4(){
9 System.out.println("c");
10 }
11 public static String getOut(){
12 try{
13 return "1";
14 }catch(Exception e){
15 return "2";
16 }finally{
17 return "3";
18 }
19 }
20 public static void main(String[] args) {
21 System.out.println(getOut());//3
22 }
23 }
运行结果：
a
3
Java 异常处理 之 异常处理机制一：try-catch-finally
标签：处理异常 打开 try 有关 point 处理 产生 img lock
原文地址：https://www.cnblogs.com/niujifei/p/14293299.html
