异常的介绍

最新推荐文章于 2024-08-20 18:14:32 发布
最新推荐文章于 2024-08-20 18:14:32 发布
阅读量976 收藏 3
点赞数
分类专栏： JavaSe 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/120306722
版权

异常

  • 概念：在程序运行过程中出现的一种意外的情况，而非编译错误。

1 异常的分类

  • 比如：
    1. Throwable：所有异常的父类。
2. Error：Throwable子类，表示错误，JVM崩溃,硬件出现问题或与操作系统相关的问题;特点：无法避免，无法处理。
3. Exception:Throwable子类，表示异常，编译时异常或已检查异常。
4. RuntimeException：Exception子类，表示异常，运行时异常或未检查异常。
    Exception所有的子类都是已检查异常，编译时异常。
    是一种程序的已知异常，必须手动处理予以解决方案，否则编译错误。
特点：无法避免，必须处理。
    RuntimeException所有的子类都是未检查异常，运行时异常。
    是一种因为程序员不好好检查出现的异常，可以提供解决方案也可以不提供，编译器不干预。
特点：可以避免，可处理可不处理。

2 异常的产生方式

2.1 自动抛出异常
  • 写程序时不严谨，不好好检查，用错误的使用方式自动出现的异常。
    演示：数组下标越界异常。
    String str = "ABC";
char[] cs = str.toCharArray();
System.out.println( cs[3] );
2.2 手动抛出异常
  • 语法如下：
    throw 异常对象;
    演示：
    NullPointerException npe = new NullPointerException();
throw npe;

throw new NullPointerException();
throw new NullPointerException("自定义异常描述信息");
2.3 异常对程序的影响
  • 程序会因为异常的出现而终止。
  • 异常传递过程：
    类似于方法的返回值，将异常对象沿着方法调用链逐层返回。
    演示的代码如下：
package com.txw.test;

public class TestException {
    public static void main(String[] args) {
        System.out.println("main---start");
        m1( 0 );
        System.out.println("main---end");

    }
    public static void m1(int n){
        System.out.println("m1---start");
        // 异常对象
        // NullPointerException npe = new NullPointerException();
        // if(n==0) throw npe;
        m2( n );
        System.out.println("m1---end");
    }
    public static void m2(int n){
        System.out.println("m2---start");
        if(n==0)throw new NullPointerException("空指针异常");
        System.out.println("m2---end");
    }
}

3 异常的处理方式【重点】

3.1 声明抛出【消极处理】
  • 语法：在出现已检查的方法中添加声明抛出。
    访问权限修饰符 返回值类型 方法名(参数表) throws 异常,异常2...{
    
}
    声明抛出对程序的影响：自己不处理谁调用谁处理。
    演示：
    public static void main(String[] args) throws Exception{
        System.out.println("main---start");
        m1( 2 );
        System.out.println("main---end");

    }

    public static void m1(int n)throws IOException,SQLException {
        System.out.println("m1---start");
        m2( n );
        System.out.println("m1---end");
    }
    public static void m2(int n)throws EOFException,FileNotFoundException,SQLException{
        System.out.println("m2---start");
        if(n==0)throw new NullPointerException("空指针异常");
        if(n==1)throw new EOFException();
        if(n==2)throw new FileNotFoundException();
        if(n==3)throw new SQLException();
        System.out.println("m2---end");
    }
    可以声明抛出父类异常处理所有子类异常（多态）。
    演示的代码如下：
package com.txw.test;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
public class TestThrows {
    public static void main(String[] args) throws Exception{
        System.out.println("main---start");
        m1( 2 );
        System.out.println("main---end");
    }
    public static void m1(int n)throws IOException,SQLException {
        System.out.println("m1---start");
        m2( n );
        System.out.println("m1---end");
    }
    public static void m2(int n)throws EOFException,FileNotFoundException,SQLException{
        System.out.println("m2---start");
        if(n==0)throw new NullPointerException("空指针异常");
        if(n==1)throw new EOFException();
        if(n==2)throw new FileNotFoundException();
        if(n==3)throw new SQLException();
        System.out.println("m2---end");
    }
}
3.2 捕获处理【积极处理】
  • 当方法中出现异常时，可以捕获异常对象，跳转到专门用于处理异常的代码块中，处理完毕后程序由异常自动转换为正常，程序不会因为异常的产生而意外终止，可以配合throws一起使用。
  • 语法如下：
    try{
    // 可能出现异常的代码
    // 用于捕获异常
}catch(声明处理的异常1 | 声明处理异常2 e){
    [可选]e.printStackTrace();		// 打印异常栈信息（异常来源）
    [可选]String message = e.getMessage();	// 打印描述信息
         System.out.println(message);
    [可选]throw e;		// 再次声明抛出异常
    
}catch(声明处理的异常 e){
    
}...finally{
    // 无论是否有异常产生，必定执行
    // 通常用于释放（关闭）资源
}
    演示的代码如下：
