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

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

java语言是很完善的语言，提供了异常的处理方式，以下程序执行过程中出现了不正常情况，

java把该异常信息打印输出到控制台，供程序员参考。程序员看到异常信息之后，可以对

程序进行修改，让程序更加的健壮。

什么是异常：程序执行过程中的不正常情况。

异常的作用：增强程序的健壮性。

以下程序执行控制台出现了：

Exception in thread "main" java.lang.ArithmeticException: / by zero
       at com.bjpowernode.javase.exception.ExceptionTest01.main(ExceptionTest01.java:14)

这个信息被我们称为：异常信息。这个信息是JVM打印的。

示例代码01：

public class ExceptionTest01 {
    public static void main(String[] args) {
        /*int a = 10;
        / 实际上JVM在执行到此处的时候，会new异常对象：new ArithmeticException("/ by zero");
        // 并且JVM将new的异常对象抛出，打印输出信息到控制台了。
        int b = 0;
        int c = a / b;
        System.out.println(a + "/" + b + "=" + c);*/
        // 此处运行也会创建一个：ArithmeticException类型的异常对象。
        //System.out.println(100 / 0);
        // 我观察到异常信息之后，对程序进行修改，更加健壮。
        int a = 10;
        int b = 0;
        if(b == 0){
            System.out.println("数字错误，b不能为0！");
            return;
        }
        // 程序执行到此处表示除数一定不是0
        int c = a / b;
        System.out.println(a + "/" + b + "=" + c);
    }
}

运行结果：

数字错误，b不能为0

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

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

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

火灾(异常类)：

2008年8月8日,小明家着火了（异常对象）

2008年8月9日,小刚家着火了（异常对象）

2008年9月8日,小红家着火了（异常对象）

类是：模板。

对象是：实际存在的个体

钱包丢了（异常类）：

2008年1月8日，小明的钱包丢了（异常对象）

2008年1月9日，小芳的钱包丢了（异常对象）

…

示例代码02：

public class ExceptionTest02 {
    public static void main(String[] args) {
        NumberFormatException num = new NumberFormatException("数字格式化异常！");
        //java.lang.NumberFormatException: 数字格式化异常！
        System.out.println(num);
        NullPointerException nul = new NullPointerException("空指针异常！");
        //java.lang.NullPointerException: 空指针异常！
        System.out.println(nul);
    }
}

3、异常处理机制

java中异常的作用是：增强程序健壮性。

java中异常以类和对象的形式存在。

Object下有Throwable（可抛出的）

Throwable下有两个分支：Error（不可处理，直接退出JVM）和Exception（可处理的）

Exception下有两个分支：

Exception的直接子类：编译时异常（要求程序员在编写程序阶段必须预先对这些异常进行处理，如果不处理编译器报错）

RuntimeException:运行时异常。（在编写程序阶段程序员可以预先处理，也可以不管，都行）

编译时异常和运行时异常，都是发生在运行阶段。编译阶段异常是不会发生的。

4、编译时异常因为什么而得名？

因为编译时异常必须在编译(编写)阶段预先处理，如果不处理编译器报错，因此得名。

所有异常都是在运行阶段发生的。因为只有程序运行阶段才可以new对象。

因为异常的发生就是new异常对象。

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

编译时异常一般发生的概率比较高。

举个例子：

你看到外面下雨了，倾盆大雨的。

你出门之前会预料到：如果不打伞，我可能会生病（生病是一种异常）。

而且这个异常发生的概率很高，所以我们出门之前要拿一把伞。

“拿一把伞”就是对“生病异常”发生之前的一种处理方式。

对于一些发生概率较高的异常，需要在运行之前对其进行预处理。

运行时异常一般发生的概率比较低。

举个例子：

小明走在大街上，可能会被天上的飞机轮子砸到。

被飞机轮子砸到也算一种异常。

但是这种异常发生概率较低。

在出门之前你没必要提前对这种发生概率较低的异常进行预处理。

如果你预处理这种异常，你将活的很累。

假设你在出门之前，你把能够发生的异常都预先处理，你这个人会更加

的安全，但是你这个人活的很累。

6、编译时异常还有其它名字：

受检异常：CheckedException

受控异常

运行时异常还有其它名字：

未受检异常：UnCheckException

非受检异常

再次强调：所有异常都是发生在运行阶段的

7、Java语言中对异常的处理包括两种方式：

第一种方式：在方法声明的位置上，使用throws关键字，抛给上一级。

谁调用我，我就抛给谁。抛给上一级。上报

