认识异常类

最新推荐文章于 2024-10-14 20:53:59 发布
最新推荐文章于 2024-10-14 20:53:59 发布
阅读量385 收藏 5
点赞数 4
分类专栏： Java 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76124988/article/details/142109510
版权

认识异常

异常的概念与体系结构

异常的概念

在java中，将程序执行过程中发生的不正常行为称为异常。如我们经常遇到的：

  1. 算术异常
public class Test {
    public static void main(String[] args) {
        System.out.println(10 / 0);
    }
}
//执行结果：
//Exception in thread "main" java.lang.ArithmeticException: / by zero
  1. 数组越界异常
public class Test {
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3};
        System.out.println(array[100]);
    }
}
//执行结果：
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 100 out of bounds for length 3
  1. 空指针异常
public class Test {
    public static void main(String[] args) {
        int[] array = null;
        System.out.println(array.length);
    }
}
//执行结果：
//Exception in thread "main" java.lang.NullPointerException: Cannot read the array length because "array" is null

从上述过程中我们可以看到，java中不同类型的异常，都有与其对应的类来进行描述。

异常的体系结构

异常的种类繁多，为了对不同异常或者错误进行很好的分类管理，java内部维护了一个异常的体系结构：
在这里插入图片描述
从上图可以看到：

  1. Throwable：是异常体系的顶层类，其派生出两个重要的子类，Error和Exception
  2. Error：指的是java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverFlowError和OutOfMemoryError，一旦发生，回天乏术。
  3. Exception：异常产生后的程序员可以通过代码进行处理，使程序继续执行。我们平时所说的异常就是Exception。

异常的分类

异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为：

  1. 编译时异常
    在程序编译期间发生的异常，称为编译时异常，也称为受检查异常(Checked Exception)
public class Person {
    public String name;
    public int age;

    @Override
    protected Object clone()  {
        return super.clone();
    }
    //编译报错，java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出
}

protected native Object clone() throws CloneNotSupportedException;
//Object类中该方法声明了异常，所以使用该方法必须处理该异常或继续声明抛出异常

//正确写法：
public class Person {
    public String name;
    public int age;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
  1. 运行时异常
    在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception)
    RunTimeException以及子类对应的异常，都称为运行时异常。比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException。

注意：编译时出现的语法性错误，不能称之为异常。例如将System写成system，此时编译过程中就会出错，这是编译期出错。而运行时指的是程序已经通过编译得到class文件了，再由JVM执行过程中出现的错误。

异常的处理

防御式编程

错误在代码中是客观存在的，因此我们要让程序出现问题的时候及时通知程序员。主要的方式：

  1. LBLY：Look Before You Leap。在操作之前做充分的检查，即：事前防御型
boolean ret = false;
ret = 登陆游戏();
if (!ret) {
处理登陆游戏错误;
return;
}
ret = 开始匹配();
if (!ret) {
处理匹配错误;
return;
}
ret = 游戏确认();
if (!ret) {
处理游戏确认错误;
return;
}
ret = 选择英雄();
if (!ret) {
处理选择英雄错误;
return;
......

缺陷：正常流程和错误处理流程混在一起，代码整体显得比较混乱。

  1. EAFP: It’s Easier to Ask Forgiveness than Permission.“事后获取原谅比事前获取许可更容易”，也就是先操作遇到问题再处理，即：事后认错型
try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
}
......

优势：正常流程和错误流程是分离开的，程序员更关注正常流程，代码更清晰，更容易理解代码
异常处理的核心思想就是 EAFP。
在java中，异常处理主要的5个关键字：throw、try、catch、final、throws。

异常的抛出

在编写程序时，如果程序中出现错误，此时就需要将错误信息告知给调用者，比如：参数检测
在java中，可以借助 throw 关键字，指出一个指定的异常对象，将错误信息告知给调用者，具体语法如下：

throw new XXXExceptiom("异常产生的原因");

例子：需求：实现一个获取数组中任意位置元素的方法：

public class Test {
    public static int getElement(int[] array, int index){
        if(null == array){
            throw new NullPointerException("传递的数组为null");
        }
        if(index < 0 || index >= array.length){
            throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
        }
        return array[index];
    }
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4};
        getElement(array,4);
    }
    //结果为：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 传递的数组下标越界
}

注意：

  • throw必须写在方法体内部
  • 抛出的对象必须是Exception 或者 Exception 的子类对象
  • 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
  • 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
  • 异常一旦抛出，其后的代码不会执行。

