（5）使用场景

针对需要如何处理的异常，采用捕获的方式去处理异常。

5.Java异常处理过程——声明异常throws

（１）定义

• 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置: 写在方法名 或方法名列表之后 ，在方法体之前。）

（２）结构语法

 static void pop() throws Exception1,Exception2,Exception3{
        //方法体
    }

（３）throws与throw的区别

• throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
• 意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
• throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象。

（４）举例

• 例1

public class Example6_3 {
//定义方法并抛出NegativeArraySizeException异常
    static void pop() throws NegativeArraySizeException{
        int[] arr = new int[-5];
    }
    public static void main(String[] args){
         try {//处理异常信息
            pop();//调用pop方法
        }catch (NegativeArraySizeException e){
             System.out.println("pop()方法抛出的异常");//输出异常消息
         }
    }
}

使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。pop方法中没有处理异常NegativeArraySizeException，而是main函数来处理。

（５）使用场景

• 非检查异常(运行时异常)可以不使用throws关键字来声明要抛出的异常，编译也可顺利通过，但在运行时会被系统抛出。
• 受检异常(编译时异常)，必须使用try-catch/throws处理，否则会导致编译错误。
• 仅当抛出了异常，该方法的调用者才必须处理或重新抛出该异常。当方法的调用者无力处理该异常时，应该继续抛出而不是直接调用方法。
• 调用方法必须遵循一个原则：若覆盖一个方法，则不能声明与覆盖方法不同的异常，声明的任何异常必须是被覆盖方法所声明异常的同类或子类。如下例子：

public class Example6_3 {
    void method1() throws IOException {
    }//合法

    //编译错误，必须捕获或声明抛出IOException
    void method2() {
        method1();
    }

  	//编译错误，必须捕获或声明抛出IOException或其父类
    void method3() throws IOError {
        method1();
    }

    //合法，声明抛出IOException
    void method3() throws IOException {
        method1();
    }

    //合法，声明抛出Exception，Exception是IOException的父类
    void method4() throws Exception {
        method1();
    }

    //合法，捕获IOException
    void method5() {
        try {
            method1();
        }catch (IOException e){
            
        }
    }
    
    //编译错误，必须捕获或声明抛出Exception
    void method6() {
        try {
            method1();
        }catch (IOException e){
            throw new Exception();
        }
    }

    //合法，声明抛出Exception
    void method7() throws Exception {
        try {
            method1();
        }catch (IOException e){
            throw new Exception();
        }
    }
}

6.Java异常处理过程——抛出异常throw

（１）定义

Java程序的当前方法或自身不去处理异常，选择在方法内部使用throw抛出一个Throwable类型的异常。

（２）结构语法

• 关键字是throw，throw语句抛出的是异常类对象，因此需要new关键字创建这一异常实例，而且只能抛出一个异常实例。
• throw在方法体中，程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里到外寻找含有与其匹配的catch子句的try块。
• new 的异常类名称必须是Throwable或其子类

throw new 异常类名称([描述信息])

（３）举例

• 例1

public class Example6_5 {
    public static void main(String[] args) {
        int a = 6;
        int b = 0;
       
       try {           
            System.out.println(a / b);
            throw new ArithmeticException();
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
           
        }
    }
}

运行结果：

除数不能为0

上面的例子中，b=0，引发了ArithmeticException异常，因此创建了ArithmeticException对象，并由throw语句将异常抛给Java运行时系统，系统寻找匹配的异常处理器catch并运行相应的异常处理代码，打印输出”除数不能为0“。try-catch语句结束。

实际上，除数为0等于ArithmeticException，是RuntimeException的子类，运行时异常将由系统自动抛出，不需要使用throw语句，上面的代码等价于如下代码：

public class Example6_5 {
    public static void main(String[] args) {
        int a = 6;
        int b = 0;
        try {           
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }
    }
}

• 例2：

public class Example6_5 {
    public static boolean main() throws ArithmeticException  {
        int a = 6;
        int b = 0;
        try {
            if (b == 0) {
                throw new ArithmeticException();//通过throw抛出异常
            }
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
            throw e;//通过throw抛出异常
        }finally {
            return false;
        }
    }

