Java核心技术卷一 -第七章：异常

系列文章目录

Java核心技术卷一 -第一章：java“白皮书”的关键术语
Java核心技术卷一 -第三章：数据类型
Java核心技术卷一 -第三章：变量与常量
Java核心技术卷一 -第三章：运算符
Java核心技术卷一 -第三章：字符串
Java核心技术卷一 -第三章：输入与输出
Java核心技术卷一 -第三章：数组
Java核心技术卷一 -第四章：类之间的关系-依赖
Java核心技术卷一 -第四章：预定义类-LocalDate类小应用
Java核心技术卷一 -第四章：构造器
Java核心技术卷一 -第四章：null引用
Java核心技术卷一 -第四章：方法参数
Java核心技术卷一 -第四章：对象构造
Java核心技术卷一 -第五章：覆盖方法与super
Java核心技术卷一 -第五章：super关键字
Java核心技术卷一 -第五章：类的强制类型转换与instanceof操作符
Java核心技术卷一 -第五章：抽象类与abstract关键字
Java核心技术卷一 -第五章：Object类的toString方法
Java核心技术卷一 -第五章：数组列表初识
Java核心技术卷一 -第五章：装箱和拆箱
Java核心技术卷一 -第五章：枚举类再认识

---

前言

本人为java初学者，文章内容仅为个人学习总结分享，其中包含了大量Java核心技术卷一里面的文章内容以及一些网站文章内容，由于参考文章过多，在此并不一一列出，如有侵权，请联系删除。

一、什公是异常，java提供异常处理机制有什么用？

以下程序执行过程中发生了不正常的情况，而这种不正的情况叫做：异常

java语言是很完善的语言，提供了异常的处理方式，以下程序行过程中出现了不正常情况。java把该异常信息打印输出到控制台，供程序员参考，程序员看到异常信息之后，可以对程序进行修改让程序更加的健壮。

代码展示：

public class Test02 {
    public static void main(String[] args) {
        int a=10;
        int b=0;
        int c=a/b;

        System.out.println(a+"/"+b+"="+c);
    }
}

结果：

改-代码展示：

public class Test02 {
    public static void main(String[] args) {
        int a=10;
        int b=0;

        if(b==0){
            System.out.println("除数不能为零");
            return;
        }
        //程序执行到此表示除数一定不为零
        int c=a/b;
        System.out.println(a+"/"+b+"="+c);
    }
}

结果：

二、java语言中异常是以什么形式存在的呢？

1、异常在java中以类的形式存在，每一个异常类都可以创建异常对象。

图示：

用前面的代码展示：

        //实际上JVN在执行到此处的时候，会new异常对象：new ArithmeticException（＂/by zero”）；
        //并且JVM将new的异常对象抛出，打印输出信息到控制台了。
        int c=a/b;

2、异常对应的现实生活是怎样的？

三、java的异常处理机制

1、异常的继承结构：

梳理：

object
object下有Throwable（可抛出的）
Throwable下有两个分支：Error（不可处理，直接退出JVM）和Exception（可处理的）
Exception下有两个分支：
Exception的直接子类：编译时异常（要求程序员在编写程序阶段必须预先对这些异常进行处理，如果不处理编译器报错，因此得名编译时异常。）
RuntimeException:运行时异常。（在编写程序阶段程序员可以预先处理，也可以不管，都行。）

2、编译时异常和运行时异常

2.1、编译时异常和运行时异常，都是发生在运行阶段。编译阶段异常是不会发生的。那么编译时异常因为什么而得名？

因为编译时异常必须在编译（编写）阶段预先处理，如果不处理编译器报错，因此得名。
所有异常都是在运行阶段发生的。因为只有程序运行阶段才可以new对象。
因为异常的发生就是new异常对象。

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

编译时异常一般发生的概率比较高。
举个例子：

你看到外面下雨了，倾盆大雨的。
你出门之前会预料到：如果不打伞，我可能会生病.（生病是一种异常）。而且这个异常发生的概率很高，所以我们出门之前要拿一把伞。
“拿一把伞”就是对“生病异常”发生之前的一种处理方式。 对于一些发生概率较高的异常，需要在运行之前对其进行预处理。

运行时异常一般发生的概率比较低。
举个例子：

小明走在大街上，可能会被天上的飞机轮子砸到。 被飞机轮子砸到也算一种异常。 但是这种异常发生概率较低。
在出门之前你没必要提前对这种发生概率较低的异常进行预处理。 如果你预处理这种异常，你将活的很累。

小提示：
假设你在出门之前，你把能够发生的异常都预先处理，你这个人会更加的安全，但是你这个人活的很累。
同理，假设java中没有对异常进行划分，没有分为：编译时异常和运行时异常，所有的异常都霜要在编写程序阶段对其进行顶处理，将是怎样的效果呢？
首先，如果这样的话，程序肯定是绝对的安全的。
但是程序员编写程序太累，代码到处都是处理异常的代码。

3、java语言中对异常的两种处理方式

注意：

Java中异常发生之后如果一直上抛，最终抛给了main方法，main方法继续向上抛，抛给了调用者JVM，JVM知道这个异常发生，只有一个结果。终止java程序的执行。

代码展示1：

public class Test02 {
    public static void main(String[] args) {
/*      程序执行到此处爱生了ArithmeticException异常，
        底层new了一个ArithmeticException异常对象，然后抛出了。
        由于是main方法薄用了100/0，所以这个异常ArithmeticException抛给了main方法，
        mn方法没有处理，这个异常自动给了JVM。
        JVM最终终止程序的换行。*/
        System.out.println(100/0);

        //这里的没有输出，没有执行。
        System.out.println("Hello World!");
    }
}

