java语言进阶（五）

第一章异常

1.1 异常概念

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行。

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Throwable体系：

Error: 严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception: 表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法：

public void printStackTrace():打印异常的详细信息。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage():获取发生异常的原因。

提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。

出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。

1.3 异常分类

常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常进行分类

编译时期异常: checked异常。在编译时期，就会检查，如果没有处理异常，则编译失败。(如日期格式化异常)
运行时期异常: runtime异常。在运行时期，检查异常。在编译时期，运行异常不会编译器检测(不报错)。(如数学异常)

1.4 异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

工具类

public class ArrayTools {

    // 对给定的数组通过给定的角标获取元素。

    public static int getElement(int[] arr, int index) {

        int element = arr[index];

        return element;

    }

}

测试类

public class ExceptionDemo {

    public static void main(String[] args) {

        int[] arr = { 34, 12, 67 };

        intnum = ArrayTools.getElement(arr, 4)

        System.out.println("num=" + num);

        System.out.println("over");

    }

}

上述程序执行过程图解：

第二章异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

2.1 抛出异常throw

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。

使用格式：

throw new xxxException("异常产生的原因");

注意:

throw关键字必须写在方法的内部
throw关键字后边new的对象必须是Exception或者Exception的子类对象
throw关键字抛出指定的异常对象，必须处理这个异常对象
- throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象，则可以不处理，默认交给JVM处理(打印异常对象，中断程序)
- throw关键字后边创建的是编译异常(写代码的时候报错)，就必须处理这个异常，要么throws，要么try...catch。

例如一下两个异常均是运行期异常，不用处理，默认交给JVM处理。

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

示例：

以后(工作中)首先必须对方法传递过来的参数进行合法性校验。如果参数不合法，那么就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题。

public class ThrowDemo {

    public static void main(String[] args) {

        //创建一个数组

        int[] arr = {2,4,52,2};

        //根据索引找对应的元素

        int index = 4;

        int element = getElement(arr, index);

        System.out.println(element);

        System.out.println("over");

    }

    /*

     * 根据 索引找到数组中对应的元素

     */

    public static int getElement(int[] arr,int index){

        if(arr == null){

            throw new NullPointerException("传递的数组的值是null");  // 交给JVM处理

        }

       	//判断  索引是否越界

        if(index<0 || index>arr.length-1){

             /*

             判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。

             此时会结束当前方法的执行，并将异常告知给调用者。

              */

             throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");

        }

        int element = arr[index];

        return element;

    }

}

注意：如果产生了问题，throw会将问题描述类即异常进行抛出，将问题返回给该方法的调用者。

调用者处理：1）进行捕获处理，2）继续将问题声明出去，使用throws声明处理。

2.2 Objects非空判断

Objects类，有一些静态方法，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的）。在它的源码中，为对象为null的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj):查看指定引用对象不是null。

查看该方法源码，发现源码里为值是null的对象进行了抛出异常操作：

public static <T> T requireNonNull(T obj) {

    if (obj == null)

      	throw new NullPointerException();

    return obj;

}

示例：

import java.util.Objects;

public class Demo04Objects {

    public static void main(String[] args) {

        method(null);

    }

    public static void method(Object obj){

        //对传递过来的参数进行合法性判断,判断是否为null

        /*if(obj == null){

            throw new NullPointerException("传递的对象的值是null");

        }*/

		//直接调用对象即可，不用自己再写if语句判断！

		// 1）方法一

        Objects.requireNonNull(obj);

		// 2）方法二 （使用中选择一个方法即可）

        Objects.requireNonNull(obj,"传递的对象的值是null");

    }

}

2.3 声明异常throws (第一种方式)

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（try...catch），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)。

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

声明异常注意：

throws关键字必须写在方法声明处。
throws关键字后边声明的异常必须是Exception或者是Exception的子类。
方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常。
- 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可。
调用了一个声明抛出异常的方法，就必须的处理声明的异常，有两种方式：
- 1）继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM。
- 2）try...catch自己处理异常。

声明异常的代码演示：

public class ThrowsDemo {

    public static void main(String[] args) throws FileNotFoundException {

        //  1）关键字在方法后声明

        //  2）调用了一个声明抛出异常的方法【read()】，必须的处理声明的异常。因此main函数后也需要throws FileNotFoundException

        read("a.txt");

    }

    // 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明

    public static void read(String path) throws FileNotFoundException {     1）关键字在方法后声明

        if (!path.equals("a.txt")) {

            // 假设  如果不是 a.txt ，认为该文件不存在，是一个错误，也就是异常  throw

            throw new FileNotFoundException("文件不存在");  //  FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常

                                                           //  可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理

        }

    }

}

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {

    //  FileNotFoundException extends IOException extends Excepiton

    // 如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可

    //  三种写法：1）throws FileNotFoundException,IOException 2）throws IOException 3）throws Exception

    public static void main(String[] args) throws IOException {

        read("a.txt");

    }

    public static void read(String path)throws FileNotFoundException, IOException {

        if (!path.equals("a.txt")) {

            //假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw

            throw new FileNotFoundException("文件不存在");

        }

        /*

            如果传递的路径，不是.txt结尾。

            那么就抛出IO异常对象，告知方法的调用者，文件的后缀名不对。

         */

        if(!fileName.endsWith(".txt")){

            throw new IOException("文件的后缀名不对");

        }

        System.out.println("路径没有问题,读取文件");

    }

}

