Java中的异常处理，一文学完Java异常

异常处理

目录：

1. try…catch…

2. 异常处理关键字try{ }catch{ }finally{ }

3. 异常处理关键字多重catch

4. 异常处理关键字try{ }finally{ }

5. 异常的声明 throws关键字

6. 抛出异常  Throw

7. 自定义异常

8. 带有异常声明的方法的覆盖（重写）

---

 

第一节  try…catch…

一、样式

Try{…可能出现异常的代码…}

catch(Exception e){…异常进行处理的相关代码getMessage(),printStackTrace等…}

二、出现的情况

第一种：正常请求，不出现异常

import java.util.Scanner;


public class Exception1 {

    public static void main(String[] args) {

        Scanner input=new Scanner(System.in);

        int result=0;

       // try {

            System.out.println("请输入第一个数字：");

            int n1 = input.nextInt();

            System.out.println("请输入第二个数字：");

            int n2 = input.nextInt();

            result = n1 / n2;

       // } catch (Exception e) {

        //    //异常的捕获

        //    e.printStackTrace();

        //    System.out.println(e.getMessage());

        //}

        System.out.println("程序运行结果是："+result);

        System.out.println("程序运行结束了。。。");

    }

}

 

即正常输入符合基本运算规律的数字

第二种：出现异常并进行处理

import java.util.Scanner;


public class Exception1 {

    public static void main(String[] args) {

        Scanner input=new Scanner(System.in);

        int result=0;

        try {

            System.out.println("请输入第一个数字：");

            int n1 = input.nextInt();

            System.out.println("请输入第二个数字：");

            int n2 = input.nextInt();

            result = n1 / n2;

        } catch (Exception e) {

            //异常的捕获

            e.printStackTrace();

            System.out.println(e.getMessage());

        }

        System.out.println("程序运行结果是："+result);

        System.out.println("程序运行结束了。。。");

    }

}

 

如果程序在运行过程中出现了不符合基本运算规律的数字，比如10/0，或者a等字符等，此时出现异常

 

第三种：异常的类型不匹配

import java.util.Scanner;

public class Exception1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int result=0;
        try {
            System.out.println("请输入第一个数字：");
            int n1 = input.nextInt();//InputMismatchException异常
            System.out.println("请输入第二个数字：");
            int n2 = input.nextInt();
            result = n1 / n2;//ArethmicException异常
        } catch (NullPointerException e) {//空指针异常
            //异常的捕获
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
        System.out.println("程序运行结果是："+result);
        System.out.println("程序运行结束了。。。");
    }
}
//无法捕获异常

 

即可能不以Exception创建对象而使用Exception的子类进行创建，比如说上述代码是以空指针异常NullPointException创建的对象，而代码中可能出现是算术异常ArethmicException或者数据不匹配异常InputMismatchException。

 

---

 

 

异常处理关键字try{ }catch{ }finally{ }

一、语句语法

Try{…}catch{…}finally{…}

import java.util.Scanner;

public class Exception1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int result=0;
        try {
            System.out.println("请输入第一个数字：");
            int n1 = input.nextInt();
            System.out.println("请输入第二个数字：");
            int n2 = input.nextInt();
            result = n1 / n2;
        } catch (Exception e) {
            //异常的捕获
            e.printStackTrace();
            System.out.println(e.getMessage());
        }finally {
            System.out.println("通常情况下，finally用来释放资源，且无论是否产生异常都可以执行，唯一一个不会执行的情况是退出了java的虚拟机");
        }
        System.out.println("程序运行结果是："+result);
        System.out.println("程序运行结束了。。。");
    }
}

 

二、注意事项

1. finally块是否发生异常都会执行，可以释放资源

2. finally不执行的唯一情况，推出了JVM虚拟机

下面是对于2. 的演示实例

import java.util.Scanner;

public class Exception1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int result=0;
        try {
            System.out.println("请输入第一个数字：");
            int n1 = input.nextInt();
            System.out.println("请输入第二个数字：");
            int n2 = input.nextInt();
            result = n1 / n2;
            //手动推出JVM虚拟机
            System.exit(0);
        } catch (Exception e) {
            //异常的捕获
            e.printStackTrace();
            System.out.println(e.getMessage());
        }finally {
            System.out.println("通常情况下，finally用来释放资源，且无论是否产生异常都可以执行，唯一一个不会执行的情况是退出了java的虚拟机");
        }
        System.out.println("程序运行结果是："+result);
        System.out.println("程序运行结束了。。。");
    }
}

 