结果：

代码展示2：

两种处理：

4、异常捕捉和上报的联合使用

代码展示：

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/*
处理异常的第一种方式：
        在方法声明的位置上使用throws关键字抛出。谁调用我这个方法，我就抛给谁，抛给调用者来处理。
        这种处理异常的态度：上报。
处理异常的第二种方式：
        使用try，catch语句对异常进行捕捉
        这个异常不会上报。自己把这个事儿处理了。
        异常抛到此处为止，不再上抛了。*/

public class Test02 {
    //一般不建议在main方法上使用throws，因为这个异常如果真正的发生了，一定会抛给JVM。JVM只有终止。
    // 异常处理机制的作用就是增强程序的健壮性。怎么能做到，异常发生了也不影程序的执行。所以
    //一般main方法中的异常建议使用try，catch进行捕捉。main就不要继续上抛了。
    public static void main(String[] args) {
        System.out.println("main begin");
        try {
            m1();
        } catch (FileNotFoundException e) {
            System.out.println("输入路径名错误！！！");
        }
        System.out.println("main over");
    }

    public static void m1() throws FileNotFoundException {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }
    //抛别的不行，抛CLassCastException说明你还是没有对FileNotFoundException进行处理
    //private static void m2()throws ClassCastException{
    //抛FileNotFoundException的父对象IOException，这样是可以的。因为IOException包活FileNotFoundException
    //private static void m2()throws IOException{
    //这祥也可以，因为Exception包括所有的异常。
    //private static void m2()throws Exception（
    //throws后面也可以写多个异常，可以使用逗号隔开，
    //pnivate static void m2()throws CLassCastException，FiLeNatFoundException{
    public static void m2() throws FileNotFoundException{
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    public static void m3() throws FileNotFoundException {
        //调用SUN jdk中某个类的构造方法。
        //这个类还没有接触过，后期IO物流的时就如道了。
        //我们只是借助这个类学习一下异常处理机制。
        //创建一个输入流对象，该流指向一个文件。
/*
        编译报错的原因是什么？
        第一：这里调用了一个构造方法：FileInputStream(String name)
        第二：这个构造方法的声明位置上有：throws FileNotFoundException
        第三：通过的类的继承结构看到：FileNotFoundException父类是IOException，IOException的父类是Exception
        最终得知，FileNotFoundException是编译时异常。

        错误原团？编译时异常要程序员编写程序阶段对它进行处理，不处理编译器就报错。*/
        //我们采用第一种处理方式：在方法声明的位置上使用throws继续上抛。
        new FileInputStream("D:\\course\\1e1-开课\\1学习方法.txt");
    }
}

结果：

5、异常对象的常用方法

异常对象有两个非常重要的方法：
获取异常简单的描述信息：

String msg = exception.getNessage();

打异常追踪的堆栈信息：

exception.printStackTrace();

代码展示：

public class Test02 {
    public static void main(String[] args) {
        //这里只是为了测试getMessage()方法和printStackTrace()方法。
        //这里只是new了异常对象，但是没有将异常对象抛出。JVM会认为这是一个普通的java对象。
        NullPointerException e = new NullPointerException("空针异常fdsafdsafdsafds");

        //获取异常简单描述信意：这个信息实际上就是构造方法上面String参数：
        String msg = e.getMessage();//空针异常fdsafdsafdsafds
        System.out.println(msg);

        //打印异常堆栈信息
        e.printStackTrace();

        System.out.println("Hello World！");
    }
}

结果：

6、finally子句的使用

关于try…catch中的finally子句：
1、在finally子句中的代码是最后执行的，并且是一定会执行的，即使try语句块中的代码出现了异常。
finally子句必须和try一起出现，不能单独编写。
2、finally语句通常使用在哪些情况下呢？
通常在finally语句块中完成资源的释放/关闭。
因为finally中的代码比较有保障。
即使try语句块中的代码出现异常，finally中代码也会正常执行。

代码展示：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test02 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("C:\\Users\\luo\\Desktop\\物预报名汇总表");

            String s=null;
            //这里一定会出现空指针异常！
            s.toString();
            System.out.println("Hello World！");

            //流使用完器关闭，固为流是点甲资源约。
            //即使以上程序出现异常，流也颜要关闭！
            //放在这里有可能流关不了。
            //fis.close;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            e.printStackTrace();
        } finally {
            System.out.println("Hello LXH！");
            //流的关闭放在这里比较保险
            //finalLy中的代码是一定会执行的。
            //即try中出现了异常！
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println("Hello Kitty！");
    }
}

结果：

7、java中自定义异常

1、SUN提供的JDK内置的异常肯定是不够用的，在实际的开发中，有很多业务，这些业务出现异常之后，JDK中都是没有的。和业务挂钩的。那么异常类我们程序员可以自已定义？可以！
2、java中怎么自定义异常呢？
两步：
第一步：编写一个类继承Exception或RuntimeException。
第二步：供两个构造方法，一个无参数的，一个带String参数的。

代码展示：

public class MyException extends Exception{ //编译时异常
    public MyException() {
    }
    public MyException(String s) {
        super(s);
    }
}

public class MyException extends RuntimeException{ //运行时异常
    public MyException() {
    }
    public MyException(String s) {
        super(s);
    }
}

例子：

8、异常练习题

题目：用户业务类，处理用户相关的业务：例如登录、注册等功能。

UserService类：

自定义异常类：

测试类（Test）：

结果：

结果一（不符合要求）：

结果二（符合要求）：

总结

以上就是本文的内容，记录了一些关于java“异常”的内容，本人也是刚开始接触java，不能保证总结内容的正确性，若是有错误的话，欢迎大家指出，谢谢！