JavaSE 核心知识点梳理：面向对象、String 与 IO 流详解

深拷贝则会递归复制所有引用对象，确保新对象与原对象完全独立，互不影响。

实现深拷贝主要有两种方式：手动复制所有引用对象，或者利用序列化与反序列化。

① 手动拷贝

class Person {
    String name;
    int age;
    Address address;

    public Person(Person person) {
        this.name = person.name;
        this.age = person.age;
        this.address = new Address(person.address.city);
    }
}

class Address {
    String city;
    public Address(String city) {
        this.city = city;
    }
}

public class Main {
    public static void main(String[] args) {
        Address address = new Address("张家口");
        Person person1 = new Person("寻星探路", 18, address);
        Person person2 = new Person(person1);
        System.out.println(person1.address == person2.address); // false
    }
}

② 序列化与反序列化

import java.io.*;

class Person implements Serializable {
    String name;
    int age;
    Address address;

    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public Person deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Person) ois.readObject();
    }
}

class Address implements Serializable {
    String city;
    public Address(String city) {
        this.city = city;
    }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address = new Address("张家口");
        Person person1 = new Person("寻星探路", 18, address);
        Person person2 = person1.deepClone();
        System.out.println(person1.address == person2.address); // false
    }
}

2. Java 创建对象有哪几种方式？

Java 中创建对象主要有四种常见方式：

1. new 关键字：最直接的方式，调用构造方法。

   Person person = new Person();
   

2. 反射机制：运行时动态创建，常用于框架开发。

   Class clazz = Class.forName("Person");
   Person person = (Person) clazz.newInstance();
   

3. clone 拷贝：需实现 Cloneable 接口。

   Person person = new Person();
   Person person2 = (Person) person.clone();
   

4. 序列化机制：通过字节流恢复对象，需实现 Serializable 接口。

   Person person = new Person();
   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
   oos.writeObject(person);
   ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
   Person person2 = (Person) ois.readObject();
   

二、String

1. String、StringBuilder 和 StringBuffer 的区别

String 是不可变的，适合存储不常变化的数据；StringBuilder 线程不安全但性能高，适合单线程频繁修改；StringBuffer 线程安全但性能略低。

String 的特点

• 对象不可变，修改操作会生成新对象。
• 适合作为 HashMap 的 Key。

StringBuilder 的特点

• 底层基于数组，支持原地修改。
• 非线程安全，多线程环境需注意同步。
• 字符串拼接 + 操作底层通常由它实现。

StringBuffer 的特点

• 与 StringBuilder 类似，但方法加了 synchronized，线程安全。
• 现代开发中较少使用，除非明确需要线程安全的可变字符串。

2. String 是不可变类吗？

是的，String 是不可变类。一旦创建，内容无法更改。这主要基于以下原因：

1. 安全性：字符串常作为参数传递（如网络连接、文件路径），不可变性防止被恶意篡改。
2. 缓存重用：字符串常量池依赖不可变性来复用相同内容的对象，节省内存。
3. 哈希值稳定：便于作为集合的 Key，无需重新计算哈希值。

如何保证不可变？

• 内部使用 private final char value[] 存储数据。
• 不提供修改内容的公共方法，修改操作返回新对象。
• 类本身声明为 final，禁止继承。

三、异常处理

1. Java 中的异常体系

Java 异常体系以 Throwable 为基类，分为 Error 和 Exception。

• Error：严重错误，JVM 通常无法处理（如 OutOfMemoryError）。
• Exception：程序可处理的异常，分为两类：
  • 编译时异常（Checked Exception）：必须捕获或声明抛出，如 IOException。
  • 运行时异常（RuntimeException）：编译器不强制处理，通常由逻辑错误引起，如 NullPointerException。

2. 异常的处理方式

1. 抛出异常：使用 throws 声明，throw 抛出，交给上层处理。

   public void test() throws Exception {
       throw new Exception("抛出异常");
   }
   

2. 捕获异常：使用 try-catch-finally。

   try {
       // 可能出错的代码
   } catch (Exception e) {
       // 处理异常
   } finally {
       // 必执行代码
   }
   