异常的捕获

异常的捕获也就是异常的具体处理方式，主要有两种：异常声明throws以及try-catch捕获处理。

异常声明throws

在方法声明时参数列表后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。

语法格式：
修饰符 返回值类型 方法名(参数列表)throws 异常类型1，异常类型2...{

}

需求：加载指定的配置文件config.ini

public class Config {
    File file;
    /*
    FileNotFoundException:编译时异常，表明文件不存在
    此处不处理，也没有能力处理，应将错误信息报告给调用者，让调用者检查文件名字是否给错误了
     */
    public void openConfig(String fileName)throws FileNotFoundException{
        if(fileName.equals("config.ini")){
            throw new FileNotFoundException("配置文件名字不对");
        }
        //打开文件
    }
    public void readconfig(){
    }
}

注意：

  • throws 必须跟在方法的参数列表之后
  • 声明的异常必须是Exception 或者 Exception 的子类
  • 方法的内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。
public class Config {
    File file;
    /*
    public void openConfig(String fileName)throws IOException,FileNotFoundException{
    FileNotFoundException继承自IOException
     */
    public void openConfig(String fileName)throws IOException{
        if(fileName.equals("config.ini")){
            throw new FileNotFoundException("配置文件名字不对");
        }
        //打开文件
    }
    public void readconfig(){
    }
}
  • 调用声明跑抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出
public class Test {
    public static void main(String[] args) throws IOException {
        Config config = new Config();
        config.openConfig("config.ini");
    }
}

try-catch捕获并处理

throws对异常并没有真正处理，而是将异常报告给抛出抛出异常方法的调用者，由调用者处理，如果真正要对异常进行处理，就需要try-catch。

语法格式：
try{
	//将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
	//如果try中的代码抛出异常了，此处catch捕获的异常类型与try中抛出的类型一致时，或者是try中抛出异常的基类时，就会被捕获到
	//对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码	
}[catch(异常类型 e){
	//对异常进行处理
}finally{
	//此处代码一定会被执行到
}]

//后序代码
//当异常被捕获到时，异常就被处理了，这里的后序代码一定会被执行。
//如果捕获了，由于捕获类型不对，那就没有捕获到，这里的代码就不会被执行

//[]中表示可选项，可以添加，也可以不用添加
//try中的代码可能会抛出异常，也可能不会。

需求：读取配置文件，如果配置文件名字不是指定名字，抛出异常，调用者进行处理

public class Config {
    File file;
    public void openConfig(String fileName)throws FileNotFoundException{
        if(fileName.equals("config.ini")){
            throw new FileNotFoundException("配置文件名字不对");
        }
        //打开文件
    }
    public void readconfig(){
    }
}

public class Test {
    public static void main(String[] args) {
        Config config = new Config();
        try{
            config.openConfig("config.ini");
            System.out.println("文件打开成功");
        }catch(IOException e){
            //异常的处理方式
            //System.out.println(e.getMessage()); //只打印异常信息
            //System.out.println(e);  //打印异常类型：异常信息
            e.printStackTrace();    //打印信息最全面
        }

        //一旦异常被捕获处理了，此处的代码会执行
        System.out.println("异常如果被处理了，这里的代码也可以执行");

    }
}

关于异常的处理方式
异常的种类有很多，要根据不同的业务场景来决定
对于比较严重的问题，应该让程序直接崩溃，防止造成更严重的后果
对于不太严重的问题，可以记录错误日志，并通过监控报警程序及时通知程序员
对于可能会恢复的问题(网络相关场景)，可以尝试进行重试

注意：

  • try块内抛出异常位置之后的代码将不会被执行。
  • 如果抛出的异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序，异常是按照类型来捕获的。
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            System.out.println(array[3]);
        }catch(NullPointerException e){
            e.printStackTrace();
        }

        System.out.println("后序代码");
    //运行结果：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
    }
}
  • try可能会抛出多个不同的异常对象，则必须使用多个catch来捕获，即多种异常，多次捕获，但是不可能同时抛出多个异常，try块中发生异常后的代码将不会执行。
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            System.out.println("before");
            //array = null;
            //System.out.println(array.length);
            System.out.println(array[3]);
            System.out.println("after");

        }catch(NullPointerException e){
            e.printStackTrace();
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }

        System.out.println("后序代码");
        //运行结果：
        //before
        //后序代码
        //java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        //	at demo1.Test.main(Test.java:19)
    }
}

