Java异常

异常的处理方式

三种方式：

1.JVM默认的处理方式

2.自己处理

3.抛出异常

 JVM默认的处理方式

把异常的名称，异常的原因及异常出现的位置等信息输出在了控制台

程序停止执行，异常以下的代码不会执行了

public static void main(String[] args) {
        System.out.println("hello world");
        System.out.println(2/0);
        System.out.println("长矛沾屎戳谁谁死");
    }

 没有第二行输出：

否则：

 自己处理

语法：

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

目的：当代码出现异常时，可以让程序继续往下执行。

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(arr[10]);
        } catch (ArrayIndexOutOfBoundsException e){
            //如果出现了异常，我该如何处理
            System.out.println("索引越界了");
        }
        System.out.println("看看我执行了吗？");
    }

运行界面：

几个思考

1.如果try中的代码没有出现异常，会如何执行？

2.如果try中出现多个异常，会如何执行？

3.如果try中遇到的问题没有被捕获，会如何执行？

4.如果try中遇到了问题，那么try中出现异常之后的代码会执行吗？

回答：

1.

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(arr[0]);
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }
        System.out.println("看看我执行了吗？");
 }

由以上代码和运行界面来看，try中的代码没有异常也会执行，只是因为未捕获到异常，所以catch中的代码不会被执行。

2.

第一种，未捕获的异常在捕获的异常之前，那么该未捕获的异常之后的代码不会执行。且运行后控制台会输出该异常。

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(2/0);
            System.out.println(arr[10]);
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }
        System.out.println("看看我执行了吗？");
 }

第二种，未捕获的异常在捕获的异常之后，那么被捕获的异常之后的代码不会运行，直接运行catch中的代码。

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(arr[10]);
            System.out.println(2/0);
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }
        System.out.println("看看我执行了吗？");
}

多个异常我们会写多个catch语句来捕获异常，如果这些异常中存在父子关系，那么父系一定要写在下面，不然其父类以下的代码不会执行。不存在父子关系的话，在捕获到第一个异常后，之后try...catch语句中的代码就不会运行了。

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(arr[10]);
            System.out.println(2/0);
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        } catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }
        System.out.println("看看我执行了吗？");
}

3.

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(arr[10]);//ArrayIndexOutOfBoundsException
        } catch (NullPointerException e){
            System.out.println("空指针异常");
        }
        System.out.println("看看我执行了吗？");
}

由此可见，如果try中的异常没有被捕获，那么catch中的代码以及之后的代码都不会执行，直接JVM默认处理。也就是说咱们的try...catch白写。

4.不会执行了，直接跳转到对应的catch中，执行catch中的语句，但是如果没有对应的catch会交给虚拟机处理（JVM默认处理）。

printStackTrace()方法

public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        try{
            System.out.println(arr[10]);
        } catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        System.out.println("看看我执行了吗？");
}

抛出异常

涉及到两个关键词：throws和throw

throws

写在方法定义处，表示声明一个异常，告诉调用者，使用本方法可能会有哪些异常，语法如下：

public void 方法() throws 异常类名1，异常类名2...{
     ...
}

 该方法编译时异常必须写，运行时异常可以不写。

public static void main(String[] args) {
        int[] arr= {};
        int max=getMax(arr);
        System.out.println(max);
    }
    public static int getMax(int[] arr) throws NullPointerException,ArrayIndexOutOfBoundsException{
        if(arr==null){
            //手动创建一个异常对象，并把这个异常交给方法的调用者处理
            //此时方法会结束，下面的代码不会执行了
            throw new NullPointerException();
        }
        if(arr.length==0){
            throw new ArrayIndexOutOfBoundsException();
        }
        System.out.println("有我吗");
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        return max;
    }

throw

写在方法内，结束方法，手动抛出异常对象，交给调用者，方法中下面的代码不再执行了，语法：

public void 方法(){
   throw new 方法类名();
}

public static void main(String[] args) {
        int[] arr=null;
        int max=getMax(arr);
        System.out.println(max);
    }
 public static int getMax(int[] arr){
        if(arr==null){
            //手动创建一个异常对象，并把这个异常交给方法的调用者处理
            //此时方法会结束，下面的代码不会执行了
            throw new NullPointerException();
        }
        System.out.println("有我吗");
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        return max;
  }

自定义异常

步骤：

1.定义异常类

2.写继承关系

3.空参构造

4.带参构造

意义：为了让控制台的报错信息更加的见名知意

定义异常类： 

public class NameFormatException extends Exception {
    public NameFormatException() {
    }

    public NameFormatException(String message) {
        super(message);
    }
}

import java.util.Scanner;

public class Main {
    String name;

    public String getName() {
        return name;
    }

    public void setName(String name) throws NameFormatException{
        int len=name.length();
        if(len<3 || len>10){
            throw new NameFormatException(name + "格式有误，长度应为3-10");
        }
        this.name = name;
    }

    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        try {
            String name=scan.nextLine();
            Main main=new Main();
            main.setName(name);
        } catch (NameFormatException e) {
            e.printStackTrace();
        }

    }
}

课程：【黑马程序员Java零基础视频教程_下部(Java入门，含斯坦福大学练习题+力扣算法题和大厂java面试题）】