注意：如果 catch 和 finally 都抛出异常，最终抛出的是 finally 中的异常。若需保留 catch 中的异常信息，建议在 finally 中捕获并记录，避免覆盖。

四、I/O

1. Java 中 IO 流分为几种？

IO 流可从多个维度划分：

• 方向：输入流（Input Stream）、输出流（Output Stream）。
• 单位：字节流（Byte Streams）、字符流（Character Streams）。
• 功能：节点流（直接连接源/目的）、处理流（包装增强功能）、管道流（线程间通信）。

设计模式：Java IO 大量使用了装饰器模式。例如 BufferedInputStream 装饰 FileInputStream，在不改变原有结构的前提下增加缓冲功能。

InputStream input = new BufferedInputStream(
    new DataInputStream(
        new FileInputStream("data.txt")
    )
);

缓冲区溢出预防：

• 合理设置缓冲区大小。
• 写入前检查剩余容量（如 ByteBuffer.remaining()）。

2. 有了字节流为什么还要有字符流？

字符流解决了编码问题。字节流直接读写二进制，处理文本时容易因编码不一致导致乱码。字符流封装了字节转换过程，方便处理文本数据。

• 文本文件：推荐使用字符流。
• 视频/音频：推荐使用字节流。

3. BIO、NIO、AIO 之间的区别

• BIO：阻塞式 I/O，一个连接一个线程，适用于连接数少的场景。
• NIO：非阻塞 I/O，通过 Selector 多路复用，适用于连接数多但时间短的场景。
• AIO：异步 I/O，操作完成后回调通知，适用于连接数多且时间长的场景。

五、序列化

1. 什么是序列化？什么是反序列化？

• 序列化：将对象转换为字节流，用于持久化或网络传输。
• 反序列化：将字节流还原为对象。

基本步骤：实现 Serializable 接口 -> 使用 ObjectOutputStream 写入 -> 使用 ObjectInputStream 读取。

2. 有几种序列化方式？

1. Java 原生序列化：使用 ObjectOutputStream，简单但效率较低。
2. JSON 序列化：常用 Jackson 等库，跨语言性好，目前最流行。
3. ProtoBuff 序列化：Google 出品，高效紧凑，适合高性能场景。

六、网络编程

1. 了解过 Socket 网络套接字吗？

Socket 是网络通信的端点，基于 TCP 或 UDP 建立连接。

TCP 客户端示例：

class TcpClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8080);
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        out.println("Hello, Server!");
        System.out.println("Server response: " + in.readLine());
        socket.close();
    }
}

RPC 框架：远程过程调用，屏蔽底层网络细节。常见框架包括 gRPC、Dubbo、Spring Cloud OpenFeign 等。

七、泛型

1. 什么是泛型？

泛型提高了类型安全性，允许在编译时检查类型一致性，避免强制转换和 ClassCastException。

三种使用方式：

• 泛型类：class Generic<T> { private T key; ... }
• 泛型接口：interface Generator<T> { T method(); }
• 泛型方法：<T> void print(T[] array)

通配符：

• ?：不确定类型。
• T：具体类型。
• K/V：键值对。
• E：元素。

类型擦除： Java 泛型在编译期进行类型检查，运行时会擦除泛型信息以兼容旧版本 JDK。因此运行时无法获取泛型的具体类型。

八、反射

1. 什么是反射？原理？应用？

反射允许在运行时动态获取类的信息（字段、方法、构造器）并操作对象。

原理：每个类加载后都会在 JVM 方法区生成对应的 Class 对象，包含元数据。

应用场景：

• Spring 框架管理 Bean。
• 动态代理（AOP）。
• 测试框架（JUnit）扫描测试方法。
• 通用工具类（如对象拷贝）。

优缺点：

• 优点：灵活、动态、通用性强。
• 缺点：性能开销大、破坏封装性。

九、Lambda 表达式

1. Lambda 表达式了解多少？

Lambda 表达式简化了匿名方法的定义，使 Java 支持函数式编程特性。

简化线程创建：

new Thread(() -> System.out.println("Hello World")).start();

配合 Stream 流：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

其中 n -> n % 2 == 0 即为 Lambda 表达式，表示传入参数 n，返回判断结果。