java学习【知识点及代码12.1异常】

一：

异常：

1.1

异常：就是程序出现的不正常的情况。

异常：

错误：这是非常严重的问题，一般我们处理不了,一般在这里指的是硬件问题。
异常：
编译时期异常  开始就必须要处理的，如果不处理，后面就走不了。
运行时期异常  开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序。

体系结构：

Throwable：

Error：
Exception：
非RuntimeException：编译时期异常
RuntimeException：运行时期异常

异常演示：

除数不能为0

java.lang.ArithmeticException: / by zero

package day12.edu_01;
public class ExceptionDemo {
public static void main(String[] args) {
System.out.println("start");
int num1 = 10;
int num2 = 0;
System.out.println(num1/num2);// java.lang.ArithmeticException: / by zero
System.out.println("end");
}
}

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

一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。
并且，会自动从当前出问题的地方停止掉。
这种处理方案虽然可以，但是不够好。
其实程序出问题，不应该直接停止，因为我们的程序可能是由多部分组成的，
其中一个部分出问题了，不应该影响其他部分的执行。
所以，我们应该想办法让其他的部分能够执行下去。

1.2

我们是如何处理异常，保证各个部分不影响的呢?

两种方案：

A:try…catch…finally

B:throws

try...catch...finally:
try{
可能出现异常的代码
}catch(异常类名 变量名) {
针对异常的代码处理
}finally {
释放资源的地方
}

简化一下第一个：

try{
可能出现异常的代码
}catch(异常类名 变量名) {
针对异常的代码处理
}

package day12.edu_01;

public class ExceptionDemo2 {
public static void main(String[] args) {
System.out.println("start");
int a = 10;
int b = 0;
try {
//可能出现异常的代码
System.out.println(a/b);
} catch (ArithmeticException e) {//当除数为0的时候会抛出ArithmeticException这个异常
//接着程序会拿着这个异常和catch里面的异常类已经对比
System.out.println("除数不能为0");
//当程序抛出ArithmeticException这个异常之后给出的具体的处理方法
}
System.out.println("end");
}
}

1.3

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

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

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

try…catch…catch…

遇到try里面的问题，就自动和catch里面进行匹配。
一旦匹配就执行catch里面的内容，执行完毕后，接着执行后面的代码。

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

package day12.edu_01;

public class ExceptionDemo3 {
public static void main(String[] args) {
//多个异常处理的第一种解决方案
//A：给每一个可能出现异常的代码全部加上try..catch..
//      try {
//          System.out.println(10/0);
//      } catch (ArithmeticException e) {
//          System.out.println("除数不能为0");
//      }
//
//      int[] ary = {1,2,3,4,5};
//      try {
//          System.out.println(ary[8]);
//      } catch (IndexOutOfBoundsException e) {
//          System.out.println("数组越界");
//      }

//B:针对多个异常，采用一个try，多个catch的情况。
//当存在多个catch情况下，如果异常类之间存在子父关系，那么父类应该放到最后
int[] ary = {1,2,8};
try {
//System.out.println(ary[3]);
//System.out.println(10/0);
ary = null;
System.out.println(ary[2]);
} catch (IndexOutOfBoundsException e) {
System.out.println("数组越界");
} catch (ArithmeticException e){
System.out.println("除数不能为0");
} catch (Exception e){
System.out.println("其他异常");
}
}
}

1.4

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

编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
FileNotFoundException（文件未找到异常）
运行时期异常：无需显示处理，也可以和编译时异常一样处理
ArithmeticException

package day12.edu_01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExceptionDemo4 {
public static void main(String[] args) {
//   运行时期异常：无需显示处理，也可以和编译时异常一样处理
//   什么是异常的显示处理：try...catch...
try {
System.out.println(10/0);
} catch (ArithmeticException e) {
System.out.println("除数不能为0");
}

//      编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
//      FileNotFoundException（文件未找到异常）
try {
FileInputStream fileInputStream = new FileInputStream("D://a.txt");
} catch (FileNotFoundException e) {
System.out.println("文件没有找到");
}
}
}

1.5

Throwable中的方法：(演示除数为0异常)

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

package day12.edu_01;

public class ExceptionDemo5 {
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)
}
}
}

1.6（演示编译器异常，运行期异常）

try…catch 是直接进行了处理。

而throws则是把异常处理的事情交给了调用者。

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

但是呢，如果是编译时期异常，调用就必须处理。如果是运行时期异常，调用者可以处理，也可以不处理。

1.7

throws:(演示文件未找到异常，除数为0异常)

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

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

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

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

package com.edu_01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExceptionDemo7 {
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);
}
}

1.8

异常处理：

try…catch…finally

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

特点：

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

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

package day12.edu_01;

public class ExceptionDemo7 {
public static void main(String[] args) {
try {
System.out.println(10/0);
} catch (ArithmeticException e) {
System.out.println("除数不能为0");
//System.exit(0);
//          被finally控制的语句体一定会执行
//          特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
}
finally{
System.out.println("这个代码块一定会被执行");
}
}
}

1.9

finally相关的面试题:

final,finally的区别?

final:最终的意思。可以修饰类，方法，变量。
修饰类，类不能被继承
修饰方法，方法不能被重写
修饰变量，变量是常量
finally:
异常处理的一部分。被finally控制的代码一定会执行。
特殊情况：在执行到finally之前，jvm退出了。

1.9.1

注意：

A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

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

1.9.2

throw和throws的区别？

throws:

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

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

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

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

throw:

用在方法体内，跟的是异常对象名

只能抛出一个异常对象名

表示抛出异常，由方法体内的语句处理

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

案例演示：演示编译时期异常(文件未找到异常)和运行时期异常(除数为0异常)使用上的区别

throw:

如果throw的是编译时期异常，在方法声明上必须用throws进行标记

如果throw的是运行时期异常，在方法声明上可以用throws进行标记，也可以不用。

package day12.edu_02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowDemo {
public static void main(String[] args) {
method();
try {
method2();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

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

}

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