如果多个异常的处理方式是完全相同，也可以写成：

catch(NullPointerException | ArrayIndexOutOfBoundsException e){
	...
}

如果异常之间具有父子关系，一定是子类在前catch，父类异常在后catch，否则语法错误：

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            System.out.println("before");
            //array = null;
            //System.out.println(array.length);
            System.out.println(array[3]);
            System.out.println("after");
        }catch(Exception e){    //Exception 可以捕获到所以异常
            e.printStackTrace();
        }catch(ArrayIndexOutOfBoundsException e){   //这个异常已经被捕获到
            e.printStackTrace();
        }
        System.out.println("后序代码");
        //运行结果：
        //java: 已捕获到异常错误java.lang.ArrayIndexOutOfBoundsException
    }
}
  • 可以通过一个catch捕获到所有异常，即多个异常，一次捕获(不推荐)
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            System.out.println("before");
            //array = null;
            //System.out.println(array.length);
            System.out.println(array[3]);
            System.out.println("after");
        }catch(Exception e){    //Exception 可以捕获到所以异常
            e.printStackTrace();
        }
        System.out.println("后序代码");
        //运行结果：
        //before
        //后序代码
        //java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        //	at demo1.Test.main(Test.java:19)
    }
}

由于Exception类是所有异常的父类，因此可以用这个类型表示捕捉所有异常
catch进行类型匹配时，不光会匹配相同类型的异常对象，也会捕捉目标异常类型的子类对象。

finally

在写程序时，有些特定的代码，不论是程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或异常退出时，必须要对资源进行回收；另外由于异常会引发程序发生跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

语法格式：
try{
	//将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
	//如果try中的代码抛出异常了，此处catch捕获的异常类型与try中抛出的类型一致时，或者是try中抛出异常的基类时，就会被捕获到
	//对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码	
}[catch(异常类型 e){
	//对异常进行处理
}finally{
	//此处代码一定会被执行到
}]

//后序代码
//当异常被捕获到时，异常就被处理了，这里的后序代码一定会被执行。
//如果捕获了，由于捕获类型不对，那就没有捕获到，这里的代码就不会被执行

//[]中表示可选项，可以添加，也可以不用添加
//try中的代码可能会抛出异常，也可能不会。

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        try{
            array[100] = 0;
            array[0] = 0;
        }catch(Exception e){    //Exception 可以捕获到所以异常
            e.printStackTrace();
        }finally {
            System.out.println("finally中的代码一定会被执行");
        }

        System.out.println("如果没有抛出异常，或者异常被处理了，try-catch代码后的代码也会执行");
        //运行结果：
        //finally中的代码一定会被执行
        //如果没有抛出异常，或者异常被处理了，try-catch代码后的代码也会执行
        //java.lang.ArrayIndexOutOfBoundsException: Index 100 out of bounds for length 3
        //	at demo1.Test.main(Test.java:16)
    }
}

问题：既然finallly中的代码和异常处理后的try-catch后的后续代码都会被执行，那为什么还要有finally呢？
需求：实现getData方法，内部输入一个整型数字，然后将该数字返回，并再main方法中打印。

public class Test {
    public static int getData(){
        Scanner scanner  = null;
        try{
            scanner = new Scanner(System.in);
            int data = scanner.nextInt();
            return data;
        }catch(InputMismatchException e){
            e.printStackTrace();
        }finally{
            System.out.println("finally中的代码");
        }

        System.out.println("try-catch-finally之后的代码");
        if(null != scanner){
            scanner.close();
        }
        return 0;
    }
    public static void main(String[] args) {
        int data = getData();
        System.out.println(data);
        //运行结果：
        //5
        //finally中的代码
        //5
    }
}

上述程序，如果正常输入成功接收输入后程序就会返回了，try-catch-finally之后的代码根本就没有执行，即输入流没有被释放，造成资源泄露。
注意：finally中的代码一定会被执行，一般会在finally中进行一些资源清理的扫尾工作。

public class Test {
    public static int func(){
        try{
            return 10;
        }finally{
            return 20;
        }
    }
    public static void main(String[] args) {
        System.out.println(func());
        //运行结果：
        //20
    }
}

finally执行的时机时是在方法返回之前(try或者catch中如果有return会在这个return之前执行finally)，但是如果finally中也存在return语句，那么就会执行finally中的return语句，从而不会执行到try中原有的return，一般不建议在finally中写return(被编译器当做一个警告)

