Java异常处理

异常

1.1 异常介绍

1.2 异常体系图一览

小结：
1. 异常分为两大类，运行时异常和编译时异常·
2. 运行时异常，编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常
3. 对于运行时异常，可以不作处理，因为这类异常很普遍,若全处理可能会对程序的可读性和运行效率产生影响
4. 编译时异常,是编译器要求必须处置的异常。

1.3 常见的运行时异常

1) NullPointerException 空指针异常
2) ArithmeticException 数学运算异常
3) ArrayIndexOutOfBoundsException 数组下标越界异常
4) ClassCastException 类型转换异常
5) NumberFormatException 数字格式不正确异常[]

1.4 举例

1.4.1 NullPointerException 空指针异常

当应用程序试图在需要对象的地方使用 null 时，抛出该异常

代码:

 package com.zakedu.exception_;
 /**
 * @author 
*@version1.0
 */
 public class NullPointerException_{
     public static void main(String[]args){
     String name = null;
     System.out.println(name.length());
 } }

1.4.2 ArithmeticException数学运算异常

当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例,

代码:

package com.zakedu.exception_;
 /**
 *@author
*@version1.0
 */
 public class NumberFormatException_{
 public static void main(String[]args){
 String name="zak";
 //将String转成int
int num = Integer.parseInt(name);//抛出NumberFormatException
 System.out.println(num);//1234
 } }

1.4.3 ArrayIndexOutOfBoundsException数组下标越界异常

用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引

代码:

package com.zakedu.exception_;
 /**
 *@author
*@version1.0
 */
 public class ArrayIndexOutOfBoundsException_{
 public static void main(String[]args){
 int[] arr = {1,2,4};
 for(int i = 0; i< = arr.length; i++){
 System.out.println(arr[i]);
 }

1.4.4 ClassCastException类型转换异常

当试图将对象强制转换为不是实例的子类时，抛出该异常。

代码:

 package com.zakedu.exception_;
 /**
 *@author
*@version1.0
 */
 public class ClassCastException_{
 public static void main(String[]args){
 A b = new B();//向上转型
 B b2 =(B)b;//向下转型，这里是OK
 C c2 =(C)b;//这里抛出ClassCastException
 } }
 classA{ }
 class B extends A{ }
 class C extends A{ }

1.4.5 NumberFormatException数字格式不正确异常

        当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常=>使用异常我们 可以确保输入是满足条件数字.

代码:

 package com.zakedu.exception_;
 /**
 *@author
*@version1.0
 */
 public class NumberFormatException_{
 public static void main(String[]args){
 String name="zak";
 //将String转成int
 int num = Integer.parseInt(name);//抛出NumberFormatException
 System.out.println(num);//1234
 } }

1.5 编译异常

介绍：编译异常是指在编译期间,就必须处理的异常，否则代码不能通过编译。

常见的编译异常：

案例代码：

package com.zakedu.exception_;
 import java.io.FileInputStream;
 import java.io.IOException;
 /**
 *@author
*@version1.0
 */
 public class Exception02{
     public static void main(String[]args){
         try{
             FileInputStream fis;
             fis = new FileInputStream("d:\\aa.jpg");
             int len;
             while ((len = fis.read()) !=-1) {
             System.out.println(len);
         }
             fis.close();
         } catch (IOException e) {
             e.printStackTrace();
 } } }

1.6 异常处理

基本介绍：异常处理就是当异常发生时，对异常处理的方式。

异常处理的方式：

示意图：

1.7  try-catch异常处理

1.7.1 try-catch 方式处理异常说明：

代码：

public static void main(String[] args) {
     int num1 =10;
     int num2 =0;
     try{
         int res = num1 / num2;
     } catch(Exceptione){
     System.out.println(e.getMessage());
 } }

try-catch方式处理异常-注意事项：

代码：

package com.zakedu.try_;
 /**
 *@author
*@version1.0
 */
public class TryCatchDetail {
 public static void main(String[] args) {
 //解读
 //1. 如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块
 //2. 如果异常没有发生，则顺序执行try的代码块，不会进入到catch
 //3. 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码-finally
 try {
     String str = "zak";
     int a = Integer.parseInt(str);
     System.out.println("数字：" + a);
 } catch (NumberFormatException e) {
     System.out.println("异常信息=" + e.getMessage());
 } finally {
     System.out.println("finally 代码块被执行...");
 }
     System.out.println("程序继续...");
 } }

代码：

package com.zakedu.try_;
 /**
 * @author 
* @version 1.0
 */
 public class TryCatchDetail02 {
 public static void main(String[] args) {
 //解读
 //1.如果 try 代码块有可能有多个异常
 //2.可以使用多个catch 分别捕获不同的异常，相应处理
 //3.要求子类异常写在前面，父类异常写在后面
 try {
     Person person = new Person();
     //person = null;
     int n1 = 10;
     System.out.println(person.getName());//NullPointerException
     int n2 = 0;
     int res = n1 / n2;  //ArithmeticException
 } catch (NullPointerException e) {
     System.out.println("空指针异常=" + e.getMessage());
    } catch (ArithmeticException e) {
     System.out.println("算术异常=" + e.getMessage());
 } catch (Exception e) {
     System.out.println(e.getMessage());
 } finally {
 } } }

class Person {
     private String name = "jack";
     public String getName() {
     return name;
 } }

代码：

 package com.zakedu.try_;
/**
 * @author 
* @version 1.0
 */
public class TryCatchDetail03 {
  public static void main(String[] args) {
 /*
    可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，
    因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，
    都必须执行某个业务逻辑
*/
 try{
     int n1 = 10;
     int n2 = 0;
     System.out.println(n1 / n2);
 }finally {
     System.out.println("执行了 finally..");
 }
     System.out.println("程序继续执行..");
 } }

1.7.2  try-catch-finally 执行顺序小结

1.7.3 练习题

如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止

代码：

package com.zakedu.try_;
 import java.util.Scanner;
/**
 * @author 
* @version 1.0
 */
public class TryCatchExercise04 {
     public static void main(String[] args) {
     //如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止
    //思路
    //1. 创建Scanner 对象
    //2. 使用无限循环，去接收一个输入
    //3. 然后将该输入的值，转成一个int
    //4. 如果在转换时，抛出异常，说明输入的内容不是一个可以转成int的内容
    //5. 如果没有抛出异常，则break 该循环
    Scanner scanner = new Scanner(System.in);
     int num = 0;
     String inputStr = "";
     while (true) {
     System.out.println("请输入一个整数:"); //
     inputStr = scanner.next();
     try {
         num =Integer.parseInt(inputStr); //这里是可能抛出异常
        break;
     } catch (NumberFormatException e) {
        System.out.println("你输入的不是一个整数:");
   } }
     System.out.println("你输入的值是=" + num);
 } }

1.8 throws 异常处理

1.8.1 介绍

入门案例：

1.8.2 注意事项

1) 对于编译异常，程序中必须处理，比如try-catch或者throws
2) 对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
3) 子类重写父类的方法时，对抛出异常的规定:子类重写的方法。所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型
4) 在throws 过程中，如果有方法 try-catch,就相当于处理异常，就可以不必throws
代码：

