throws,throw,try···catch···finally

throws—声明异常

• 使用throws关键字对外声明该方法有可能发生异常
  这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。

格式为
返回值类型 方法名( )或类名 throws Exception1,Exception2·····
注：如果有多个异常类，它们之间用逗号分隔

/**
 * throws 声明异常
 */

class Math {
    //定义除法方法
    //在方法后加throws声明该方法可能抛出异常
    public int Division(int i,int j) throws Exception{
        //由于result是int型，所以很有可能出现异常
        int result = i/j;
        System.out.println("i/j= "+result);
        return result;
    }
}

public class throwsDemo {
    public static void main(String[] args) {
        Math math = new Math();
        try
        {
            math.Division(10,2);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("除法错误");
        }
    }
}

• 在类继承代码中要注意，子类在重写父类带 throws 子句的方法时，子类的方法声明中的 throws 子句不能出现父类对应方法的 throws 子句中没有的异常类型
• main函数也能用throws抛出异常给JVM

try···catch···finally—处理异常

• 使用try catch 语句来捕获异常并处理

格式为

try {
//把可能引发异常的语句封装在try语句块
//一旦发生异常，那么一个相应的异常对象就会被拋出
    逻辑代码块;
} catch(ExceptionType e) {
//catch 语句就会依据所拋出异常对象的类型进行捕获，并处理
    处理代码块;
} finally{
//finally中的语句不管是否发生异常都会执行
}

注：发生异常后，程序会跳过 try 语句块中剩余的语句，转到 catch 语句块后面的第一条语句开始执行

/**
 * try catch finally 捕捉异常
 */

import java.util.Scanner;

public class trycatchDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("-----信息登记表-----");
        String name;
        int age;
        try {
            System.out.println("请输入姓名:");
            name = scanner.next();
            System.out.println("请输入年龄:");
            age = scanner.nextInt();
        } catch(Exception e) {
            e.printStackTrace();
            System.out.println("输入错误，请重新输入");
        }
    }
}

• 如果一个 catch 语句的异常类型参数是多个异常类型的父类，那么她可以同时捕捉这几个异常类型
• finally需要和try联系在一起使用

throw—抛出对象

• throw 语句用来直接拋出一个异常，后接一个可拋出的异常类对象

格式为throw ExceptionObject
注：ExceptionObject 必须是 Throwable 类或其子类的对象

/**
 * throw 抛出异常
 */
import java.util.Scanner;

class userName {
    public boolean namingRule(String username){
        boolean sign =false;
        //用户名要少于8个字符
        if (username.length()<8) {
            for (int i = 0;i<username.length();i++) {
                //获取用户名中的每个字符
                char c = username.charAt(i);
                //用户名只能是字母
                if ((c >= 'a'&& c <= 'z') || (c >= 'A'&&c <= 'Z')) {
                    sign = true;
                } else {
                    //在用户名有字母之外的字符时抛出异常
                    throw new IllegalArgumentException("用户名只能由字母组成");
                }
            }
        } else {
            //IllegalArgumentException
            //非法参数异常，当方法接收到不符合参数列表的参数时，就会报这个异常
            throw new IllegalArgumentException("用户名长度不能多于8位");
        }
        return sign;
    }
}
public class throwDemo {
    public static void main(String[] args) {
        userName user = new userName();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = scanner.next();
        try {
            boolean sign = user.namingRule(username);
            if (sign) {
                System.out.println("用户名输入正确！");
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

异常茶话会

一、异常分类

1. 编译时异常（受控）
   在Java 中，Exception类中除了RuntimeException 类及其子类外都是编译时异常
2. 运行时异常（非受控）
   RuntimeException 类及其子类运行异常
3. 自定义异常
   Java中允许用户自定义异常，自定义的异常类继承自Exception则为编译时异常，继承自Runtimeexception则为运行时异常

二、Exception 和 error

1. 异常Exception可处理，而错误error不可处理

三、新线程

1. 异常由一条新线程执行，与main函数并非同一线程
2. 所以异常出现的位置可能与main函数中的代码的位置不对应