Generic

特長

ジュネーブの使い方

class Box<T> {}

Box<String> b = new Box<String>();

ジェニーリック使用前

class Box {
    Object item;
    
    void setItem(Object item) { this.item = item; }
    Object getItem() { return item; }
}

ジェニーンリックを使った後

class Box<T> {  // 제네릭 타입 T를 선언
    T item;
    
    void setItem(T item) { this.item = item; }
    T getItem() { return item; }
}

Box<String> b = new Box<String>();  // 타입 T 대신, 실제 타입을 지정
b.setItem(new Object());            // 에러. String 이외의 타입은 지정불가
b.setITem("ABC");                   // 성공. String 타입이므로 가능
String item = b.getItem();          // 형변환 필요 없음

class Box {
    String item;
    
    void setItem(String item) { this.item = item; }
    String getItem() { return item; }
}

制限

Box<String> box = new Box<Integer>(); // 에러

ジュネーブこうへん

ArrayList<Object> objectList = new ArrayList<String>();  // 컴파일 에러

class Course<T> {
    private String name;
    private T[] students;
    
    public Course(String name, int capacity) {
        this.name = name;
        // 배열은 공변이기 때문에 제네릭 타입으로 형변환한 배열을 생성할 수는 있다.
        // 하지만 이후 배열의 원소 사용이 불가능하다.
        students = (T[]) (new Object[capacity]);
    }

    // 배열 초기화 시 클래스 타입을 추가해줘야 한다.
    public Course(String name, int capacity, Class<T> tClass) {
        this.name = name;
        /* 
        제네릭은 타입을 알수 없기 때문에 어쩔수 없이 배열 정보를 얻어오려면 
        만드는 객체자체를 원하는 타입으로 받아와야 함..
        그래서 생성자에 클래스 타입을 받는 방법(Reflection API)으로 해결은 가능하다
        */
        students = (T[]) Array.newInstance(tClass, capacity);
    }

    public String getName() {
        return name;
    }

    public T[] getStudents() {
        return students;
    }

    public void add (T t) {
        for(int i=0;i<students.length;i++) {
            if (students[i] == null) {
                students[i] = t;
                break;
            }
        }
    }
}

マルチタイプパラメータ

public class Product<T, M> {
    private T kind;
    private M model;
}

ジェニーリックの主な概念

バインドタイプ(境界タイプ)

public <T extends 상위타입> 리턴타입 메서드(매개변수, ...) { ... }

ワイルドカードタイプ(ワイルドカードタイプ)

Unbounded Wildcards : <?>

Upper Bounded Wildcards : <? extends T>

Lower Bounded Wildcards : <? super T>

ジェニーリックの方法

static <T> void sort(List<T> list, Comparator<? super T> c)

static <T extends Fruit> Juice makeJuice(FruitBox<T> box) {
    ...
}

JENARICタイプの削除(Erasure)

実際のアンインストールプロセス

class Box<T extends Fruit> { -> class Box
    void add(T t) { -> void add(Fruit T) {
        ...
    }
}

T get(int i) { -> Fruit get(int i) {
    return list.get(i); -> return (Fruit)list.get(i);
}