JVM 스택 슬롯:
┌─────────────────────────────┐
│  boolean (1bit~1byte 사용)   │ ← 32비트 슬롯 하나 차지
└─────────────────────────────┘

메모리:  [a][b][c][d]  ← 4개의 boolean (각 1바이트)
        └─────────┘
        CPU는 이걸 한 덩어리로 읽음

public class Example {
    static int staticField;      // 0으로 초기화
    int instanceField;           // 0으로 초기화
    int[] array = new int[10];   // 모든 요소 0으로 초기화

    void method() {
        int localVar;            // 초기화 안 됨 - 사용 시 컴파일 에러
        // System.out.println(localVar);  // 컴파일 에러
    }
}

int primitive = 42;        // 스택에 4 bytes (값 직접 저장)
Integer wrapper = 42;      // 스택에 참조(4-8 bytes) + 힙에 객체(16-28 bytes)

// Bad - 매 반복마다 박싱/언박싱 발생
Long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;  // 언박싱 → 연산 → 박싱
}

// Good - 원시 타입 사용
long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}

Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true (같은 객체)

Integer c = 128;
Integer d = 128;
System.out.println(c == d);  // false (다른 객체)

private static class IntegerCache {
    static final int low = -128;
    static final int high;  // 기본 127, 설정 가능
    static final Integer[] cache;

    static {
        int h = 127;
        String prop = VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (prop != null) {
            int i = parseInt(prop);
            i = Math.max(i, 127);
            h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
        }
        high = h;
        cache = new Integer[(high - low) + 1];
        int j = low;
        for (int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }
}

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

// package com.example.p1
class DefaultClass {         // package-private 클래스
    int defaultField;        // package-private 필드
    void defaultMethod() {}  // package-private 메서드
}

// package com.example.p2
class Other {
    void test() {
        DefaultClass obj = new DefaultClass();  // 컴파일 에러
    }
}

// package p1
public class Parent {
    protected int x;
}

// package p2
public class Child extends Parent {
    void test(Parent p, Child c, Sibling s) {
        this.x = 10;  // OK - this는 Child 타입
        c.x = 10;     // OK - Child 타입 참조
        p.x = 10;     // 컴파일 에러 - Parent 타입 참조
        s.x = 10;     // 컴파일 에러 - 형제 서브클래스
    }
}

class Sibling extends Parent {}

public class PublicClass {}      // OK
class PackagePrivateClass {}     // OK
private class PrivateClass {}    // 컴파일 에러
protected class ProtectedClass {} // 컴파일 에러

public class Outer {
    private class PrivateInner {}     // OK
    protected class ProtectedInner {} // OK
}

public class InitOrder {
    // 1. final static 상수 (컴파일 타임 상수)
    static final int CONSTANT = 100;

    // 2. static 필드와 static 블록은 소스코드 순서대로
    static int value1 = getValue("value1");  // 2번째

    static {
        System.out.println("static block 1");  // 3번째
    }

    static int value2 = getValue("value2");  // 4번째

    static {
        System.out.println("static block 2");  // 5번째
    }

    static int getValue(String name) {
        System.out.println("Initializing " + name);
        return 0;
    }
}

// 출력:
// Initializing value1
// static block 1
// Initializing value2
// static block 2

// 1. 새 인스턴스 생성
new MyClass();

// 2. static 메서드 호출
MyClass.staticMethod();

// 3. non-constant static 필드 접근 (아래 설명 참고)
MyClass.staticField;

// 4. 리플렉션 API
Class.forName("MyClass");

// 5. 하위 클래스 초기화
class Child extends Parent {}  // Parent도 초기화

// 6. JVM 시작 시 초기 클래스
// java MainClass

public class MyClass {
    static final int CONSTANT = 100;       // 컴파일 타임 상수
    static int nonConstant = 100;          // non-constant

    // 이것도 non-constant -> 이건 실행해봐야 알기에 복사 안 됨.
    static final int RUNTIME = getNumber(); 
}

// 다른 클래스에서
int x = MyClass.CONSTANT;     // 클래스 로딩 안 됨 - 컴파일러가 100으로 대체
int y = MyClass.nonConstant;  // 클래스 로딩됨 - 런타임에 값 필요

public class Example {
    int instanceField;  // 객체가 있어야 존재

    public static void staticMethod() {
        // this.instanceField;  // 컴파일 에러
    }
}

// 호출 시점을 보면 이해됨
Example.staticMethod();  // 객체 없이 호출
// 이 시점에 instanceField는 어디에도 없음 -> this가 가리킬 대상이 없음

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();  // 클래스 로딩 시 바로 생성

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public class Singleton {
    private Singleton() {}

    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;  // 이때 LazyHolder 초기화
    }
}

