四、面向对象进阶

4.1 多态的核心定义与实现条件

• 4.1.1 多态的定义：同一方法在不同对象上有不同的实现形式

多态是面向对象编程的核心特性，它的本质是同一个方法在不同对象上会表现出不同的实现形式。简单来说，就是调用同一个方法名时，因为对象的实际类型不同，最终执行的代码逻辑也会完全不同，实现了 “一种接口，多种实现” 的灵活设计。

• 4.1.2 多态的三大实现条件：继承、方法重写、父类引用指向子类对象

• 继承：需要存在父类（或接口、抽象类）与子类的层级关系；
• 方法重写：子类必须对父类的方法提供自己的具体实现，以此体现行为差异；
• 父类引用指向子类对象：在代码中使用父类类型的引用变量来接收子类实例，这是让多态在运行时生效的语法基础。

4.2 多态的底层原理（动态绑定）

• 4.2.1 动态绑定的核心逻辑

       动态绑定（也叫运行时绑定）是多态得以实现的底层核心，它的核心逻辑是：在编译阶段，编译器只根据引用的类型确定可调用的方法范围，而真正执行哪一个子类的方法实现，要等到程序运行时，由 JVM 根据引用所指向的实际对象类型来决定。简单来说就是 “编译看左边，运行看右边”—— 编译时只检查父类是否有该方法，运行时才会去调用对应子类的重写版本，这也是多态能表现出 “同一方法不同行为” 的根本原因。

• 4.2.2 动态绑定与静态绑定的区别

        静态绑定是在编译阶段就确定了要执行的方法，比如private、static、final修饰的方法以及构造方法，它们在编译时就能明确调用目标，运行时不会再改变，优点是执行效率高，但缺乏扩展性；动态绑定则是在运行时才确定方法的具体实现，普通的非静态成员方法都遵循动态绑定，它能让程序根据实际对象类型灵活选择行为，是多态的基础，但会带来轻微的运行时开销。简单总结：静态绑定在编译期确定，适合固定不变的逻辑；动态绑定在运行期确定，适合需要扩展、多态的业务场景。

4.3 多态的两种实现方式

• 4.3.1 方式1：继承+方法重写

这种方式是多态最基础的实现形式，核心是通过子类继承父类，并对父类的方法进行重写，再用父类引用指向子类对象，从而实现 “同一方法不同行为”。

// 父类（抽象类，定义统一接口）
abstract class BaseModel {
    // 定义抽象方法，要求子类必须实现
    public abstract void callModel();
}

// 子类1：豆包模型，继承父类并重写方法
class DoubaoModel extends BaseModel {
    @Override
    public void callModel() {
        System.out.println("调用豆包大模型，生成智能回答");
    }
}

// 子类2：通义模型，继承父类并重写方法
class TongyiModel extends BaseModel {
    @Override
    public void callModel() {
        System.out.println("调用通义大模型，执行文本生成");
    }
}

// 测试类
public class PolymorphismDemo1 {
    public static void main(String[] args) {
        // 父类引用指向不同子类对象（向上转型）
        BaseModel model1 = new DoubaoModel();
        BaseModel model2 = new TongyiModel();
        
        // 调用同一个方法名，执行不同子类的实现
        model1.callModel(); // 输出：调用豆包大模型，生成智能回答
        model2.callModel(); // 输出：调用通义大模型，执行文本生成
    }
}

这种方式依赖类的继承关系，父类定义统一的方法规范，子类通过重写提供具体实现。在调用时，父类引用可以指向任意子类实例，JVM 会在运行时根据对象实际类型，动态绑定到对应的子类方法，从而实现多态行为。

• 4.3.2 方式2：接口+实现类

接口是 Java 中实现多态更灵活、更推荐的方式，核心是接口定义行为规范，实现类提供具体逻辑，同样通过 “接口引用指向实现类对象” 来触发多态。

// 接口：定义模型调用的统一规范
interface ModelService {
    void invoke();
}

// 实现类1：OpenAI模型，实现接口方法
class OpenAIModel implements ModelService {
    @Override
    public void invoke() {
        System.out.println("调用OpenAI模型，进行对话生成");
    }
}

// 实现类2：讯飞模型，实现接口方法
class XunfeiModel implements ModelService {
    @Override
    public void invoke() {
        System.out.println("调用讯飞大模型，执行语音转文字");
    }
}

