// 지네릭스 사용 전 (JDK 1.5 이전)
ArrayList list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);  // 형변환 필요

// 지네릭스 사용 후
ArrayList<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);  // 형변환 불필요

// 지네릭 클래스 정의
class Box<T> {
    T item;

    void setItem(T item) { this.item = item; }
    T getItem() { return item; }
}

// 사용
Box<String> stringBox = new Box<>();
stringBox.setItem("Hello");
String s = stringBox.getItem();  // 형변환 불필요

Box<Integer> intBox = new Box<>();
intBox.setItem(100);
int n = intBox.getItem();

class Box<T> {}            // Box<T>: 지네릭 클래스
Box<String> b = new Box<>();  // Box<String>: 지네릭 타입

class Box<T> {
    static T item;           // 에러! T는 인스턴스 변수로 간주
    static int compare(T t1, T t2) { ... }  // 에러!
}

class Box<T> {
    T[] itemArr;  // OK. 참조변수 선언은 가능

    T[] toArray() {
        T[] tmpArr = new T[itemArr.length];  // 에러! 배열 생성 불가
        return tmpArr;
    }
}

// 방법 1: Reflection API 사용
@SuppressWarnings("unchecked")
T[] createArray(Class<T> clazz, int size) {
    return (T[]) Array.newInstance(clazz, size);
}

// 방법 2: Object 배열 생성 후 형변환
@SuppressWarnings("unchecked")
T[] toArray() {
    return (T[]) new Object[size];
}

// 참조변수와 생성자의 타입이 일치해야 함
Box<Apple> appleBox = new Box<Apple>();  // OK
Box<Apple> appleBox = new Box<Grape>();  // 에러!

// 상속 관계여도 대입된 타입이 다르면 에러
Box<Fruit> fruitBox = new Box<Apple>();  // 에러!

// 지네릭 클래스 간의 상속은 가능 (대입된 타입이 같을 때)
Box<Apple> appleBox = new FruitBox<Apple>();  // OK (FruitBox가 Box의 자손일 때)

// JDK 1.7부터 타입 추론 가능 (다이아몬드 연산자)
Box<Apple> appleBox = new Box<>();  // OK

// Fruit의 자손만 타입으로 지정 가능
class FruitBox<T extends Fruit> {
    ArrayList<T> list = new ArrayList<>();
    void add(T item) { list.add(item); }
}

// 사용
FruitBox<Apple> appleBox = new FruitBox<>();  // OK
FruitBox<Toy> toyBox = new FruitBox<>();      // 에러! Toy는 Fruit의 자손이 아님

interface Eatable {}

// Fruit의 자손이면서 Eatable을 구현한 클래스만 허용
class FruitBox<T extends Fruit & Eatable> {
    ArrayList<T> list = new ArrayList<>();
}

// 문제 상황: static 메서드에서 특정 지네릭 타입만 받을 수 있음
class Juicer {
    static Juice makeJuice(FruitBox<Fruit> box) { ... }
}

FruitBox<Fruit> fruitBox = new FruitBox<>();
FruitBox<Apple> appleBox = new FruitBox<>();

Juicer.makeJuice(fruitBox);  // OK
Juicer.makeJuice(appleBox);  // 에러! FruitBox<Apple>은 FruitBox<Fruit>이 아님

class Juicer {
    // Fruit의 자손이면 모두 가능
    static Juice makeJuice(FruitBox<? extends Fruit> box) {
        StringBuilder sb = new StringBuilder();
        for (Fruit f : box.getList()) {
            sb.append(f).append(" ");
        }
        return new Juice(sb.toString());
    }
}

// 이제 다양한 FruitBox 사용 가능
Juicer.makeJuice(new FruitBox<Fruit>());   // OK
Juicer.makeJuice(new FruitBox<Apple>());   // OK
Juicer.makeJuice(new FruitBox<Grape>());   // OK

// Producer(데이터 제공) - extends 사용
public void printAll(List<? extends Number> list) {
    for (Number n : list) {
        System.out.println(n);  // 읽기만 함
    }
}

// Consumer(데이터 소비) - super 사용
public void addNumbers(List<? super Integer> list) {
    list.add(1);   // 쓰기 작업
    list.add(2);
}

// 사용 예
List<Number> numbers = new ArrayList<>();
addNumbers(numbers);   // OK (Number는 Integer의 조상)
printAll(numbers);     // OK

class FruitBox<T> {
    // 지네릭 메서드 - 메서드마다 독립적인 타입 변수
    static <T> void sort(List<T> list, Comparator<? super T> c) {
        Collections.sort(list, c);
    }
}

// 명시적 타입 지정
FruitBox.<Fruit>sort(list, comparator);

// 타입 추론 (컴파일러가 추론 가능하면 생략)
FruitBox.sort(list, comparator);

