异常概述

最新推荐文章于 2022-10-19 20:48:04 发布
最新推荐文章于 2022-10-19 20:48:04 发布
阅读量525 收藏
点赞数 1
分类专栏： Java进阶 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46502538/article/details/119540480
版权

一、异常

1.1 异常概念

异常：是指由于各种不期而至的情况，导致程序中断运行的一种指令流，如：文件找不到、非法参数、网络超时等。
异常也是一种对象，java当中定义了许多异常类，并且定义了基类java.lang.Throwable作为所有异常的超类。

异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行。

1.2 异常体系

Java语言设计者将异常划分为两类：Error和Exception，其体系结构大致如下图所示：
异常体系

Throwable 体系：
Throwable 有两个重要的子类：Exception（异常）和Error（错误），两者都包含了大量的异常处理类。

  • Error：是程序中无法处理的错误，表示运行应用程序中出现了严重的错误。此类错误一般表示代码运行时JVM出现问题。通常有Virtual MachineError（虚拟机运行错误）、NoClassDefFoundError（类定义错误）等。比如说当jvm耗完可用内存时，将出现OutOfMemoryError。此类错误发生时，JVM将终止线程。
    这些错误是不可查的，非代码性错误。因此，当此类错误发生时，应用不应该去处理此类错误。
  • Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

1.3 异常分类

我们平常说的异常就是指 Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类：根据在编译时期还是运行时期去检查异常?

  • 编译异常(受检异常)：Exception中除 RuntimeException 极其子类之外的异常。如果程序中出现此类异常，比如说 IOException，必须对该异常进行处理，否则编译不通过。在程序中，通常不会自定义该类异常，而是直接使用系统提供的异常类。
  • 运行时异常(不受检异常)：RuntimeException 类极其子类表示JVM在运行期间可能出现的错误。比如说试图使用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理。

异常的分类

二、异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

2.1 抛出异常 throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

  1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。

  2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

    throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数);

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

注意：

  1. throw关键字必须写在方法的内部

  2. throw关键字后边new的对象必须是 Exception 或者 Exception 的子类对象

  3. throw关键字抛出指定的异常对象,我们就必须处理这个异常对象

    • throw关键字后边创建的是 RuntimeException 或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
    • throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try…catch

下面程序演示下throw的使用。

public class Demo03Throw {
    public static void main(String[] args) {
        //int[] arr = null;
        int[] arr = new int[3];
        int e = getElement(arr,3);
        System.out.println(e);
    }
    /*
        定义一个方法,获取数组指定索引处的元素
        参数:
            int[] arr
            int index
        以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验
        如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
        注意:
            NullPointerException 是一个运行期异常,我们不用处理,默认交给JVM处理
            ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理
     */
    public static int getElement(int[] arr,int index){
        /*
            我们可以对传递过来的参数数组,进行合法性校验
            如果数组arr的值是null
            那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
         */
        if(arr == null){
            throw new NullPointerException("传递的数组的值是null");
        }

        /*
            我们可以对传递过来的参数index进行合法性校验
            如果index的范围不在数组的索引范围内
            那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
         */
        if(index<0 || index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }

        int ele = arr[index];
        return ele;
    }
}

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续讲问题声明出去，使用throws声明处理。

2.2 声明异常 throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过 throw 抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理(自己不处理,给别人处理)，最终交给JVM处理–>中断处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

修饰符 返回值类型 方法名(参数列表) throws 异常类名1,异常类名2…{   }

注意:

  1. throws关键字必须写在方法声明处
  2. throws关键字后边声明的异常必须是Exception或者是Exception的子类
  3. 方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常类，用逗号隔开
    如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
  4. 调用了一个声明抛出异常的方法,我们就必须的处理声明的异常
    要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
    要么try…catch自己处理异常

声明异常的代码演示：

