Java基础学习笔记之异常处理

异常是导致程序中断运行的一种指令流，如果不对异常处理，则可能发生程序中断运行

异常的父类是Throwable，其分为两个子类：1.Exception2.Error。Exception表示程序处理异常，而Error表示JVM错误（java虚拟机错误），此错误无法处理。
1.常见的java异常处理操作
(a)异常处理格式：

try{
//有可能出现异常的语句
}catch(异常类 异常对象){
//编写异常处理语句
}catch(异常类 异常对象){
//编写异常处理语句
}finally{

  //一定会运行到的程序

}

异常可以使用try...catch处理，也可以使用try...catch...finally处理，在try中捕获异常然后在catch中处理异常，finally作为异常的统一出口，不管是否发生异常都要执行此代码。

(b) 以下是几种常见的异常

例子1：普通的除零运算

//除零异常
public static void main(String[] args) {
int i = 5,j = 0;
int result = i / j;
System.out.println(result);

}

结果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
at java_logic.exception.Test_1.main(Test_1.java:22)

//除零异常处理操作，算术异常
public static void main(String[] args) {
try {
int i = 5,j = 0;
int result = i / j;
System.out.println(result);
} catch (Exception e) {
// TODO: handle exception
System.out.println("出现异常了" + e);
//可以用e.printStackTrace();打印出完整的错误信息
//e.printStackTrace();
}finally {
System.out.println("我还在执行");
}
}

结果：

出现异常了java.lang.ArithmeticException: / by zero
我还在执行

例子2：数组超出

//数组超出绑定异常
public static void main(String[] args) {
int[] a = {1,2,3,4,5};//为一个数组赋值
try {
int result = a[6];//取出一个超出界限的数组值
System.out.println(result);
} catch (Exception e) {
// TODO: handle exception
System.out.println("数组超出绑定异常" + e);
}

}

结果：

数组超出绑定异常java.lang.ArrayIndexOutOfBoundsException: 6

例子3：数字格式化异常

public static void main(String[] args) {
Scanner input = new Scanner(System.in);//用于执行输入操作
try {
String in = input.next();//获取用户输入操作
int num = Integer.parseInt(in);
System.out.println(num);
} catch (Exception e) {
// TODO: handle exception
//System.out.println("数字格式化异常" + e);
e.printStackTrace();//打印出完整异常信息
}
}

结果：输入a

a
java.lang.NumberFormatException: For input string: "a"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java_logic.exception.Test_1.main(Test_1.java:61)

例子4：空指针异常

//空指针异常
public static void main(String[] args) {
//创建一个空集合
List<String> list= null;
try {
Object obj = list.get(0);//获取一个集合的值
} catch (Exception e) {
// TODO: handle exception
System.out.println("空指针异常"+e);
}

}

结果：

空指针异常java.lang.NullPointerException

(c) 当try捕获到异常后出现异常后的程序将不会运行

//当捕获异常后后面的代码是否会继续执行,以先前空指针异常为例
//空指针异常java.lang.NullPointerException
//结果显示出现异常后后面的语句不会运行
public static void main(String[] args) {
//创建一个空集合
List<String> list= null;
try {
Object obj = list.get(0);//获取一个集合的值
System.out.println("出现异常了，还会执行么");
} catch (Exception e) {
// TODO: handle exception
System.out.println("空指针异常"+e);
}
}

结果：

空指针异常java.lang.NullPointerException

(d) 捕获多个异常，java中捕获范围小的异常必须放在捕获范围大的异常后面，最后最好都加上Exception进行其他异常的捕获

//捕获多个异常，java中捕获范围小的异常必须放在捕获范围大的异常后面，最后最好都加上Exception进行其他异常的捕获
public static void main(String[] args) {
try {
int result = 1 / 0;
int num = Integer.parseInt("sasd");//字符串转型,程序不会执行
//理论上会出现两个异常，但由于前面提到的原因所以后面的程序不会执行于是就只会出现一个异常
} catch (ArithmeticException e) {
// TODO: handle exception
//空指针异常
System.out.println("算术异常" + e);
}catch (NumberFormatException e) {
// TODO: handle exception
//数据格式异常
System.out.println("数据格式异常" + e);
}catch (Exception e) {
// TODO: handle exception
//最后放个捕获范围大的异常
System.out.println("出现异常了");
}
}

结果：

算术异常java.lang.ArithmeticException: / by zero

2.throw和throws关键字

throw抛出异常
  throws声明异常

(a) throws声明异常

//创建一个类，类里面定义一个声明异常的方法，在方法中可以不处理异常，而交给调用方法处处理
//public 返回值类型  方法名称（参数列表）throws 异常类{}
public void div(int i,int j) throws Exception{
int result = i / j;
System.out.println(result);
}

public static void main(String[] args) {
Test_1_ThrowAndThrows_1 t = new Test_1_ThrowAndThrows_1();
try {
t.div(2, 0);
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println("throws声明的异常:" + e);
}
}

结果：

throws声明的异常:java.lang.ArithmeticException: / by zero

(b) throw抛出异常

//抛出异常
public static void main(String[] args) {
try {
//使用throw人为抛出一个异常类的实例化对象
throw new Exception("我抛出的异常");
} catch (Exception e) {
// TODO: handle exception
System.out.println("捕获的异常：" + e);
}
}

结果：

捕获的异常：java.lang.Exception: 我抛出的异常

(c) throw 与 throws 混用

public void throwTest() throws Exception{
try {
throw new Exception("这是我人为抛出的异常");
} catch (Exception e) {
// TODO: handle exception
System.out.println("捕获的异常：" + e);
throw new Exception("已经捕获到自己抛出的异常了，于是我又抛出了一个");//抛出异常时需要使用throws
}
}

public static void main(String[] args) {
Test_1_ThrowAndThrows_1 t = new Test_1_ThrowAndThrows_1();
//throw抛出异常
try {
t.throwTest();
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println("捕获到的异常：" + e);
}
}

结果：

捕获的异常：java.lang.Exception: 这是我人为抛出的异常
捕获到的异常：java.lang.Exception: 已经捕获到自己抛出的异常了，于是我又抛出了一个

3.自定义异常类
定义异常类只要创建一个类继承Exception类

public class MyException extends Exception {
//在构造方法中接收异常信息
public MyException(String msg){
super(msg);//调用父类中的构造方法
}
}

/**
* 自定义异常类
* 自定义异常类只需要继承Exception类即可
*
* @param args
*/
public static void main(String[] args) {
try {
throw new MyException("这是我自定义的异常");
} catch (Exception e) {
// TODO: handle exception
System.out.println("捕获到的异常：" + e);
}
}

结果：

捕获到的异常：java_logic.exception.MyException: 这是我自定义的异常