public class GenericMethodExample {
    // 배열을 리스트로 변환하는 지네릭 메서드
    public static <T> List<T> arrayToList(T[] arr) {
        return new ArrayList<>(Arrays.asList(arr));
    }

    // 두 값 중 큰 값 반환
    public static <T extends Comparable<T>> T max(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }

    public static void main(String[] args) {
        String[] strArr = {"A", "B", "C"};
        List<String> list = arrayToList(strArr);

        String maxStr = max("apple", "banana");  // "banana"
        Integer maxInt = max(10, 20);            // 20
    }
}

// 컴파일 전
class Box<T> {
    T item;
    void setItem(T item) { this.item = item; }
    T getItem() { return item; }
}

// 컴파일 후 (타입 소거)
class Box {
    Object item;
    void setItem(Object item) { this.item = item; }
    Object getItem() { return item; }
}

// 컴파일 전
class FruitBox<T extends Fruit> {
    T item;
}

// 컴파일 후 (상한 타입으로 대체)
class FruitBox {
    Fruit item;
}

// 열거형 사용 전
class Card {
    static final int CLOVER = 0;
    static final int HEART = 1;
    static final int DIAMOND = 2;
    static final int SPADE = 3;
}

// 열거형 사용 후
enum Kind { CLOVER, HEART, DIAMOND, SPADE }

enum Direction { EAST, SOUTH, WEST, NORTH }

class EnumExample {
    public static void main(String[] args) {
        Direction d = Direction.EAST;

        // 비교 - == 사용 가능
        if (d == Direction.EAST) {
            System.out.println("동쪽");
        }

        // switch문에서 사용
        switch (d) {
            case EAST:  System.out.println("→"); break;
            case SOUTH: System.out.println("↓"); break;
            case WEST:  System.out.println("←"); break;
            case NORTH: System.out.println("↑"); break;
        }
    }
}

enum Direction { EAST, SOUTH, WEST, NORTH }

public class EnumMethodExample {
    public static void main(String[] args) {
        // values() - 모든 상수 배열
        Direction[] dirs = Direction.values();
        for (Direction d : dirs) {
            System.out.println(d.name() + " : " + d.ordinal());
        }
        // EAST : 0, SOUTH : 1, WEST : 2, NORTH : 3

        // valueOf() - 이름으로 상수 찾기
        Direction east = Direction.valueOf("EAST");
        System.out.println(east);  // EAST

        // compareTo() - 순서 비교
        System.out.println(Direction.EAST.compareTo(Direction.NORTH));  // -3
    }
}

enum Direction {
    EAST(1, "→"),
    SOUTH(2, "↓"),
    WEST(3, "←"),
    NORTH(4, "↑");  // 상수 정의 끝에 세미콜론 필수

    private final int value;
    private final String symbol;

    // 생성자 (private만 허용)
    Direction(int value, String symbol) {
        this.value = value;
        this.symbol = symbol;
    }

    public int getValue() { return value; }
    public String getSymbol() { return symbol; }
}

public class EnumWithMemberExample {
    public static void main(String[] args) {
        for (Direction d : Direction.values()) {
            System.out.printf("%s: %d %s%n", d.name(), d.getValue(), d.getSymbol());
        }
        // EAST: 1 →
        // SOUTH: 2 ↓
        // WEST: 3 ←
        // NORTH: 4 ↑
    }
}

enum Operation {
    PLUS("+") {
        @Override
        public double apply(double x, double y) { return x + y; }
    },
    MINUS("-") {
        @Override
        public double apply(double x, double y) { return x - y; }
    },
    TIMES("*") {
        @Override
        public double apply(double x, double y) { return x * y; }
    },
    DIVIDE("/") {
        @Override
        public double apply(double x, double y) { return x / y; }
    };

    private final String symbol;

    Operation(String symbol) {
        this.symbol = symbol;
    }

    public String getSymbol() { return symbol; }

    // 추상 메서드 - 각 상수에서 구현
    public abstract double apply(double x, double y);
}

public class OperationExample {
    public static void main(String[] args) {
        double x = 10, y = 3;

        for (Operation op : Operation.values()) {
            System.out.printf("%.1f %s %.1f = %.1f%n",
                x, op.getSymbol(), y, op.apply(x, y));
        }
        // 10.0 + 3.0 = 13.0
        // 10.0 - 3.0 = 7.0
        // 10.0 * 3.0 = 30.0
        // 10.0 / 3.0 = 3.3
    }
}

import java.util.*;

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