package com.zakedu.throws_;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 /**
 *@author
*@version1.0
 */
 public class ThrowsDetail{
     public static void main(String[]args){
         f2();
 }

     public static void f2()/*throwsArithmeticException*/{
         //1.对于编译异常，程序中必须处理，比如try-catch或者throws
         //2.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
         int n1=10;
         int n2=0;
         double res = n1/n2;
}

 public static void f1() throws FileNotFoundException {
     //这里大家思考问题 调用f3() 报错
     //解读
     //1. 因为f3() 方法抛出的是一个编译异常
    //2. 即这时，就要f1() 必须处理这个编译异常
    //3. 在 f1() 中，要么 try-catch-finally ,或者继续 throws 这个编译异常
        f3(); // 抛出异常
    }
     public static void f3() throws FileNotFoundException {
     FileInputStream fis = new FileInputStream("d://aa.txt");
 }

public static void f4() {
 //解读:
 //1. 在 f4()中调用方法f5() 是OK
 //2. 原因是f5() 抛出的是运行异常
    f5();
 }
 //3. 而 java 中，并不要求程序员显示处理,因为有默认处理机制
public static void f5() throws ArithmeticException {
 } }

class Father { //父类
public void method() throws RuntimeException {
 } }

 class Son extends Father {//子类
    //3. 子类重写父类的方法时，对抛出异常的规定:子类重写的方法，
    //所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常类型的子类型
    //4. 在 throws 过程中，如果有方法 try-catch, 就相当于处理异常，就可以不必throws
     @Override
     public void method() throws ArithmeticException {
 } }

1.9 自定义异常

基本概念：
        当程序中出现了某些“错误”，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类,用于描述该错误信息。

自定义异常的步骤：

自定义异常的应用实例：

        题：当我们接收Person对象年龄时，要求范围在18-120之间，否则抛出一个自定义异常(要求继承RuntimeException)，并给出提示信息
代码：

package com.zakedu.customexception_;
 /**
 * @author 
* @version 1.0
 */
 public class CustomException {
   public static void main(String[] args) /*throws AgeException*/ {
    int age = 180;
     //要求范围在 18–120 之间，否则抛出一个自定义异常
    if(!(age >= 18 && age <= 120)) {
     //这里我们可以通过构造器，设置信息
    throw newAgeException("年龄需要在 18~120 之间");
 }
     System.out.println("你的年龄范围正确.");
 } }
 //自定义一个异常
 //解读
 //1. 一般情况下，我们自定义异常是继承 RuntimeException
 //2. 即把自定义异常做成 运行时异常，好处时，我们可以使用默认的处理机制
 //3. 即比较方便

 class AgeException extends RuntimeException {
     public AgeException(String message) {//构造器
        super(message);
 } }

1.10 throw 和 throws 的区别

一览表：