JavaSE 核心知识点总结 | 极客日志

Javajava

JavaSE 核心知识点总结

JavaSE 核心知识点涵盖面向对象、String、异常处理、I/O、序列化、网络编程、泛型、反射及 Lambda 表达式。文章对比了深拷贝与浅拷贝实现，分析了 String 不可变性原理，梳理了异常体系与处理机制，区分了 BIO、NIO、AIO 模型差异，并讲解了泛型擦除策略及反射的动态调用原理。内容旨在帮助开发者系统掌握 Java 基础理论与常用 API 应用。

steve发布于 2026/3/28更新于 2026/4/230 浏览

JavaSE 核心知识点总结

一、面向对象

1、深拷贝和浅拷贝的区别

在 Java 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种拷贝对象的方式，它们在拷贝对象的方式上有很大不同。

浅拷贝和深拷贝示意图

浅拷贝会创建一个新对象，但这个新对象的属性（字段）和原对象的属性完全相同。如果属性是基本数据类型，拷贝的是基本数据类型的值；如果属性是引用类型，拷贝的是引用地址，因此新旧对象共享同一个引用对象。

浅拷贝的实现方式为：实现 Cloneable 接口并重写 clone() 方法。

class Person implements Cloneable { 
    String name; 
    int age; 
    Address address; 
    public Person(String name, int age, Address address) { 
        this.name = name; 
        this.age = age; 
        this.address = address; 
    } 
    @Override 
    protected Object clone() throws CloneNotSupportedException { 
        return super.clone(); 
    } 
} 
class Address { 
    String city; 
    public Address(String city) { 
        this.city = city; 
    } 
}
public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address   ();
            (, , address);
           (Person) person1.clone();
        System.out.println(person1.address == person2.address); 
    }
}

class Person { 
    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(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
    }
}

Person person = new Person();

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

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

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();

private final char value[];

public String concat(String str) { 
    if (str.isEmpty()) { 
        return this; 
    } 
    int len = value.length; 
    int otherLen = str.length(); 
    char buf[] = Arrays.copyOf(value, len + otherLen); 
    str.getChars(buf, len); 
    return new String(buf, true); 
}

public final class String

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

try { 
    // 包含可能会出现异常的代码以及声明异常的方法 
} catch(Exception e) { 
    // 捕获异常并进行处理 
} finally { 
    // 可选，必执行的代码 
}

public class Example { 
    public static void main(String[] args) { 
        try { 
            throw new Exception("Exception in try"); 
        } catch (Exception e) { 
            throw new RuntimeException("Exception in catch"); 
        } finally { 
            throw new IllegalArgumentException("Exception in finally"); 
        } 
    } 
}

public class Example { 
    public static void main(String[] args) { 
        Exception catchException = null; 
        try { 
            throw new Exception("Exception in try"); 
        } catch (Exception e) { 
            catchException = e; 
            throw new RuntimeException("Exception in catch"); 
        } finally { 
            try { 
                throw new IllegalArgumentException("Exception in finally"); 
            } catch (IllegalArgumentException e) { 
                if (catchException != null) { 
                    System.out.println("Catch exception: " + catchException.getMessage()); 
                } 
                System.out.println("Finally exception: " + e.getMessage()); 
            } 
        } 
    } 
}

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

import java.nio.ByteBuffer;
public class ByteBufferExample {
    public static void main(String[] args) {
        // 模拟接收到的数据
        byte[] receivedData = {1, 2, 3, 4, 5};
        int bufferSize = 1024; // 设置一个合理的缓冲区大小
        // 创建 ByteBuffer
        ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
        // 写入数据之前检查容量是否足够
        if (buffer.remaining() >= receivedData.length) {
            buffer.put(receivedData);
        } else {
            System.out.println("Not enough space in buffer to write data.");
        }
        // 准备读取数据：将 limit 设置为当前位置，position 设回 0
        buffer.flip();
        // 读取数据
        while (buffer.hasRemaining()) {
            byte data = buffer.get();
            System.out.println("Read data: " + data);
        }
        // 清空缓冲区以便再次使用
        buffer.clear();
    }
}

public class Person implements Serializable { 
    private String name; 
    private int age; 
    // 省略构造方法、getters 和 setters 
}

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.ser"));

Person person = new Person("张三", 18);
out.writeObject(person);

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();
    }
}

class TcpServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080); // 创建服务器端 Socket
        System.out.println("Server started, waiting for connection...");
        Socket socket = serverSocket.accept(); // 等待客户端连接
        System.out.println("Client connected: " + socket.getInetAddress());
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        String message;
        while ((message = in.readLine()) != null) {
            System.out.println("Received: " + message);
            out.println("Echo: " + message); // 回送消息
        }
        socket.close();
        serverSocket.close();
    }
}

List list = new ArrayList();
list.add("hello");
String str = (String) list.get(0); // 必须强制类型转换

// 此处 T 可以随便写为任意标识，常见的如 T、E、K、V 等形式的参数常用于表示泛型
// 在实例化泛型类时，必须指定 T 的具体类型
public class Generic<T>{ 
    private T key; 
    public Generic(T key) { 
        this.key = key; 
    } 
    public T getKey(){ 
        return key; 
    } 
}

Generic<Integer> genericInteger = new Generic<Integer>(123456);

public interface Generator<T> { 
    public T method(); 
}

class GeneratorImpl<T> implements Generator<String>{ 
    @Override 
    public String method() { 
        return "hello"; 
    } 
}

public static < E > void printArray( E[] inputArray ) { 
    for ( E element : inputArray ){ 
        System.out.printf( "%s ", element ); 
    } 
    System.out.println(); 
}

// 创建不同类型数组：Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray( intArray );
printArray( stringArray );

LinkedList<Cat> cats = new LinkedList<Cat>();
LinkedList list = cats; // 注意我在这里把范型去掉了，但是 list 和 cats 是同一个链表！
list.add(new Dog()); // 完全没问题！

LinkedList cats = new LinkedList(); // 注意：没有范型！
LinkedList list = cats;
list.add(new Dog());

Person person = new Person();

String className = "java.util.Date";
Class<?> cls = Class.forName(className);
Object obj = cls.newInstance();
System.out.println(obj.getClass().getName());

// 加载并实例化类
Class<?> cls = Class.forName("java.util.Date");
Object obj = cls.newInstance();
// 获取并调用方法
Method method = cls.getMethod("getTime");
Object result = method.invoke(obj);
System.out.println("Time: " + result);
// 访问字段
Field field = cls.getDeclaredField("fastTime");
field.setAccessible(true); // 对于私有字段需要这样做
System.out.println("fastTime: " + field.getLong(obj));

Class<?> clazz = Class.forName("com.example.MyClass");
Object instance = clazz.newInstance();

InvocationHandler handler = new MyInvocationHandler();
MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
    MyInterface.class.getClassLoader(), 
    new Class<?>[] { MyInterface.class }, 
    handler 
);

Method testMethod = testClass.getMethod("testSomething");
testMethod.invoke(testInstance);

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

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