Java 创建对象的方式

Gavin James2019/4/28大约 5 分钟

Java 创建对象的方式

创建对象是 Java 里最基本的操作，但除了最常见的 new，还有反射、克隆、反序列化等多种途径。理解它们的差异，有助于在框架开发、对象拷贝、缓存等场景做出正确选择。

1. 概览

方式	是否调用构造器	典型用途
`new`	是	普通对象创建
反射（`newInstance` / `Constructor`）	是	框架、IoC 容器、动态加载
克隆（`clone`）	否	复制已有对象的副本
反序列化	否	对象持久化 / 网络传输后还原
`Unsafe.allocateInstance`	否	绕过构造器分配实例（序列化框架内部用）
工厂 / 建造者 / 单例	视实现	封装创建逻辑、控制实例数量

下面统一以 Worker 类为例（含无参与有参构造器、实现 Cloneable 与 Serializable）。

2. 使用 new

最直接的方式，编译期即确定类型，可读性与性能最好。绝大多数业务对象都应当用它创建。

public class WorkerFactory {
    public static Worker createWorker() {
        return new Worker();
    }

    public static Worker createWorker(String name, int age) {
        return new Worker(name, age);
    }
}

3. 使用反射

反射在运行时根据类名创建对象，是各种框架（IoC、ORM、RPC）的基础。

3.1 Class.newInstance()

public static Worker createByNewInstance() throws Exception {
    Class<?> clazz = Class.forName("com.example.creation.Worker");
    // 仅能调用无参构造器，且要求构造器可访问
    return (Worker) clazz.newInstance();
}

Class.newInstance() 已被标记为过时（deprecated），推荐改用 Constructor.newInstance()，它能明确要求使用构造器，异常处理也更清晰。

3.2 Constructor.newInstance()

import java.lang.reflect.Constructor;

public static Worker createByConstructor() throws Exception {
    Class<?> clazz = Class.forName("com.example.creation.Worker");
    Constructor<?> ctor = clazz.getConstructor();        // 无参
    return (Worker) ctor.newInstance();
}

public static Worker createByConstructor(String name, Integer age) throws Exception {
    Class<?> clazz = Class.forName("com.example.creation.Worker");
    Constructor<?> ctor = clazz.getConstructor(String.class, int.class);
    return (Worker) ctor.newInstance(name, age);
}

反射的注意点

反射调用有性能开销，频繁创建时应缓存 Class / Constructor；
反射能突破访问控制（setAccessible(true)），但会带来安全与模块化（JPMS）限制；
反射通常与"通过类名创建"绑定，类名拼写错误会在运行时才暴露。

4. 序列化与反序列化

序列化把对象状态写成字节流，反序列化则在还原时创建对象。这条路径常常是破解单例、绕过构造器校验的入口，因此也备受安全关注。

import java.io.*;

public class SerializeDemo {
    // 写出对象
    public static void storeObject(String path, Worker worker) throws IOException {
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(path))) {
            out.writeObject(worker);
        }
    }

    // 从字节流还原对象
    public static Worker loadObject(String path) throws IOException, ClassNotFoundException {
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(path))) {
            return (Worker) in.readObject();
        }
    }
}

被序列化的类必须实现 Serializable，并建议显式声明 serialVersionUID，否则类结构变化后反序列化可能失败。

5. 深拷贝 / 克隆

clone 直接复制已有对象，不经过构造器。

public class Worker implements Cloneable, Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Worker() {
        this.name = "";
        this.age = 0;
    }

    public Worker(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public Worker clone() throws CloneNotSupportedException {
        return (Worker) super.clone();
    }
}

浅拷贝 vs 深拷贝

Object.clone() 默认是浅拷贝：基本类型字段被复制，引用类型字段仍指向同一个对象。若字段是可变对象（如 List），需要手动对每个引用字段再克隆，或改用"序列化再反序列化"实现深拷贝。经典的深拷贝实现可以借助 ByteArrayOutputStream + ObjectOutputStream 把对象写出再读回。

6. 绕过构造器：Unsafe 与 Objenesis

序列化框架（如 Kryo、部分 ORM）如果调用构造器会带来副作用，于是需要"不调用构造器而分配实例"的能力：

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public static Worker createWithoutConstructor() throws Exception {
    Field f = Unsafe.class.getDeclaredField("theUnsafe");
    f.setAccessible(true);
    Unsafe unsafe = (Unsafe) f.get(null);
    return (Worker) unsafe.allocateInstance(Worker.class);
}