异常的处理流程

关于调用栈
方法之间是存在相互调用的关系，这种调用关系我们可以用“调用栈”来描述，在JVM中有一块内存空间称为“虚拟机栈”专门存储方法之间的调用关系，当代码中出现异常的时候，我们就可以使用阿。printStackTrace();的方式查看出现异常代码的调用栈

如果本方法没有中没有出现合适的处理异常的方式，就会沿着调用栈向上传递

public class Test {
    public static void func(){
        int[] array = {1,2,3};
        System.out.println(array[100]);
    }
    public static void main(String[] args) {
        try{
            func();
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }

        System.out.println("try-catch后的代码");
        //运行结果：
        //java.lang.ArrayIndexOutOfBoundsException: Index 100 out of bounds for length 3
        //	at demo1.Test.func(Test.java:17)
        //	at demo1.Test.main(Test.java:21)
        //try-catch后的代码
    }
}

如果向上一直传递都没有合适的方法处理异常，最终就会交给JVM处理，程序就会异常终止(和我们最开始未使用try-catch时是一样的)

public class Test {
    public static void func(){
        int[] array = {1,2,3};
        System.out.println(array[100]);
    }
    public static void main(String[] args) {
        func();

        System.out.println("try-catch后的代码");
        //运行结果：
        //java.lang.ArrayIndexOutOfBoundsException: Index 100 out of bounds for length 3
        //	at demo1.Test.func(Test.java:17)
        //	at demo1.Test.main(Test.java:21)
    }
}

可以看到程序已经异常终止了，并没有执行到System.out.println(“try-catch后的代码”);这行代码上。
异常处理流程总结：

  • 程序先执行try中的代码
  • 如果try中的代码出现异常，就会结束try中的代码，看和catch中的异常类型是否匹配
  • 如果找到匹配的异常类型，就会执行catch中的代码
  • 如果没有找到匹配的异常类型，就会将异常向上传递到上层调用者
  • 无论是否找到匹配的异常类型，finally中的代码都会被执行到(在该方法结束之前执行)
  • 如果上层调用者也没有处理的了的异常，就继续向上传递
  • 一直到main方法也没有合适的代码处理异常，就交给JVM来进行处理，此时程序就会异常终止。

自定义异常类

java中虽然已经内置了丰富的异常类，但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构。
需求：用户登录

public class Login {
    private String name;
    private String password;

    public void setName(String name) {
        this.name = name;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void loginInfo(String name, String password){
        if(!this.name.equals(name)){

        }
        if(!this.password.equals(password)){

        }
        System.out.println("登录成功");
    }
}

public class Test {
    public static void main(String[] args) {
        Login usr1 = new Login();
        usr1.setName("张三");
        usr1.setPassword("123456");
        usr1.loginInfo("张三","123456");
        //运行结果：
        //登录成功
    }
}

此时我们在处理用户名密码错误的时候就可能需要抛出两种异常，我们就可以基于已有的异常类进行拓展(继承)，创建和我们业务相关的异常类。
具体方式：

  1. 自定义异常类，然后继承自 Exception 或者 RunTimeException
  2. 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因
public class UserNameException extends RuntimeException{
    public UserNameException(String message) {
        super(message);
    }
}

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

public class Login {
    private String name;
    private String password;

    public void setName(String name) {
        this.name = name;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void loginInfo(String name, String password){
        if(!this.name.equals(name)){
            throw new UserNameException("用户名错误！");
         }
        if(!this.password.equals(password)){
            throw new PasswordException("密码错误！");
        }
        System.out.println("登录成功");
    }
}

public class Test {
    public static void main(String[] args) {
        Login usr1 = new Login();
        usr1.setName("张三");
        usr1.setPassword("123456");
        try{
            usr1.loginInfo("张三","123456");
        }catch(UserNameException e){
            e.printStackTrace();
        }catch(PasswordException e){
            e.printStackTrace();
        }
        //运行结果：
        //登录成功
    }
}

注意：