第二种方式：使用try…catch语句进行异常的捕捉。

这件事发生了，谁也不知道，因为我给抓住了。不会上报，不会上抛

举个例子：

我是某集团的一个销售员，因为我的失误，导致公司损失了1000元，

“损失1000元”这可以看做是一个异常发生了。我有两种处理方式，

第一种方式：我把这件事告诉我的领导【异常上抛】

第二种方式：我自己掏腰包把这个钱补上。【异常的捕捉】

张三 --> 李四 —> 王五 --> CEO

思考：

异常发生之后，如果我选择了上抛，抛给了我的调用者，调用者需要

对这个异常继续处理，那么调用者处理这个异常同样有两种处理方式。

注意：Java中异常发生之后如果一直上抛，最终抛给了main方法，main方法继续

向上抛，抛给了调用者JVM，JVM知道这个异常发生，只有一个结果。终止java程序的执行。

示例代码03：

public class ExceptionTest03 {
    public static void main(String[] args) {
        /*
        * 程序执行到此处发生了ArithmeticException异常，
        * 底层new了一个ArithmeticException异常对象，
        * ，然后跑出了，由于是main方法调用了100/0,
        * 所以这个异常ArithmeticException抛给了main方法，
        * main方法没有处理，将这个异常自动抛给了JVM
        * JVM最终终止程序的执行
        *
        * ArithmeticException 继承RuntimeException，属于运行时异常
        * 在编写程序阶段不需要对这种异常进行预先的处理
        * */
        int i = 10;
        int a = 0;
        System.out.println(i / a);
        //这里的HelloWorld没有输出，没有执行
        System.out.println("HelloWorld!");
    }
}

示例代码04：

/*
* 以下代码报错的原因是什么？
*    因为doSome()方法声明位置上使用了：throws ClassNotFoundException
*    而ClassNotFoundException是编译时异常。必须编写代码时处理，没有处理编译器报错。
* */
public class ExceptionTest04 {
    public static void main(String[] args) {
        //main方法中调用doSome（）方法
        //因为dosome（）方法声明位置上有：throws ClassNOtFoundException
        //我们在调用doSome（）方法时必须对这种对象进行预先的处理
        //如果不处理，编译器就报错
        //编译器报错信息： UnHandled exception:java.lang.ClassNotFoundException
        //doSome();
    }
    /**
     * doSome方法在方法声明的位置上使用了：throws ClassNotFoundException
     * 这个代码在表示doSome（）方法在执行过程中，有可能会出现ClassNotFoundException异常
     * 叫做类没找到异常，这个异常直接父类是：Exception，所以ClassNotFoundException属于编译时异常
     * @throws ClassNotFoundException
     */
    public static void doSome() throws ClassNotFoundException{
        System.out.println("异常测试方法！");
    }
}

示例代码05：

public class ExceptionTest05 {
    //第一种处理方式，把异常抛给上一级
    //在方法声明位置上继续使用：throws，来完成异常的继续上抛。抛给调用者。
    //上抛类似于推卸责任。（继续把异常传递给调用者）
    public static void main(String[] args) throws Exception{
       //第二种处理方式
        //捕捉等于把异常来下了，异常真正的解决了。（调用者是不知道的）
       try{
           doSome();
       }catch(ClassNotFoundException e){
           e.printStackTrace();
       }
    }
    public static void doSome() throws ClassNotFoundException{
        System.out.println("输出类找不到异常！");
    }
}

注意：

只要异常没有捕捉，采用上报的方式，此方法的后续代码不会执行。

另外需要注意，try语句块中的某一行出现异常，该行后面的代码不会执行。

try…catch捕捉异常之后，后续代码可以执行。

在以后的开发中，处理编译时异常，应该上报还是捕捉呢，怎么选？

如果希望调用者来处理，选择throws上报。

其它情况使用捕捉的方式。

示例代码06：

