Java异常相关知识总结

异常：

概述：java程序运行过程中出现的错误

常见的异常：
StackOverflowError
ArrayIndexOutOfBoundsException
NullPointerException
ClassCastException
ParseException

异常的分类：
Trowable：
　　1.--Error: a.相当于天灾人祸，虚拟机出现了问题
　　2.--Exception:
　　　　1).RuntimeException：运行过程中出现的异常 可以处理可以不处理，一般出现这种问题都是代码逻辑有问题，推荐修改代码
　　　　2).编译期异常：出发之前因该检查的异常，必须处理，负责编译不通过

1,编译时异常： 除了RuntimeException及其子类,Exception中所有的子类都是,这种异常必须要处理,要不编译通不过。

2,运行时异常 ：RuntimeException及其子类都是,这种异常不用处理,编译会通过,不过这样的程序会有安全隐患,遇到这种异常是需要改代码的。

3,严重错误问题 ：用Error进行描述,这个问题发生后,一般不编写针对代码进行处理,而是要对程序进行修正.通常都是由虚拟机抛出的问题。

举例说明：

异常分三类：
骑车去旅行：

　　Error:走到半路上，发生山路塌陷，或者出现了泥石流，这个问题很严重，不是班长能够立马解决的。

　　Exception:出门前，班长要看看车轮子以及车链子等是否还在

　　RuntimeException:在骑车的过程中，有好路不走，偏偏要走石子路

异常举例：

 //异常测试：
 //  a.除数为0
 //  b.数组越界
 public class HomeWork_02 {
     public static void main(String[] args) {
         System.out.println("start");
         f1();
         //f2();
         System.out.println("end");
     }
     //数组越界异常
     public static void f2(){
         int[]arr={1,2,3};
         System.out.println(arr[0]);
         System.out.println(arr[1]);
         System.out.println(arr[2]);
         //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
     }
     //除数为0异常
     public static void f1(){
         int a=23;
         int b=0;
         System.out.println(a/b);//ArithmeticException: / by zero
     }
 }

jvm对异常的默认处理：
a. 哪个线程出现的问题
b. 异常的类型以及详细信息
c. 调用栈信息
d. 终止程序

如下图为异常举例代码中数组溢出是jvm所报的错误：

---

---

因为jvm处理异常的时候直接停止了程序，所以我们要学会自己处理异常：

如何自己处理异常：
　　a. try...catch...finally　　
　　b. throws

---

---

1. try...catch...finally语句
　　try {
　　要检查的代码
　　　　} catch (异常类型 对象名) {
　　　　　　对异常的处理
　　　} finally {
　　　　释放资源
　　}
a. 一种异常的情况

 public class ExceptionDemo_03 {
     public static void main(String[] args) {
         System.out.println("Start");
         int a =10;
         int b=0;
         try{
             System.out.println(a/b);
             System.out.println("one");
             System.out.println("two");
             System.out.println("three");
         }catch(ArithmeticException e){
             System.out.println("除数为0");
             System.out.println(e);
         }
         System.out.println("end");
     }
 }
//问题：为什么e局部变量会有值？

//如果try里面出现了异常, JVM会把异常信息封装成对应类型的异常对象。

 //然后和catch语句依次匹配，找到对应的异常类型，然后把它赋值给引用变量e

输出结果：

注意事项：
a. try里面的代码越少越好,最好只放可能出现异常的代码
b. try里面出现了异常，就不会执行try里面里面后序的代码
c. ArithmeticException e 是局部变量, 作用范围是对应的catch语句。
d. catch 捕获了异常，执行对应的处理，异常就不再存在了。

b.多种异常的情况：
　　　　a. 一个一个处理
　　　　b. 一次性处理
　　　　c. JDK7 新特性
　　　　　　把多个处理方式相同的catch语句，合成一个catch语句。
　　　　　　　　catch(类型1 | 类型2 | 类型3... e)
注意事项：
一个try语句中, 最多只会抛出一个异常，最多也只会执行一个catch语句
如果异常没有兼容惯性，谁先谁后没关系，如果有兼容关系，那么父类应该方法在子类之后。
JDK7新特性, 一个catch 语句不能出现子父类关系

