Java 认识异常

这篇具有很好参考价值的文章主要介绍了Java 认识异常。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Java 认识异常,java,开发语言

Java 认识异常,java,开发语言

 登神长阶 第五阶 认识异常

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀 


目录

🛠️一.异常的概念与体系结构

🗡️1.异常的概念

🪃2.异常的体系结构

🪃3.异常的分类

🏹二. 异常的处理 

🛡️1.常用的处理方式

🪚2.异常的抛出 

🔧3.异常的捕获

 🪛4.finally

🔩三.异常的处理流程

⚙️四.自定义异常类

♨️五.总结与反思


🛠️一.异常的概念与体系结构

🗡️1.异常的概念

  在Java中,异常是指程序执行过程中发生的问题或错误。当某个代码块无法正常执行时,会抛出一个异常。这可能是由于输入错误、资源不足、网络连接问题或其他原因导致的。在Java中,异常被表示为对象,它们都是Throwable类的子类。常见的异常类型包括Checked异常(需要明确捕获或声明)和Unchecked异常(编译器不要求处理的异常)。处理异常可以通过try-catch语句块来捕获和处理异常,也可以通过throws关键字将异常向上传递给调用者。Java还提供了一些内置的异常类,同时也允许开发者自定义异常类来处理特定的错误情况。

部分异常举例

算术异常
System.out.println(10 / 0);
// 执行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero

数组越界异常

int[] arr = {1, 2, 3};
System.out.println(arr[100]);
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

 空指针异常

int[] arr = null;
System.out.println(arr.length);
// 执行结果
Exception in thread "main" java.lang.NullPointerException
从上述过程中可以看到, java 中不同类型的异常,都有与其对应的类来进行描述

🪃2.异常的体系结构

   异常种类繁多,为了对不同异常或者错误进行很好的分类管理,Java内部维护了一个异常的体系结构:

Java 认识异常,java,开发语言

 

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

🪃3.异常的分类

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

1. 编译时异常

   在程序编译期间发生的异常,称为编译时异常,也称为受检查异常 (Checked Exception)
public class Person {    
    private String name;
    private String gender;
    int age;
    // 想要让该类支持深拷贝,覆写Object类的clone方法即可
    @Override
    public Person clone() {
    return (Person)super.clone();
    }
}
编译时报错:
Error:(17, 35) java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出
2. 运行时异常
   在程序执行期间发生的异常,称为运行时异常,也称为非受检查异常 (Unchecked Exception)
RunTimeException 以及其子类对应的异常,都称为运行时异常 。比如: NullPointerException
ArrayIndexOutOfBoundsException ArithmeticException
注意:编译时出现的语法性错误,不能称之为异常。例如将 System.out.println 拼写错了 , 写成了 system.out.println. 此时编译过程中就会出错 , 这是 " 编译期 " 出错。而运行时指的是程序已经编译通过得到class 文件了 , 再由 JVM 执行过程中出现的错误 .

🏹二. 异常的处理 

🛡️1.常用的处理方式

在Java中,异常处理通常通过以下方式来实现:

   1.使用try-catch块:可以使用try语句块捕获可能抛出异常的代码,并在catch块中处理异常。示例代码如下:

try {
    // 可能会抛出异常的代码
    // 比如调用可能会抛出异常的方法
} catch (Exception e) {
    // 处理异常的代码
    // 可以打印错误信息或者进行其他操作
}

   2.throws关键字:在方法声明时使用throws关键字声明可能会抛出的异常,然后在调用该方法的地方处理异常。示例代码如下:

public void doSomething() throws SomeException {
    // 可能会抛出SomeException异常的代码
}

// 在调用doSomething方法的地方处理异常
try {
    doSomething();
} catch (SomeException e) {
    // 处理异常的代码
}

   3.finally块:finally块中的代码总是会执行,无论try块中是否有异常抛出,用于处理资源清理等操作。

try {
    // 可能会抛出异常的代码
} catch (Exception e) {
    // 处理异常的代码
} finally {
    // 无论是否有异常都会执行的代码,比如资源释放
}