package com.txw.test;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.sql.SQLException;
import java.util.zip.DataFormatException;
public class TestTryCatch2 {
    public static void main(String[] args) {
        try {
            m1(1);
        }catch(SQLException e){

        }catch(Exception e){

        }
    }

    public static void m1(int n) throws SQLException,DataFormatException{		// 耳鼻喉科
        try {
            System.out.println("m1------1");
            m2( n );
            System.out.println("m1------2");
        }catch(FileNotFoundException | EOFException e) {
            e.printStackTrace();
        }
            /*catch(IOException e){
            //  可以处理IOException或任意子类异常
        }*/
        System.out.println("m1------3");
    }
    public static void m2(int n)throws EOFException,FileNotFoundException,SQLException,DataFormatException{
        System.out.println("m2---start");
        if(n==0)throw new NullPointerException("空指针异常");
        if(n==1)throw new EOFException("文件已读完！！！！");	// 打喷嚏
        if(n==2)throw new FileNotFoundException();		// 嗓子疼
        if(n==3)throw new SQLException();				// 牙疼
        if(n==4)throw new DataFormatException();		// 头疼
        System.out.println("m2---end");
    }
}

可以声明处理父类异常，当需要多个catch时，遵循从子到父的顺序。
演示的代码如下：

package com.txw.test;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.sql.SQLException;
public class TestTryCatch1 {
    public static void main(String[] args) {
        System.out.println("main---start");
        m1( 1 );
        System.out.println("main---end");
    }
    public static void m1(int n) {
        try {
            // 捕获异常对象，为catch中异常引用赋值
            System.out.println("m1---start");
            m2(n);
        }catch(EOFException e){
            // 出现EOFException时执行
            // System.out.println("catch EOFException");
            // e.printStackTrace();			// 打印异常信息
            String message = e.getMessage();
            System.out.println(message);
        }catch(FileNotFoundException e){
            // System.out.println("catch FileNotFoundException");
        }catch(SQLException e){
            // System.out.println("catch SQLException");
        }
        System.out.println("m1---end");
    }
    public static void m2(int n)throws EOFException,FileNotFoundException,SQLException{
        System.out.println("m2---start");
        if(n==0)throw new NullPointerException("空指针异常");
        if(n==1)throw new EOFException("文件已读完！！！！");
        if(n==2)throw new FileNotFoundException();
        if(n==3)throw new SQLException();
        System.out.println("m2---end");
    }
}

演示：

try {
          
}catch(SQLException e){

}catch(Exception e){

}

注意：try框中的代码不一定执行，当方法需要返回值时，return语句尽量写在外层。

try{
	1. 登录输入卡号密码
	2. 输入转账金额
	3. 验证余额
	4. 从原账户扣款 -2000 出现异常
	5. 为对方账户增加余额
}catch(Exception e){
	原账户余额 +2000
}finally{
	退卡
}
  • 常见的try-catch结构。
    1. try{ }catch(Exception e){ }
2. try{ }catch(Exception e){ }finally{   }
3. try{ }finally{  }
    如果finally代码框中有return语句，那么将作为该方法最终结果返回。
    关于异常：一般情况下程序员不会手动抛出异常，因为代价太大，通常情况都是在处理由框架或其他类抛出的已检查异常。
    演示的代码如下：
package com.txw.test;

import java.io.EOFException;
import java.sql.SQLException;
public class TestTryCatchFinally {
    public static void main(String[] args)throws SQLException{
        System.out.println("main---start");
        m1( 2 );
        System.out.println("main---end");
    }

