异常使用总结

异常的概念

• 异常是指程序在运行时出现错误通知调用者的一种机制。

• 运行时指的是程序已经编译通过得到 class 文件了， 再由 JVM 执行过程中出现的错误。异常的种类有很多，不同种类的异常具有不同的含义， 也有不同的处理方式。

举个栗子：

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        System.out.println(arr[4]);
    }
}


//执行结果
Exception in thread "main" 
java.lang.ArrayIndexOutOfBoundsException: 4
	at Test.main(Test.java:4)

异常的基本用法

• 捕获异常
  • 基本语法

try{ 
 有可能出现异常的语句 ; 
} catch (异常类型 异常对象) {
} finally {
 异常的出口
}
try 代码块中放的是可能出现异常的代码。
catch 代码块中放的是出现异常后的处理行为。
finally 代码块中的代码用于处理善后工作，会在最后执行。
catch finally 根据情况加或者不加

1. try 中出现异常， 那么 try 代码块中的程序就不会继续执行， 而是交给 catch 中的代码来执行，catch执行完毕会继续往下执行。

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        try {
            System.out.println("before");
            System.out.println(arr[4]);
            System.out.println("after");
        } catch (ArrayIndexOutOfBoundsException e) {
           //打印异常的调用栈
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
}

//执行结果
before
java.lang.ArrayIndexOutOfBoundsException: 4
after try catch

2. catch只能处理对应种类的异常

public class Test {
    public static void main(String[] args) {
        int[] arr = null;
        try {
            System.out.println("before");
            System.out.println(arr[4]);
            System.out.println("after");
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
}
//执行结果
//因为是空指针异常，catch捕获异常种类不匹配，由jvm抛出异常，程序中断。
before
Exception in thread "main" java.lang.NullPointerException
	at Test.main(Test.java:6)

3. catch可以有多个。`

public class Test {
   public static void main(String[] args) {
       int[] arr = null;
       try {
           System.out.println("before");
           System.out.println(arr[4]);
           System.out.println("after");
       } catch (ArrayIndexOutOfBoundsException e) {
           e.printStackTrace();
       } catch (NullPointerException e) {
           e.printStackTrace();
       }
       System.out.println("after try catch");
   }
}

//执行结果
before
java.lang.NullPointerException
after try catch

也可以这样写：

catch (ArrayIndexOutOfBoundsException | NullPointerException e) { 
 ... 
} 

4. 也可以用一个 catch 捕获所有异常

public class Test {
    public static void main(String[] args) {
        int[] arr = null;
        try {
            System.out.println("before");
            System.out.println(arr[4]);
            System.out.println("after");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
}

//执行结果
before
after try catch
java.lang.NullPointerException
	at Test.main(Test.java:6)

 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉
 所有异常.
备注: catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 
也会捕捉目标异常类型的子类对象.
如刚才的代码, NullPointerException 和 ArrayIndexOutOfBoundsException 
都是 Exception 的子类, 因此都能被捕获到。

5. finally 表示最后的善后工作, 例如释放资源。
   无论是否存在异常, finally 中的代码一定都会执行到. 保证最终一定会执行到 Scanner 的 close 方法。

public class Test {
    public static void main(String[] args) {
        int[] arr = null;
        try {
            System.out.println("before");
            System.out.println(arr[4]);
            System.out.println("after");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("fianlly code");
        }
        System.out.println("after try catch");
    }
}
//执行结果
java.lang.NullPointerException
before
	at Test.main(Test.java:6)
fianlly code
after try catch

6. 使用 try 负责回收资源。

 try (Scanner sc = new Scanner(System.in)) {
            int num = sc.nextInt();
            System.out.println("num = " + num);
        } catch (Exception e) {
            e.printStackTrace();
        }

• 抛出异常
  除了java内置的类抛出一些异常之外，我们也可以手动抛出某个异常。在构造异常对象中可以制定一些描述性语言。

public class Test {
    public static void main(String[] args) {
        invide(4,0);
    }
    public static int invide(int x, int y) {
        if (y == 0) {
            throw new ArithmeticException("除数为零");
        }
        return x / y;
    }
}

//执行结果
Exception in thread "main" java.lang.ArithmeticException: 除数为零
	at Test.invide(Test.java:9)
	at Test.main(Test.java:5)

• 异常说明
  我们可以使用 throws 关键字， 把可能抛出的异常显式的标注在方法定义的位置， 从而提醒调用者要注意捕获这些异常。

 public static int invide(int x, int y) throws ArithmeticException {
        if (y == 0) {
            throw new ArithmeticException("除数为零");
        }
        return x / y;
    }

• finally 的注意事项
  finally 执行的时机是在方法返回之前(try 或者 catch 中如果有 return 会在这个 return 之前执行 finally).。但是如果finally 中也存在 return 语句， 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return。

public static void main(String[] args) {
   System.out.println(func()); 
} 
public static int func() { 
  try { 
    return 10; 
  } finally { 
    return 20; 
  } 
} 

// 执行结果
20 

自定义异常类
声明一个自定义异常类
将自定义类继承Exception
编写两个构造器，一个空的，一个有参数的构造器

public class NewException extends Exception{
    public NewException(String s) {//s根据自己需要传入
            super(s);
    }
}

public class Test {
    private static String userName = "admin";
    private static String password = "123456";

    static class UserError extends Exception {
        public UserError(String message) {
            super(message);
        }
    }

    static class PasswordError extends Exception {
        public PasswordError(String message) {
            super(message);
        }
    }

    public static void main(String[] args) {
        try {
            login("in", "123456");
        } catch (UserError userError) {
            userError.printStackTrace();
        } catch (PasswordError passwordError) {
            passwordError.printStackTrace();
        }
    }
    public static void login(String userName, String password) throws UserError,
            PasswordError {
        if (!Test.userName.equals(userName)) {
            throw new UserError("用户名错误");
        }
        if (!Test.password.equals(password)) {
            throw new PasswordError("密码错误");
        }
        System.out.println("登陆成功");
    }
}

//执行结果
Test$UserError: 用户名错误
	at Test.login(Test.java:29)
	at Test.main(Test.java:19)