// 测试类
public class PolymorphismDemo2 {
    public static void main(String[] args) {
        // 接口引用指向不同实现类对象
        ModelService service1 = new OpenAIModel();
        ModelService service2 = new XunfeiModel();
        
        // 调用同一个接口方法，执行不同实现类的逻辑
        service1.invoke(); // 输出：调用OpenAI模型，进行对话生成
        service2.invoke(); // 输出：调用讯飞大模型，执行语音转文字
    }
}

接口不涉及具体实现，只约定 “能做什么”，实现类则负责 “怎么做”。相比继承，接口避免了单继承的限制，一个类可以实现多个接口，让代码扩展性更强。在智能体开发中，这种方式尤其适合对接不同厂商的大模型 —— 只需新增实现类，无需修改原有代码，就能无缝切换模型

4.4 多态的优势与注意事项

• 4.4.1 优势：降低耦合度、提高代码灵活性（结合智能体多模型切换场景说明，理解多态在实际开发中的价值）

多态最核心的价值在于解耦与扩展，它让程序依赖抽象而非具体实现，在智能体多模型切换场景中体现得尤为明显：

• 降低耦合度：业务代码只依赖父类 / 接口（如BaseModel），不与任何具体子类（如DoubaoModel、TongyiModel）绑定，模块间依赖关系更松散。
• 提高代码灵活性：新增模型时只需新增子类并实现方法，无需修改原有调用逻辑，实现 “热插拔” 式扩展。
• 统一调用入口：无论底层切换为哪个模型，上层调用代码始终保持model.invoke()不变，大幅提升可维护性。

在智能体开发中，这意味着我们可以在不改动核心业务代码的前提下，灵活切换豆包、通义、讯飞等不同厂商的大模型，完美适配需求变化。

• 4.4.2 注意事项：父类引用不能调用子类独有的方法（向下转型的使用，代码示例，自身实操向下转型，标注转型的注意事项，避免类型转换异常）

当使用父类引用指向子类对象时，编译器只认可父类中定义的方法，子类独有的方法无法被直接调用。若需要调用子类特有功能，必须使用向下转型。

// 父类
abstract class BaseModel {
    public abstract void invoke();
}

// 子类：豆包模型，新增独有方法
class DoubaoModel extends BaseModel {
    @Override
    public void invoke() {
        System.out.println("调用豆包大模型");
    }

    // 子类独有方法：流式输出
    public void streamOutput() {
        System.out.println("豆包模型：开启流式输出");
    }
}

// 测试
public class PolymorphismNoticeDemo {
    public static void main(String[] args) {
        // 向上转型：父类引用指向子类对象
        BaseModel model = new DoubaoModel();
        model.invoke(); //  正常调用（父类定义的方法）
        // model.streamOutput(); //  编译报错：父类无此方法

        // 向下转型：恢复为子类类型
        if (model instanceof DoubaoModel) { // 先判断类型，避免异常
            DoubaoModel doubao = (DoubaoModel) model;
            doubao.streamOutput(); //  正常调用子类独有方法
        }
    }
}

向下转型注意事项

1. 必须先向上转型：只有原本是子类对象、被向上转型为父类引用的实例，才能安全向下转型回原子类。
2. 使用instanceof判断：转型前务必用instanceof检查引用指向的真实对象类型，否则会抛出ClassCastException（类型转换异常）。
3. 避免滥用：过度使用向下转型会破坏封装性，说明抽象设计可能存在缺陷，应优先考虑将子类共性方法提升到父类 / 接口中。

4.5 核心关键字详解

• 4.5.1 static关键字：静态变量、静态方法、静态代码块

static 表示 “属于类，不属于对象”，被它修饰的成员会在类加载时初始化，无需创建对象即可直接访问。

• 静态变量：所有对象共享一份数据，适合存储全局配置（如智能体超时时间）。
• 静态方法：可通过类名直接调用，不能访问非静态成员，常用来编写工具类方法。
• 静态代码块：类加载时自动执行一次，用于初始化静态资源（如加载 API 配置）。

注意事项：静态方法无法实现多态，不能直接访问非静态变量 / 方法，避免在静态方法中编写依赖对象状态的逻辑。

• 4.5.2 final关键字：修饰变量、方法、类

final 表示 “不可改变”，不同修饰位置含义不同：

• 修饰变量：变量一旦赋值就不能修改，适合存储固定配置（如智能体 API 密钥、版本号）。
• 修饰方法：方法不能被子类重写，保护核心业务逻辑不被篡改。
• 修饰类：类不能被继承，保证类的行为稳定（如 Java 中的 String 类）。

注意事项：final 修饰引用变量时，仅限制引用指向不能改变，对象内部属性仍可修改。

