Java —— 教练，我想搬砖！

Java 基础：异常

2018-06-07  本文已影响0人  千面娇你妹的娃

目录：
一、 异常继承体系
二、 发生异常到时候，程序的执行特征：
三、 异常与错误的区别
四、 抛出异常 throw
五、 声明异常 throws
六、 捕获异常 try…catch…finally
七、 try…catch…finally 异常处理的组合方式
八、 异常在方法重写中细节
九、 Throwable 类中的常用方法
十、 try和finally中都有return语句，执行哪一个 return？
十一、 自定义异常

一、 异常继承体系

  • 运行时期异常:
    • 方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
    • 运行时期异常一旦发生,需要程序人员修改源代码.
  • 编译时异常: 必须在编译前处理，否则无法通过编译

二、 发生异常到时候，程序的执行特征：

三、 异常与错误的区别

四、 抛出异常 throw

throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
//具体范例：
public static void main(String[] args) {
    String s = "abc";
    if(s.equals("abc")) {
        throw new NumberFormatException();
    } else {
        System.out.println(s);
    }
    //function();
}

五、 声明异常 throws

public static void function() throws NumberFormatException{
        String s = "abc";
        System.out.println(Double.parseDouble(s));
    }

    public static void main(String[] args) {
        try {
            function();
        } catch (NumberFormatException e) {
            System.err.println("非数据类型不能转换。");
        }
}

六、 捕获异常 try…catch…finally

1. 概述
try {
    //需要被检测的语句。
}
catch(异常类 e) { //try中抛出的是什么异常，在括号中就定义什么异常类型。
    //异常的处理语句。
}
finally {
    //一定会被执行的语句。
}
//try：该代码块中编写可能产生异常的代码。
//catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
//finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
2. 异常处理流程：
  1. 首先，当异常在 try 代码块中发生的时候，虚拟机首先捕获这个异常，创建一个异常对象(包含本次异常的所有详细信息)
  2. 虚拟机会把这个异常，抛出给catch代码块（类似于方法调用，虚拟机会调用catch代码块中，处理异常的代码）
  3. 执行catch代码块，中的处理异常的代码
  4. 没有终止我们应用程序，而是从catch语句之后的代码开始，继续执行我们的应用程序

在try语句块中，一旦发生异常，我们的代码仍然被一分为二

  1. 在异常发生之前带代码都正常运行
  2. 在异常发生之后的代码，不会执行，而是直接跳转到我们自己处理异常的catch代码块中

七、 try…catch…finally 异常处理的组合方式

即使在finally代码块执行了return语句，finally代码块中的代码，仍然会执行
特殊情况: 走到finally之前 JVM 退出了,就不会执行finally了
finally在开发中的应用：用于释放资源

  • 执行特征是：
    • 每个try-catch中是否抛出异常，相互独立的
    • 在实际执行的时候，每一个try-catch代码块可能都产生异常。
  • 实际开发的时候，一般来讲：
    • 效率角度，try 块中方的代码越少越好
    • 开发的时候，会将相关的异常，放在同一个 try 块
      • 相关异常： 一个连续的流程中，可能发生的一系列异常
      • 所以一系列相关的流程中，一旦前一步出现了异常，就会导致，即使后面的流程正常执行，其实也已经没有意义了

这种异常处理方式，要求多个catch中的异常不能相同，
若catch中的多个异常之间有子父类异常的关系，那么先写子类异常类型，再写父类异常类型
当发生异常的时候， 最多执行一个catch分支的代码

public class Demo {
    public static void main(String[] args) {
        try{
            int i = 10;
            //可能发生异常的语句
            int j = i / 0;
            System.out.println("try after exception");
            //空指针异常
            int[] a = null;
            System.out.println(a[0]);
            //数组越界异常
            int[] b = {1, 2, 3};
            System.out.println(b[3]);
        }catch (ArithmeticException e) {
            System.out.println("发生了除0异常");
        } catch (NullPointerException | ArrayIndexOutOfBoundsException e) { //一个catch分支处理多种类型的异常
            System.out.println("发生了数组异常");
        }
    }
}

八、 异常在方法重写中细节

class Fu {
    public void method () throws RuntimeException {
    }
}

class Zi extends Fu {
    public void method() throws RuntimeException { }  //抛出父类一样的异常
    //public void method() throws NullPointerException{ } //抛出父类子异常
}

class Fu {
    public void method () throws NullPointerException, ClassCastException{
    }
}
class Zi extends Fu {
    public void method()throws NullPointerException, ClassCastException { }
    public void method() throws NullPointerException{ } //抛出父类异常中的一部分
    public void method() throws ClassCastException { } //抛出父类异常中的一部分
}

九、 Throwable类中的常用方法

十、 try和finally中都有return语句，执行哪一个return？

问：如果try和finally语句里面都有return，会执行哪一个呢？
首先，在程序没有异常的情况下，首先执行到try里面的语句，但是只执行到了return里面的****expression，expression首先存放在操作数栈顶，然后复制到局部变量区，并没有执行返回语句return（执行返回语句通常意味着程序执行结束）。然后执行finally，当执行到finally里面的return时候，会将return语句执行完整，此时程序已经有了返回值，因为，执行结束。

十一、 自定义异常

1. 概述
Class 异常名 extends Exception{ //或继承RuntimeException
    public 异常名(){
    }
    public 异常名(String s){
        super(s);
    }
}
2. 示例

需求描述：
定义Person类，包含name与age两个成员变量。
在Person类的有参数构造方法中，进行年龄范围的判断，若年龄为负数或大于200岁，则抛出NoAgeException异常，异常提示信息“年龄数值非法”。
要求：在测试类中，调用有参数构造方法，完成Person对象创建，并进行异常的处理。

//自定义异常类
class NoAgeException extends Exception{
    NoAgeException() {
        super();
    }

    NoAgeException(String message)  {
        super(message);
    }
}

//Person类
class Person{
    private String name;
    private int age;
    Person(String name,int age) throws NoAgeException   {
        //加入逻辑判断
        if(age<0 || age>200)        {
            throw new NoAgeException(age+",年龄数值非法");
        }
        this.name = name;
        this.age = age;
    }
    //定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。
    public String toString()    {
        return "Person[name="+name+",age="+age+"]";
    }
}

//测试类
class ExceptionDemo{
    public static void main(String[] args) {
        try {
            Person p = new Person("xiaoming",20);
            System.out.println(p);
        }
        catch (NoAgeException ex){
            System.out.println("年龄异常啦");
        }
        System.out.println("over");
    }
}

总结一下，构造函数到底抛出这个NoAgeException是继承Exception呢？还是继承RuntimeException呢？
继承Exception，必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行。
继承RuntimeExcpetion,不需要throws声明的，这时调用是不需要编写捕获代码的，因为调用根本就不知道有问题。一旦发生NoAgeException，调用者程序会停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码。

上一篇 下一篇

猜你喜欢

热点阅读