Java 基础核心知识点总结：深拷贝、泛型、对象与反射

• 使用序列化和反序列化

import java.io.*;

class Person implements Serializable { 
    String name; 
    Address address; 
    // Address 也需实现 Serializable 
}

public class DeepCopyUtils { 
    public static <T extends Serializable> T deepCopy(T obj) { 
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
             ObjectOutputStream oos = new ObjectOutputStream(bos)) { 
            oos.writeObject(obj); 
            try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); 
                 ObjectInputStream ois = new ObjectInputStream(bis)) { 
                return (T) ois.readObject(); 
            } 
        } catch (IOException | ClassNotFoundException e) { 
            throw new RuntimeException("Deep copy failed", e); 
        } 
    } 
}
// 使用示例
Person original = new Person();
Person deepCopy = DeepCopyUtils.deepCopy(original);

• 手动递归复制

class Person { 
    String name; 
    Address address; 
    public Person deepCopy() { 
        Person copy = new Person(); 
        copy.name = this.name; 
        copy.address = this.address.deepCopy(); // 手动递归复制 
        return copy; 
    } 
} 

class Address { 
    String city; 
    public Address deepCopy() { 
        Address copy = new Address(); 
        copy.city = this.city; 
        return copy; 
    } 
}
// 使用示例
Person original = new Person();
Person deepCopy = original.deepCopy();

对比总结

2. 泛型

2.1 定义

泛型是 Java 中的一个特性，它允许在定义类和方法和接口时只需要指定一个或者多个类型参数（泛型符号）就行，在使用时再指定具体的类型。

2.2 作用

当多个类需要共享相同代码逻辑时，可以通过定义泛型来实现。泛型允许在使用时指定具体类型，使不同类都能复用相同的代码逻辑。 由于泛型在定义时使用类型参数而非具体类型，它可以接收任何类型参数而无需强制类型转换，从而避免了类型安全问题。

3. 对象

3.1 创建对象的方式

• 通过 new 关键字创建对象
• 通过克隆创建对象
• 通过反射创建对象
• 通过反序列化创建对象

3.2 对象回收

对象是由垃圾回收器回收，垃圾回收器会在程序运行时自动运行，周期性去检查对象是否被引用，没有就直接回收，释放内存。

垃圾回收器实现的主要的机制：

1. 引用计数法：它会根据该对象的引用计数，如果为 0，代表没有被引用直接回收释放。
2. 可达性分析算法：它会从根对象出发，根据根对象的属性和方法的引用链来判断，如果这个对象没有一个引用链那么代表没有被引用，直接回收释放内存。
3. 终结器：在对象里面你可以重写 finalize() 方法，如果重写了该方法，那么垃圾回收器在回收该对象之前会先执行该方法，但是会出现一个问题，你清楚你的这个对象什么时候被回收吗？不确定时间，那么该方法执行的时间也不确定，因此会出现一些可能会出现的问题（可能导致性能问题、死锁和资源争用），就比如性能问题，如果你在 finalize() 方法中释放了某些资源，但是由于不确定时间释放，就会导致一些性能问题（可能都不会释放）。

3.3 获取私有成员

由于定义的私有成员，那么只能该类内部访问，如果外部需要访问：

• 你对外提供方法来访问（比 getter 方法）
• 你通过反射直接获取该成员

4. 反射

4.1 定义

反射就是可以获取任何一个类里面的全部信息（父类，实现的接口都可以），并且反射可以调用任何一个类里面的成员。

4.2 特性

4.3 原理

编译器会将源代码先编译成字节码，然后 JVM 根据字节码翻译成机器码，而反射就是通过字节码从而知道类的全部信息。

5. 异常

5.1 异常的种类

5.2 处理异常的方法

• 使用 try-catch-finally（包裹可能会出现异常的代码）
• 手动抛出异常（throw）
• 方法或类抛出异常（throws）

如果你使用 try-catch-finally 那么你需要注意：

