异常类及其使用方法

异常(广义）

• 异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。

• Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分

为两类：

• Error : Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资

源耗尽等严重情况。一般不编写针对性的代码进行处理。

• Except ion: 其它因编程错误或偶然的外在因素导致的一般性问题，可

以使用针对性的代码进行处理。例如：

访问数组下标越界

试图读取不存在的文件

网络连接中断

• 对于这些异常，一般有两种解决方法：一是遇到异常就终止程序的运行。

• 另一种方法是由程序员在编写程序时，就考虑到异常的检测、异常消息

的提示，以及异常的处理。

• 捕获异常最理想的是在编译期间，但有的异常只有在运行时才会发生。

比如：除数为0，数组下标越界等

分类：编译时异常和运行时异常

异常(狭义)

● 异常分为运行期异常和编译期异常两种

编译时异常:

● 运行期异常：程序运行时抛除的异常，所有RuntimeException的子类都

是运行期异常

● 数学异常

● 空指针异常

● 数组下标越界

● ……

运行时异常:

● 编译期异常(Checked Exception)：除去运行期的异常都是编译期异常，

也称为检测异常

● IOException

● SQLException

● ……

提示的各部分含义：

重点运行时异常处理:

关键字：try,catch,finally,throw,throws

●try

检测不安全的代码块（发现异常）

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将

跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代

码放到try块中，因为随时可能会中断执行。

● catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去

catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，

一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类

的顺序写，否则有编译错误

• 捕获异常的有关信息：

与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

e.getMessage() 获取异常信息，返回字符串

e.printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值

● finally

finally该内容总是会执行的，只能有一个finally语句

finally{

必须执行的逻辑

}

● throws,定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常，而交给方法调用处进行处理。

例如:

public void test (参数)throws 异常1，异常2，异常3{ 
​代码段;
} 

● 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。

● 子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常(针对编译期异常)。

● 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明。

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象.

• 在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。

语法：

throw throw new 异常类构造方法

如：

throw new RunTimeException(); 
​
public static void someMethod() { 
​
if (1==1) { 
​
throw new RuntimeException("错误原因"); 
​
} 
}

throws和throw

● throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try catch捕获异常，要么使用throws声明异常

● throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处理这些异常

● 抽象方法也可以使用throws

重写抽象方法后，该方法抛出的异常类型范围要等于或者小于抽象方法抛出的异常

​

import java.io.IOException;
​
abstract class text{
    abstract void text1()throws IOException, Exception;
    abstract void text2()throws IOException;
        }
​
​
public class Dome3 extends text {           //抽象类中的抽象方法也可以抛出异常
@Override                  //但在继承抽象类的类中，重写该抽象方法时，抛出的异常类型要小于或等于原抽象方法的抛出异常
    void text1() throws Exception{
​
    }
@Override
    void text2()throws IOException {
​
    }
​
    public static void main(String[] args) {
​
    }
}

try{

监控代码的放置区域，在这里可能会产生异常类；

}catch(可以捕获的异常类型的引用变量){

输出异常的信息或者提示错误原因

}

​
public class Dome1 {
    public static void main(String[] args){
        try {//在try的监控代码中若出现错误是java中已经定义好的，将会创建一个该对象的错误，并抛出该错误对象
            System.out.println(10/0);
            System.out.println("结果数出来咯");
        }catch(Exception a){
            /*在try抛出错误后catch将捕获该异常，捕获就是将该异常创建的异常对象的地址赋给在
            catch(创建具体的错误类型的引用变量){
                      便可以在这里输出各种提示信息;
            }
             当然也可以像示例一样用生成一个所有错误类型的父类引用变量
              */
            a.printStackTrace();//输出错误类型
            System.out.println(a.getMessage());//输出错误原因
            System.out.println("错误出现");//输出一些信息
        }
        System.out.println("我出来喽");
​
    }
}
//在try中监控的代码一但出现异常，那么便会停止运行在try中出现异常后的代码，转而进行catch{}中的语句，之后便会执行catch{}后的代码
​

基本语法

通常在main方法里的用法 用在方法中可能出现异常的地方使用，但解决问题，在调用处解决

try{ 
   try{
可能会发生异常的代码
}catch(异常类型 引用名){ }
finally{
异常处理代码
}finally{ }
必须执行代码
}

例子

​

public class Dome2 {
    public static void main(String[] args) {
        try{
            text1();
        }
        catch(Exception e){
           e.printStackTrace();
            System.out.println("bbbbbbbbbb");
        }
        finally{
            System.out.println("程序结束");
        }
        System.out.println(text2(10,0));
        System.out.println(text2(5,2));
    }
​
    public static void text1(){
        try{                          //在方法中出现错误但不处理,在方调用处用异常处理机制处理问题
            int a=10;
            int b=0;
            System.out.println(a/b);
        }finally {
            System.out.println("有错误");
        }
    }
​
    public static int text2(int a,int b){      //在方法中出现错误后，在方法中用try，catch，fianlly处理
        try {                                   //先运行finally{}中的在return
            int c=a/b;
            return c;
        }catch(Exception e){
            return -1;
        }finally {
            System.out.println("aaaaaaaaaaa");
        }
    }
}

连续使用throws

import java.io.IOException;
import java.nio.charset.StandardCharsets;
​
public class Dome4 {        //在方法中出现异常，一直要抛到该方法调用处用try，catch处理,一个方法可以抛出多个种异常
    public static void main(String[] args) {
      try{
         text1();
​
      }catch(ArithmeticException e){
          e.printStackTrace();
      }
      catch (IOException c){
​
      }
      finally {
          System.out.println("aaaaaa");
      }
​
    }
​
​
    public static void text1()throws ArithmeticException, IOException {
        text2();
    }
​
    public static void text2()throws ArithmeticException, IOException {
        System.out.println(1/0);
    }
​
}
​

自定义异常

● 自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

● 作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

● 自定义异常类

● 基本语法

public class 异常类名 extends Exception/RuntimeException{

public 异常类名(String msg){

super(msg);

     }

}

 

● 自定义异常类中往往不写其他方法，只重载需要使用的构造方法

● 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或throws抛出

自定异常类举例

import java.util.*;
public class triangle
{
    int a1,a2,a3;
​
    public static void main(String[] args) {
     Scanner a=new Scanner(System.in);
​
             try {
                 System.out.println("请输入三条边：");
                 triangle one=new triangle(a.nextInt(),a.nextInt(),a.nextInt());
                 one.prn();
             } catch (triangleException e) {
                 e.pr();
             }
​
​
    }
​
​
    public triangle(int a,int b,int c) throws triangleException {
          if(a+b>c&&a+c>b&&b+c>a){
              a1=a;
              a2=b;
              a3=c;
          }
          else {
              throw new triangleException(a,b,c);
          }
​
    }
​
​
    public void prn(){
        System.out.println("输入的三边可以生成三角形");
    }
​
}
​
class triangleException extends Throwable{
    int b1,b2,b3;
    public triangleException(int b1, int b2, int b3){
        this.b1=b1;
        this.b2=b2;
        this.b3=b3;
    }
​
    void pr(){
        System.out.println("输入的 "+b1+b2+b3+"无法组成三角形");
    }
}

运行结果：