测试代码：

 /*多种异常的情况：
         a. 一个一个处理
         b. 一次性处理
        处理方式相同的catch语句，合成一个catch语句。
         catch(类型1 | 类型2 | 类型3... e)*/
 public class ExceptiomDemo_04 {
     public static void main(String[] args) {
         System.out.println("start");
         /*try {
             f1();
             f2();
             // f2()在后面的时候，执行到f1()的时候就不再往下执行了，没有输出arr[0]，arr[1],arr[2]
         } catch (ArithmeticException e) {
             // System.out.println("除数为0");
             System.out.println("发生了异常");
         } catch (ArrayIndexOutOfBoundsException e) {
             // System.out.println("数组索引越界");
             System.out.println("发生了异常");
         } catch (Exception e) {
             System.out.println("其他异常");
         }*/
         try {
             f2();
             f1();
         } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
             System.out.println("除数为0或者数组索引越界");
         }

     }
     public static void f2(){
         int []arr={1,2,3};
         System.out.println(arr[0]);
         System.out.println(arr[1]);
         System.out.println(arr[2]);
         System.out.println(arr[3]); // ArrayIndexOutOfBoundsException: 3
     }
     public static void f1(){
         int a =10;
         int  b=0;
         System.out.println(a/b);// ArithmeticException: / by zero

     }
 }
   

---

---

编译期异常和运行时异常：
Exception:
　　|-- 运行时异常: RuntimeException和其子类。
可以显示处理，也可以不处理，一般出现运行时异常，都是代码逻辑有问题，推荐修改代码逻辑。
　　|-- 编译期异常：其他类。无论运行时是否发生异常，都必须显示处理，否则无法通过编译。
测试代码:

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.SimpleTimeZone;

 //编译期异常和运行时异常：
 public class ExecptionDemo_05 {
     //一般不要在主方法中抛出异常，这里为方便在主方法中抛出异常
     public static void main(String[] args) throws ParseException {
         //运行时异常：
         int a=10;
         int b=0;
         try{
             System.out.println(a/b);
         }catch(ArithmeticException e){
             System.out.println("除0异常");
         }
         //编译期异常，不解决不能通过编译
         Date time=new Date();
         SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         String date=sf.format(time);
         System.out.println(date);
         Date date1=sf.parse(date);//ParseException
     }
 }

---

---

Throwable

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。

类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

　　构造方法摘要: 
　　　　Throwable()
　　　　　　构造一个将 null 作为其详细消息的新 throwable。
　　　　Throwable(String message)
　　　　　　构造带指定详细消息的新 throwable。
　　成员方法：
　　　
　　　　　　返回此 throwable 的详细消息字符串。

　　　　　　默认实现：getClass().getName()+“：”+getMessage();
　　　　　　返回此 throwable 的简短描述。
　　　　void printStackTrace() //推荐使用它，而且输出内容会用红色标识
　　　　　　　　将此 throwable 及其追踪输出至标准错误流。

注意：通常e.getMessage()并不能获取全部的错误信息,需要用到e.printStackTrace()查看完整错误信息，但是这个方法是void 只能在控制台输出。

测试代码：

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 //Throwable():、
 public class ExceptionDemo_06 {
     public static void main(String[] args) {
         String s = "2001/01/01 00:00:00";
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         Date date = null;
         try{
             date=sdf.parse(s);
         }catch(ParseException e){
             System.out.println("解析异常");
             System.out.println(e.getMessage());
             System.out.println(e.toString());
             e.printStackTrace();
         }
     }
 }

---

---

thorws

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识。
举例：
村里出现了问题，如果能自己解决就自己解决，解决不掉就交给乡里，乡里解决不掉就抛给县里解决， 县里解决不掉，抛给市里，如果市里解决不掉，抛给省里，如果省里解决不掉，抛给中央。中央就直接干掉。

throws: 把问题抛给调用者
a.编译期异常
b.运行期异常

注意事项：
不要在main()方法抛出异常，如果抛出异常就会执行JVM的默认处理。

测试代码：

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 public class ExceptionDemo_07 {
     public static void main(String[] args) {
         String s = "2019/7-9 11:31:00";
         String pattern = "yyyy-MM-dd HH:mm:ss";
         Date date = null;
         try {
             date = string2Date(s, pattern);
         } catch (ParseException e) {
             e.printStackTrace();
         }
         System.out.println(date);
         int a = 10;
         int b = 0;
         int c = 0;
         try {
             c = f1(a, b);
         } catch (Exception e) {
             e.printStackTrace();
         }
         System.out.println("c = " + c);
         System.out.println("end");
     }
     //throw:告诉调用者，注意：调用这个方法可能会有某某异常
     public static Date string2Date(String s, String pattern) throws ParseException {
         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
         return sdf.parse(s);
     }
     public static int f1(int a, int b) throws Exception{
         // return a / b;
         if (b != 0) {
             return a / b;
         }
         throw new Exception("除0异常");
     }
 }