Singleton.class        // Singleton 클래스
Singleton$LazyHolder.class  // LazyHolder 클래스 (별도 파일)

public class Singleton {
    private Singleton() {}

    private class LazyHolder {  // static 없음
        final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        // LazyHolder를 만들려면 Singleton 인스턴스가 필요
        // 근데 Singleton 인스턴스가 아직 없음 (싱글톤이니까)
        // 컴파일 에러!
    }
}

public class Outer {
    private String data;

    private class Inner {
        // 숨겨진 Outer.this 참조를 갖고 있음
    }

    public Inner createInner() {
        return new Inner();
    }
}

// 문제 상황
Outer outer = new Outer();
Outer.Inner inner = outer.createInner();
outer = null;  // Outer 해제하고 싶음
// 하지만 inner가 Outer.this를 들고 있어서 GC 안 됨 (메모리 누수)

// non-static이 자연스러운 경우: Iterator
public class MyList<E> {
    private E[] elements;

    private class MyIterator implements Iterator<E> {
        int cursor = 0;

        public E next() {
            return elements[cursor++];  // 바깥 필드에 직접 접근
        }
    }
}

// 클래스 정의 (설계도)
public class Car {
    String model;
    int speed;

    void accelerate() {
        speed += 10;
    }
}

// 객체 생성 (실체화)
Car myCar = new Car();  // myCar는 Car 클래스의 인스턴스

Car car1 = new Car();
Car car2 = new Car();

public class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
}

// 컴파일 에러 - 시그니처가 같음
int process(int x) { return x; }
double process(int x) { return x; }  // 반환 타입만 다름

calc.add(1, 2);      // 컴파일러: "int, int니까 add(int, int) 호출"
calc.add(1.0, 2.0);  // 컴파일러: "double, double이니까 add(double, double) 호출"

class Animal {
    void sound() { System.out.println("..."); }
}

class Dog extends Animal {
    @Override
    void sound() { System.out.println("Bark"); }
}

Animal animal = new Dog();  // 변수 타입: Animal, 실제 객체: Dog
animal.sound();  // 뭐가 실행될까?

// 컴파일러: "Animal.sound() 호출하겠다" (변수 타입만 봄)
// 런타임: "어? 실제로는 Dog 객체네. Dog.sound() 실행" (실제 객체 봄)

class Animal {
    Animal create() { return new Animal(); }
}

class Dog extends Animal {
    @Override
    Dog create() { return new Dog(); }  // OK - Dog은 Animal의 하위 타입
}

class Parent {
    protected void method() {}
}

class Child extends Parent {
    @Override
    public void method() {}     // OK - public > protected

    // @Override
    // private void method() {}  // 컴파일 에러 - private < protected
}

class Parent {
    void method() throws IOException {}
}

class Child extends Parent {
    @Override
    void method() throws FileNotFoundException {}  // OK - 하위 예외

    // @Override
    // void method() throws Exception {}  // 컴파일 에러 - 상위 예외
}

class Child extends Parent {
    @Override
    public void metohd() {}  // 컴파일 에러 - 오타, 실제로 오버라이드 아님
}

class Animal {
    void sound() { System.out.println("Animal"); }
    static void info() { System.out.println("Animal info"); }
}

class Dog extends Animal {
    @Override
    void sound() { System.out.println("Bark"); }
    static void info() { System.out.println("Dog info"); }
}

Animal animal = new Dog();
animal.sound();  // "Bark" - 동적 바인딩 (런타임에 Dog.sound() 호출)
animal.info();   // "Animal info" - 정적 바인딩 (컴파일 타임에 Animal.info() 결정)

Animal animal = new Dog();
animal.info();  // 컴파일러: "animal의 타입이 Animal이네. Animal.info() 호출"
                // 실제 객체가 Dog인지 안 봄

class Dog extends Animal {
    @Override  // 컴파일 에러! static 메서드는 오버라이드 불가
    static void info() { System.out.println("Dog info"); }
}

public interface MyInterface {
    // 필드: 암묵적으로 public static final
    int CONSTANT = 100;
    // == public static final int CONSTANT = 100;

    // 메서드: 암묵적으로 public abstract
    void method();
    // == public abstract void method();
}

// Java 7 시절
public interface List<E> {
    void add(E e);
    E get(int index);
    // ... 기존 메서드들
}

// 구현 클래스가 100개 있다고 가정
class MyList implements List<String> { ... }
class YourList implements List<Integer> { ... }
// ... 98개 더