public class EnumSetMapExample {
    public static void main(String[] args) {
        // EnumSet
        EnumSet<Day> weekdays = EnumSet.range(Day.MON, Day.FRI);
        EnumSet<Day> weekend = EnumSet.of(Day.SAT, Day.SUN);
        EnumSet<Day> allDays = EnumSet.allOf(Day.class);

        System.out.println("Weekdays: " + weekdays);  // [MON, TUE, WED, THU, FRI]
        System.out.println("Weekend: " + weekend);    // [SAT, SUN]

        // EnumMap
        EnumMap<Day, String> schedule = new EnumMap<>(Day.class);
        schedule.put(Day.MON, "회의");
        schedule.put(Day.FRI, "코드 리뷰");
        schedule.put(Day.SAT, "휴식");

        System.out.println("Schedule: " + schedule);
        // {MON=회의, FRI=코드 리뷰, SAT=휴식}
    }
}

class Parent {
    void method() {}
}

class Child extends Parent {
    @Override
    void method() {}  // OK

    @Override
    void methd() {}   // 컴파일 에러! 오타 발견
}

class OldClass {
    @Deprecated
    public void oldMethod() {
        // 이 메서드는 더 이상 사용하지 마세요
    }

    public void newMethod() {
        // 대신 이 메서드를 사용하세요
    }
}

// 특정 경고 억제
@SuppressWarnings("unchecked")
public void method() {
    List list = new ArrayList();  // raw type 경고 억제
}

// 여러 경고 동시 억제
@SuppressWarnings({"unchecked", "deprecation"})
public void method2() { ... }

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
    // int another(int x);  // 추가하면 컴파일 에러!
}

@SafeVarargs
static <T> List<T> asList(T... elements) {
    return Arrays.asList(elements);
}

@Target({ElementType.TYPE, ElementType.METHOD})
@interface MyAnnotation {}

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {}

@Documented
@interface MyAnnotation {}

@Inherited
@interface SuperAnnotation {}

@SuperAnnotation
class Parent {}

class Child extends Parent {}  // @SuperAnnotation 상속됨

@Repeatable(ToDos.class)  // 컨테이너 애너테이션 지정
@interface ToDo {
    String value();
}

@interface ToDos {  // 컨테이너 애너테이션
    ToDo[] value();
}

// 사용
@ToDo("기능 구현")
@ToDo("테스트 작성")
@ToDo("문서화")
class MyClass {}

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface TestInfo {
    String author() default "unknown";
    String date();
    int version() default 1;
    String[] tags() default {};
}

// 사용
class Example {
    @TestInfo(
        author = "홍길동",
        date = "2024-01-15",
        version = 2,
        tags = {"service", "api"}
    )
    public void testMethod() {}
}

import java.lang.annotation.*;
import java.lang.reflect.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Test {
    String value() default "";
}

class TestRunner {
    @Test("테스트 1")
    public void test1() { System.out.println("test1 실행"); }

    @Test("테스트 2")
    public void test2() { System.out.println("test2 실행"); }

    public void normalMethod() { System.out.println("일반 메서드"); }

    public static void main(String[] args) throws Exception {
        TestRunner runner = new TestRunner();

        for (Method m : runner.getClass().getDeclaredMethods()) {
            // @Test 애너테이션이 있는 메서드만 실행
            if (m.isAnnotationPresent(Test.class)) {
                Test test = m.getAnnotation(Test.class);
                System.out.println("실행: " + test.value());
                m.invoke(runner);
            }
        }
    }
}
// 출력:
// 실행: 테스트 1
// test1 실행
// 실행: 테스트 2
// test2 실행

public class GenericUtils {
    // null 안전 비교
    public static <T> boolean equals(T a, T b) {
        return (a == null) ? (b == null) : a.equals(b);
    }

    // 기본값 반환
    public static <T> T defaultIfNull(T value, T defaultValue) {
        return value != null ? value : defaultValue;
    }

    // 리스트 필터링
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
}

enum OrderStatus {
    PENDING("주문 접수", false),
    CONFIRMED("주문 확인", false),
    SHIPPED("배송 중", false),
    DELIVERED("배송 완료", true),
    CANCELLED("주문 취소", true);

    private final String description;
    private final boolean isFinal;

    OrderStatus(String description, boolean isFinal) {
        this.description = description;
        this.isFinal = isFinal;
    }

    public String getDescription() { return description; }
    public boolean isFinal() { return isFinal; }

    public boolean canTransitionTo(OrderStatus next) {
        if (this.isFinal) return false;
        return this.ordinal() < next.ordinal() || next == CANCELLED;
    }
}

public class OrderStatusExample {
    public static void main(String[] args) {
        OrderStatus status = OrderStatus.PENDING;

        System.out.println(status.getDescription());  // 주문 접수
        System.out.println(status.canTransitionTo(OrderStatus.CONFIRMED));  // true
        System.out.println(status.canTransitionTo(OrderStatus.DELIVERED));  // true

        OrderStatus delivered = OrderStatus.DELIVERED;
        System.out.println(delivered.canTransitionTo(OrderStatus.CANCELLED));  // false (이미 완료)
    }
}