Java学习 第二十五章 异常/throw关键字/throws/try...catch/finally代码块

第二十五章

一、异常概念&异常体系

1.1 异常

抛出异常就是把异常交给出现异常程序的上一级程序处理。处理不了,最终会交给JVM处理。
异常:指的是程序在程序执行的过程中,出现的非正常的情况,最终会导致JVM非正常停止,在Java等面向对象的编程语言中,异常本身就是一个类,产生异常就是创建异常对象,并抛出了一个异常对象。Java处理异常的方式是 中断处理

1.2 异常体系

Throwable 类是 Java 语言中所有错误或异常的超类。
从前从前,有位老人,他的名字叫Throwable,他生了两个儿子,大儿子叫Error,二儿子叫Exception。

Error

表示编译时或者系统错误,如虚拟机相关的错误,OutOfMemoryError等,error是无法处理的。

Exception

代码异常,Java程序员关心的基类型通常是Exception。它能被程序本身可以处理,这也是它跟Error的区别。

1.3 异常分类

/*
    Java.lang.Throwable:类是Java语言中所有错误或异常的超类
       Exception:编译期异常,进行编译(写代码)java程序出现的问题
           RuntimeException:运行期异常,java程序运行过程中出现的问题
              异常就相当于得了一个小毛病(感冒、发烧),把异常处理掉,程序可以继续执行(吃点药继续工作)

     Error:错误
            错误就相当于程序得了绝症,必须修改源代码,程序才能继续执行
 */
public class Demo01Exception {
    public static void main(String[] args) /*throws ParseException*/ {
       // Exception:编译期异常,进行编译(写代码)java程序出现的问题
  /*      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
        Date date = null;//把字符串格式的日期,解析为Date格式的日期
        try {//try catch 把异常处理之后,后边的程序能继续执行
            date = sdf.parse("1999-0909");//把字符串格式的日期,解析为Date格式的日期
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);*/


//   RuntimeException:运行期异常,java程序运行过程中出现的问题
//        int[] arr = {1,2,3};
//     //   System.out.println(arr[0]);
//        try {
//            //可能会出现异常的代码
//            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException索引越界异常
//
//        }catch(Exception e){
//            //异常的处理逻辑
//            System.out.println(e);
//
//        }

        /*
          Error:错误
        */
        //OutOfMemoryError: Java heap space 内存溢出错误,超出了给JVM分配的内存
     //   int[] arr = new int[1024*1024*1024];
        //必须修改代码

        System.out.println("后续代码");
    }
}

1.3 异常的产生过程分析

Java学习 第二十五章 异常/throw关键字/throws/try...catch/finally代码块_第1张图片

1.4 throw关键字(抛出异常)

/*
    throw 关键字
    作用:
        可以使用throw关键字,在指定的方法中抛出指定的异常
     使用格式:
         throw new xxxException("异常产生的原因")
     注意:
        1.throw关键字必须写在方法的内部
        2.throw关键字后边必须是Exception或者Exception的子类对象
        3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
            throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象,
            我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
            throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,
            要么throws要么try...catch
          注意:
          NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
          ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理

 */
public class Demo03Throw {
    public static void main(String[] args) {
     //   int[]  arr = null;
        int[]  arr = new int[3];
        int element = getElement(arr,3);
        System.out.println(element);
    }

    /*
  定义一个方法,获取数组指定索引处的元素
  参数:
        int[] arr
        int index
        以后我们首先必须对方法传递过来的参数进行合法性的校验
        如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
   */
    public static int getElement(int[] arr,int index){
        /*
        我们可以对传递过来的参数数组,进行合法性校验
        如果数组arr的值是null
        那么我们就抛出空指针异常,告知方法的调用者”传递的数组的值是null“
         */
        if(arr == null){
         throw   new NullPointerException("传递的数组的值是null");
        }
        /*
        我们可以对传过来的参数index进行合法性校验
        如果index的范围不再数组的索引范围内
        那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
         */
        if(index < 0 || index > arr.length){
            throw  new ArrayIndexOutOfBoundsException("数组索引越界");
        }
        int ele = arr[index];
        return ele;
    }
}

1.5 Objects非空判断

Objects类,由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),那么在它的源码中,对对象为null的值进行了抛出异常操作。

/*
    Objects类中的静态方法
    public static  requiredNonNull(T obj):查看指定引用对象不是null
    源码:
        public static  T requiredNonNull(T obj){
                if(obj == null){
            throw new NullPointerException();
            return obj;
        }
        }
 */