🪚2.异常的抛出 

Java 中,可以借助 throw 关键字,抛出一个指定的异常对象,将错误信息告知给调用者。具体语法如下:
throw new XXXException("异常产生的原因");
注意事项
1. throw 必须写在方法体内部
2. 抛出的对象必须是 Exception 或者 Exception 的子类对象
3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类,则可以不用处理,直接交给 JVM 来处理
4. 如果抛出的是编译时异常,用户必须处理,否则无法通过编译
5. 异常一旦抛出,其后的代码就不会执行

🔧3.异常的捕获

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

异常声明throws

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

语法格式:
修饰符 返回值类型 方法名(参数列表) throws 异常类型1,异常类型2...{
}
注意事项
1. throws 必须跟在方法的参数列表之后
2. 声明的异常必须是 Exception 或者 Exception 的子类
3. 方法内部如果抛出了多个异常, 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.endsWith(".ini")){
        throw new IOException("文件不是.ini文件");
        }
    if(filename.equals("config.ini")){
        throw new FileNotFoundException("配置文件名字不对");
        }
// 打开文件
    }
    public void readConfig(){
    }
}
4. 调用声明抛出异常的方法时,调用者必须对该异常进行处理,或者继续使用 throws 抛出
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{
    // 此处代码一定会被执行到
}]

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

注意:
1. []中表示可选项,可以添加,也可以不用添加
2. try中的代码可能会抛出异常,也可能不会
关于异常的处理方式
异常的种类有很多 , 我们要根据不同的业务场景来决定 .
对于比较严重的问题 ( 例如和算钱相关的场景 ), 应该让程序直接崩溃 , 防止造成更严重的后果
对于不太严重的问题 ( 大多数场景 ), 可以记录错误日志 , 并通过监控报警程序及时通知程序猿
对于可能会恢复的问题 ( 和网络相关的场景 ), 可以尝试进行重试 .
在我们当前的代码中采取的是经过简化的第二种方式 . 我们记录的错误日志是出现异常的方法调用信息 , 能很 快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息 .
注意事项
1. try 块内抛出异常位置之后的代码将不会被执行
2. 如果抛出异常类型与 catch 时异常类型不匹配,即异常不会被成功捕获,也就不会被处理,继续往外抛,直到JVM收到后中断程序 ---- 异常是按照类型来捕获的
 public static void main(String[] args) {
        try {
            int[] array = {1,2,3};
            System.out.println(array[3]); // 此处会抛出数组越界异常
        }catch (NullPointerException e){ // 捕获时候捕获的是空指针异常--真正的异常无法被捕获到
            e.printStackTrace();
        }
        System.out.println("后序代码");
    }
   /* Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
    at day20210917.ArrayOperator.main(ArrayOperator.java:24)*/

3. try中可能会抛出多个不同的异常对象,则必须用多个catch

 public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println("before");
    // arr = null;
            System.out.println(arr[100]);
            System.out.println("after");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("这是个数组下标越界异常");
            e.printStackTrace();
        } catch (NullPointerException e) {
            System.out.println("这是个空指针异常");
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
如果多个异常的处理方式是完全相同 , 也可以写成这样:
catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
    ...
}
如果异常之间具有父子关系,一定是子类异常在前 catch ,父类异常在后 catch ,否则语法错误:
public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println("before");
            arr = null;
            System.out.println(arr[100]);
            System.out.println("after");
        } catch (Exception e) { // Exception可以捕获到所有异常
            e.printStackTrace();
        }catch (NullPointerException e){ // 永远都捕获执行到
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
    Error:(33, 10) java: 已捕获到异常错误java.lang.NullPointerException

Java 认识异常,java,开发语言

4. 可以通过一个catch捕获所有的异常,即多个异常,一次捕获(不推荐) 

public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            System.out.println("before");
            arr = null;
            System.out.println(arr[100]);
            System.out.println("after");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }

Java 认识异常,java,开发语言

 🪛4.finally

在 Java 中,finally 是一个关键字,用于定义在异常处理结构中的一个代码块。finally 块通常用于执行一些无论是否发生异常都需要被执行的清理工作。