    public static void m1(int n) throws SQLException{
        try {
            System.out.println("m1---1");
            m2(n);
            System.out.println("m1---2");
        }catch(EOFException e){
            e.printStackTrace();
        }finally{
            System.out.println(" finally {   }");
        }
        System.out.println("m1---3");
    }
    public static void m2(int n)throws EOFException,SQLException{
        System.out.println("m2---start");
        if(n==0)throw new NullPointerException("空指针异常");
        if(n==1)throw new EOFException();
        if(n==2)throw new SQLException();
        System.out.println("m2---end");
    }
}

4 自定义异常

  • 自定义已检查异常。
    // 继承Exception
class MyException1 extends Exception{
    public MyException1(){}
    public MyException1(String message){
        super(message);			// 使用父类构造方法，添加描述信息
    }
}
// 抛出异常
throw new MyException1("自定义已检查异常");
  • 自定义未检查异常[推荐]。
    // 继承RuntimeException
class MyException2 extends RuntimeException{
   public MyException2(){}
    public MyException2(String message){
        super(message);		// 使用父类构造方法，添加描述信息
    } 
}
// 抛出异常
throw new MyException2("自定义已检查异常");

演示的代码如下：

package com.txw.test;

public class TestMyException {
    public static void main(String[] args) throws MyException1{
        m1(2);
    }
    public static void m1(int n)throws MyException1{
        if(n==1)throw new MyException1("自定义已检查异常");			// 抛出自定义已检查异常
        if(n==2)throw new MyException2("自定义未检查异常");
    }
}
// 自定义已检查异常
class MyException1 extends Exception{
    public MyException1(){}
    public MyException1(String message){
        super(message);		// 使用父类构造方法
    }
}
// 自定义未检查异常
class MyException2 extends RuntimeException{
    public MyException2(){}
    public MyException2(String message){
        super(message);
    }
}

5 方法覆盖的语法要求

  • 语法要求：
    访问权限修饰符相同或更宽，返回值类型、方法名、参数表与父类一致。
不能比父类抛出更宽泛的异常。
    演示的代码如下：
    class Super{
    public void m1()throws IOException {}
}
class Sub extends Super{
    @Override
    public void m1()throws FileNotFoundException, EOFException {}
    // 虽然m1方法抛出的异常数量多，但是都是IOException的子类，并没有比父类方法抛出的异常更宽泛
}
  • 面试问题
    1. final、finally、finalize三个的区别
final 是修饰符
finally 是代码块
finalize 是Object类中的一个方法
    演示的代码如下：
package com.txw.test;

