概述

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入的数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

异常：在 Java 语言中，将程序执行中发生的不正常情况称为“异常”。（开发过程中的语法错误和逻辑错误不是异常）
Java 程序执行过程中所发生的异常事件课分为两类：
- Error：Java 虚拟机无法解决的严重问题。如：JVM 系统内部错误、资源耗尽等严重情况。比如：StackOverflowError 和 OOM。
- Exception：其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如：
  - 空指针访问
  - 试图读取不存在的文件
  - 网络连接中断
  - 数组角标越界
对于这些错误，一般有两种解决办法：一是遇到错误就终止程序的运行。另一种方法是由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理
捕获错误最理想的是在编译期间，但是有的错误只有在运行时才会发生。比如：除数为 0，数组下边越界等
- 分类：编译时异常和运行时异常

异常体系结构

java.lang.Throwable

java.lang.Error：一般不编写针对性的代码进行处理

java.lang.Exception：可以进行异常处理

编译时异常（checked)
- IOException
  - FileNotFoundException
- ClassNotFoundException

运行时异常（unchecked)

NullPointerException

@Test
public void test() {
    // int[] arr = null;
    // System.out.println(arr[3]);
    String string = "abc";
    string = null;
    System.out.println(string.charAt(0));
}

ArrayIndexOutOfBoundsException

@Test
public void test() {
    // ArrayIndexOutOfBoundsException
    // int[] arr = new int[10];
    // System.out.println(arr[10]);
    // StringIndexOutOfBoundsException
    String string = "abc";
    System.out.println(string.charAt(3));
}

ClassCastException

@Test
public void test() {
    Object obj = new Date();
    String str = (String) obj;
}

NumberFormatException

@Test
public void test() {
    String str = "123";
    str = "abc";
    int num = Integer.parseInt(str);
}

InputMismatchException

@Test
public void test() {
    Scanner scanner = new Scanner(System.in);
    int score = scanner.nextInt();
    System.out.println(score);
    scanner.close();
}

ArithmeticException

@Test
public void test() {
    int a = 10;
    int b = 0;
    System.out.println(a / b);
}

异常处理机制

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的if-else扽之会导致程序的代码加长、臃肿，可读性复查。因此采用异常处理机制。

Java异常处理

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护

异常的处理：抓抛模型

过程一：“抛”：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行
- 关于异常对象的产生：
  - 系统自动生成的异常对象
  - 手动生成一个异常对象，并抛出（throw）
- 过程二：“抓”：可以理解为异常的处理方式：
  - try-catch-finally
  - throws

Java异常处理的方式

try-catch-finally

结构

try{
    // 可能出现异常的代码
}catch(异常类型1 变量名1){
    // // 处理异常的方式1
}catch(异常类型2 变量名2){
    // // 处理异常的方式2
}catch(异常类型n 变量名n){
    // // 处理异常的方式n
}finally{
    // 一定会执行的代码
}

finally 是可选的
使用 try 将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch 中匹配
一旦 try 中的异常对象匹配到某一个 catch 时，就进出 catch 中进行异常处理。一旦处理完成，就跳出当前的 try-catch 结构（在没有写 finally 的情况）继续执行其后的代码
catch 中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓
catch 中的异常类型如果满足子父类关系，则要求子类一定生命在父类的上面。否则报错
常用的异常处理方式：
- String getMessage()
- 在 try 结构中生命的变量，在出了 try 结构以后，就不能再被调用
在 try 结构中生命的变量，在出了 try 结构以后，就不能再被调用
try-catch-finally 结构可以嵌套
finally 中声明的是一定会被执行的代码。即使 catch 中又出现异常了，try 中有 return 语句，catch 中有 return 语句等情况
像数据库连接、输入输出流、网络编程 Socket 等资源，JVM 是不能自动回收的，我们需要手动的进行资源的释放。此时的资源释放，就需要声明在 finally 中

体会1：使用 try-catch-finally 处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错，相当于我们使用 try-catch-finally 将一个编译时可能出现的异常，延迟到运行时出现
体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写 try-catch-finally 了，针对于编译时异常，我们说一定考虑异常的处理

throws + 异常类型

结构

public void method() throws 异常类型1,异常类型2,异常类型n{
    
}

