#Java 对象创建方式

// 最常见的创建方式
Person person = new Person("Alice", 30);

// 编译后字节码：
// new Person           // 在堆中分配内存，创建对象
// dup                  // 复制引用（用于后续调用）
// ldc "Alice"          // 加载常量
// bipush 30           // 加载整数
// invokespecial Person.<init>  // 调用构造器
// astore_1            // 存储到局部变量表

// JDK 8
Class<Person> clazz = Person.class;
Person p = clazz.newInstance(); // 调用无参构造器

// 缺点：
// 1. 只能调用无参构造器
// 2. 权限检查：private 构造器无法调用
// 3. JDK 9+ 废弃

Class<Person> clazz = Person.class;

// 无参构造器
Person p1 = clazz.getDeclaredConstructor().newInstance();

// 有参构造器
Constructor<Person> ctor = clazz.getDeclaredConstructor(String.class, int.class);
Person p2 = ctor.newInstance("Alice", 30);

// 可以访问 private 构造器
Constructor<Person> privateCtor = clazz.getDeclaredConstructor(String.class);
privateCtor.setAccessible(true);
Person p3 = privateCtor.newInstance("Bob");

// Spring IOC 使用 Constructor.newInstance() 创建 Bean
// BeanWrapperImpl 中：
public void createBean(Class<?> beanClass) {
    Constructor<?> ctor = BeanUtils.findPrimaryConstructor(beanClass);
    reflectionSupport.makeAccessible(ctor);
    return ctor.newInstance(args);
}

class Person implements Cloneable {
    String name;
    Person(String name) { this.name = name; }

    @Override
    protected Person clone() throws CloneNotSupportedException {
        return (Person) super.clone(); // 调用 Object.clone()
    }
}

Person p1 = new Person("Alice");
Person p2 = p1.clone(); // 不需要调用构造器

public class DeepCopyUtil {
    public static <T extends Serializable> T deepCopy(T obj) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectObjectStream(bos);
            oos.writeObject(obj);
            oos.close();

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            @SuppressWarnings("unchecked")
            T copy = (T) ois.readObject();
            return copy;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

import sun.misc.Unsafe;

Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
Unsafe unsafe = (Unsafe) f.get(null);

// 方式一：分配内存但不调用构造器
Person person = (Person) unsafe.allocateInstance(Person.class);
// person.name = null（构造器未执行！）

// 方式二：直接分配指定大小的内存
long address = unsafe.allocateMemory(16); // 分配 16 字节

// 场景一：普通业务代码
Person p = new Person("Alice", 30); // ✅ 推荐

// 场景二：框架创建 Bean
// Spring IOC 使用 Constructor.newInstance()
// MyBatis 使用 Constructor.newInstance()

// 场景三：原型模式
public class PrototypeManager {
    private Map<String, Cloneable> prototypes = new HashMap<>();

    public Cloneable getClone(String key) {
        return prototypes.get(key).clone();
    }
}

// 场景四：高性能序列化
// FastJSON 使用 Unsafe + 手动字段设置
// Kryo 使用低拷贝序列化

// 1. 类加载检查
//    如果类还没加载，先进行类加载（加载-验证-准备-解析-初始化）

// 2. 分配内存
//    - 指针碰撞（内存规整）：CAS 更新指针
//    - 空闲列表（内存碎片）：维护空闲块列表

// 3. 设置对象头
//    Mark Word: 哈希码、GC 年龄、锁状态
//    Klass 指针: 指向方法区的类元数据
//    数组长度: 如果是数组

// 4. 初始化字段
//    设置零值（零值初始化）

// 5. 执行构造器
//    调用 <init> 方法