    public static void main(String[] args) {
        try {
            System.out.println(main());
        }catch (Exception e){
            System.out.println("捕获");
        }
    }
}

程序运行的结果为：

除数不能为0
false

可以看到finally语句块中的return会覆盖掉catch里面的throw抛出的异常；

• 例3：

public class Example6_5 {
    public static boolean main() throws ArithmeticException  {
        int a = 6;
        int b = 0;
        try {
            if (b == 0) {
                throw new ArithmeticException();//通过throw抛出异常
            }
            System.out.println(a / b);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
            return true;//通过throw抛出异常
        }finally {
            throw  new ArithmeticException();
        }
    }

    public static void main(String[] args) {
        try {
            System.out.println(main());
        }catch (Exception e){
            System.out.println("捕获");
        }
    }
}

可以猜测一下程序的运行结果：

除数不能为0
捕获

可以看到同样finally里面的throw会覆盖catch里面的return

（４）使用场景

• 针对不知道如何处理的异常，采用抛出的方式去处理。
• throw可抛出系统自定义异常，通常情况下，是用来抛出用户自定义的异常。
• throw后面不能跟其它代码块，否则编译不能通过，但是可以在finally语句块中有return语句，finally语句可以让throw和return共存

try {           
	System.out.println("除数不能为0")
    }catch (ArithmeticException e){
	throw new ArithmeticException();
	System.out.println(a / b);//将会报错
}finally {
    return false;
}    
return true;//将会报错       

四、自定义异常

1.定义

继承Throwable或者他的子类Exception的用户自己定义的异常类。前面的内容提到的都是系统有的异常类。

2.在程序中使用自定义异常的步骤

• 创建自定义异常类
• 在方法中通过throw抛出异常对象
• 如果在当前方法中对抛出的异常对象作处理，可以使用try－catch语句块捕获抛出异常对象并且处理，否则要在方法的声明处通过throws关键字指明要抛出给方法调用者的异常。
• 在出现异常方法的调用者中捕获并处理异常

3.结构语法

class UserException extends Exception {
    UserException(){
        super();
        ...//其他语句
    }
}

throw关键字通常用在方法体中，并且抛出一个异常对象

4.举例

• 例1

public class Example6_4 {
    static int quotient(int x,int y) throws Exception{
        if(y<0){
            throw  new MyException("除数不能是负数");
        }
        return x/y;//返回值
    }

    public static void main(String[] args) {
        int a= 3;
        int b=0;
        try {
            int result = quotient(a,b);//调用quotient自定义异常方法，当b=0,会抛出ArithmeticException类的异常对象
            System.out.println(result);
        }catch (MyException e){
            System.out.println(e.getMessage());
        }catch (ArithmeticException e) {//异常对象会被此ArithmeticException类捕获
            System.out.println("除数不能为0");
        }catch (Exception e){
            System.out.println("程序发生了其它的异常");
        }
    }
}

/**
 * 创建自定义异常
 */