2.4 捕获异常try…catch（第二种方式）

异常出现，会立刻终止程序，所以要处理异常:

该方法不处理，而是声明抛出，由该方法的调用者来处理(throws)。该方法异常后面的代码不会继续执行！
在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常，方法自己处理异常。

捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下(catch可以有多个)：

try{

     编写可能会出现异常的代码

}catch(异常类型  e){

     处理异常的代码

     // 记录日志/打印异常信息/继续抛出异常

}

...

catch(异常类型  e){

     处理异常的代码

     // 记录日志/打印异常信息/继续抛出异常

}

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意：

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

如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try...catch之后的代码。
try和catch都不能单独使用，必须连用。

演示如下：

public class TryCatchDemo {

    public static void main(String[] args) {

        try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。

            read("b.txt");

        } catch (IOException e) { // try中抛出的是什么异常，在括号中就定义什么异常类型

            System.out.println("catch - 传递的文件后缀不是.txt");

            /*

            Throwable类中定义了3个异常处理的方法：

            1）

            System.out.println(e.getMessage());   //返回信息：文件的后缀名不对

            2）

            System.out.println(e.toString());     //返回信息：java.io.IOException: 文件的后缀名不对。【相当于重写Object类的toString】

            System.out.println(e);//              //返回信息：ava.io.IOException: 文件的后缀名不对

            3)

            e.printStackTrace();

                //输出：

                //java.io.IOException: 文件的后缀名不对

                    //at com.itheima.demo02.Exception.Demo01TryCatch.readFile(Demo01TryCatch.java:55)

                    //at com.itheima.demo02.Exception.Demo01TryCatch.main(Demo01TryCatch.java:27)

            */

        }

        System.out.println("over");

    }

    /*

       如果传递的路径,不是.txt结尾

       那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对

    */

    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){

            throw new IOException("文件的后缀名不对");

        }

        System.out.println("路径没有问题，读取文件");

    }

}

如何获取异常信息：

Throwable类中定义了一些查看方法:

public String getMessage(): 返回此 throwable 的简短描述。即获取异常的描述信息、原因。
public String toString():返回此 throwable 的详细消息字符串。即获取异常的类型和异常描述信息。
public void printStackTrace():打印异常的跟踪栈信息并输出到控制台，JVM打印异常对象，默认此方法，打印的异常信息是最全面的。

包含了异常的类型、异常的原因、还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace。

2.5 finally 代码块

finally：因为异常会引发程序跳转，导致有些语句执行不到。然而有一些特定的代码无论异常是否发生，都需要执行。finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

如在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等)，使用之后，最终关闭打开的资源。

finally的语法:

try{

      可能产生异常的代码

}catch(定义一个异常的变量,用来接收try中抛出的异常对象){

      异常的处理逻辑

      一般在工作中,会把异常的信息记录到一个日志中

}

...

catch(异常类名 变量名){

}finally{

      无论是否出现异常都会执行

}

注意:

finally不能单独使用，必须和try一起使用。
finally一般用于资源释放(资源回收)，无论程序是否出现异常，最后都要资源释放(IO)。

finally代码参考如下：

public class TryCatchDemo4 {

    public static void main(String[] args) {

        try {

            readFile("a.txt");

        } catch (IOException e) {

            //抓取到的是编译期异常  抛出去的是运行期

            e.printStackTrace();

        } finally {

            System.out.println("不管程序怎样，这里都将会被执行。");

        }

        System.out.println("over");

    }

    /*

     *

     * 我们 当前的这个方法中 有异常  有编译期异常

     */

    /*

       如果传递的路径,不是.txt结尾

       那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对

    */

    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){

            throw new IOException("文件的后缀名不对");

        }

        System.out.println("路径没有问题,读取文件");

}

只有在try或者catch中调用退出JVM的相关方法时，finally才不会执行，否则finally永远会执行。

2.6 异常注意事项

多个异常捕获三种处理方法：
1. 多个异常分别处理。
  
  即，一个异常写一个try...catch语句，有几个异常写几个try...catch语句。
2. 多个异常一次捕获，多次处理。
  
  即，try...catch...catch处理，一个try多个catch处理多个异常。
3. 多个异常一次捕获一次处理。
  
  即，只有一个catch，该catch异常类型为方法遇到所有异常类的父类。该父类异常可以同时捕获父类极其子类的异常。