public class Demo05Throws {
    /*
        FileNotFoundException extends IOException extends Excepiton
        如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
     */
    //public static void main(String[] args) throws FileNotFoundException,IOException {
    //public static void main(String[] args) throws IOException {
    public static void main(String[] args) throws Exception {
        readFile("c:\\a.tx");
    }

    /*
        定义一个方法,对传递的文件路径进行合法性判断
        如果路径不是"c:\\a.txt",那么我们就抛出文件找不到异常对象,告知方法的调用者
        注意:
            FileNotFoundException是编译异常,抛出了编译异常,就必须处理这个异常
            可以使用throws继续声明抛出FileNotFoundException这个异常对象,让方法的调用者处理
     */
    public static void readFile(String fileName) throws FileNotFoundException,IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
        }

        /*
            如果传递的路径,不是.txt结尾
            那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对

         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("路径没有问题,读取文件");
    }
}

2.4 捕获异常 try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

  1. 该方法不处理，而是声明抛出，由该方法的调用者来处理(throws)。
  2. 在方法中使用 try-catch 的语句块来处理异常。

try-catch的方式就是 捕获异常。

  • 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
 ...
 catch(异常类名 变量名){

}

try ：该代码块中编写可能产生异常的代码。

catch ：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意：

  1. try和catch都不能单独使用，必须连用。
  2. try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
  3. 如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码
  4. 如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try…catch之后的代码

演示如下：

public class TryCatchDemo {
    public static void main(String[] args) {
        try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。
            read("b.txt");
        } catch (FileNotFoundException e) {
          	//try中抛出的是什么异常，在括号中就定义什么异常类型
            System.out.println(e);
        }
        System.out.println("over");
    }
   
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            throw new FileNotFoundException("文件不存在");
        }
    }
}

2.4 获取异常信息

Throwable 类中定义了一些查看方法:

  • public String getMessage()：获取异常的简短描述信息，原因(提示给用户的时候,就提示错误原因。

  • public String toString()：获取异常的类型和异常详细描述信息(一般不用)。

  • public void printStackTrace()：打印异常的跟踪栈信息并输出到控制台。默认此方法，打印的异常信息是最全面的 包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段,都得使用printStackTrace。

2.5 finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法:

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
 ...
 catch(异常类名 变量名){

}finally{
     无论是否出现异常都会执行
}

注意：

  1. finally不能单独使用，必须和try一起使用
  2. finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)

finally代码参考如下：

public class Demo02TryCatchFinally {
    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            readFile("c:\\a.tx");
        } catch (IOException e) {
            //异常的处理逻辑
            e.printStackTrace();
        } finally {
            //无论是否出现异常,都会执行
            System.out.println("资源释放");
        }
    }

    /*
       如果传递的路径,不是.txt结尾
       那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对

    */
    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }

        System.out.println("路径没有问题,读取文件");
    }
}

当只有在try或者catch中调用退出JVM的相关方法,此时 finally 才不会执行,否则 finally 永远会执行。

2.6 异常注意事项

多个异常使用捕获处理

  1. 多个异常分别处理。

    public class Demo01Exception {
    public static void main(String[] args) { 
        try {
            int[] arr = {1,2,3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }

        try{
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }
    }
}

  2. 多个异常一次捕获，多次处理。

    一般我们是使用一次捕获多次处理方式，格式如下：

    try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

    程序演示如下：

    public class Demo01Exception {
    public static void main(String[] args) { 
   	  try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }

        /*
            一个try多个catch注意事项:
                catch里边定义的异常变量,如果有子父类关系,那么子类的异常变量必须写在上边,否则就会报错
                ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
         */
       /* try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }catch (ArrayIndexOutOfBoundsException e){ // 此处编译报错
            System.out.println(e);
        }*/
    }
}

    注意：这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常必须在上面的catch处理，父类异常在下面的catch处理。

  3. 多个异常一次捕获一次处理。

    public class Demo01Exception {
    public static void main(String[] args) { 
   	  try {
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
        }catch (Exception e){
            System.out.println(e);
        }	
    }
}

运行时异常被抛出可以不处理。

