异常

throw关键字
throws关键字
try…catch关键字
Throwable中的3个异常处理方法
finally关键字
异常重要注意事项
自定义异常类

异常指在程序在运行过程中出现的非正常情况，最终导致JVM的非正常停止。

在Java等面向对象的编程语言中，一场本身是一个类，产生异常

throw关键字

作用：可以使用throw关键主动抛出指定的异常终止程序。
使用格式：throw new xxxException(“异常产生原因”);
注意：
(1) throw关键字必须写在方法的内部
(2) throw关键字后边new的对象必须是Exception或者Exception的子类对象
(3) throw关键字抛出指定的异常对象，我们就必须处理这个异常对象。
如果创建的是RuntimeException或者RuntimeException的子类对象，我们可以将其交给JVM处理；如果创建的是编译异常，我们就必须手动处理，要么throw交给上级处理，要么try…catch自己处理。

package C4_异常;
import java.util.Arrays;
public class class01_throw关键字 {
    public static void main(String[] args) {
        String[] 安理会常任理事国={"中国","俄罗斯","美国","英国","法国"};
        String[] 空指针数组=null;
        printArray(安理会常任理事国);
        printArray(空指针数组);
    }
    static void printArray(String[] strings){
        if(strings==null)
            throw  new NullPointerException("传入数组错误！");
            //抛出异常

        if(strings!=null)
            System.out.println(Arrays.toString(strings));
    }
}

throws关键字

throws关键字会将异常抛给方法的调用者，也就是自己不处理，让别人处理，最终交给JVM做出中断处理。
(1) throws关键字必须写在方法的声明处
(2) throws关键字后面声明的异常必须是Exception或Exception的子类
(3) 方法内部如果抛出了多个异常，那么throws后面也必须声明多个异常。如果抛出的异常有子父类关系，那么直接抛出父类异常即可
(4) 掉用一个声明抛出异常的方法，就必须处理声明的异常。要么继续用throws抛出，要么使用try…catch自己处理异常。

package C4_异常;
public class class02_throws关键字 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        new throwsTest().print(arr);
    }
}
class throwsTest{
    void print(int[] arr) throws ArrayIndexOutOfBoundsException{
        for (int i = 0; i <= arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
}

try…catch关键字

(1) try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常
(2) 如果try中产生了异常，那么就会执行catch中的异常处理逻辑。执行完异常处理之后继续执行try…catch之后的代码 ； 如果try中没有产生异常，就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try…catch之后的代码。

package C4_异常;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class class03_try_catch关键字 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("张三",23);
        map.put("李四",24);
        map.put("王五",25);
        Set set=map.entrySet();
        try {
            for (String key:map.keySet()) {
                String k=key;
                int value=map.get(k);
                System.out.println(k+":"+value);

                map=null;   //制造异常
            }
        }catch (NullPointerException e){
            System.err.println("程序运行出错！！！");
            e.printStackTrace();
        }

        System.out.println("异常处理之后的代码");
        System.out.println("异常处理之后的代码");
        System.out.println("异常处理之后的代码");
    }
}

Throwable中的3个异常处理方法

System.out.println(e.getMessage()); //返回错误的简短描述
System.out.println(e.toString()); //返回错误的较详细消息
e.printStackTrace(); //返回最详细的错误信息

package C4_异常;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class class04_Throwable类中3个异常处理方法 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("张三",23);
        map.put("李四",24);
        map.put("王五",25);
        Set set=map.entrySet();
        try {
            for (String key:map.keySet()) {
                String k=key;
                int value=map.get(k);
                System.out.println(k+":"+value);
                map=null;   //制造异常
                System.out.println();
            }
        }catch (NullPointerException e){
            System.err.println("程序运行出错！！！");

            System.out.println("简短描述:"+e.getMessage()); //返回错误的简短描述
            System.out.println("较详细描述:"+e.toString());   //返回错误的较详细消息
            System.out.print("最详细信息:");
            e.printStackTrace();                //返回最详细的错误信息
        }
    }
}

finally关键字

finally是在异常处理后必定执行的代码，无论是否发生异常都会继续将finally中的代码执行完。

package C4_异常;
public class class05_finally {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5};
        try {
            for (int i = 0; i < arr.length+1; i++) {
                System.out.println(arr[i]+"\t");
            }
        }catch (ArrayIndexOutOfBoundsException e){
            e.getMessage();
        }finally {
            System.out.println("必定执行的代码");
        }
    }
}

此外，finally中还能有返回值

package C4_异常;
public class class06_finally的return语句 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        System.out.println(printArray(arr));
    }
    static String printArray(int[] arr){
        try {
            for (int i = 0; i <= arr.length; i++) {
                System.out.println(arr[i]);
            }
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }finally {
            return "数组打印方法调用完毕";
        }
    }
}

异常重要注意事项

常见的异常处理方式有：
(1) 多个异常分别处理
也就是使用多个try…catch…，每个try…catch…只处理一个异常
(2) 多个异常一次捕获，多次处理
使用一个try，多个catch
(3) 多个异常一次捕获一次处理
直接捕获可能出现的异常的

自定义异常类

package C4_异常;
import java.util.Scanner;
public class class07_自定义异常 {
    public static void main(String[] args) throws MyException{
        Scanner scanner=new Scanner(System.in);
        String input=scanner.nextLine();
        check(input);
    }
    static void check(String username) throws MyException{
        String[] User={"张三","李四","王五"};
        for(String value:User){
            if(username.equals(value)){
                throw new MyException("当前用户名已被注册!");
            }
        }
    }
}
class MyException extends Exception{
    public MyException(){
        super();            //空参构造
    }
    //带异常信息的构造
    public MyException(String Message){
        super(Message);
    }
}