异常

醺默？

于 2020-11-26 20:44:25 发布

阅读量137

点赞数

本文链接：https://blog.csdn.net/ZJ_1011487813/article/details/110204123

版权

异常

Java异常概念

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

运行时,由于各种原因导致程序不能正常执行

Java程序在执行过程中所发生的异常事件可分为两类：

Error: Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。

对于这些异常，一般有两种解决方法：一是遇到异常就终止程序的运行。另一种方法是由程序员在编写程序时，就考虑到异常的检测、异常消息的提示，以及异常的处理。

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

比如：除数为0，数组下标越界等分类：编译时异常和运行时异常

package day;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Demo1 {
    public static void main(String[] args) {
       /*
        当内存不够用时 或抛出异常，程序控制不了，称为错误（Error）
        List list=new ArrayList();
        while (true){
            list.add(new Random());
        }*/
        /*
        异常：
         */
        //数组下标越界
        /*int [] a=new int[3];
        a[3]=1;*/

        /*                           异常类型                                   原因
         Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
        at day.Demo1.main(Demo1.java:20) 异常位置
        */

        /*
          算数异常
         */
       /* int w=10;
        int b=0;
        System.out.println(w/b);*/

        /*
        类类型转换异常
         */
        /*String s="acs";
        Object obj=s;
        if(obj instanceof Integer){
            Integer i=(Integer)obj;
        }*/


        /*
        数字格式化异常：NumberFormatException

         */
        //int i=Integer.parseInt("as");

        /*
        空指针异常：
         */
        String s=null;
        s.length();

    }
}

异常的体系

Throwable类有两个直接子类：Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。Exception表示异常，是所有异常类的父类，是程序员所关心的。

在这里插入图片描述

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

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

数学异常

空指针异常

数组下标越界

……

编译期异常(Checked Exception)：除去运行期的异常都是编译期异常，也称为检测异常

IOException

SQLException

ParseException

……

异常处理

Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws

jvm 默认的异常在控制台抛出对应类型的异常类对象（异常信息）；终止程序运行

也可以使用异常处理机制处理
try{
写的时可能出现异常的代码代码尽可能缩小范围
}catch（异常类型）{
当try中出现异常执行catch中的语句
}

package day;

public class Demo3 {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 2;
            System.out.println(a / b);

            String c = "null";
            c.length();

            Integer.parseInt("zxz");

        } catch (ArithmeticException s) {
            System.out.println("算数异常");
        } catch (NullPointerException da) {     //catch（）中如果没有try{}中的异常类型   jvm也会停止运行
            System.out.println("空指针");
        }catch (Exception as){    //不知道异常类型时  一般可以直接用Exception（范围较大）来表示异常类型
            System.out.println(as.getMessage());
            as.printStackTrace();

        }
        System.out.println("assssssssssssssassssssss");
    }
}

try

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

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

catch

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

catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

finally

finally语句块是处理异常机制中必须执行的语句块

package day;

public class Demo4 {
    public static void main(String[] args) {
        /*try {
            int a = 10;
            int b = 0;
            System.out.println(a / b);



        } catch (Exception as){    //不知道异常类型时  一般可以直接用Exception（范围较大）来表示异常类型
            System.out.println("系统忙");
        }finally {
            System.out.println("1322222223333333");

            无论是否出现异常  最终都会执行
        }
        System.out.println("assssssssssssssassssssss");*/
        //System.out.println(text());
        System.out.println(text1());
    }
    public static int text(){
        try {
            int a = 10;
            int b = 2;
            System.out.println(a / b);

        } catch (Exception as){    //不知道异常类型时  一般可以直接用Exception（范围较大）来表示异常类型
            System.out.println("系统忙");
            return 0;     //状态码
        }finally {
            System.out.println("1322222223333333");
            return 2;   //finally中如果有return  最终返回finally中的
        }

       /* System.out.println("assssssssssssssassssssss");
        return 1;*/
    }
    public static int text1(){
        try {
            int a = 10;
            int b = 0;
            System.out.println(a / b);  //此处发生异常  并没有catch处理 但是会执行finally{} 后续代码不会执行
        }finally {
            System.out.println("qqqqqqqqqqq");
        }
        System.out.println("6666666");
        return 1;
    }
    }

throws和throw

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

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

•子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常。

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

package day;

import java.io.UnsupportedEncodingException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class ThrowsDemo {
    public static void main(String[] args) {
        /*
        printStackTrace 是编译期异常  在编写时就提示我们需要进行处理
        SimpleDateFormat sdf=new SimpleDateFormat();
        try {
            sdf.parse("2010-12-30") ;
        } catch (ParseException e) {
            e.printStackTrace();
        }*/
        /*try {
            byte [] b="assa".getBytes("utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }*/
        try{
            chu(10,0);
        }catch (ArithmeticException a){
            System.out.println("算数异常");
        }

        System.out.println("主线程后面的代码 可以继续执行");

        try {
            te();   //在顶级的调用处  就需要try catch处理
        } catch (ParseException e) {
            e.printStackTrace();
            System.out.println("系统忙");
        }

    }
    /**
     * 除法运算：  声明此方法可能会出现   算数异常
     * @param a  声明的如果是运行时异常，调用时可以不处理
     * @param b
     * @return
     * @throws ArithmeticException
     */
    public static int chu(int a ,int b)throws ArithmeticException{
        return a/b;
    }
    public static void te()throws ParseException{
        System.out.println("ass");
        System.out.println("ass");
        System.out.println("ass");
    }

}

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

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

语法：throw throw new 异常类构造方法

package day;

public class ThrowDemo  {
    public static void main(String[] args) {
        /*
        throws
           作为在方法的声明，此方法可能会出现异常
           throws  后面声明多个异常类型，多为编译期异常

        throw
             在方法中主动抛出异常对象，相当于程序出现异常情况，后面的程序不执行
             在不满足条件的情况下以抛出异常的形式  告诉调用处

        自定义异常
            由于java中封装的异常类都是与语法相关

         */
        try {
            text(101);
        }catch (ScoreException q){
            q.printStackTrace();
            System.out.println(q.getMessage());
        }
    }
    public static int text(int s) throws ScoreException{
        if(s<0 || s>100){
            //throw new RuntimeException("分数不合法");  //在程序中主动抛出异常对象，在构造方法中可以传入异常原因
            throw  new ScoreException("分数不合法");
        }
        return s;
    }
}

throws与throw的区别

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

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

抽象方法也可以使用throws

自定义异常

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

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

基本语法：

public class 异常类名 extends Exception/RuntimeException{

public 异常类名(String msg){

super(msg);

}

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

异常