public interface List<E> {
    void add(E e);
    E get(int index);
    Stream<E> stream();  // 새로 추가
}

public interface List<E> {
    void add(E e);
    E get(int index);

    default Stream<E> stream() {
        // 기본 구현 제공
        return StreamSupport.stream(spliterator(), false);
    }
}

interface A { default void m() { System.out.println("A"); } }
interface B { default void m() { System.out.println("B"); } }

class C implements A, B {
    @Override
    public void m() {
        A.super.m();  // A 인터페이스로부터 상속받은 m() 호출
        B.super.m();  // B 인터페이스로부터 상속받은 m() 호출
    }
}

// 클래스 상속: 부모가 하나라 super만 쓰면 됨
class Child extends Parent {
    void m() { super.m(); }  // 부모는 하나
}

// 인터페이스 다중 구현: super가 여러 개라 구분 필요
class C implements A, B {
    void m() {
        super.m();    // 컴파일 에러! A의 m()? B의 m()?
        A.super.m();  // A로부터 상속받은 m()
        B.super.m();  // B로부터 상속받은 m()
    }
}

interface Calculator {
    default int add(int a, int b) {
        return calculate(a, b, (x, y) -> x + y);
    }

    default int multiply(int a, int b) {
        return calculate(a, b, (x, y) -> x * y);
    }

    // 인터페이스 내부에서만 사용
    private int calculate(int a, int b, BiFunction<Integer, Integer, Integer> op) {
        return op.apply(a, b);
    }
}

인터페이스 (List)
    │  "get(), add(), size() 있어야 해" (계약)
    ▼
추상 클래스 (AbstractList)
    │  "isEmpty()는 size() == 0이면 돼" (공통 구현)
    │  "get()은 구현체마다 다르니까 abstract로 남김" (원시 메서드)
    ▼
구체 클래스 (ArrayList, LinkedList)
    └  "get()은 이렇게 구현할게" (핵심 구현)

public abstract class AbstractList<E> implements List<E> {

    // 원시 메서드: 구현체마다 다름 → abstract로 남김
    abstract public E get(int index);
    abstract public int size();

    // 파생 메서드: 원시 메서드 조합으로 구현 가능 → 여기서 구현
    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean contains(Object o) {
        for (int i = 0; i < size(); i++) {
            if (Objects.equals(get(i), o)) return true;
        }
        return false;
    }

    public int indexOf(Object o) {
        for (int i = 0; i < size(); i++) {
            if (Objects.equals(get(i), o)) return i;
        }
        return -1;
    }
}

public class ArrayList<E> extends AbstractList<E> {
    private Object[] elementData;

    @Override
    public E get(int index) {
        return (E) elementData[index];  // 핵심만 구현
    }

    @Override
    public int size() {
        return size;
    }

    // isEmpty(), indexOf(), contains()는 AbstractList 거 그대로 씀
}

public abstract class AbstractSet<E> implements Set<E> {

    // 인터페이스에서는 equals() 오버라이드 불가
    @Override
    public boolean equals(Object o) {
        if (o == this) return true;
        if (!(o instanceof Set)) return false;
        // Set 비교 로직...
    }

    @Override
    public int hashCode() {
        int h = 0;
        for (E e : this) h += Objects.hashCode(e);
        return h;
    }
}

// Object.equals() 실제 구현
public boolean equals(Object obj) {
    return (this == obj);  // 참조 비교
}

class User {
    String id;
    User(String id) { this.id = id; }
}

User user1 = new User("john");
User user2 = new User("john");  // 같은 id

user1.equals(user2);  // false! 다른 메모리 주소

// HashSet에 넣으면?
Set<User> set = new HashSet<>();
set.add(user1);
set.add(user2);
set.size();  // 2! 논리적으로 같은 유저인데 두 개로 취급

class User {
    String id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        return id.equals(((User) o).id);  // id가 같으면 같은 유저
    }

    @Override
    public int hashCode() {
        return id.hashCode();  // id 기반 해시
    }
}

User user1 = new User("john");
User user2 = new User("john");

user1.equals(user2);  // true! id가 같으니까

Set<User> set = new HashSet<>();
set.add(user1);
set.add(user2);
set.size();  // 1! 같은 유저로 취급

interface MyInterface {
    default boolean equals(Object o) {  // 컴파일 에러!
        return true;
    }
}

class MyClass implements MyInterface {
    // Object.equals()가 있음
    // MyInterface.equals()도 있음 (가정)
}

MyClass obj = new MyClass();
obj.equals(other);  // 뭘 호출해야 하지?