public class Demo04Objects {
    public static void main(String[] args) {
        method(null);
    }

    public static void method(Object obj){
        //对传递过来的参数合法性判断,判断是否为空
  /*      if(obj == null){
            throw new NullPointerException("传递对象的值是null");
        }*/
       // Objects.requireNonNull(obj);
        //方法的重载
        Objects.requireNonNull(obj,"递对象的值是null");

    }
}

1.6 声明异常throws–异常处理的第一种处理方式,交给别人处理

/*
    throws关键字:异常处理的第一种方式,交给别人处理
    作用:
        当方法内部抛出异常的时候,那我们就必须处理这个异常对象
        可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理
            (自己不处理,给别人处理),最终交给JVM处理-->中断处理
     使用格式:在方法声明时使用
            修饰符 返回值类型 方法名(参数列表) throws{
                throw new AAAException(“产生原因”);
                throw new AAAException(“产生原因”);
                ...
              }
       注意:
            1.throws关键字必须写在方法声明处
            2.throws关键字后边声明的异常必须是Exception或者是Exception的子类
            3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
                如果抛出多个异常对象有子父类关系,那么直接声明父类异常即可
            4.调用了一个声明抛出异常的方法,我们就必须处理声明的异常
                    要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
                    要么try...catch自己处理异常

 */
public class Demo05Throws {
    /*
        FileNotFoundException extends IOException extends Exception
    如果抛出多个异常对象有子父类关系,那么直接声明父类异常即可
     */

                                        //throws 交给JVM处理
    //public static void main(String[] args) throws FileNotFoundException,IOException {
    public static void main(String[] args) throws Exception {
        redFile("c:\\a.txt");

    }
    /*
        定义一个方法,对传递的文件路径进行合法性判断
        如果路径不是“c:\\a.txt”,那么我们就抛出文件找不到异常对象,告知方法的调用者
        注意:
            文件找不到异常  是编译异常,抛出了编译异常,就必须处理这个异常
            可以使用throws继续声明抛出FileNotFoundException这个异常,让方法调用者处理

     */

    public static void redFile(String filename) throws FileNotFoundException,IOException{
        if (!filename.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }
        /*
            如果传递的路径,不是.txt结尾
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
         */
        if (!filename.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }

}

1.6 try…catch–异常处理的第一种处理方式

Java学习 第二十五章 异常/throw关键字/throws/try...catch/finally代码块_第2张图片

/*
    try...catch:异常处理的第二种方式,自己处理异常
    格式:
        try{
            可能产生异常的代码
        }catch(定义一个异常的变量,用来接受try中抛出的异常对象){
            异常的处理逻辑,产生异常对象之后,怎么处理异常
            一般在工作中,会把异常的信息记录到一个日志中
        }...
        catch(异常数据类型 变量名){

        }
    注意:
        1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
        2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,
        继续执行try...catch之后的代码,
        如果try中没有产生异常,那么就不会执行catch中的异常的处理逻辑,执行完try中的代码。继续执行
        try...catch之后的代码

 */
public class Demo06TryCatch {
    public static void main(String[] args) {
        try {
            //可能产生异常的代码
            redFile("c:\\a.txt");
        } catch (IOException e) {//try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
           // 异常的处理逻辑,产生异常对象之后,怎么处理异常
            System.out.println("catch - 传递的文件后缀不是.txt");
        }
        System.out.println("后续代码");
    }
    /*
           如果传递的路径,不是.txt结尾
           那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
        */
    public static void redFile(String filename) throws  IOException {
        if (!filename.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }

        if (!filename.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }

}

1.7 Throwable类中三个异常处理的方法

public class Demo06TryCatch {
    public static void main(String[] args) {
        try {
            //可能产生异常的代码
            redFile("d:\\a.tx");
        } catch (IOException e) {//try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
           // 异常的处理逻辑,产生异常对象之后,怎么处理异常
          //  System.out.println("catch - 传递的文件后缀不是.txt");

            /*
                Throwable类中定义的三个处理异常的方法
             */
            //String getMessage() 返回此throwable的简短描述
           // String toString()返回此throwable的详细详细字符串
            //void  printStackTrace() JVM打印异常对象,默认此方法,打印的异常信息是最全面的
           // System.out.println(e.getMessage());//文件的后缀名不对
           // System.out.println(e.toString());//重写Object类的toString
           // System.out.println(e);//文件的后缀名不对
            e.printStackTrace();
/*
            java.io.FileNotFoundException: 传递的文件路径不是c:\a.txt
            at cn.itcast.day14.demo04.Demo06TryCatch.redFile(Demo06TryCatch.java:59)
            at cn.itcast.day14.demo04.Demo06TryCatch.main(Demo06TryCatch.java:30)*/




        }
        System.out.println("后续代码");
    }
    /*
           如果传递的路径,不是.txt结尾
           那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
        */
    public static void redFile(String filename) throws  IOException {

        if (!filename.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }

}

1.8 finally代码块

/*
    finally代码块:
        格式:
            try{
            可能产生异常的代码
             }catch(定义一个异常的变量,用来接受try中抛出的异常对象){
                异常的处理逻辑,产生异常对象之后,怎么处理异常
                一般在工作中,会把异常的信息记录到一个日志中
        }... catch(异常数据类型 变量名){

        }finally{
              无论是否出现异常都会执行
        }
        注意:
            1.finally不能单独使用,必须和try一起使用
            2.finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)
 */
public class Demo07TryCatchFinally {
    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            redFile("c:\\a.tx");
        } catch (IOException e) {
            //异常处理逻辑
            e.printStackTrace();//打印异常信息,最全
            /*
             //String getMessage() 返回此throwable的简短描述
           // String toString()返回此throwable的详细详细字符串
            //void  printStackTrace() JVM打印异常对象,默认此方法,打印的异常信息是最全面的
             */
        }finally {
            //无论是否出现异常都会执行
            System.out.println("资源释放");
        }

    }