  • 自定义异常通常会继承自Exception 或者 RunTimeException
  • 继承自Exception 的异常默认是受查异常
  • 继承自RunTimeException 的异常默认是非受查异常

关于异常我们先了解到这里，我们后续对的理解和运用也会越来越深刻和熟练，永不言弃，不断学习，never give up！！

running up that hill
关注
专栏目录
Java 认识异常
2302_79806056的博客
03-19 1726
通过学习和实践 Java 中的异常处理，我深刻认识到异常处理不仅是代码中的一部分，更是一种思维方式，一种面对问题和挑战的态度。
java异常分类三大类_Java异常机制
weixin_30145703的博客
02-22 1282
前言声明：该文章中所有测试都是在JDK1.8的环境下。该文章是我在学习Java中的异常处理这方面知识时，做的一些总结和记录。如果有不正确的地方请大家多多包涵并作出指点，谢谢！一、异常机制介绍1.1 基本概念什么是异常？顾名思义就是非正常的现象。就是Java程序在运行的时候出现不正常的情况。举个例子：我们有一个等式"10/0=?"需要计算，我们都知道，10除以0结果是无意义的，所以我们用Java程序...
Throwable类与异常
跋涉者
08-12 7632
Throwable类，异常
Javase.认识异常
Joseit的博客
06-21 2295
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
Java——认识异常
qq_63492484的博客
05-03 1758
Java异常的超强详解！！！
JavaSE：认识异常
xiaochuan_bsj的博客
07-19 1020
关于Java中的异常部分
【一步一步了解Java系列】：认识异常类
2302_81249757的博客
06-22 1676
使用的较多的异常类往往是我们自己定义的比较多，那么如何自定义异常类呢，下面我们就来讲讲如何自定义异常类。int a=0;if(a==0){如上我们只需让自己创建出的类继承Exception或其它异常类即可，这样这个类也是一个异常类了。然后我们在需要抛出异常时，抛出自己定义的异常即可。也可以用try-catch进行使用解决自己定义的异常。** 自定义异常通常会继承自 Exception 或者 RuntimeException **
异常分类
mmalan的博客
03-29 2320
ava异常机制异常是程序运行过程中出现的错误。本文主要讲授的是Java语言的异常处理。Java语言的异常处理框架，是Java语言健壮性的一个重要体现。Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。Java异常体系结构呈树状，其层次结构图如图...
认识异常exception
H48530的博客
02-02 845
认识异常exception异常exception 异常exception
【javaSE】 万字带你认识异常
m0_71731682的博客
08-07 1591
程序先执行 try 中的代码如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.如果找到匹配的异常类型, 就会执行 catch 中的代码如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).如果上层调用者也没有处理的了异常, 就继续向上传递.
11.认识异常1
08-03
在Java中，异常处理是通过异常类来实现的，这些异常类构成了Java异常体系。异常的发生通常分为编译期错误和运行时错误。编译期错误在代码编写阶段就能被检测出来，如语法错误、类型不匹配等；而运行时错误则是在程序...
Java软件开发实战 Java基础与案例开发详解 10-2 认识异常 共5页.pdf
07-07
#### 10.2 认识异常 在Java编程中，**异常**是指程序在运行时遇到的问题或错误状态，这些问题可能是由于编程错误导致的，也可能是由于外部因素（如文件不存在）造成的。Java提供了一套完整的异常处理机制，帮助...
C++软件调试与异常排查从入门到精通系列文章汇总
热门推荐
dvlinker的技术专栏
06-29 18万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
开发语言最佳实践
AngelCryToo的专栏
10-13 711
开发iOS最好的语言是。Swift是由苹果公司推出的一种现代编程语言，专门为iOS、macOS、watchOS和tvOS开发应用程序设计。它的语法简洁、安全性高、性能优越，非常适合构建高效和复杂的iOS应用。Swift支持面向对象和函数式编程，具有出色的可读性和开发效率。另一个常见的语言是，它曾是开发iOS应用的主要语言，但随着Swift的推出，Objective-C逐渐被Swift取代。尽管如此，Objective-C在一些老项目或与Swift互操作时仍然有用。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1416
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
确保Spring Boot定时任务只执行一次方案
最新发布
2301_76419561的博客
10-14 101
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
Springboot api http并发测试请求
nsa65223的专栏
10-11 245
【代码】Springboot api http并发测试请求。
代理模式、BigDecimal详解
Pre_W的博客
10-14 665
BigDecimal可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过BigDecimal来做的。浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断。想要解决浮点数运算精度丢失这个问题，可以直接使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可​​// 0。
多实例异常点识别方法与应用
作者认识到现有的单一实例异常检测器，如LOF（Local Outlier Factor）方法，在处理多实例数据时可能存在局限性。 针对这一挑战，文中提出了两种基于LOF的多实例异常检测方法。第一种方法利用核方法的原理，将距离...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值