即不捕获也不声明抛出。

public class Demo01Exception {
    public static void main(String[] args) {
       //默认给虚拟机处理,终止程序,什么时候不抛出运行时异常了,在来继续执行程序
        int[] arr = {1,2,3};
        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        List<Integer> list = List.of(1, 2, 3);
        System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
    } 
}

如果finally有return语句，永远返回finally中的结果，避免该情况。

public class Demo02Exception {
    public static void main(String[] args) {
        int a = getA();
        System.out.println(a);
    }

    //定义一个方法,返回变量a的值
    public static int getA(){
        int a = 10;
        try{
            return a;
        }catch (Exception e){
            System.out.println(e);
        }finally {
            //一定会执行的代码
            a = 100;
            return a;
        }
    }
}
输出结果：
    100

子父类的异常

  • 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
  • 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

注意:
    父类异常时什么样,子类异常就什么样

public class Fu {
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
 
    public void show04() {}
}

class Zi extends Fu{
    //子类重写父类方法时,抛出和父类相同的异常
    @Override
    public void show01() throws NullPointerException,ClassCastException{}
    //子类重写父类方法时,抛出父类异常的子类
    @Override
    public void show02() throws ArrayIndexOutOfBoundsException{}
    //子类重写父类方法时,不抛出异常
    @Override
    public void show03() {}

    /*
        父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。

     */
    //public void show04() throws Exception{}