import java.io.EOFException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestOverride {
    public static void main(String[] args){
        // 可以表示计算机中的一个文件
        try {
            File f = new File("D:/abc.txt");
            f.createNewFile();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Super{
    public void m1()throws IOException {}
}

class Sub extends Super{
    @Override
    public void m1()throws FileNotFoundException, EOFException {}
}

package com.txw.test;

public class TestReturnResult {
    public static void main(String[] args) {
        System.out.println(method());
    }
    public static int method(){
        // 返回值通常都声明在try框外
        int count = 0;
        try {
            // 定义计数变量
            for (int i = 1; i <= 999; i++) {
                if(i%2==0)count++;
            }
            return 1;
        }catch(Exception e){
            e.printStackTrace();
            return 2;
        }finally{
            return 2000;
        }
    }
}

习题

1.Java 中所有的错误都继承自 Throwable 类；在该类的子类中，Error 类表示严重的底层错误，对于这类错误，程 序代码不可处理；Exception 表示例外、异常。
2. 查阅 API，完成以下填空：
(1) 异常类 java.rmi.AlreadyBoundException，从分类上说，该类属于已检（已检查|运行时）异常， 从处理方式上说，对这种异常必须处理。
(2) 异常类 java.util.regex.PatternSyntaxException，从分类上说，该类属于|运行时（已检查|运行时） 异常，从处理方式上说，对这种异常可以处理也可以不处理。
3. Java 中用来抛出异常的关键字是( C )。
A. try
B. catch
C. throw
D. finally
4. 在异常处理中，释放资源、关闭文件等应由____处理(C ) 。
A. try 语句
B. catch 语句
C. finally 语句
D. throw 语句
5. finally 语句块中的代码(A) 。
A. 总是被执行
B. 当 try 语句块后面没有 catch 时，finally 中的代码才会被执行
C. 异常发生时才被执行
D. 异常没有发生时才被执行
6. 自定义异常类时，可以继承的类是(C )
A. Error
B. ArrayList
C. Exception
D. NullPointerException
7. 对于 try{ … }catch…语句的排列方式，下列描述正确的是(A )。
A. 子类异常在前，父类异常在后
B. 父类异常在前，子类异常在后
C. 只能有子类异常
D. 父类异常不能与子类异常同时出现
8. 仔细阅读以下代码，将代码补全。

package com.txw.test;

public class TestThrow {
    public static void main(String[] args) {
        throwException(10);
    }

    public static void throwException(int n){
        if (n == 0) {
            // 抛出一个NullPointerException
        }else {
            // 抛出一个ClassCastException
            // 并设定详细信息为类型“转换出错”
        }
    }
}

答：代码如下:

package com.txw.test;

public class TestThrow {
    public static void main(String[] args) {
        throwException(10);
    }

    public static void throwException(int n){
        if (n == 0) {
            // 抛出一个NullPointerException
            throw  new NullPointerException();
        }else {
            // 抛出一个ClassCastException
            // 并设定详细信息为"类型转换出错”
            throw new ClassCastException("类型转换出错");
        }
    }
}
  1. 代码改错：仔细阅读以下程序，将错误的代码进行改正。
package com.txw.test;

class MyException{

}
public class TestException {
    public static void main(String[] args) {
        ma();
    }
    public static int ma(){
        try {
            m();
            return 100;
        } catch (Exception e) {
            System.out.println("Exception");
        }catch (ArithmeticException e){
            System.out.println("ArithmeticException");
        }
    }

    public static void m(){
        throw new MyException();
    }
}

答：改正的代码如下：

package com.txw.test;

// MyException类必须要继承自Exception的某一个子类
class MyException extends RuntimeException{

}
public class TestException {
    public static void main(String[] args) {
        ma();
    }

    public static int ma(){
        try {
            m();
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException");
        }catch (Exception e){           // 捕获Exception的语句应当放在所有catch语句的最后。
            System.out.println("Exception");
        }
        return 100;
    }

    // 根据 MyException是否继承自RuntimeException
    // 此处考虑是否声明抛出
    public static void m(){
        throw new MyException();
    }
}
  1. 仔细阅读以下代码，当读入的 n 分别为 1，2，3，4，5 时，输出的结果分别是什么？
    在这里插入图片描述
    在这里插入图片描述
    答：
    I. n = 1 时，输出 main1 ma1 mb1 Catch EOFException In finally main2
    II. n = 2 时，输出 main1 ma1 mb1 Catch IOException In finally main2
    III. n = 3 时，输出 main1 ma1 mb1 Catch SQLException In finally main2
    IV. n = 4 时，输出 main1 ma1 mb1 Catch Exception In finally main2
    V. n = 5 时，输出 main1 ma1 mb1 mb2 ma2 In finally main2 注意：不论是否出现异常，出现什么异常，In finally 语句都会被打印出来。
  2. 仔细阅读以下代码：
    在这里插入图片描述
    在//1 处，填入以下__A B____代码可以编译通过，在//2 处，填入____D__代码可以编译通过。
    A. throws java.io.IOException
    B. throws java.io.FileNotFoundException, java.io.EOFException
    C. throws java.sql.SQLException
    D. 不能抛出任何异常
    原因：
    I. 根据方法覆盖的要求，子类的覆盖方法不能比父类的被覆盖方法抛出更宽泛的异常。
    II. ma 方法抛出 IOException，则子类可以抛出 IOException，也可以抛出 IOException 的子类异常。
    III. mb 方法没有抛出任何异常，则子类也不能抛出任何异常。
  3. 仔细阅读以下代码，关于程序描述正确的是(A)。
    在这里插入图片描述
    A. 编译不通过
    B. 编译通过，输出-1
    C. 编译通过，输出 0
    D. 以上描述都不正确
    原因:n的赋值语句产生异常后，找到catch执行里面的代码，最后return n，此时因为对n的赋值语句异常所以赋值失败，n没有 值，局部变量必须先有值才能使用。
  4. 仔细阅读以下代码，在 ma 方法中，当读入的 b 为 100 时，输出结果为___100___，当读入的 b 为 0 时，输出结果为100。
    在这里插入图片描述
    原因：Finally中的代码一定会执行。
  5. 仔细阅读以下代码，在 ma 方法中，读入整数 b，如果读入的值为 10，则输出_ma1 ma2 1 In Finally ；如果读入的 值为 0，则输出 ma1 In Finally。
    在这里插入图片描述
  6. 仔细阅读以下代码，是否能编译通过？如果不能，应该如何修改？
    在这里插入图片描述
    答：不能编译通过。由于 MySub2 继承自 MySub 类，因此不能抛出比MySub 中的方法更多的异常。由于MySub 类中的 m 方法抛出 EOFException，而 MySub2 类的 m 方法抛出的 FileNotFoundException不是 EOFException 的子 类，因此这个方法 抛出了 MySub 类中的 m 方法更多的异常，因此编译不通过。
  7. 仔细阅读以下代码，关于程序描述正确的是(A)。
    在这里插入图片描述
    A. 编译出错
    B. 编译正常，输出 main1 ma1 In Catch
    C. 编译正常，运行时出错
    D. 以上描述都不正确
    原因：ma 方法中第二个输出语句，由于上一个语句是 throw 语句，因此第二个输出语句永远都执行不到，因此编译出错。
  8. 仔细阅读以下程序，下面哪些代码放在/1/处可以编译通过（AB）。
    在这里插入图片描述
    A. catch(NullPointerException npe){}
    B. catch(IOException ioe){}
    C. catch(SQLException sqle){}
    原因：
    I. 在/1/处，由于 ma 方法声明有可能抛出 IOException 异常，因此 B 编译通过。
    II. 由于 NullPointerException 异常是运行时异常，即使 ma 方法的throws 语句中没有声明抛出，调用时也有可 能产生该异常，因此 A编译通过；
    III. 由于 SQLException 没有声明抛出，并且是已检查异常，因此在/1/处不可能捕获到该类异常，因此 C 编译不 通过。
  9. 简述 final、finlize、finally 的区别。
    答：final:修饰变量，方法，类。
    修饰变量为常量，只能赋值一次 修饰方法，不能被覆盖 修饰类不能被继承 finally:是异常处理的一部分，finally中的代码一定会执行，多数用于数 数据库和io流中用来释放资源。
    finalize:是Ojbect类中的一个方法用于垃圾回收。
  10. 在 try 里有 return 语句，那 finally 里的语句还会执行么？为什么？
    答：会执行，放在finally中的代码一定会执行。
  11. 仔细阅读以下代码，写出程序执行的结果。
    在这里插入图片描述
    答：
    StepB StepE
    原因：s为null调用方法会产生空指针异常找到对应的catch，执行完毕后，执行finally中的代码。
  12. 编程：创建两个自定义异常类 MyException1 和 MyException2，要求如下：
    (1) MyException1 为已检查异常，MyException2 为运行时异常；
    (2) 这两个异常均具有两个构造函数：一个无参，另一个带字符串参数，参数表示产生异常的信息。
    演示的代码如下：
package com.txw.test;

public class TestMyException {
    public static void main(String[] args) throws MyException1{
        m1(2);
    }
    public static void m1(int n)throws MyException1{
        if(n==1)throw new MyException1("自定义已检查异常");			// 抛出自定义已检查异常
        if(n==2)throw new MyException2("自定义未检查异常");
    }
}
// 自定义已检查异常
class MyException1 extends Exception{
    public MyException1(){}
    public MyException1(String message){
        super(message);		// 使用父类构造方法
    }
}
// 自定义未检查异常
class MyException2 extends RuntimeException{
    public MyException2(){}
    public MyException2(String message){
        super(message);
    }
}
  1. 在上一题的基础上，把下面代码补充完整。
    在这里插入图片描述
    演示的代码如下：
package com.txw.test;

import java.util.Scanner;
class MyException1 extends Exception {
    public MyException1() {
        super();
    }

    public MyException1(String message) {
        super(message);
    }
}
class MyException2 extends RuntimeException {
    public MyException2() {
        super();
    }

    public MyException2(String message) {
        super(message);
    }
}

public class TestMyException {
    public static void main(String args[]) {
        int n;
        // 读入n
        Scanner sc = new Scanner(System.in);
         n = sc.nextInt();
        try {
            m(n);
        } catch (MyException1 ex1) {
            // 输出ex1详细的方法调用栈信息 
            ex1.printStackTrace();
        } catch (MyException2 ex2) {
            // 输出ex2的详细信息 
            System.out.println(ex2.getMessage());
            // 并把ex2重新抛出 throw ex2; 
        }
    }

    public static void m(int n) throws MyException1 {
        // 声明抛出MyException1 
        if (n == 1) {
            // 抛出MyException1 
            // 并设定其详细信息为“n == 1” 
            throw new MyException1("n == 1");
        } else {
            // 抛出MyException2 
            // 并设定其详细信息为“n == 2”
            throw new MyException2("n == 2");
        }
    }
}

总结在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

学无止路
关注
专栏目录
异常的概述和分类
qq_39153706的博客
08-11 651
异常的概述和分类 异常的概述： 异常就是java程序在运行时出现的错误。 异常的分类： 编译期异常：非RuntimeException。 运行期异常：RuntimeException及其子类，运行期异常我们自己可以解决，也可以不解决交由JVM 解决。JVM的默认处理方式是打印详细的异常信息，然后退出虚拟机。 自己处理运行期异常： 我们可以使用try catch 来进行异常的捕获处理 try 里面放的是你认为有可能会出现异常的代码。 catch(Arithmet
异常的种类
weixin_59497353的博客
01-16 2940
一、 编译时异常、运行时异常。 1、编译时异常：没有继承RuntimeExcpetion的异常，编译阶段就会出错。 2、运行时异常：继承自RuntimeException的异常或其子类，编译阶段不报错，运行可能报错。 二、异常的示例 1、 ...
JAVA学习之异常
最新发布
m0_74122592的博客
08-20 835
（1）非检查异常：RuntimeException类及其子类都称为非检查异常，也叫运行时异常，这种异常的特点是JAVA编译器不会检查它，也就是说，当程序中可能出现这类异常时，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。要合理处理异常，常用的方式是使用try-catch语句块来捕获异常。（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
Java异常介绍
腹黑大壁花
12-07 733
1. 概述在计算机中，很多计数都是从0开始的，所以有时候我们得注意一下，像下面代码运行后，就会有问题public class ExceptionDemo { public static void main(String[] args) { String[] arr = {"a","b","c"}; accessArr(arr, 3); } publ
异常的分类
yinshuiy的专栏
02-28 670
<br />1. 异常机制 <br /><br />     异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。 <br />     传统的处理异常的办法是，函数返回一个特殊的结果来表示出现异常（通常这个特殊结果是大家约定俗称的），调用该函数的程序负责检查并分析函数返回的结果。这样做有如下的弊端：例如函数返回-1代表出现异常，但是如果函数确实要返回-1这个正确的值时就会出现混淆；可读性降低，将程序代码
Java异常
qq_42031380的博客
12-01 182
异常 1、了解异常的背景 认识异常 在以前，我们已经认识了一些异常了 例如： 除以0 System.out.println(10 / 0); // 执行结果 Exception in thread "main" java.lang.ArithmeticException: / by zero 数组下标越界 int[] arr = {1, 2, 3}; System.out.println(arr...
Java异常介绍及Spring Boot统一异常处理
01-05
Spring Boot 提供了统一的异常处理机制，通过使用 @ControllerAdvice 和 @ExceptionHandler 注解，可以实现对控制器层、Service 层、Dao 层以及 Spring 系统内定义的部分异常的统一处理。 在 Spring Boot 中，可以...
中断与异常介绍
02-22
总的来说，这篇名为“中断与异常介绍”的PPT文档将详细解析这两个概念，帮助读者掌握它们的基本原理、处理流程以及在实际应用中的角色。通过学习，无论是硬件工程师还是软件开发者，都能更好地理解和利用中断与异常...
feign服务端发现异常客户端处理的方法介绍
08-25
feign服务端发现异常客户端处理的方法介绍 在使用feign进行远程方法调用时，如果远程服务端方法出现异常，客户端有时需要捕获，并且把异常信息返回给前端，而如果在开启熔断之后，这个异常会被消化，所以说，如果...
C++ 异常的详细介绍
01-21
C++ 异常的详解 程序有时会遇到运行阶段错误，导致程序无法正常执行下去。c++异常为处理这种情况提供了一种功能强大的而灵活的工具。异常是相对比较新的C++功能，有些老编译器可能没有实现。另外，有些编译器默认...
基于SpringMVC的全局异常处理器介绍
08-29
基于SpringMVC的全局异常处理器介绍 在SpringMVC框架中，全局异常处理器是一个非常重要的组件，它可以捕获和处理应用程序中的异常，从而提供更好的用户体验和错误处理机制。在这篇文章中，我们将详细介绍基于...
异常分类
Whiteleaf3er的博客
09-05 189
1-可查异常： CheckedException 可查异常即必须进行处理的异常，要么try catch住,要么往外抛，谁调用，谁处理，比如 FileNotFoundException 如果不处理，编译器，就不让你通过 2-运行异常 比如空指针，无对象，下标越界，除数为0 String str = null; str.length();//空指针异常 这种异常不会导致编译错误，且较普遍，用...
异常-异常的分类
狂风的博客
03-18 362
异常-异常的分类异常的分类1. 编译时被检测异常2. 编译时不被检测异常（运行时异常） 异常的分类 1. 编译时被检测异常 只要Exception和其子类都是，除了特殊的子类RuntimeException体系。 这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。 这样的问题都可以针对性的处理。 2. 编译时不被检测异常（运行时异常） Exception和中的RuntimeEx...
异常分三类，三类怎么分？
qq_36760873的博客
09-06 3246
异常分三类，三类怎么分？ 1.可查异常 可查异常： CheckedException 可查异常即必须进行处理的异常，要么try catch住,要么往外抛，谁调用，谁处理，比如 FileNotFoundException 如果不处理，编译器，就不让你通过 代码行数较多，请点击查看 package exception; import java.io.File; import java...
异常Exception分类
weixin_34221775的博客
04-08 243
1：编译时被检测异常：只要有是Exception和其子类都是，除了特殊子类RuntimeException体系。 这种问题已但出现，希望在编译时进行检测，让这种问题有对应处理方式 这样的问题都可以针对性处理2：编译时不检测异常（运行时异常）：就是Excepton中的RuntimeException和其子类。 这种问题的发生，无法让功能继续，运算无法进行，更多是因...
了解异常
weixin_33881140的博客
04-05 139
'''' 异常本事是个类，python中所有的异常类都是继承于BaseException，这个在builtins.py文件中可以明显看到 异常通常会带来怎么样的问题：异常时程序会运行停止 如何能够防止异常发生： 具体如何做 -------try...except...学习---------------------------- try: #首先写一个try,然后把所有可能出错的代码...
异常类有哪些?
热门推荐
BoomMan
02-05 1万+
转载自:Java 常见异常种类 1、Error 2、Runtime Exception 运行时异常 3、Exception 4、throw 用户自定义异常 异常类分两大类型：Error类代表了编译和系统的错误，不允许捕获；Exception类代表了标准Java库方法所激发的异常。Exception类还包含运行异常类Runtime_Exception和非运行异常类Non_Runtime
异常是什么
qq_39703644的博客
08-08 399
异常用于在指定误发生时改变脚本的正常流程。 异常是什么 PHP 5 提供了一种新的面向对象的错误处理方法。 异常处理用于在指定的错误（异常）情况发生时改变脚本的正常流程。这种情况称为异常。 当异常被触发时，通常会发生： 当前代码状态被保存 代码执行被切换到预定义（自定义）的异常处理器函数 根据情况，处理器也许会从保存的代码状态重新开始执
Java异常体系详解
"本资料详细介绍了Java编程中常见的异常类型，包括算术异常、空指针异常、类型转换异常等，覆盖了从基本的运行时异常到特定场景的错误，帮助开发者理解和处理Java程序中的异常情况。" 在Java编程中，异常处理是一项...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

学无止路

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值