• 4.5.3 this关键字：调用成员变量、方法、构造方法

this 代表 “当前对象自身”，主要有三个用途：

• 调用成员变量：区分局部变量与成员变量同名的场景（如构造方法中给成员变量赋值）。
• 调用成员方法：显式调用当前对象的其他方法，增强代码可读性。
• 调用构造方法：在一个构造方法中调用本类的其他构造方法，必须放在构造方法第一行。

与 super 的区别：this 指向当前对象，super 指向父类对象；this() 调用本类构造，super() 调用父类构造。

• 4.5.4 abstract关键字：抽象类与抽象方法

abstract 用于定义 “只规范行为、不提供实现” 的抽象结构：

• 抽象类：不能被实例化，可包含抽象方法与普通方法，作为子类的模板。
• 抽象方法：只有方法声明、没有方法体，强制子类必须重写实现。

抽象类的核心作用是提取共性、规范行为，在智能体开发中常用来定义模型基类，要求所有具体模型必须实现统一的调用方法。

注意事项：包含抽象方法的类必须是抽象类；抽象类的子类必须重写所有抽象方法，否则子类也需声明为抽象类。

五、异常处理

5.1 异常的核心概念与分类

• 5.1.1 异常的定义：程序运行时出现的不正常情况

它会打断正常的执行流程，导致代码无法继续按预期运行。与 “错误”（Error，如虚拟机崩溃、内存溢出）不同，异常（Exception）通常是可预见、可捕获并处理的，比如文件不存在、网络请求失败、空指针访问等，是开发中需要重点处理的问题。

• 5.1.2 异常分类

Java 中的异常主要分为两大类：

• Checked 异常（编译时异常）必须在代码中显式处理（捕获或声明抛出），否则编译器会报错。这类异常是可预见的外部问题，比如 IOException（文件读写失败）、SQLException（数据库操作失败），在智能体开发中常出现在文件读取、API 调用等场景。

• Unchecked 异常（运行时异常）编译器不强制要求处理，通常由代码逻辑错误导致，在运行时才会抛出。比如 NullPointerException（空指针）、ArrayIndexOutOfBoundsException（数组越界）、IllegalArgumentException（参数非法），这类异常需要通过优化代码逻辑来避免。运行时异常一定会直接或间接得到继承RuntimeException。

5.2 异常处理机制详解

• 5.2.1 try-catch-finally：语法、执行顺序

 是 Java 最基础的异常处理语法，用于捕获并处理运行时可能出现的异常，保证程序在出错后仍能稳定执行。其中的finally下面的代码块无论什么情况都会执行

try {
    // 可能抛出异常的代码
} catch (ExceptionType e) {
    // 捕获并处理对应类型的异常
} finally {
    // 无论是否发生异常，都会执行的代码
}

• 正常情况：try 代码块执行完毕 → 进入 finally → 继续执行后续代码。
• 异常情况：try 中抛出异常 → 匹配到对应 catch 并执行处理逻辑 → 进入 finally → 继续执行后续代码。
• finally 块一定会执行（除非调用 System.exit(0) 终止虚拟机），常用于释放资源（如关闭文件流、网络连接）。

