20_Java中的异常

Java中的异常

一、异常的概述

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

2、异常体系：

​ Throwable

Error Exception

​ RuntimeException 非RuntimeException

Error：严重问题，不需要处理

Exception：称为异常类，它表示程序本身可以处理的问题

• RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码
• 非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

二、JVM的默认处理方案

1、如果程序出现了问题，我们没有做任何处理，最终JVM会默认的处理：

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

​ 程序停止了运行

三、异常处理

一个程序不能够因为一个地方的异常就停止整个运行，这就需要我们手动处理异常，并且有以下两种方案：

1、异常处理之try...catch...:

1、格式;

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

执行流程：

程序从try里面的代码开始执行

出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统

当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理

执行完毕之后，程序还可以继续往下执行

package com.itheima_02;
/*
try{
    可能出现异常的代码;
}
catch(异常类名，变量名){
    异常的处理代码;
}
 */
 
public class ExceptionDemo01 {
    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]); //new ArrayIndexOutOfBoundsException();
        }
        catch(ArrayIndexOutOfBoundsException e){
//            System.out.println("你访问的数组的索引越界了");   实际开发中会给出一个页面提示（现在给不了）
            e.printStackTrace();    //调用了对象中的一个方法来打印输出异常的名称、原因、位置，程序继续运行
        }
 
    }
}

2、异常处理之throws...（自身并不会处理，例如：抛出给调用者处理）:

虽然我们通过 try...catch... 可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理

也就是说，有些时候可能出现的异常是我们处理不了的，这个时候怎么办呢？

针对这种情况，Java提供了throws的处理方案

格式：

throws 异常类名;	//只是抛出异常并没有处理

注意：这个格式是跟在方法后面的

​ 编译时异常必须要进行处理，两种处理方案：try...catch...或者throws，如果采用throws这种方案，将来谁调用谁处理

​ 运行时异常可以不处理，出现问题后，需要我们回来修改代码

package com.itheima_03;
/*
    throws 异常处理
    这个格式时跟在方法的括号后面
    只是抛出异常并没有处理
 */
//导包
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class ExceptionDemo {
    public static void main(String[] args){
        System.out.println("开始：");
//        method();
        try {
            method2();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("结束：");
    }
 
    //编译时异常
    public static void method2() throws ParseException {
        String s = "2048-08-09";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d = sdf.parse(s);
        System.out.println(d);
    }
 
    //运行时异常 如同没有做异常处理一般
    public static void method() throws ArrayIndexOutOfBoundsException{
        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);
    }
}

四、Throwable的成员方法

所有错误和异常的祖宗类，所以所有错误和异常都可以使用它的成员方法

1、成员方法：

方法名	说明
public String getMessage()	返回此 throwable 的详细消息字符串
public String toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常错误信息输出在控制台

package com.itheima_02;
/*
 public String getMessage()     返回此 throwable 的详细消息字符串
 
 public String toString()       返回此可抛出的简短描述
 public void printStackTrace()  把异常错误信息输出在控制台
 */
public class ExceptionDemo02 {
    public static void main(String[] args){
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
 
    public static void method(){
        try{
            int[] arr = {1, 2, 3};
            //new ArrayIndexOutOfBoundsException("xxx"); 从23行方法底层可以看出此构造方法有参
            System.out.println(arr[3]);
        }
        catch(ArrayIndexOutOfBoundsException e){
//            e.printStackTrace();
 
            //public String getMessage()     返回此 throwable 的详细消息字符串
//            System.out.println(e.getMessage());
            //Index 3 out of bounds for length 3（异常原因）
 
            //public String toString()       返回此可抛出的简短描述
//            System.out.println(e.toString());
            //java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3（包含了异常类名）
 
            //public void printStackTrace()  把异常错误信息输出在控制台
            e.printStackTrace();
            //异常信息全面
//            java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
//            at com.itheima_02.ExceptionDemo02.method(ExceptionDemo02.java:19)
//            at com.itheima_02.ExceptionDemo02.main(ExceptionDemo02.java:11)
        }
    }
}
/*
        public class Throwable{
 
            private String detailMessage;
 
            public Throwable(String message){
                detailMessage = message;
            }
 
            public String getMessage() {
                return detailMessage;
            }
        }
 */

五、编译时异常和运行时异常的区别

Java 中的异常被分为两大类：编译时异常 和 运行时异常，也被称为受检异常 和 非受检异常

所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常

1、编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译

2、运行时异常：无需显示处理，也可以和编译时异常一样处理

package com.itheima_02;
/*
Java 中的异常被分为两大类：编译时异常 和 运行时异常，也被称为 受检异常 和 非受检异常
 
所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常
 
1、编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译
 
2、运行时异常：无需显示处理，也可以和编译时异常一样处理
 
 
 */
//导包    Alt + Shift + Enter快速导包
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class ExceptionDemo03 {
    public static void main(String[] args) {
//        method();
        method2();
    }
 
    //编译时异常 不一定会异常（比如此处取决于字符串格式是否匹配：要不输入规范 要不打错了） 但是一定要处理
    public static void method2(){
        try {
            String s = "2048-08-09";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date d = sdf.parse(s);  //以前直接Alt + Enter 导包处理了
            System.out.println(d);
        }
        catch(ParseException e){
            e.printStackTrace();
        }
    }
 
    //运行时异常 查文档看父类或以上是否继承RuntimeException
    public static void method(){
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); //ArrayIndexOutOfBoundsException
        }
        catch(ArrayIndexOutOfBoundsException e){    //此处其实就是类名做形参
            e.printStackTrace();
        }
    }
}

六、自定义异常

1、格式：

public class 异常类名 extends Exception{	//或者继承RuntimeException
    无参构造
    带参构造
}
 
//范例：
public class ScoreException extends Exception{
    public ScoreException() {}
    
    public ScoreException(String message){
        super(message);	//直接调用父类的有参构造
    }
}

注意：手动抛出异常关键词throw比起异常处理throws少了个s

参考代码：

package com.itheima_04;
/*
自定义异常类
 */
public class ScoreException extends Exception{
    public ScoreException(){
 
    }
 
    public ScoreException(String message){
        super(message);
    }
}

package com.itheima_04;
/*
    在Teachar类中定义一个方法检测成绩是否正常 并且抛出
 */
public class Teacher {  //如果继承自运行时异常可以抛出或者不抛出
 
    public void checkScore(int score) throws ScoreException{//此处只是表示可能会存在异常
        if(score < 0 || score > 100){
            //走了这里一定会是有一个异常
//            throw new ScoreException(); //这里没 + s 啊
            //使用有参构造 显示报错原因
            throw new ScoreException("你输入的分数有误，分数应该在0~100之间");
 
        }
        else{
            System.out.println("分数正常");
        }
    }
}

package com.itheima_04;
 
/*
测试类
 */
 
//导包
import java.util.Scanner;
 
public class TeacharTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入对应分数");
 
        Teacher t = new Teacher();
        try {
            t.checkScore(103);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

2、throws与throw的区别

throws	throw
用在方法声明后面，跟的是异常类名	用在方法体内，用的是异常对象名
表示抛出异常，由该方法的调用者来处理	表示抛出异常，由方法体内的语句处理
表示出现异常的一种可以能性，并不一定会发生这些异常	执行throw一定抛出了某种异常