public class ExceptionTest06 {
    public static void main(String[] args) {
        //一般不建议在main方法上使用throws，因为这个异常如果真正的发生了，一定会抛给JVM。JVM只有终止。
        //异常处理机制的作用就是增强程序的健壮性。怎么能做到，异常发生了也不影响程序的执行。所以
        //一般main方法中的异常建议使用try..catch进行捕捉。main就不要继续上抛了。
        // 100 / 0这是算术异常，这个异常是运行时异常，你在编译阶段，可以处理，也可以不处理。编译器不管。
        //System.out.println(100 / 0); // 不处理编译器也不管
        // 你处理也可以。
        /*
        try {
            System.out.println(100 / 0);
        } catch(ArithmeticException e){
            System.out.println("算术异常了！！！！");
        }
         */
        //try.caytch把异常捕捉之后，这里的代码会继续执行
        System.out.println("main begin!");
        try {
            //try尝试
            m1();
            //以上代码出现异常，直接进入catch语句块中执行
        }catch(FileNotFoundException e){//catch后面的好像一个方法的形参
            //这个分支中可以使用e引用，e引用保存的内存地址是
            //catch是捕捉异常之后走的分支
            //在catch分支中干什么？处理异常
            System.out.println("文件异常，文件路径错误，或者文件不存在！");
        }
        //try..catch把异常抓住之后，这里的代码会继续执行
        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 IOExcception
    //这样也可以，因为Exception包括所有的异常
    //private static void m2() throws Exception
    //throws后面也可以写多个异常，可以使用逗号隔开
    //private static void m2() throws ClassCastException,FileNotFoundException
    public static void m2() throws ClassCastException,FileNotFoundException{
        System.out.println("m2 begin!");
        //编译器报错的原因是：m3()方法声明位置上有：throws FileNotFoundException
        //我们在这里调用m3()没有对异常进行预处理，所以编译报错
        //m3();
        m3();
        //以上出现异常，这里是无法执行的！
        System.out.println("m2 over!");
    }
    public static void m3() throws FileNotFoundException {
        //调用SUN jdk中每个类的构造方法
        //这个类还没有接触过，后期IO流的时候就知道了
        //这里借助这个类学习以下异常处理机制
        //创建一个输出流对象，该流指向一个文件
        /*
        * 编译报错的原因是什么?
        * 第一：这里调用了一个构造方法：FileNotFoundException(String name)
        * 第二：这个构造方法的声明的位置上有：throws FileNotFoundException
        * 第三：通过类的继承结构看到：FileNotFoundException父类是IOException，IOException的父类是Exception
        * 最终得知：FileNotFoundException是编译时异常
        *
        * 错误原因？编译时异常要求程序员编写阶段必须对它进行处理，不处理编译器就报错
        * */
        //我们采用第一种处理方式：在方法声明的位置上使用throws继续上抛
        //一个方法体当中的代码出现异常之后，如果上报的话，此方法结束。
        new FileInputStream("D:\\Notepad++\\config.java");//\是转义
        System.out.println("如果以上代码出现异常，这里会执行吗？？？？？？？？？不会！！！");
    }
}

运行结果：

示例代码08：

public class ExceptionTest07 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
            System.out.println("以上出现异常，这里无法执行！");
        }catch(FileNotFoundException e){
            System.out.println("文件不存在！");
        }
        try{
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
        }catch(IOException e){//多态 IOException e = new FileNotFoundException();
            System.out.println("文件不存在！");
        }
        try{
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
        }catch(Exception e){//多态 Exception e = new FileNotFoundException();
            System.out.println("文件不存在！");
        }
        try{
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
            fis.read();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在！");
        }catch(IOException e){
            System.out.println("读文件报错了！");
        }
        try{
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
            fis.read();
        }catch(Exception e){//多态 IOException e = new FileNotFoundException();
            System.out.println("文件不存在！");
        }
        /*try{
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
            fis.read();
        }catch(IOException e){
            System.out.println("文件异常！");
        }catch(FileNotFoundException e){//报错，因为IOException已经包括FileNotFoundException
            System.out.println("文件不存在！");
        }*/
        // JDK8的新特性！
        try{
            FileInputStream fis = new FileInputStream("D:\\Notepad++\\config.xml");
            fis.read();
            System.out.println( 10 / 0);
        }catch(IOException | ArithmeticException | NullPointerException e){
            System.out.println("文件不存在 | 读文件报错 | 数字异常 | 空指针异常");
        }
    }
}

运行结果：

Java基础异常

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

示例代码01：

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

示例代码02：

3、异常处理机制

4、编译时异常因为什么而得名？

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

6、编译时异常还有其它名字：

7、Java语言中对异常的处理包括两种方式：

示例代码03：

示例代码04：

示例代码05：

示例代码06：

示例代码08：

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java基础异常

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

示例代码01：

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

示例代码02：

3、异常处理机制

4、编译时异常因为什么而得名？

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

6、编译时异常还有其它名字：

7、Java语言中对异常的处理包括两种方式：

示例代码03：

示例代码04：

示例代码05：

示例代码06：

示例代码08：

热门文章

最新文章

相关课程

相关电子书

相关实验场景