class MyException extends Exception{
    String message;
    public MyException(String ErrorMessage){
        this.message = ErrorMessage;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

输出结果是：

除数不能为0

• 例2
  创建自定义异常类AgeException,继承自类Exception。使用Throw关键字抛出异常对象。
  input方法用于接收从键盘输入的姓名和年龄，如果输入为负数，则会抛出AgeException异常并积极捕获处理，如果输入正确，则会将姓名和年龄输出同时结束整个程序。

//定义异常类AgeException

import java.util.Scanner;

/**
 * 1、java内置的异常类无法描述年龄的异常，所以需要自定义一个可以描述年龄的异常类
 */
class AgeException extends Exception {
    public AgeException(String message) {
        super(message);
    }
}

public class Example6_9 {
    //用户输入年龄方法
    public static void input() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入姓名：");
        String name = scanner.next();//接收键盘上姓名的输入
        System.out.println("请输入年龄：");

        while (scanner.hasNext()) {
        //Scanner类中的hasNext()方法可以判断下一个输入是否为整数，整数才会进入到循环体，该程序利用这个特点并且结合if判断语句来控制年龄的输入是否<0
            try {
                int age = scanner.nextInt();//接收键盘上年龄的输入
                if (age < 0) {
                    throw new AgeException("年龄不能为负数");//２、一旦出现年龄输入为< 0的情况，就会通过throw抛出一个AgeException类的对象并且捕获处理
                }
                System.out.println("姓名" + name);
                System.out.println("年龄" + age);
                break;

            } catch (AgeException e) {
                System.out.println(e.getMessage() + "请重新输入：");
            }
        }
    }

    public static void main(String[] args) {
        input();
    }
}

输出结果是：

请输入姓名：
jack
请输入年龄：
-20
年龄不能为负数请重新输入：
-34
年龄不能为负数请重新输入：
-5
年龄不能为负数请重新输入：
11
姓名jack
年龄11

五、Try-With-Resources

• Java库中有很多资源需要手动关闭，例如打开的文件、连接的数据库等。在java7之前都是try－finally的方式关闭资源，try后面总是跟着一个“{”。

• 举个例子：try-finally方式关闭资源

package com.chapter6;

import java.io.*;

/**
 * @Author: qp
 * @Time: 2021/9/3 19:14
 * @Description
 */
public class Example6_8 {
    public static void main(String[] args) {
        copy("E:/MyFirst.java","F:/First.Java");//复制文件
    }

    private static void copy(String src, String des) {
        InputStream in = null;
        OutputStream out = null;
        try{
            in = new FileInputStream(src);
            out = new FileOutputStream(des);
            byte[] buff = new byte[1024];//创建一个长度为1024字节的字节数组
            int n;
            //从输入流一次最多流入buff.length个字节的数据到buff中，直到文件末尾结束
            while ((n=in.read(buff))>=0){
                //将数组buff中的数据从0位置开始，长度为n的字节输出到输出流中
                out.write(buff,0,n);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(in!=null){
                try{
                in.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }

            if(out!=null){
                try{
                    out.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }

    }

}

从上例可以看出，这种实现非常的杂乱冗长。

Java7之后，推出了Try-With-Resources声明代替之前的方式，try后跟括号"("，括号内的部分称为资源规范头。**资源规范头中可以包含多个定义，通过分号进行分隔。**规范头中定义的对象必须实现java.lang.AntoCloseable接口，这个接口中有一个close()方法，因此无论是否正常退出try语句块，这些对象都会在try语句块运行结束之后调用close方法，从而替代以前的在finally中关闭资源的功能，且不需要冗长的代码，另外，Try-With-Resources中的try语句可以不包含catch或者finally语句块而独立存在。

public class Example6_9 {
    public static void main(String[] args) {
        copy("E:/MyFirst.java","F:/First.Java");//复制文件
    }

    private static void copy(String src, String des) {
        try (InputStream in = new FileInputStream(src);
             OutputStream out = new FileOutputStream(des)) {
            byte[] buff = new byte[1024];//创建一个长度为1024字节的字节数组
            int n;
            //从输入流一次最多流入buff.length个字节的数据到buff中，直到文件末尾结束
            while ((n=in.read(buff))>=0){
                //将数组buff中的数据从0位置开始，长度为n的字节输出到输出流中
                out.write(buff,0,n);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

六、异常的使用原则

Java异常强制用户去考虑程序的健壮性和安全性，异常处理不用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个异常时可遵循以下的一些原则：

1. 在当前方法声明中使用try-catch捕获异常
2. 一个方法被调用时，调用它的方法必须抛出相同的异常或异常的父类；
3. 如果父类抛出多个异常，则覆盖方法必须抛出多个异常的一个子集，不能抛出新的异常
4. 不要过度使用异常，不要使用异常代替流程控制，不要抛出简单异常代替所有错误
5. 不要使用庞大的try语句，否则会增加编程的复杂度，可以把大块的try语句分成多个可能出现异常的程序段落，分别放在单独的try模块中
6. 避免一个catch处理很多异常
7. 不要忽略捕捉到的异常，对于捕捉到的异常尽可能在catch语句块解决
8. 尽可能使用try-with-resources