异常

1. 异常概述

异常：就是程序出现了不正常的情况

异常体系

Throwable —> Error
—> Exception —> RuntimeException
—> 非RuntimeException
Error： 严重问题,不需要处理
Exception: 称为异常,它表示程序本身可以处理的问题
RuntimeException:在编译期间不检查,出现问题后,需要修改代码
非RuntimeException: 编译期间就必须处理,否则程序不能通过编译,不能正常运行

2. JVM处理异常概述

如果程序出现问题, 我们没有做任何处理, 最终JVM 会做默认的处理 ,
把异常的名称, 原因 , 异常出现的未知等信息输出在了控制台
程序停止执行

3. 异常处理

如果程序出现了问题, 我们需要自己来处理 , 目前有两种方案: 

  1.         1. try... catch...
  2.         1. throws

3.1 异常处理之 try… catch…

格式:
try{
可能出现异常的代码;
} catch( 异常类名 变量名){
异常的处理代码
}
执行流程:
程序从try里面的代码开始执行
出现异常,会自动生产一个异常类对象,该异常对象将被提交给Java运行时的系统
当Java运行时系统接收到异常对象时, 会到catch 中去找匹配的异常类, 找到后进行异常的处理执行完毕之后,程序还可以继续往下执行
public class ExceptionDemo {
_public static void main(String[] args) {
System._out.println(“开始”);
method();
System.out.println(“结束”); }
_public static void method(){
int[] arr = {1,2,3};
System._out.println(_arr[3]); } }
// 输出: 开始
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
at com_10.ExceptionDemo.method(ExceptionDemo.java:21)
at com_10.ExceptionDemo.main(ExceptionDemo.java:10)
————————————————————————
public class ExceptionDemo {
public static void main(String[] args) {
System._out.println(“开始”);
method();
System.out.println(“结束”); }
_public static void method(){
try {
int[] arr = {1,2,3};
System._out.println(_arr[3]);
} catch (ArrayIndexOutOfBoundsException e){
System._out.println(“你访问数组的索引不存在”); } } }

3.2 异常处理之 Throwable 的成员方法

public String getMessage() 返回throwable的详细消息字符串
public String toString() 返回此可抛出的简短描述
public void printStackTrace() 把异常的错误信息输出在控制台
public class ExceptionDemo {
_public static void main(String[] args) {
System._out.println(“开始”);
method();
System.out.println(“结束”);
}
_public static void method(){
try {
int[] arr = {1,2,3};
System._out.println(_arr[3]);
} catch (ArrayIndexOutOfBoundsException e){
// public void printStackTrace() 把异常的错误信息输出在控制台
e.printStackTrace();
/ 输出:
java.lang.ArrayIndexOutOfBoundsException: 3
at com_10.ExceptionDemo.method(ExceptionDemo.java:16)
at com_10.ExceptionDemo.main(ExceptionDemo.java:10)/
// public String getMessage() 返回throwable的详细消息字符串
System._out.println(_e.getMessage());
// 输出: 3
// public String toString() 返回此可抛出的简短描述
System._out.println(_e.toString());
// 输出: java.lang.ArrayIndexOutOfBoundsException: 3
} } }_

4. 编译时异常和运行时异常的区别概述

Java 中的异常被分为两大类: 编译时异常和运行时异常, 也被称为受检异常和非受检异常
所有的RuntimeException 类及其子类被称为运行时异常,其他的异常都是编译时异常

　编译时异常 ：必须显示处理，否则程序就会发生错误，无法通过编译
　运行时异常：无需显示处理，也可以和编译时异常一样处理
public static void main(_String[] args) { method1(); }
// 运行时异常
public static void method(){
int[] arr = {1,2,3};
System._out.println(_arr[3]); }
// 编译时异常:
// 编译时异常是表示编译器无法直接判断是否有异常,就是可能会出现异常,需要自己try..catch…判断
public static void method1(){
try {
String s = “2048-11-11”;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd”);
Date date = simpleDateFormat.parse(s);
System._out.println(_date);
}catch (ParseException e){
e.printStackTrace(); } }_

5. 异常处理之throws

虽然可以通过try …catch .. 可以对异常进行处理, 但不是所有的异常情况我们都有权限进行异常处理, 所以为了对我们处理不了的异常情况, Java提供了throws 的处理异常方案

格式:
throws 异常类名;
注意: 这个格式是跟在方法的括号后面的 —> methods() throws

编译时异常必须要进行处理 ， 两种处理方案：try… catch … 或者 throws ， 如果采用throws 这种方案， 如果未来要调用这个方法，必须再调用时再进行处理
运行时异常可以不处理，出现问题后，需要修改代码
public class ExceptionDemo {
_public static void main(String[] args) {
System._out.println(“开始”);
// method();
// 编译时异常 使用throws 抛出异常， 调用时必须再使用try… catch .. 进行处理
try { method1();
} _catch (ParseException e) {
e.printStackTrace(); }
System._out.println(“结束”); }
// 运行时异常： 使用throws 解决异常方法，只是抛出异常 没有解决
/ public static void method() throws ArrayIndexOutOfBoundsException{
int[] arr = {1,2,3};
System.out.println(arr[3]); }/
// 编译时异常:使用throws 并不能直接处理，只是抛出异常 调用方法必须再调用方法的地方处理
public static void method1() _throws ParseException {
String s = “2048-11-11”;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy-MM-dd”);
Date date = simpleDateFormat.parse(s);
System._out.println(_date); } }_

6. 异常处理之自定义异常

格式;
public class 异常类名 extends Exception{
无参构造
带参构造
}
范例：
public class ScoreException extends Exception{
public ScoreException() { }
public ScoreException(String message) {
super(message);
}
}

6.1 throws 和 throw 的区别

throws throw
用于在方法声明后门,跟的是异常类名 用在方法体内,跟的是异常对象名
表示抛出异常, 如果该方法被调用 需要调用者处理 表示抛出异常,由方法体内的语句处理
表示出现异常的一种可能性, 并不一定会发生 执行了throw 一定是抛出了某种异常
代码实现:
// 创建一个类继承Exception 就是异常类
public class ScoreException extends Exception{
// 无参构造,类名一致
public ScoreException() { }
// 带参构造,类名一致
public ScoreException(_String message) {
super(message); // 通过super()将参数传给Exception } }
———————————————————————————————————-
// 创建一个Teacher异常类,手动throw抛出异常
public class Teacher {
// 因为方法体内部throw 自定义抛出异常 所以方法也应该抛出异常 throws
public void checkScore(int score) throws ScoreException {
if (score < 0 || score > 100){
// throw 关键字是用于在方法体内部手动抛出异常
// 手动throw 抛出一个无参构造方法
// throw new ScoreException();
// 手动throw 抛出一个带参的构造方法
throw new ScoreException(“查询成绩错误”);
} else {
System._out.println(“查询分数正确”); } } }
———————————————————————————————————-
// 创建一个测试类执行Teacher类的方法
public class TeacherTest {
_public static void main(String[] args) {
Scanner scanner = new Scanner(System._in);
System.out.println(“请输入查询的分数”);
int i = scanner.nextInt();
Teacher t = new Teacher();
// 因为定义了异常类并且使用throws抛出，所以调用checkScore时需要解决异常
try {
_t.checkScore(i);
} catch (ScoreException e) {
e.printStackTrace(); } } }_