---

 

异常处理关键字多重catch

一、语法样例

Try{  }catch(异常类型1){  }.. catch(异常类型2){  }.. catch(异常类型3){  }..finally(){  }

二．注意事项

1.子类异常在前，父类在后

2.发生异常按顺序，逐个匹配

3.只执行第一个与异常类匹配的catch语句

4.finally可以根据实际需要可以添加也可以不添加

三、示例

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

public class Exception1 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int result=0;
        try {
            System.out.println("请输入第一个数字：");
            int n1 = input.nextInt();
            System.out.println("请输入第二个数字：");
            int n2 = input.nextInt();
            result = n1 / n2;
        }catch (ArithmeticException a){
            System.out.println("这是一个算术方面的异常情况");
        }catch (InputMismatchException i){
            System.out.println("这是一个输入不匹配的异常");
        }
        catch (Exception e) {
            //异常的捕获
            e.printStackTrace();
            System.out.println(e.getMessage());
            System.out.println("未知错误。。");
        }
        finally {
            System.out.println("通常情况下，finally用来释放资源，且无论是否产生异常都可以执行，唯一一个不会执行的情况是退出了java的虚拟机");
        }
        System.out.println("程序运行结果是："+result);
        System.out.println("程序运行结束了。。。");
    }
}

 

 

---

 

异常处理关键字try{ }finally{ }

一、应用

一般用于底层代码，只释放资源，不进行捕获，异常会按照调用顺序向上找到相关可捕获的代码或者交给JVM

二、案例演示：

import java.util.InputMismatchException;

import java.util.Scanner;

public class Exception2 {
    public static void main(String[] args) {
        try {
            divide();
        }
        catch (Exception e){
            System.out.println("该异常被捕获："+e.getMessage());
        }
    }
    public static void divide(){
        Scanner input=new Scanner(System.in);
        int result=0;
        try {
            System.out.println("请输入第一个数字：");
            int n1 = input.nextInt();
            System.out.println("请输入第二个数字：");
            int n2 = input.nextInt();
            result = n1 / n2;
        }catch (ArithmeticException a){
            System.out.println("这是一个算术方面的异常情况");
        }catch (InputMismatchException i){
            System.out.println("这是一个输入不匹配的异常");
        }
        catch (Exception e) {
            //异常的捕获
            e.printStackTrace();
            System.out.println(e.getMessage());
            System.out.println("未知错误。。");
        }
        finally {
            System.out.println("通常情况下，finally用来释放资源，且无论是否产生异常都可以执行，唯一一个不会执行的情况是退出了java的虚拟机");
        }
        System.out.println("程序运行结果是："+result);
        System.out.println("程序运行结束了。。。");
    }
}

 

 

解释：在这段代码中，我输入被除数7和除数2，这种情况下，主函数main()调用了divide()函数，此时divide()出现了错误，但是divide()本身不会对这汇总情况进行处理，于是向上抛出给了主函数main()，与此同时，main()中有捕获方法catch，此时进行了捕获。

同时我们也可以试想，如果主函数也无法进行捕获呢？它会交给JVM进行错误打印,同时直接对程序进行中断。

 

 

---

 

异常的声明 throws关键字

一、使用原则：

底层代码向上声明或抛出异常，最上一层一定要处理否则交给JVM程序中断

二、演示案例

import java.util.Scanner;

public class Exception3 {
    public static void main(String[] args) {
        try {divide();}catch (Exception e){
            System.out.println(e.getMessage());
        }
    }//此时异常由divide传递到了主函数中，如果不继续向上抛出的话，主函数必须对异常进行捕获
    public static void divide() throws Exception{
        Scanner input=new Scanner(System.in);
        System.out.println("Please input the first number");
        int num1=input.nextInt();
        System.out.println("Please input the second number");
        int  num2=input.nextInt();
        int result=num1/num2;
        System.out.println("result is :"+result);
        System.out.println("The end of the software");
    }
}

 

如果不想在主函数中加入TRY CATCH语句，同时又不想他进行报错。我们可以在PSVM后面加throws Exception，把异常继续向上抛出给JVM

 

 