    //此时子类产生该异常，只能捕获处理，不能声明抛出
    @Override
    public void show04()  {
        try {
            throw  new Exception("编译期异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.7 异常注意事项总结

  1. 子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。
  2. 如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常。
  3. 如果被重写的方法没有抛出异常，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws。
  4. 建议不要在finally中使用return，不用尝试通过catch来控制代码流程。

三、自定义异常

3.1 概述

为什么需要自定义异常类:

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类。

格式 :

public class XXXExcepiton extends Exception | RuntimeException{
            添加一个空参数的构造方法
            添加一个带异常信息的构造方法       
}

注意:

  1. 自定义异常类一般都是以 Exception 结尾，说明该类是一个异常类
  2. 自定义异常类,必须的继承 Exception 或者 RuntimeException
    • 继承 Exception :那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这个异常，要么throws，要么try…catch
    • 继承 RuntimeException :那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理(中断处理)

3.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先自定义一个登陆异常类 RegisterException：

// 业务逻辑异常
public class RegisterException extends /*Exception*/ RuntimeException{
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

public class Demo01RegisterException {
    // 1.使用数组保存已经注册过的用户名(数据库)
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名:");
        String username = sc.next();
        checkUsername(username);

    }

    //3.定义一个方法,对用户输入的中注册的用户名进行判断
    public static void checkUsername(String username) /*throws RegisterException*/ {
        //遍历存储已经注册过用户名的数组,获取每一个用户名
        for (String name : usernames) {
            //使用获取到的用户名和用户输入的用户名比较
            if(name.equals(username)){
                //true:用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
                /*try {
                    throw new RegisterException("亲，该用户名已经被注册");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return; //结束方法
                }*/
                throw new RegisterException("亲，该用户名已经被注册");//抛出运行期异常，无需处理，交给JVM处理，中断处理。
            }
        }

        //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
        System.out.println("恭喜您,注册成功!");
    }
}

四、异常的使用

  • 原则：
    如果该功能内部可以将问题处理，用 try，否则交由调用者处理，这时用throws。
  • 区别：
1. 后续程序需要继续运行就 `try`。
2. 后续程序不需要继续运行就 `throws`。
3. 如果JDK没有提供对应的异常，需要自定义异常类。
江七7
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
异常处理
君越轻寒的博客
07-28 167
1.异常概述 异常的类型：Error（致命的）,Exception（非致命的）以及必检和免检异常。 异常就是一种对象，表示阻止正常进行程序执行的错误或者情况。 异常是从方法中抛出的。方法的调用者可以捕获以及处理该异常。 一个简单的例子： package exception; import java.util.Scanner; public class QuotientWithIf { public...
day14-异常
qq_43635902的博客
02-13 343
异常 异常也是一个对象 1. 异常的目的: 提高程序的容错性 容错性不能太高也不能太低 open('hehe.txt') # FileNotFoundError: [Errno 2] No such file or directory: 'hehe.txt' 常见的异常 1. TypeError:类型异常,注释清楚变量的类型 2. ValueError:值异常 3. SyntaxError:语法错误 4. IndexError:索引错误 5. KeyError:键异常 6. Attribu
Java面试02——详解异常处理及常见的面试题
南国的技术栈
01-31 1148
前言 这篇文章，南国想写一篇关于异常处理的文章，关于异常处理在日常学习中经常遇到。在IT互联网公司的面试中，如果你想从事java开发相关的工作 或者简历有写最擅长的编程语言是java时，这也是一道高频次的出题。 话不多说，干货送上。。 异常 异常指不期而至的各种状况，如：文件找不到、网络连接失败、除0操作、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。 Java语言在设计...
异常
慕北丶
01-26 149
异常的概念: 程序出现了不正常的情况 异常本质就是Java当中对可能出现的问题进行描述的一种对象体现。 简单来说:异常本质就是异常描述的对象体现 异常的分类： 异常(Exception) 编译时异常 (受检异常): 在程序的编译时期就出问题,这个是可以提前处理的 不是继承自RuntimeException的Exception的子类都成为编译时期异常。 运行时异常 (非受检异常): 在程序运行时...
26、Java面向对象——异常
CSDN_Loveletter的博客
10-19 915
一、异常 1、异常的含义 二、Throwable类 三、 Error类和Exceptio类 1、Error类 2、Exception类 3、RuntimeException类 4、异常体系 四、异常处理机制 1、Jvm的默认处理方案 2、使用try-catch处理异常 3、Throwable中的成员方法 4、使用try-catch-finally处理异常 5、使用throws声明异常 6、使用throw手动抛出异常 7、 自定义异常 五、常见异常类
exception_tracker:用于获取log4j异常概述的服务
05-19
【标题】"exception_tracker:获取log4j异常概述的服务"是一个专门为Java开发的工具，它的主要功能是收集和分析来自不同项目中log4j-appender的异常信息。这个项目目前正处于早期开发阶段，这意味着它可能还不完全...
计算机后端-Java-Java核心基础-第17章 异常处理 06. 异常概述.avi
05-22
计算机后端-Java-Java核心基础-第17章 异常处理 06. 异常概述.avi
Java异常处理-异常处理概述与常见异常举例
最新发布
01-09
Java异常处理是编程中必不可少的部分，用于处理程序运行时可能出现的错误情况。异常是程序执行过程中遇到的非正常状态，可能导致程序中断。Java提供了强大的异常处理机制来确保程序的健壮性和稳定性。 1- 什么是...
C++异常机制概述1
08-08
C++异常处理是编程中处理错误和异常情况的关键机制，它允许程序员在程序运行时捕获和处理非正常状态。异常处理的核心概念包括`try`、`catch`和`throw`关键字。 首先，`try`块是异常处理的起点，它包围了可能会抛出...
异常底层详解
01-29
掌握异常概述 理解异常的基础操作以及最简单的捕获处理 理解多异常捕获处理 理解声明抛出异常 掌握自定义异常 掌握异常处理注意事项 第1章 异常 什么是异常？Java代码在运行时期发生的问题就是异常。 在Java中，把...
异常的基本概念
月与清酒的博客
12-14 1847
1.异常的定义 2.常见的异常 3.异常的处理方式 4.自定义异常
异常的概述
qq_37753562的博客
12-27 88
/* 1、什么是异常，java提供异常处理机制有什么用？ 以下程序执行过程中发生了不正常的情况，而这种不正常的情况叫做：异常 java语言是很完善的语言，提供了异常的处理方式，以下程序执行过程中出现了不正常情况， java把该异常信息打印输出到控制台，供程序员参考。程序员看到异常信息之后，可以对 程序进行修改，让程序更加的健壮。 什么是异常：程序执行过程中的不正常情况。 异常的作用：增强程序的健壮性。 2、以下程序执行控制台出现了： Excepti...
异常（Exception）的概念
Caiaixiong的博客
12-17 690
异常指程序运行过程中出现的非正常现象，例如用户输入错误、除数为0、需要处理的文件不存在、数组下标越界等。 在Java的异常处理机制中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义中包含了该类异常的信息和对异常处理的方法。 所谓异常处理，就是指程序在出现问题时依然可以正确的执行完。 Java是采用面向对象的方式来处理异常的。处理过程: 抛出异常：在执行一个方法时，如果发生异常，则这个方...
异常（概念）
qq_32486015的博客
03-10 226
了解异常的概念，分类，处理方式。纯理论 异常：父类：Throwable,下面的子类分为：error 和exception * error:不可控制的，是系统错误，不需要我们管。 * exception:是程序员导致的错误，应由程序员及时处理。分为编译时（检查时）异常和运行时异常 * 编译时异常，编译器会自己检查代码是否错误，处理方式有两种：1，使用try/catch捕获，...
【异常的基本概念】_异常的基本概念笔记
牛儿吃草的博客
01-09 656
【异常的基本概念】_异常的基本概念笔记 了解异常的基本概念 掌握异常的基本处理格式 掌握异常类的继承结构 掌握java的异常处理机制 异常： 异常是导致程序中断运行的一种指令流.如果不对异常进行正确的处理,则可能导致程序的中断执行，造成不必要的损失。 3.1为什么需要异常处理？ public class ExceptionDemo01{ public s
Java异常对象
weixin_44371237的博客
12-07 425
Error和Exception区分： Error是编译时错误和系统错误，系统错误在除特殊情况下，都不需要你来关心，基本不会出现。而编译时错误，如果你使用了编译器，那么编译器会提示。 Exception则是可以被抛出的基本类型，我们需要主要关心的也是这个类。 Exception又分为RunTimeException和其他Exception。 RunTimeException和其他Exception区分： 其他Exception，受检查异常。可以理解为错误，必须要开发者解决以后才能编译通过，解决的方法有两种，.
Java异常练习题（带答案）
xinghuo0007的博客
06-27 6832
ps：案例来源于毕向东老师Java基础教程大家可以从我的资源库里面下载：
java web 中几种异常处理
u010926082的专栏
07-20 1212
全局异常映射：        局部异常映射:            exception： 异常类型 result：指定Action出现该异常时,系统转入result属性所指向的结果。  异常信息的输出： 输出异常对象本身。 输出异常对象的信息。 输出异常对象本身。   1.业务异常类      1.所以业务异常类派生于BusinessException基类。
详述一下爬虫异常总体概述
06-07
爬虫异常是指在爬虫程序执行过程中可能会出现的各种异常情况，包括但不限于以下几种： 1. 网络异常：比如访问目标网站时出现网络连接超时、DNS解析失败等情况。 2. 页面解析异常：比如目标网站的页面结构发生了变化，导致爬虫无法正常解析页面信息。 3. 频率限制异常：有些网站会对频繁访问的IP地址进行限制，比如设置验证码、返回空白页面等。 4. 数据处理异常：比如爬虫程序在处理数据时出现错误，导致数据无法正常存储或处理。 5. IP被封禁：由于一些网站设置了反爬虫机制，如果爬虫程序频繁访问同一IP地址，可能会导致该IP地址被封禁，进而导致爬虫无法正常运行。 6. 其他异常：比如程序逻辑错误、内存溢出、线程异常等。 在爬虫程序开发过程中，需要对这些异常情况进行充分考虑，并编写相应的异常处理机制，以确保程序的稳定性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江七7

感谢大佬的赏赐

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值