throws + 异常类型写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦放当方法执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时就会被抛出。异常代码后续的代码就不再执行
try-catch-finally：真正的将异常给处理掉了
throws 的方式只是将异常抛给了方法的调用者。并没有真正的处理掉
开发中选择使用 try-catch-finally 还是使用 throws ？
- 如果父类中被重写的方法没有 throws 方式处理异常，则子类重写的方法也不能使用 throws，意味着如果子类重写的方法中有异常，必须使用 try-catch-finally 方式处理
- 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用 throws的方式进行处理。而执行的方法a可以考虑使用 try-catch-finally 方式进行处理

重写方法声明抛出异常的原则

子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

public class OverrideTest {

    public static void main(String[] args) {
        OverrideTest test = new OverrideTest();
        test.display(new SubClass());
    }

    public void display(SuperClass s) {
        try {
            s.method();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class SuperClass {
    public void method() throws IOException {

    }
}

class SubClass extends SuperClass {
    public void method() throws FileNotFoundException {
        
    }
}

手动抛出异常

throw new RuntimeException("您输入的数据非法！");

可以抛出的异常必须是Throwable或其子类的实例

自定义异常类

继承于现有的异常结构：RuntimeException、Exception
提供全局常量：serialVersionUID
提供重载的构造器

public class MyException extends Exception {
    private static final long serialVersionUID = 1L;
    
    public MyException() {
        
    }
    public MyException(String msg){
        super(msg);
    }
}
/========================================================
/* 使用自定义异常类 */
throw new MyException("不能输入负数");

练习

如下代码执行后会有什么结果

public class ReturnExceptionDemo {
    static void methodA() {
        try {
            System.out.println("进入方法A");
            throw new RuntimeException("制造异常");
        } finally {
            System.out.println("用A方法的finally");
        }
    }

    static void methodB() {
        try {
            System.out.println("进入方法B");
            return;
        } finally {
            System.out.println("调用B方法的finally");
        }
    }

    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
            
        methodB();
    }
}

进入方法A
用A方法的 finally
制造异常
进入方法B
用B方法的 finally

编写应用程序EcmDef.java，接收命令行的两个参数
要求不能输入负数，计算两数相除。
对数据类型不一致（NumberFormatException）、缺少命令行参数（ArrayIndexOutOfBoundsException）、除 0（ArithmeticException）及输入负数（EcDef 自定义的异常）进行异常处理。
提示：
在主类（EcmDef）中定义异常方法（ecm）完成两数相除功能。
在 main() 方法中使用异常处理语句进行异常处理。
在程序中，自定义对应输入负数的异常类（EcDef）。
运行时接受参数 java EcmDef 20 10 //args[0]=“20”args[1]=“10”
Interger 类的 static 方法 parseInt(Strings) 将 s 转换成对应的 int 值。

类 EcmDef

public class EcmDef {
    public static void main(String[] args) {
        try {
            int i = Integer.parseInt(args[0]);
            int j = Integer.parseInt(args[1]);
            int result = ecm(i, j);
            System.out.println(result);
        } catch (NumberFormatException e) {
            System.out.println("数据类型不一致");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("缺少命令行参数");
        } catch (ArithmeticException e) {
            System.out.println("除0");
        } catch (EcDef e) {
            System.out.println(e.getMessage());
        }
    }

    public static int ecm(int i, int j) throws EcDef {
        if (i < 0 || j < 0) {
            throw new EcDef("分子或分母为负数");
        }
        return i / j;
    }
}

类 EcDef

public class EcDef extends Exception {
    
    static final long serialVersionUID = 1L;

    public EcDef() {

    }

    public EcDef(String msg) {
        super(msg);
    }
}

总结

世界上最遥远的距离，是我在 if 里你在 else 里，似乎一直相伴又永远分离；
世界上最痴心的等待，是我当 case 你是 switch，获取永远都选不上自己
世界上最真情的相依，是你在 try 我在 catch。无论你发神马脾气，我都默默承受，静静矗立。到那时，再来期待我们的 finally。

Java异常

Java异常

概述

异常体系结构

异常处理机制

Java异常处理

Java异常处理的方式

try-catch-finally

throws + 异常类型

重写方法声明抛出异常的原则

手动抛出异常

自定义异常类

练习

总结

Java多线程

Java面向对象

xiaokai54

Comments | NOTHING

概述

异常体系结构

异常处理机制

Java异常处理

Java异常处理的方式

try-catch-finally

throws + 异常类型

重写方法声明抛出异常的原则

手动抛出异常

自定义异常类

练习

总结

Java多线程

Java面向对象

xiaokai54

Comments | NOTHING

你想搜索什么...