 /*
           如果传递的路径,不是.txt结尾
           那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
        */

    public static void redFile(String filename) throws IOException {

        if (!filename.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题,读取文件");
    }
}

1.9 异常注意事项

/*
    异常的注意事项: 
        多个异常使用捕获又该如何处理呢》
        1.多个异常分别处理
        2.多个异常一次捕获多次处理
        3.多个异常一次捕获,一次处理
 

 */
public class Demo08Exception {
    public static void main(String[] args) {

   
        //1.多个异常分别处理
/*    try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);

        }
        try{
            List lsit = List.of(1, 2, 3);
            System.out.println(lsit.get(4));
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);

        }*/

        //2.多个异常一次捕获多次处理
         /*
         一个try多个catch注意事项:
               catch里边定义的异常变量。如果有子父类关系,那么子类的异常变量必须写在上边,否则就会报错
        ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
         */
   /*     try{
            int[] arr = {1,2,3};
        //    System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:

            List list = List.of(1, 2, 3);
            System.out.println(list.get(4));
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);

        } catch (IndexOutOfBoundsException e){
            System.out.println(e);

        }*/

        //3.多个异常一次捕获,一次处理
        try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:

            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(4));
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
            System.out.println(e);

        }
        //运行时异常被抛出可以不处理,即不捕获也不声明抛出
        //默认给虚拟机处理,终止程序,什么时候不排除运行时异常了,再来执行程序


            int[] arr = {1,2,3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException:
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(4));

        System.out.println("后续代码");

    }
}

1.9.1finally有return语句

Java学习 第二十五章 异常/throw关键字/throws/try...catch/finally代码块_第3张图片

public class Demo09Exception {
    public static void main(String[] args) {
        int a = getA();
        System.out.println(a);

    }
    //定义一个方法,返回变量a的值
    public static int getA(){
        int a = 10;
        try {
            return a;
        }catch (Exception e){
            System.out.println(e);

        }finally {
            //一定会执行的代码 所以尽量不要在finally中写return语句
            a = 100;
            return a;

        }
    }
}

1.9.2 子父类异常

父类异常时什么样,子类异常时就什么样

/*
    子父类的异常:

    注意:
        父类异常时什么样,子类异常时就什么样
 */
public class Fu {
                                                        //类型转换异常
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04(){}
}

class Zi extends Fu{
    //子类重写父类方法时,抛出和父类相同的异常
    public void show01() throws NullPointerException,ClassCastException{}
    //子类重写父类方法时,抛出父类异常的子类
    public void show02() throws IndexOutOfBoundsException{}
    //子类重写父类方法时不抛出异常
    public void show03(){}
    //父类没有抛出异常,子类重写该方法也不能抛出异常
        //此时子类产生该异常,只能捕获处理,不能声明抛出
    public void show04() {
        try {
            throw new Exception("编译期异常");
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

 }

你可能感兴趣的:(Java,学习)