try 块中的代码抛出异常时,程序会跳转到与之对应的 catch 块,如果有的话。而无论是否有异常抛出,finally 块中的代码总是会被执行。

以下是 finally 块的几个使用场景和特点:

  • 资源释放finaly 块通常用于释放系统资源,比如关闭文件、数据库连接或网络连接等。即使在发生异常的情况下,资源也能得到正确地释放。

  • 清理工作finally 块可以用于执行一些清理工作,例如清理临时变量、恢复状态等,以确保程序在任何情况下都处于一个良好的状态。

  • 异常处理finally 块中的代码在发生异常时也会被执行,这使得程序可以更好地处理异常情况,保持一致性和可靠性。

注意事项

  • 如果 try 块中有 return 语句,则 finally 块的代码会在 return 语句执行之后、返回之前被执行。(不推荐)

  • 如果 finally 块中的代码执行过程中抛出了异常,那么这个异常会覆盖 trycatch 块中抛出的原异常,并成为最终的异常。

总之,finally 块为处理资源释放和清理工作提供了一种强大的机制,在编写健壮的异常处理代码时起着重要的作用。

public static void main(String[] args) {
        try{
            int[] arr = {1,2,3};
            arr[100] = 10;
            arr[0] = 10;
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }finally {
            System.out.println("finally中的代码一定会执行");
        }
        System.out.println("如果没有抛出异常,或者异常被处理了,try-catch后的代码也会执行");
    }

Java 认识异常,java,开发语言

import java.io.*;

public class FinallyExample {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            // 尝试打开文件并读取数据
            br = new BufferedReader(new FileReader("example.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            // 读取完成后关闭文件
        } catch (FileNotFoundException e) {
            // 处理文件未找到异常
            System.err.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            // 处理其他 IO 异常
            System.err.println("IO Exception: " + e.getMessage());
        } finally {
            // 无论是否发生异常,最终都会执行这里的代码
            try {
                if (br != null) {
                    br.close(); // 关闭文件
                }
            } catch (IOException e) {
                System.err.println("Error while closing the file: " + e.getMessage());
            }
        }
    }
}

    在上面的示例中,我们尝试打开一个文件并从中读取数据。在 try 块内的代码尝试打开文件并读取数据,如果遇到文件未找到或其他 IO 异常,则会分别被 catch 块捕获并处理。无论是否发生异常,finally 块中的代码都会被执行,用于关闭文件并释放资源。即使在文件读取过程中发生异常,文件仍然会被关闭,确保资源得到正确释放。这个示例展示了 finally 块的作用,不管是否发生异常,我们都可以在 finally 块中执行一些必要的清理工作,以确保程序状态的一致性和资源的正确释放。

🔩三.异常的处理流程

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

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

public class StageTest {
    public static void main(String[] args) {
        try {
            func();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        System.out.println("after try catch");
    }
    public static void func() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);
    }
// 直接结果
    /*java.lang.ArrayIndexOutOfBoundsException: 100
    at demo02.Test.func(Test.java:18)
    at demo02.Test.main(Test.java:9)
    after try catch*/
如果向上一直传递都没有合适的方法处理异常 , 最终就会交给 JVM 处理 , 程序就会异常终止 ( 和我们最开始未使用 try catch 时是一样的 ).
public class StageTest {
    public static void main(String[] args) {
        func();
        System.out.println("after try catch");
    }
    public static void func() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);
    }
    // 执行结果
   /* Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
    at demo02.Test.func(Test.java:14)
    at demo02.Test.main(Test.java:8)*/
可以看到 , 程序已经异常终止了 , 没有执行到 System.out.println("after try catch"); 这一行 .
异常处理流程总结
  • 程序先执行 try 中的代码
  • 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
  • 如果找到匹配的异常类型, 就会执行 catch 中的代码
  • 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
  • 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
  • 如果上层调用者也没有处理的了异常, 就继续向上传递.
  • 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

⚙️四.自定义异常类

Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常,此时就需要维护符合我们实际情况的异常结构. 