public void readConfigFile(String path) {
    FileReader reader = null;
    try {
        reader = new FileReader(path);
        // 读取文件内容
    } catch (FileNotFoundException e) {
        System.out.println("配置文件不存在：" + e.getMessage());
    } catch (IOException e) {
        System.out.println("文件读取失败：" + e.getMessage());
    } finally {
        // 无论是否异常，都关闭文件流，避免资源泄漏
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

易错点：

• 如果在 try 或 catch 中使用 return，finally 块仍会在 return 之前执行；
• 不要在 finally 中使用 return 或 throw，否则会覆盖 try/catch 中的返回值或异常。

• 5.2.2 throw与throws：手动抛出异常、声明异常

• throw：用于在方法内部手动抛出一个具体的异常对象，表示当前逻辑发现了问题并主动中断。
• throws：用于在方法声明中标记该方法可能抛出的异常类型，提醒调用者必须处理这些异常。

// 方法声明：可能抛出 ApiException
public void callModelAPI(String apiKey) throws ApiException {
    if (apiKey == null || apiKey.isEmpty()) {
        // 手动抛出异常：API 密钥无效
        throw new ApiException("API 密钥不能为空或 null");
    }
    // 模拟 API 调用逻辑
    System.out.println("调用大模型 API...");
}

// 调用方必须处理（捕获或继续抛出）异常
public static void main(String[] args) {
    try {
        callModelAPI(null);
    } catch (ApiException e) {
        System.out.println("API 调用失败：" + e.getMessage());
    }
}

核心区别：

• throw 是动作：在方法内抛出一个异常实例；
• throws 是声明：在方法签名上告知调用者此方法可能抛出的异常类型。

5.3 异常处理规范与最佳实践

 在异常处理时，我们需要遵循三个核心规范来保证代码的健壮性与可维护性：首先，应精准捕获具体异常类型，避免使用 catch (Exception e) 这种写法，因为他是所有异常的父类所以肯定可以 运行，但是这个返回的异常信息不利于定位和解决问题因为太过于 笼统；其次，捕获异常后必须打印异常信息（如调用 e.printStackTrace()），这能帮助我们快速定位异常发生的位置、原因和调用栈，是排查线上问题的关键依据；最后，严禁在 finally 块中修改返回值或抛出新异常，否则会覆盖 try 或 catch 中的原有返回值或异常，导致程序逻辑混乱，为之后的排查增加工作量。

六、泛型+JavaIO基础

6.1 泛型基础

• 6.1.1 泛型的核心作用：解决类型不安全、强制类型转换的问题，提高代码复用性

泛型的核心价值是在编译期保障类型安全、消除强制类型转换、提升代码复用性。在没有泛型时，集合只能存储 Object，取出时需要手动强转，容易出现 ClassCastException；泛型通过在代码中明确类型约束，让编译器提前检查类型错误，避免运行时异常。

在智能体场景中，比如存储会话信息：

• 无泛型：List list = new ArrayList()，可能混入非 Session 类型数据，取出时强转易出错；
• 有泛型：List<Session> sessions = new ArrayList<>()，编译器保证只能存入 Session 对象，取出时直接使用，无需强转，更安全高效。

• 6.1.2 泛型的定义：类泛型、方法泛型

泛型通过 <类型参数> 来定义，常见于类、接口和方法中。

类泛型：在类声明时指定类型参数，整个类内都可使用。

// 泛型类：智能体结果包装类
public class AgentResult<T> {
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

// 使用：指定类型为 String（文本回答）
AgentResult<String> textResult = new AgentResult<>();
textResult.setData("你好！");

方法泛型：在方法声明时指定类型参数，仅作用于当前方法。

// 泛型方法：打印任意类型数据
public <T> void printData(T data) {
    System.out.println("数据：" + data);
}

// 使用：自动推断类型
printData("智能体回答"); // T = String
printData(100);         // T = Integer

• 6.1.3 类型擦除机制：泛型只在编译时有效，运行时会被擦除为Object类型

Java 泛型是伪泛型，只在编译期有效，运行时会被擦除为 Object 类型（或边界类型），这就是类型擦除。

核心逻辑：

• 编译时：编译器检查泛型约束，确保类型安全；
• 运行时：JVM 看不到泛型信息，List<String> 和 List<Integer> 都被视为 List，类型参数被替换为 Object。

注意：这也是为什么运行时无法直接判断 list 是 List<String> 还是 List<Integer>，泛型信息仅存在于编译阶段。

• 6.1.4 泛型通配符：?、? extends T、? super T（使用场景，代码示例，自身实操，掌握常用通配符的用法）

泛型通配符用于灵活处理泛型的继承关系，主要有三种：

通配符	含义	使用场景
?	无界通配符，代表任意类型	只读取数据，不关心具体类型
? extends T	上界通配符，代表 T 或 T 的子类	读取优先：只能获取 T 类型，不能存入
? super T	下界通配符，代表 T 或 T 的父类	存入优先：只能存入 T 或子类，获取时为 Object

// 上界通配符：读取 Session 或其子类
public void readSessions(List<? extends Session> list) {
    for (Session s : list) {
        System.out.println(s.getId());
    }
}

// 下界通配符：存入 Session 或其子类
public void addSession(List<? super Session> list) {
    list.add(new Session()); // 允许存入 Session
}

6.2 JavaIO基础

• 6.2.1 IO核心概念：输入流（读数据）、输出流（写数据）

Java IO（Input/Output）是程序与外部设备（文件、网络、控制台）进行数据交互的核心机制，其核心概念可概括为 “流”（Stream）：

• 输入流（Input Stream）：读数据。将外部设备（如本地文件、网络接口）中的数据读取到程序内存中。
• 输出流（Output Stream）：写数据。将程序内存中的数据（如生成的回答、日志信息）写入到外部设备（文件、控制台）。

• 6.2.2 IO流分类：字节流与字符流（区别，结合智能体场景，说明字符流的常用场景，如读取知识库文本）

Java 流主要分为字节流和字符流两大类，核心区别在于处理数据的单位：

流类型	单位	核心特点	智能体场景应用
字节流 (Byte Stream)	字节 (8bit)	处理所有类型数据（图片、视频、音频、文本），最底层，通用性最强。	RAG 场景的文件二进制读取、加载非文本资源。
字符流 (Character Stream)	字符 (16bit)	专门处理文本数据，基于编码转换，可读性好，处理中文更高效。	读取知识库 .txt 文件、处理日志文本、直接输出给用户的自然语言内容。

核心原则：

• 处理纯文本（如 RAG 知识库）时，优先使用 字符流，避免乱码问题。
• 处理图片、视频等二进制文件时，必须使用 字节流。

• 6.2.3 常用IO类：BufferedReader、BufferedWriter、File类

为了提升效率和操作便捷性，Java 提供了多种包装类，以下是智能体开发中最常用的两类：

• File 类：文件 / 目录的抽象表示

  • 作用：用于获取文件属性、创建 / 删除文件 / 目录、判断路径是否存在等，不负责文件内容的读写。
  • 核心用法：
    • exists()：判断文件是否存在
    • isFile()：判断是否为文件
    • getPath()/getAbsolutePath()：获取路径

• BufferedReader (字符缓冲流)：高效读取文本

  • 作用：装饰字符输入流，提供缓冲区，减少磁盘 IO 次数，大幅提高读取效率。在读取大文件或知识库文本时必备。
  • 核心方法：readLine()（一次读取一行文字，非常适合按行处理文本）。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class IODemo {
    public static void main(String[] args) {
        // 1. 定义文件路径（模拟智能体知识库路径）
        String filePath = "data/knowledge_base.txt";
        
        // 2. 创建 File 对象，先做合法性检查
        File file = new File(filePath);
        
        try (
            // 3. 创建缓冲流，自动关闭资源 (try-with-resources)
            BufferedReader br = new BufferedReader(new FileReader(file))
        ) {
            // 4. 判读文件是否存在且为普通文件
            if (!file.exists() || !file.isFile()) {
                System.out.println("知识库文件不存在！");
                return;
            }

            String line;
            // 5. 按行读取知识库内容
            while ((line = br.readLine()) != null) {
                // 模拟 RAG 检索逻辑：对每一行内容进行处理
                System.out.println("读取知识库：" + line);
            }
        } catch (IOException e) {
            // 6. 异常处理，打印堆栈信息便于排查
            e.printStackTrace();
        }
    }
}

• 6.2.4 实操练习：编写文件读取Demo，模拟智能体读取本地知识库文本文件（.txt格式）

需求：编写一个专门读取本地 .txt 知识库的 Demo，模拟 RAG 检索流程。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
 * 智能体 RAG 本地知识库读取工具
 * 功能：读取本地 .txt 文件，模拟向量数据库检索前的文档加载
 */
public class RAGKnowledgeReader {

    // 读取知识库的方法
    public static void loadKnowledgeBase(String path) {
        File knowledgeFile = new File(path);

        // 前置检查
        if (!knowledgeFile.exists()) {
            System.err.println("错误：知识库文件不存在 -> " + path);
            return;
        }
        if (!knowledgeFile.isFile()) {
            System.err.println("错误：路径不是文件 -> " + path);
            return;
        }

        // 使用 try-with-resources 自动关闭资源
        try (BufferedReader reader = new BufferedReader(new FileReader(knowledgeFile))) {
            System.out.println("=== 开始加载智能体知识库 ===");
            String content;
            int lineCount = 0;

            // 逐行读取
            while ((content = reader.readLine()) != null) {
                // 模拟处理逻辑：去除空行，准备送入向量模型
                if (!content.trim().isEmpty()) {
                    lineCount++;
                    System.out.printf("【加载第 %d 行】: %s%n", lineCount, content);
                    // 实际项目中，此处会调用 Embedding 接口生成向量
                }
            }
            System.out.println("=== 知识库加载完成，共读取 " + lineCount + " 行有效内容 ===");

        } catch (IOException e) {
            System.err.println("读取知识库失败：" + e.getMessage());
            e.printStackTrace();
        }
    }

    // 主函数测试
    public static void main(String[] args) {
        // 假设项目根目录下有一个 knowledge.txt 作为知识库
        String knowledgePath = "knowledge.txt"; 
        loadKnowledgeBase(knowledgePath);
    }
}