throw

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

测试代码：

throws和throw的区别
throws

用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常

throw

用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定会出现异常， throw抛出了一个实实在在的异常

 import java.util.Scanner;

 //举例：
        // 录入学生成绩 [0~100]
 public class ExecptionDemo_08 {
     public static void main(String[] args) {
         System.out.println("请输入学生成绩");
         Scanner sr =new Scanner(System.in);
         int score=sr.nextInt();
         //数据验证
         try{
             checkScore(score);
         }catch(Exception e){
             e.printStackTrace();

         }
     }
     public static void checkScore(int score) throws Exception {
         if(score<0||score>100){
             throw new Exception("score="+score);
         }
         //throw抛出了异常后，后面的语句就不再执行
         System.out.println("one");
         System.out.println("two");
         System.out.println("three");
     }
 }

---

---

我们到底该怎么处理异常：
原则：如果该方法知道如何处理，那用try...catch, 如果不知道怎么处理，就抛给它的调用者去处理。
区别：
　　如果try...catch，后续代码会执行。
　　如果throws,后续代码不会被执行。

try语句的变形
try...catch
try...finally
try...catch...finally
try...catch...catch...
try...catch...catch...finally

---

---

finally语句：
特点：
　　被finally控制的语句体无论出现异常还是没有出现异常，都会执行。
　　特殊情况：在执行到finally之前jvm退出了. System.exit();
作用：
　　释放系统资源

final和finally和finalize区别：

final: 最终的
　　类：不能被继承
　　方法：不能被重写
　　变量：常量
finally:
　　try语句的子句。
　　finally里面的语句, 无论出现异常还是不出现异常，都会被执行。　　
　　用来释放资源。
finalize:
　　Object中的方法。
　　对象被回收前，该方法会被自动执行。用来释放资源。
　　手动调用该方法，对象不会被回收。

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 public class ExceptionDemo_09 {
     public static void main(String[] args) {
         String s = "2019/7/9 14:40:00";
         String pattern = "yyyy-MM-dd HH:mm:ss";
         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
         try {
             Date date = sdf.parse(s);
         } catch (ParseException e) {
             e.printStackTrace();
         //finally只有在执行到finally之前虚拟机就退出的时候才会不执行
             //System.exit(0);
         } finally {
             System.out.println("finally子句");
         }
         System.out.println("end");
     }
 }            

---

---

如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问结果是怎样的？
finally语句会被执行
第一次执行return语句，就已经生成了返回路径, 并把返回值保存起来了。
后面在finally语句中修改变量，不会影响返回值。

如果finally中也有return语句。
最终执行的是finally中语句。

 public class ExceptionDemo10 {
     public static void main(String[] args) {
         System.out.println(method()); //
     }

     public static int method() {
         String s = "2019/7/9 14:40:00";
         String pattern = "yyyy-MM-dd HH:mm:ss";
         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
         int a = 10;
         try {
             a = 20;
             Date date = sdf.parse(s);
         } catch (ParseException e) {
             a = 30;
             return a;
         } finally {
             System.out.println("finally");
             a = 40;
             return a; //生成了另外一条返回路径
         }

     }
 }    

---

---

自定义异常：
类名就代表异常的种类(信息)
编译期异常：继承Exception
运行时异常：继承RuntimeException

异常类：

 public class ScoreException extends RuntimeException {
     public ScoreException(){
         super();
     }
     public ScoreException(String message){
         super(message);
     }
 }

测试类：

 public class EceptionDemo_11 {
     public static void main(String[] args) {
         System.out.println("请录入学生成绩；");
         Scanner scanner = new Scanner(System.in);
         int score = scanner.nextInt();
         // 数据验证
         /*try {
             checkScore(score);
             // 存入数据库
         } catch (ScoreException e) {
             e.printStackTrace();
         }*/
         checkScore(score);
     }
     private static void checkScore(int score) throws ScoreException{
         if (score < 0 || score > 100) {
             // throw new RuntimeException("score=" + score);
             throw new ScoreException("score=" + score);
         }
     }
 }

异常注意的事项：(编译期异常)
子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。
如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

儿子不能比父亲更坏。一代只能比一代强。
编译的时候，不检查运行时异常