在 Java 中,自定义异常类是用户根据特定需求创建的异常类,通常通过继承 Exception 类或其子类来实现。以下是详细描述 Java 中自定义异常类的步骤和使用方法:

1.创建自定义异常类

  • 自定义异常类通常需要提供构造方法和一些额外的属性或方法以满足具体的异常情况。
  • 自定义异常类可以直接继承自 Exception 类或其子类,例如 RuntimeExceptionIOException 等。
public class CustomException extends Exception {

    public CustomException() {
        super();
    }

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

    // 可以定义额外的构造方法、属性或方法
}

2.抛出自定义异常

在代码中遇到特定的业务逻辑错误或异常情况时,可以通过创建自定义异常对象并抛出来进行处理。

public class Example {
    public void doSomething(int value) throws CustomException {
        if (value < 0) {
            throw new CustomException("Value cannot be negative");
        }
        // 其他代码逻辑
    }
}

3.捕获自定义异常

当调用可能会抛出自定义异常的方法时,需要在调用处使用 try-catch 块捕获该异常。

public class Main {
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.doSomething(-1);
        } catch (CustomException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }
}

4.使用自定义异常类

  • 自定义异常类通常通过构造方法传入异常消息,以便在捕获异常时提供相关信息。
  • 可以根据业务需求在自定义异常类中添加其他属性和方法,以更好地描述异常情况和处理逻辑。

通过自定义异常类,可以更好地组织和管理异常情况,使代码结构更清晰,并确保程序在发生特定异常时能够采取正确的处理方式。

例如:我们实现一个用户登录功能

 class UserNameException extends Exception {
        public UserNameException(String message) {
            super(message);
        }
    }
    class PasswordException extends Exception {
        public PasswordException(String message) {
            super(message);
        }
    }
public class LogIn {
        private String userName = "admin";
        private String password = "123456";
        public static void loginInfo(String userName, String password)
                throws UserNameException,PasswordException{
            if (!userName.equals(userName)) {
                throw new UserNameException("用户名错误!");
            }
            if (!password.equals(password)) {
                throw new PasswordException("用户名错误!");
            }
            System.out.println("登陆成功");
        }
        public static void main(String[] args) {
            try {
                loginInfo("admin", "123456");
            } catch (UserNameException e) {
                e.printStackTrace();
            } catch (PasswordException e) {
                e.printStackTrace();
            }
        }
    }
注意事项
  • 自定义异常通常会继承自 Exception 或者 RuntimeException
  • 继承自 Exception 的异常默认是受查异常
  • 继承自 RuntimeException 的异常默认是非受查异常

♨️五.总结与反思

💡现实是此岸,理想是彼岸,中间隔着湍急的河流,行动则是架在河上的桥梁。——克雷洛夫

        在实际项目中,异常处理是不可避免的一部分,需要结合具体业务场景,灵活运用异常处理机制,确保程序的稳定性和可维护性。不断总结和反思异常处理中遇到的问题和经验,及时修正和优化异常处理代码,以提高代码质量和开发效率。

        通过学习和实践 Java 中的异常处理,我深刻认识到异常处理不仅是代码中的一部分,更是一种思维方式,一种面对问题和挑战的态度。只有不断学习和积累经验,才能更好地应对程序中可能出现的异常情况,写出更加稳健和可靠的 Java 程序。


🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上,就是本期的全部内容啦,若有错误疏忽希望各位大佬及时指出💐

  制作不易,希望能对各位提供微小的帮助,可否留下你免费的赞呢🌸文章来源地址https://www.toymoban.com/news/detail-841414.html

