Java从入门到实战总结-2.4、Java异常处理及安装IDEA

Java从入门到实战总结-2.4、Java异常处理及安装IDEA

---

文章目录

1、IDEA下载、安装及卸载

在官网进行下载和安装：

​​https://www.jetbrains.com/idea/​​

注册后绑定激活码：

​​https://www.jetbrains.com/store/redeem/​​

安装IDEA和安装其它软件没有什么区别，一直下一步即可，一直到安装完成。

安装插件：Ideavim和Chinese Language Pack等插件（Preference->plugin后搜索安装即可）

2、异常处理学习点

• 明确什么是异常 （重点）
• 能辨识出常见的异常及其含义。 （熟悉+）
• 理解异常产生的原理 （了解）
• 能处理异常 （重点）
• 能够自定义异常类型 （熟悉）

3、什么是异常

（1）、概述

异常是在程序中导致程序中断运行的一种指令流。

例如，现在有如下的操作代码：

package com.xiaoyaoyou.demo;

public class demo {
    public static void main(String[] args) {
        int i = 10;
        int j = 0;
        System.out.println("==========开始计算=============");
        int temp = i / j;
        System.out.println("temp = " + temp);
        System.out.println("==========计算结束=============");
    }
}

运行结果：

以上的代码在“int temp = i / j ;”位置处产生了异常，一旦产生异常之后，异常之后的语句将不再执行了，所以现在的程序并没有正确的执行完毕之后就退出了（从最下面开始看可以看出是第8行出错了）。

那么，为了保证程序出现异常之后仍然可以正确的执行完毕，所以要采用异常的处理机制。

（2）、处理异常

如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下：

try{

// 有可能发生异常的代码段

}catch(异常类型1 对象名1){

// 异常的处理操作

}catch(异常类型2 对象名2){

// 异常的处理操作

} …

finally{

// 异常的统一出口

}

package com.xiaoyaoyou.demo;

public class demo {
    public static void main(String[] args) {
        int i = 10;
        int j = 0;
        System.out.println("==========开始计算=============");
        try {
            int temp = i / j;
            System.out.println("temp = " + temp);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        }
        System.out.println("==========计算结束=============");
    }
}

package com.xiaoyaoyou.demo;

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        menu();
    }

    public static int menu() {
        System.out.println("请根据提示，选择功能序号：");
        System.out.println("1. 增加xx");
        System.out.println("2. 删除xx");
        System.out.println("3. 修改xx");
        System.out.println("0. 退出");

        Scanner input = new Scanner(System.in);
        int num = -1;
        try{
            num = input.nextInt();
            if(num < 0 || num > 3) {
                System.out.println("输入有误，请重新操作！");
                return menu();
            }
        }catch (InputMismatchException e) {
            System.out.println("输入有误，请重新操作！");
            return menu();
        }

        return num;
    }
}

package com.xiaoyaoyou.demo;

import java.util.InputMismatchException;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        menu();
    }

    public static int menu() {
        System.out.println("请根据提示，选择功能序号：");
        System.out.println("1. 增加xx");
        System.out.println("2. 删除xx");
        System.out.println("3. 修改xx");
        System.out.println("0. 退出");

        Scanner input = new Scanner(System.in);
        int num = -1;
        try{
            num = input.nextInt();
            if(num < 0 || num > 3) {
                System.out.println("输入有误，请重新操作！");
                return menu();
            }
        }catch (Exception e) {
            System.out.println("输入有误，请重新操作！");
            return menu();
        }

        return num;
    }
}

（3）、try+catch的处理流程

1、 一旦产生异常，则系统会自动产生一个异常类的实例化对象。

2、 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出。

3、 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

（4）、finally

在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码。

4、异常体系结构

异常指的是Exception ， Exception类， 在Java中存在一个父类Throwable（可能的抛出）Throwable存在两个子类：

1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。

2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。

多异常捕获的注意点：

1、 捕获更粗的异常不能放在捕获更细的异常之前。

2、 如果为了方便，则可以将所有的异常都使用Exception进行捕获。