---

 

抛出异常  Throw

一、概念解释及语法

除系统自动抛出异常外，有些问题要程序员自行抛出异常

语法：throw 抛出对象

二、案例演示

这里新建了两个Java类，其中Person类包含人的年龄、性别、名字，并规定，人的年龄在0-120之间是有效的，而性别只有男和女有效，其余的会显示抛出异常。

主函数会调用这个类并新建对象给这三个属性进行赋值

 

Person类

public class Person {
    int age;
    String name;
    String sex;


    public Person() {
    }

    public Person(int age, String name, String sex) {
        this.age = age;
        this.name = name;
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>=0&&age<=120){
        this.age = age;}

else{
        throw new RuntimeException("年龄异常抛出");
        }
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        if (sex.equals("男")||sex.equals("女")){
        this.sex = sex;}else {
            //抛出
            throw new RuntimeException("性别错误");
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

 

主类main

public class TestPerson {


    public static void main(String[] args) {
        Person p=new Person();
        p.setAge(20);
        //p.setName("C");
        p.setSex("e");
    }
}

运行后会发现：这里的性别会显示抛出异常，因为我们设置了性别只有男和女才被视作为有效。

Ps:我们知道

RuntimeException	运行时异常	可处理可不处理
CheckedException	检查时异常	必须处理

如果把原文中的RuntimeException全部变换为Exception会出现什么结果呢？

结果必然必然会是报错

处理方式：1.在set方法出加throws关键字向上抛出，2.加Try..Catch..语句

同样的在主类调用时同样需要重复做这一步骤。

实例如下：

public class Person {
    int age;
    String name;
    String sex;

    public Person() {
    }

    public Person(int age, String name, String sex) {
        this.age = age;
        this.name = name;
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception{
        if (age>=0&&age<=120){
        this.age = age;}else{
            throw new Exception("年龄异常抛出");
        }
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) throws Exception{
        if (sex.equals("男")||sex.equals("女")){
        this.sex = sex;
        }else {
            //抛出
            throw new Exception("性别错误");
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

public class TestPerson {
    public static void main(String[] args) throws Exception{
            Person p=new Person();
            p.setAge(20);
            p.setName("C");
            p.setSex("男");

    }
}

 

 

---

 

自定义异常

一、相关要求

1. 要继承Exception或者他的子类，常用runtimeException

2. 必要构造方法，无参构造和(String Message)

作用：报错时名字更加贴切

二、示例

快速添加构造方法：

IDEA:Alt+insert

Eclipse:Alt+shift+s

 

AgeException类

SexException类

Person类

TestPerson类

 

 

 

AgeException类

public class AgeException extends RuntimeException{
    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }

    public AgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public AgeException(Throwable cause) {
        super(cause);
    }

    public AgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

 

SexException类

public class SexException extends RuntimeException{
    public SexException() {
    }

    public SexException(String message) {
        super(message);
    }

    public SexException(String message, Throwable cause) {
        super(message, cause);
    }

    public SexException(Throwable cause) {
        super(cause);
    }

    public SexException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

 

Person类

public class Person {
    int age;
    String name;
    String sex;

    public Person() {
    }

    public Person(int age, String name, String sex) {
        this.age = age;
        this.name = name;
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception{
        if (age>=0&&age<=120){
        this.age = age;}else{
            throw new AgeException("年龄异常抛出");
        }
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) throws Exception{
        if (sex.equals("男")||sex.equals("女")){
        this.sex = sex;
        }else {
            //抛出
            throw new SexException("性别错误");
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

 

TestPerson类

public class TestPerson {
    public static void main(String[] args) throws Exception{
            Person p=new Person();
            p.setAge(20);
            p.setName("C");
            p.setSex("男");

    }
}

 

 

---

 

带有异常声明的方法的覆盖（重写）

一、

方法名、参数列表、返回值类型一定和父类相同（同重写）

二、

子类的访问修饰符和父类相同或比父类宽

例如：子类是public，父类必须是public

子类是public，父类是private

三、

子类中的方法，不可抛出比父类更多，更宽的检查时异常

例如:父类是FileNotFoundException,子类是Exception

即子类的错误类别应当包含父类，或者说父类的错误类别应当是子类的错误类别的子类。