public class HeapMemoryExample {
    
    // 对象在堆中分配
    public void heapAllocation() {
        // 对象在堆中分配内存
        Object obj = new Object();
        
        // 数组在堆中分配
        int[] array = new int[1000];
        
        // 字符串在堆中分配（字符串常量池在方法区）
        String str = new String("Hello");
    }
}

public class StackFrameExample {
    
    public int calculate(int a, int b) {
        // 栈帧包含：
        // 1. 局部变量表：a, b, result
        // 2. 操作数栈：用于计算
        // 3. 方法返回地址：返回调用者
        int result = a + b;
        return result;
    }
    
    public void methodCall() {
        int x = 10;
        int y = 20;
        int sum = calculate(x, y);  // 创建新的栈帧
        System.out.println(sum);
    }
}

public class MethodAreaExample {
    
    // 静态变量：存储在方法区
    private static String staticField = "Static Field";
    
    // 常量：存储在方法区常量池
    private static final int CONSTANT = 100;
    
    // 类信息：存储在方法区
    // - 类的全限定名
    // - 类的直接父类
    // - 类的修饰符
    // - 类的字段、方法信息
}

public class ReferenceCounting {
    
    public void circularReference() {
        Object obj1 = new Object();
        Object obj2 = new Object();
        
        // 循环引用
        obj1.ref = obj2;
        obj2.ref = obj1;
        
        obj1 = null;
        obj2 = null;
        
        // 引用计数法无法回收循环引用的对象
    }
}

public class ReachabilityAnalysis {
    
    // GC Root 1: 静态变量
    private static Object staticObj = new Object();
    
    // GC Root 2: 常量
    private static final Object CONSTANT_OBJ = new Object();
    
    public void method() {
        // GC Root 3: 局部变量（栈中引用）
        Object localObj = new Object();
        
        // 这些对象都是GC Roots，不会被回收
    }
}

public class GenerationalGC {
    
    public void objectPromotion() {
        // 1. 对象在Eden区分配
        Object obj = new Object();
        
        // 2. Minor GC：Eden区满时触发
        //    - 存活对象复制到Survivor区
        //    - 对象年龄+1
        
        // 3. 对象在Survivor区之间复制
        //    - 每经历一次Minor GC，年龄+1
        
        // 4. 对象晋升到老年代
        //    - 年龄达到阈值（默认15）
        //    - Survivor区空间不足
        //    - 大对象直接进入老年代
    }
}

public class ClassLoadingExample {
    
    // 静态变量：在准备阶段分配内存，初始值为0
    private static int staticVar;
    
    // 静态常量：在准备阶段分配内存，初始值为100
    private static final int CONSTANT = 100;
    
    // 静态代码块：在初始化阶段执行
    static {
        staticVar = 10;
        System.out.println("Static block executed");
    }
}

public class ClassLoaderExample {
    
    public void showClassLoaders() {
        // 1. 应用类加载器
        ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println("Application ClassLoader: " + appClassLoader);
        
        // 2. 扩展类加载器
        ClassLoader extClassLoader = appClassLoader.getParent();
        System.out.println("Extension ClassLoader: " + extClassLoader);
        
        // 3. 启动类加载器（null，由C++实现）
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        System.out.println("Bootstrap ClassLoader: " + bootstrapClassLoader);
        
        // 4. 当前类的类加载器
        ClassLoader currentClassLoader = this.getClass().getClassLoader();
        System.out.println("Current ClassLoader: " + currentClassLoader);
    }
}

public class ParentDelegationModel {
    
    // 双亲委派流程
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 1. 检查类是否已加载
        Class<?> c = findLoadedClass(name);
        if (c != null) {
            return c;
        }
        
        // 2. 委派给父类加载器
        try {
            if (parent != null) {
                c = parent.loadClass(name);
                if (c != null) {
                    return c;
                }
            }
        } catch (ClassNotFoundException e) {
            // 父类加载器无法加载
        }
        
        // 3. 父类加载器无法加载，自己加载
        return findClass(name);
    }
}

public class CustomClassLoader extends ClassLoader {
    
    private String classPath;
    
    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 1. 读取类文件
            byte[] classData = loadClassData(name);
            
            // 2. 定义类
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
    
    private byte[] loadClassData(String name) throws IOException {
        String path = classPath + name.replace('.', '/') + ".class";
        try (InputStream is = new FileInputStream(path);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        }
    }
}

public class BytecodeExample {
    
    public int calculate(int a, int b) {
        int result = a + b;
        return result;
    }
}

public class JITExample {
    
    // 热点代码会被JIT编译为机器码
    public void hotMethod() {
        for (int i = 0; i < 1000000; i++) {
            // 这段代码会被JIT编译
            int result = i * 2;
        }
    }
}

public class MemoryLeakExample {
    
    // 问题：静态集合持有对象引用，导致对象无法回收
    private static List<Object> cache = new ArrayList<>();
    
    public void addToCache(Object obj) {
        cache.add(obj);  // 对象被cache持有，无法回收
    }
    
    // 解决：使用WeakReference
    private static List<WeakReference<Object>> weakCache = new ArrayList<>();
    
    public void addToWeakCache(Object obj) {
        weakCache.add(new WeakReference<>(obj));
    }
}