到了这里,关于Java 认识异常的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java语言----异常处理(看了必会)

    目录 一.异常的概述 二.异常类的层次结构和种类 二.异常的基本用法 2.1异常的捕捉 2.2异常处理代码实现 三.抛出异常 3.1 throw 3.2 throws 四.finally的进一步详解 五.自定义异常类 总结 😽个人主页:tq02的博客_CSDN博客-C语言,Java领域博主  🌈理想目标:努力学习,向Java进发,拼搏

    2023年04月11日
    浏览(59)
  • 阿里Java开发手册~异常处理

    1. 【强制】 Java 类库中定义的一类 RuntimeException 可以通过预先检查进行规避,而不应该 通过 catch 来处理,比如: IndexOutOfBoundsException , NullPointerException 等等。 说明: 无法通过预检查的异常除外,如在解析一个外部传来的字符串形式数字时,通过 catch NumberFormatException 来实现

    2024年02月15日
    浏览(38)
  • Java 开发中常见的异常有哪些?

    1、空指针异常(NullPointException):当对象不存在,却又去调用对象的属性或方法时,就会出现该异常 2、数组越界异常(ArrayIndexOutOfBoundsException):当数组只存在5个元素,他们所对应的的下标即为0-4,如果访问数组下标为5的元素时,就会提示该异常,原因是该位置元素不存

    2024年02月04日
    浏览(40)
  • 瑞_Java开发手册_(二)异常日志

    🙊前言:本文章为瑞_系列专栏之《Java开发手册》的异常日志篇,本篇章主要介绍异常日志的错误码、异常处理、日志规约。由于博主是从阿里的《Java开发手册》学习到Java的编程规约,所以本系列专栏主要以这本书进行讲解和拓展,有需要的小伙伴可以点击链接下载。本文

    2024年01月16日
    浏览(51)
  • Java开发者的Python快速进修指南:异常捕获

    在之前的学习中,我们已经讲解了函数和控制流等基本概念。然而,在接触实际业务时,你会发现异常捕获也是必不可少的一部分,因为在Java编程中,异常处理是不可或缺的。Python的异常捕获与Java的异常捕获原理是相同的,只是在写法上有一些区别。它们的目的都是为了处

    2024年02月05日
    浏览(82)
  • 开发语言漫谈-Java

            由于C++过于复杂,Java诞生了。与C++相比,Java更易于学习和使用,它去掉C++中的指针和解决了内存管理问题。Java提供了垃圾自动回收机制,自动管理不再使用的内存。Python又进一步简化,使得语法更简洁,更易于阅读和编写。当然随着简化,性能就越来越低。    

    2024年04月10日
    浏览(49)
  • 海康威视相机SDK二次开发(JAVA语言)

    前言 有个项目需要使用java程序读取海康威视的相机图片。相机通过以太网连接服务器,部署在服务器上的java程序将相机拍摄的画面保存在指定路径下。 海康威视提供了sdk开发包,可以在官网中下载,windows和linux系统都有。但是开发包中给出的示例代码,无法满足实际需要,

    2024年04月29日
    浏览(51)
  • Java009——Java数据类型简单认识

    围绕以下3点学习: 1、什么是Java数据类型? 2、Java数据类型的作用? 3、Java有哪些数据类型? 4、熟悉Java8大基本数据类型 当我们写Java代码时,需要把数据保存在 变量 (指值可以变的量,例如:数学中假设x,y,z变量一样)中,这些变量的类型可以是整数(如100,5,50)、小

    2024年02月08日
    浏览(35)
  • 【Java】后端开发语言Java和C#,两者对比注解和属性的区别以及作用

    欢迎来到《小5讲堂》 大家好,我是全栈小5。 这是《Java》序列文章,每篇文章将以博主理解的角度展开讲解, 特别是针对知识点的概念进行叙说,大部分文章将会对这些概念进行实际例子验证,以此达到加深对知识点的理解和掌握。 温馨提示:博主能力有限,理解水平有限

    2024年01月16日
    浏览(53)
  • BsinCopilot:Java版端到端大语言模型开发框架

    BsinCopilot是基于BsinPaaS开源框架构建的大语言模型应用SaaS服务,借鉴langchain的框架思想,引入  langchian4j组件,微前端微服务的架构设计,可快速助您构建和体验端到端的AI应用。 概念 说明 Bsin 毕昇缩写,毕昇,中国北宋发明家,活字印刷术的发明者。毕昇出身平民,长期在

    2024年03月13日
    浏览(61)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包