一般我们是使用一次捕获多次处理方式，格式如下：
```
try{

     编写可能会出现异常的代码

}catch(异常类型A  e){  当try中出现A类型异常，就用该catch来捕获。

     处理异常的代码

     //记录日志/打印异常信息/继续抛出异常

}catch(异常类型B  e){  当try中出现B类型异常，就用该catch来捕获。

     处理异常的代码

     //记录日志/打印异常信息/继续抛出异常

}
```

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理，即不捕获也不声明抛出（throws）。默认交给虚拟机处理，程序中止。什么时候不抛出异常，再继续执行程序。
如果finally有return语句，永远返回finally中的结果，避免该情况。

public class Demo02Exception {

    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 {

            //一定会执行的代码

            a = 100;

            return a;  //该程序永远返回100！

        }

    }

}

子父类异常

如果父类抛出了多个异常，子类重写父类方法时：1）抛出和父类相同的异常 2）抛出父类异常的子类 3）不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。
即：父类异常时什么样，子类异常就什么样！

public class Fu {

    public void show01() throws NullPointerException,ClassCastException{}

    public void show02() throws IndexOutOfBoundsException{}

    public void show03() throws IndexOutOfBoundsException{}

    public void show04() throws Exception {}

}

class Zi extends Fu{

    //子类重写父类方法时,抛出和父类相同的异常

    public void show01() throws NullPointerException,ClassCastException{}

    //子类重写父类方法时,抛出父类异常的子类

    public void show02() throws ArrayIndexOutOfBoundsException{}

    //子类重写父类方法时,不抛出异常

    public void show03() {}

    /*

        父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。

     */

    //public void show04() throws Exception{}

    //此时子类产生该异常，只能捕获处理，不能声明抛出

    public void show04()  {

        try {     //  必须使用try-catch，不能使用 throw new XXXException() 抛出异常，因为父类该方法没有异常抛出！

            throw  new Exception("编译期异常");

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

第三章自定义异常

3.1 概述

为什么需要自定义异常类:

Java中不同的异常类，分别表示着某一种具体的异常情况。在上述代码中，异常都是JDK内部定义好的，但是实际开发中也会出现很多异常，这些异常在JDK中没有定义过，例如年龄负数问题、考试成绩负数问题等。此时需要根据自己业务的异常情况来定义异常类。

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类。

格式:

public class XXXExcepiton extends Exception | RuntimeException{   // 二者选其一

      添加一个空参数的构造方法

      添加一个带异常信息的构造方法

}

注意:

自定义异常类一般都是以Exception结尾，说明该类是一个异常类。
自定义异常类，必须的继承Exception或者RuntimeException：
- 继承Exception: 自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，要么throws，要么try...catch。
- 继承RuntimeException: 自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理(中断处理)。

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

public class RegisterException extends /*Exception*/ RuntimeException{

    //添加一个空参数的构造方法

    public RegisterException(){

        super();

    }

    /*

        添加一个带异常信息的构造方法

        查看源码发现,所有的异常类都会有一个带异常信息的构造方法,

        方法内部会调用父类带异常信息的构造方法,

        让父类来处理这个异常信息

     */

    public RegisterException(String message){

        super(message);

    }

}

3.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

// 业务逻辑异常

public class RegisterException extends Exception {

    /**

     * 空参构造

     */

    public RegisterException() {

        super();

    }

    /**

     *

     * @param message 表示异常提示

     */

    public RegisterException(String message) {

        super(message);

    }

}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

public class Demo {

    // 模拟数据库中已存在账号

    private static String[] names = {"bill","hill","jill"};

    public static void main(String[] args) {

        //调用方法

        try{

              // 可能出现异常的代码

            checkUsername("nill");

            System.out.println("注册成功");//如果没有异常就是注册成功

        }catch(RegisterException e){

            //处理异常

            e.printStackTrace();

        }

    }

    //判断当前注册账号是否存在

    //因为是编译期异常，又想调用者去处理 所以声明该异常

    public static boolean checkUsername(String uname) throws RegisterException{

        for (String name : names) {

            if(name.equals(uname)){   //如果名字在这里面 就抛出登陆异常

                throw new RegisterException("亲"+name+"已经被注册了！");

            }

        }

        return true;

    }

}

巴特西

java语言进阶（五）_异常

第一章异常

1.1 异常概念

1.2 异常体系

1.3 异常分类

1.4 异常的产生过程解析

第二章异常的处理

2.1 抛出异常throw

2.2 Objects非空判断

2.3 声明异常throws (第一种方式)

2.4 捕获异常try…catch（第二种方式）

2.5 finally 代码块

2.6 异常注意事项

第三章自定义异常

3.1 概述

3.2 自定义异常的练习

最新文章

热门文章

巴特西

java语言进阶（五）_异常

第一章 异常

1.1 异常概念

1.2 异常体系

1.3 异常分类

1.4 异常的产生过程解析

第二章 异常的处理

2.1 抛出异常throw

2.2 Objects非空判断

2.3 声明异常throws (第一种方式)

2.4 捕获异常try…catch（第二种方式）

2.5 finally 代码块

2.6 异常注意事项

第三章 自定义异常

3.1 概述

3.2 自定义异常的练习

最新文章

热门文章

第一章异常

第二章异常的处理

第三章自定义异常