Java学习笔记_11

一、异常

  异常：

   错误：这是非常严重的问题，一般我们处理不了,一般在这里指的是硬件问题。

   异常：

   编译时期异常
开始就必须要处理的，如果不处理，后面就走不了。

  运行时期异常
开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序。

 体系结构：
  Throwable：
   Error：错误
   Exception：异常
   非RuntimeException：
   RuntimeException：

 针对异常，JVM默认的处理方案：

   一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。

   并且，会自动从当前出问题的地方停止掉。而这种方式不够好，因为我们的程序是由多个部分组成的，一部分

出了问题不应该影响其他分部的运行，因此，我们要想办法让其他分部继续运行。

那么，如何处理异常而不影响其他分部的运行：

两种方法：

1、try...catch...finally

格式： try{可能出现异常的代码

}catch(异常的类名 变量名){

针对异常的处理方法

}finally{

释放资源的地方

}

可简化为：、

try{可能出现异常的代码

}catch(异常的类名 变量名){

针对异常的处理方法

}

  多个异常的处理(演示数组索引越界异常，除数为0异常)

  A:针对每一个出现问题的地方写一个try...catch语句

  B:针对多个异常，采用一个try，多个catch的情况。

   try...catch...catch...

 
遇到try里面的问题，就自动和catch里面进行匹配。
一旦匹配就执行catch里面的内容，执行完毕后，接着执行后面的代码。（既只会解决一个异常，就会执行后面的代码）

 

   注意：

   如果异常间有子父关系，父必须在最后。

 

public static void main(String[] args) {
int[] arr = {1,2,3};
try{
arr = null;
System.out.println(arr[2]);
}catch(IndexOutOfBoundsException e){
System.out.println("数组越界了");
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}catch(Exception e){//当前面的异常类都没有匹配到之后，会自动匹配这个异常
System.out.println("出现了其他异常");
}

这里只输出了“出现了其他异常”，而并没有打印arr[2].

 编译时期异常和运行时期异常的区别:

  编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译

   例如：
FileNotFoundException（文件未找到异常）

  运行时期异常：无需显示处理，也可以和编译时异常一样处理

   例如 ：ArithmeticException

Throwable中的方法：

Throwable

类是 Java 语言中所有错误或异常的超类。

printStackTrace():打印异常信息，程序从出问题的地方开始就会打印创建一个该异常对应的对象，

   该对象直接调用打印方法

public static void main(String[] args) {
try{
System.out.println(10/0);//当程序出问题了之后会抛出一个ArithmeticException的对象
//new ArithmeticException()
}catch(ArithmeticException e){//ArithmeticException e = new ArithmeticException();
e.printStackTrace();//打印异常信息
//java.lang.ArithmeticException: / by zero
//at com.edu_01.ExceptionDemo6.main(ExceptionDemo6.java:12)
}
}

2、throws 抛异常

 throws用在方法上，声明方法有异常，交给调用者处理。

 但是呢，如果是编译时期异常，调用就必须处理。

   如果是运行时期异常，调用者可以处理，也可以不处理。

演示：

public static void main(String[] args){
method();
//method2();//将这个异常交给了调用者去进行处理
//1.可以继续往上throws，将异常继续向上进行抛出了
//2.自己try..catch...,相当与自己处理了这个异常
try{
method2();
}catch(FileNotFoundException e){
System.out.println("文件未找到");
}

}

private static void method2() throws FileNotFoundException {
//此时会抛出一个编译时期的异常，
//我们必须在方法上进行声明，如果不声明的话，会一直编译报错
FileInputStream fis = new FileInputStream("D://a.txt");
}

private static void method() throws ArithmeticException {
//在方法声明上声明这个方法可能出现的异常，不代表这个异常一定会出现
//此时仅仅是告诉我的调用者我的这个方法可能会出现异常，并不做具体的处理，交给
//调用者自己去处理这个异常
//此时抛出的 出数为0的异常，属于运行时期异常
System.out.println(10/5);
}

原则上异常能抛就抛，等到已经抛到了程序最底层的时候，最好就不要抛了，自己抓取。

异常处理：

try...catch...finally

finally:一般用于释放资源。在数据库操作或者IO流比较常见。

 特点：

   被finally控制的语句体一定会执行

  

   特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

final与finally的区别：

final：修饰的是类、方法，变量。被修饰的类不可以重写、方法不能重写、变量会是常量

finally：是异常处理的一部分。被finally控制的代码一定会执行，除非在执行到finally之前，jvm退出了。

 注意：

   A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)

   B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

上述仅仅针对编译时期异常
与运行时期异常无关。

 

 throw和throws的区别？

 throws:

  用在方法声明后面，跟的是异常类名

   可以跟多个异常类名，用逗号隔开

   表示抛出异常，由该方法的调用者来处理

   throws表示出现异常的一种可能性，并不一定会发生这些异常

  

  throw:

   用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理

   throw则是抛出了异常，执行throw则一定抛出了某种异常? 

public static void main(String[] args) {
method();
try {
method2();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

private static void method2() throws FileNotFoundException{
try{
FileInputStream fis = new FileInputStream("D://a.txt");
}catch(FileNotFoundException e){
//当遇见这个异常之后，直接抛出(这就是我给出的处理方法)
//如果【抛出的是编译时期异常的话，必须在方法声明上给予声明
throw new FileNotFoundException();
}

}

private static void method() throws ArithmeticException{
int a = 10;
int b = 2;
if (b==0) {
//在这里抛出的是运行时期异常，抛出这个异常的同时，可以在方法声明上给予声明，也可以不声明
throw new ArithmeticException();
}else {
System.out.println(a/b);
}
}