特殊的多异常捕获写法：

catch(异常类型1 |异常类型2 对象名){

//表示此块用于处理异常类型1 和 异常类型2 的异常信息

}

5、throws关键字

在程序中异常的基本处理已经掌握了，但是随异常一起的还有一个称为throws关键字，此关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。

格式：

返回值 方法名称()throws Exception{

}

package com.xiaoyaoyou.demo;

import java.io.IOException;

public class Demo3 {
    public static void main(String[] args) {
            //这里还是没有处理异常就会报错
        shutdown("");
    }

    /**
     * 异常是否抛出去，应该站在哪个角度思考？
     *
     * 如果是因为传参导致异常，应该通过throws将异常抛出去
     * @param text
     * @throws java.io.IOException:因为传递的指令不对，会导致此问题发生
     */
    public static void shutdown(String text) throws IOException {
        Runtime.getRuntime().exec(text);
    }
}

6、throw关键字（不常用）

throw关键字表示在程序中人为的抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throw直接抛出。

代码： throw new Exception(“抛着玩的。”) ;

package com.xiaoyaoyou.demo;

public class Demo4 {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(-1);
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age < 0 || age > 180) {
            RuntimeException e = new RuntimeException("年龄不合理");
            throw e;
        }
        this.age = age;
    }
}

自己抛出异常：

7、RuntimeExcepion与Exception的区别

注意观察如下方法的源码：

Integer类： public static int parseInt(String text)throws NumberFormatException

此方法抛出了异常， 但是使用时却不需要进行try。。。catch捕获处理，原因：

因为NumberFormatException并不是Exception的直接子类，而是RuntimeException的子类，只要是RuntimeException的子类，则表示程序在操作的时候可以不必使用try…catch进行处理，如果有异常发生，则由JVM进行处理。当然，也可以通过try catch处理。

8、自定义异常类（了解）

编写一个类， 继承Exception，并重写一参构造方法 即可完成自定义受检异常类型。

编写一个类， 继承RuntimeExcepion，并重写一参构造方法 即可完成自定义运行时异常类型。

package com.xiaoyaoyou.demo;

public class Demo5 {
    public static void main(String[] args) {
        Person p = new Person();
        //这时也必须处理异常
        try {
            p.setAge(-1);
        } catch (AgeRuntimeException e) {
            //这里选择打印，不打印的话则不会报错
//            e.printStackTrace();
            System.out.println("异常打印");
        }
    }
}

//  运行时异常编辑器不检查
// class AgeRuntimeException extends RuntimeException {
class AgeRuntimeException extends Exception {
    public AgeRuntimeException(String message) {
        super(message);
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    //public void setAge(int age) {
    //这时需要抛出异常
    public void setAge(int age) throws AgeRuntimeException {
        if(age < 0 || age > 180) {
            AgeRuntimeException e = new AgeRuntimeException("年龄不合理");
            throw e;
        }
        this.age = age;
    }
}

9、异常常见面试题

• 1、try-catch-finally 中哪个部分可以省略？

答： catch和finally可以省略其中一个 ， catch和finally不能同时省略

注意:格式上允许省略catch块, 但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码.

• 2、try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

答：finally中的代码会执行

详解：

执行流程：

• 先计算返回值， 并将返回值存储起来， 等待返回（注意返回值的类型，是否是引用类型）
• 执行finally代码块
• 将之前存储的返回值， 返回出去；

需注意：

• 返回值是在finally运算之前就确定了，并且缓存了，不管finally对该值做任何的改变，返回的值都不会改变
• finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或catch中的值
• 如果在try或catch中停止了JVM，则finally不会执行.例如停电，或通过如下代码退出JVM:System.exit(0);

package com.xiaoyaoyou.demo;

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(test());
    }

    public static int test() {
        int a = 10;
        try{
            int b = 0;
            return a/b;
        }catch (Exception e) {
            System.out.println("程序异常");
            System.exit(0);
        }finally {
            a = 20;
        }

        return a;
    }
}