异常处理机制

文章目录

目录

前言

一、Java异常的概念

二、异常的体系 

三、异常处理

四、throws和throw

---

前言

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

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、Java异常的概念

异常概念：            
            广义：程序出现的任何不正常的情况
            狭义：程序在运行过程时出现的不正常情况，可以使用异常机制来处理
错误：
            Error（错误）：java虚拟机无法解决的严重问题
            Exception（异常）：编程错误，可以通过针对性代码解决。
解决方法：
            1、终止程序运行
            2、异常处理

二、异常的体系 

     Throwable类有两个直接子类：Exception类、Error类。

     Error：编译期错误或者程序错误，程序中不处理
     Exception：所有异常的父类。

异常分类

运行期异常：程序运行时抛出的异常，所有RuntimeException的子类都是运行期异常。
       算术异常：ArithmeticException
       数组越界：ArrayIndexOutOfBoundsException
       数字格式化：NumberFormatException
       空指针（使用值为null的引用）：NullPointerException
       类型转换异常：ClassCastException
编译期异常：运行期以外的所有异常，强制要求处理，Checked Exception
        ClassNotFoundException

三、异常处理

     使用异常机制进行异常处理

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

基本语法：

        异常处理

        try{

            编写可能出现异常的代码

        }catch (捕获的异常类型){

            异常处理  提示  其他操作

        }

public class Demo03 {
    public static void main(String[] args) {
        int a = 10;
         int b = 0;
         try{
             int c = a/b;
         }catch (ArithmeticException e){
             System.out.println("算术异常");
         }catch (NullPointerException n){
             System.out.println("对象为null");
         }
        System.out.println("代码");
    }
}

    try{

        可能会发生异常的代码

    }catch(Exception e){ 

        异常处理代码

    }finally{

       无论是否出现异常，finally中的代码都会执行

    }

public class Demo04 {

    public static void main(String[] args) {
        //test1();
        int res = test2(10,0);
        System.out.println(res);
    }
    private static  void test1(){
        try{
            System.out.println("10/0");
        }catch(Exception e){
            System.out.println("系统忙");
        }finally {
            System.out.println("finally 代码块");
        }
        System.out.println();
    }
    private static int test2(int a,int b){
        try{
            int c = a/b;
            return c;
        }catch(Exception e){
            return -1;
        }finally {
            System.out.println("finally 代码块");
        }
    }
}

Try：发现异常，检测不安全的代码块
         try代码块中任何一条语句发生了异常，后面的代码不会继续执行，程序将跳转到异常处理代码块中。

Catch：匹配类的异常，保证程序能继续运行
             try-catch语句：捕获异常，异常处理函数
             try后面可以写多个catch，分别捕获不同类型的异常，按照子类顺序写

捕获异常有关的信息：
       访问异常对象的成员变量或调用方法
       getMessage（）：捕获异常信息，返回字符串
       printStartTrace（）：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。

Finally：

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

public class Demo05 {
    public static void main(String[] args) {
        try{
            test1();
        }catch (UnsupportedEncodingException e){
            e.printStackTrace();
            System.out.println("不支持的编码格式");
        }
    }
    private static void test1() throws UnsupportedEncodingException{
        test2();//谁调用谁处理
    }
    private static void test2() throws NullPointerException, UnsupportedEncodingException {
        "abc".getBytes("utf-8");
    }
}

四、throws和throw

throws关键字：
·throws 在方法的形参后面，声明此方法可能会抛出某种类型的异常，可以声明多个
      如果声明行为运行时异常，编译期间不强制处理
      如果声明为编译期异常，编译期间强制提示进行处理
·定义方法的时候可以使用throws关键字声明，表示此方法不处理异常，交给方法调用处进行处理
·任何方法都可以使用throws关键字声明议程类型，包括抽象方法。
·子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常（针对编译期异常）
·使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么使用throws声明

    throw关键字：

       用于显式抛出异常，抛出一个异常类的实例化对象
       自己抛出异常对象：throw  new  异常类构造方法
       用于方法体中，用来抛出一个实际的异常对象。使用throw后，要么使用
       try-catch捕获异常，要么使用throws声明异常
       throws用于方法声明处，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处理这些异常

        抽象方法也可以使用throws

    

 五、自定义异常

      自定义异常：自己定义的异常类，API中的标准异常类的直接或间接的子类
      作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

  自定义异常类：

       基本语法：

  //自定义异常类：
       //基本语法：
      public class 异常类名 extends Exception/RuntimeException{
             public 异常类名(String msg){
                     super(msg);
             }
      }

  自定义异常类中只重载需要使用的构造方法
  继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或throws抛出

public class ScoreException extends Exception{
    //根据业务需要，开发自定义异常类
    public ScoreException(){
        super();
    }
    public ScoreException(String message){
        super(message);
    }
}

public class Demo06 {
    public static void main(String[] args) {
        try{
            test(101);
        }catch (ScoreException e){
            System.out.println(e.getMessage());
        }
    }
    public static char test(int score) throws ScoreException {
        if(score<0 || score>100){
            //不合法分数，没必要向下继续执行，此处可以使用throw直接在方法中抛出一个异常对象
            throw new ScoreException("不合法的分数");
        }
        if(score>=90){
            return 'A';
        }else{
            return 'B';
        }
    }
}

public abstract class P {
    abstract void test1() throws UnsupportedEncodingException;
    public abstract void test2() throws IOException;
    public abstract void test3() throws NullPointerException;
}

public class C extends P{
    /*
      方法重写：
         方法名相同
         参数列表相同
         返回值类型相同
         访问权限等于，大于父类声明的权限
         声明的异常类型等于或小于父类的声明类型
     */
    @Override
    public void test1() throws UnsupportedEncodingException {
    }
    @Override
    public void test2() throws IOException {
    }
    @Override
    public void test3() throws NullPointerException {
    }
}