当 try 代码块中的语句发生异常时，后续代码将不会执行，异常会立即传递给 catch 块。如果 catch 块未能捕获对应类型的异常，该异常会继续向上层抛出（例如方法 b 抛出的异常可被调用它的方法 a 捕获）。

catch 接收到异常那么就会执行 catch 里面的对应代码。

如果定义了 finally，不管有没有异常，finally 都会执行（常用于释放锁）。

执行顺序规则（finally，如果 return 在前，finally 在后）

1. return 语句计算返回值：先将返回值存储到临时变量中。
2. 执行 finally 块：无论是否有 return 或异常，finally 都会执行。
3. 方法返回临时变量中的值：如果 finally 中没有新的 return，则返回最初的值；如果 finally 中有 return，则会覆盖原值。

6. Object

6.1 等于与 equals() 区别

等于就是：比较基本类型比值，比较引用类型比地址（比表面的）。 而 equals()：你如果重写了该方法，那么比较引用类型时比较里面的属性值，没有重写与等于一样。

6.2 hashCode() 与 equals() 关系

前提：你如果要重写这其中的一个方法，那么另外一个也需要重写（约定）。

一致性：当 equals() 比较对象相等时，那么 hashCode 也一定相等（本质就是根据内部值计算出哈希值，而内部值都相等了，你的哈希值肯定相等）。

不一致性：当 hashCode 相等时，equals() 不一定相等，因为你不同的对象计算出来的哈希值可能相同（哈希冲突）。

6.3 String、StringBuffer、StringBuilder 的区别

1. 可变性 解释：在 Java 中，String 对象一旦创建就不可修改，具有不可变性。每次对 String 进行修改时，实际上都会创建一个新的 String 对象（数组也有类似特性）。而 StringBuffer、StringBuilder 可变。

2. 线程安全性 解释：由于 String 不可变，因此天然的线程安全，而 StringBuilder 是线程不安全的（单线程来访问最好），StringBuffer 是线程安全的，其内部方法（在 StringBuilder 方法上）实现了悲观锁 synchronized。

3. 性能 解释：由于 String 每次修改就需要创建一个新的对象，因此性能低，StringBuffer 由于内部方法实现了锁（而锁本身就会影响性能），因此性能一般，StringBuilder 性能最好。

7. 序列化

7.1 JVM 之间的传递对象

1. 使用序列化和反序列化 解释：你先通过序列化将对象序列化成字节流存入文件中，再将文件传输，接收到文件后再将文件反序列化成对象即可。

2. 使用消息队列 解释：使用消息队列 (RabbitMQ、Kafka) 来传递消息，另一边接收消息即可。

3. 使用远程方法（RPC）

4. 使用数据库 (MYSQL) 或缓存 (Redis) 解释：比如将对象之间存入数据库或缓存中，直接访问数据即可。

8. 设计模式

代理模式：

• 目的：控制对象的访问或增加一些新的方法
• 内容：抽象主题，真实主题，代理三个角色

适配器模式：

• 目的：转换接口，是不兼容的类可以并行执行
• 内容：目标接口，适配器，被适配对象

9. I/O

9.1 实现网络 IO 高并发编程

使用 NIO，NIO 是同步非阻塞执行的，NIO 是基于 I/O 多路复用实现的，它可以只用一个线程处理多个客户端 I/O，如果你需要同时管理成千上万的连接，但是每个连接只发送少量数据，例如一个聊天服务器，用 NIO 实现会更好一些。

9.2 BIO、NIO、AIO 区别

解释：

• 同步阻塞式执行：就是说你发完一个消息后，你会一直等待别人回你消息，并且在等待的过程中不会干任何事情。
• 同步非阻塞执行：就是说你发完一个消息后，你会一直等待别人回你消息，但是在等待的过程中你可以做一些自己的事情。
• 异步非阻塞执行：就是说你发完一个消息后，你不会等待别人回你消息。