[Java] Generics

public class Test {
    Object item;

    void setItem(Object  item) {
        this.item = item;
    }

    Object  getItem() {
        return item;
    }
}

public class Test<T> {
    T item;

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

    T getItem() {
        return item;
    }
}

  class Test<T>

public class Test<T> {
    T[] arr;
    T[] arr1 = new T[10];    // error

static void method(Box<TypeA> b){}    // Compile error
static void method(Box<TypeB> b){}    // Compile error
static void method(Box<TypeC> b){}    // Compile error

ArrayList<String> list = new ArrayList<>();
list.add("dico");

String str = list.get(0);

Test test = null;
Test<Object> objTest = null;

test = (Test) objTest;                  // Generic Type → Primitive Type. Warning
objTest = (Test<Object>) test;          // Primitive Type → Generic Type. Warning

Test<String> strTest = null;
Test<Object> objTest = null;

strTest = (Test<String>) objTest;      // error. Test<Object> → Test<String>
objTest = (Test<Object>) strTest;      // error. Test<String> → Test<Object>

// before 
class Box<T extends Fruit> {
    void add(T t){}
}

// after
class Box { 
    void add(Fruit t){}
}

// before 
T get(int i){
    return list.get(i);
}

// after
Fruit get(int i){
    return (Fruit) list.get(i);
}

// before 
static Juice makeJuice(FruitBox<? extends Fruit> box){
    String tmp = "";
    for(Fruit f : box.getList()) {
        tmp += f + " ";
    }
    return new Juice(tmp);
}

// after
static Juice makeJuice(FruitBox box){
    String tmp = "";
    Iterator it = box.getList().iterator();
    while(it.hasNext()) {
        tmp += (Fruit) it.next() + " ";
    }
    retrun new Juice(tmp);
}

package blog;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        FruitBox<Fruit> fruitBox = new FruitBox<>();
        FruitBox<Apple> appleBox = new FruitBox<>();
        FruitBox<Grape> grapeBox = new FruitBox<>();

        fruitBox.add(new Fruit("fruit", 200)); // Upper Bounded Wildcards
        fruitBox.add(new Apple("apple", 150)); // Upper Bounded Wildcards
        fruitBox.add(new Grape("grape", 300)); // Upper Bounded Wildcards

        appleBox.add(new Apple("apple", 100));
        appleBox.add(new Apple("apple", 170));
        appleBox.add(new Apple("apple", 200));

        grapeBox.add(new Grape("grape", 300));
        grapeBox.add(new Grape("grape", 400));
        grapeBox.add(new Grape("grape", 200));

        System.out.println(Juicer.makeJuice(fruitBox)); // fruit 200 apple 150 grape 300 Juice
        System.out.println(Juicer.makeJuice(appleBox)); // apple 100 apple 170 apple 200 Juice
        System.out.println(Juicer.makeJuice(grapeBox)); // grape 300 grape 400 grape 200 Juice

        Collections.sort(fruitBox.getList(), new FruitComp()); // Lower Bounded Wildcards
        Collections.sort(appleBox.getList(), new FruitComp()); // Lower Bounded Wildcards
        Collections.sort(grapeBox.getList(), new FruitComp()); // Lower Bounded Wildcards

        System.out.println(fruitBox); // [apple 150, fruit 200, grape 300]
        System.out.println(appleBox); // [apple 100, apple 170, apple 200]
        System.out.println(grapeBox); // [grape 200, grape 300, grape 400]
    }
}

class Box<T> {
    ArrayList<T> list = new ArrayList<>();

    void add(T item) {
        list.add(item);
    }

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

    ArrayList<T> getList() {
        return list;
    }

    int size() {
        return list.size();
    }

    public String toString() {
        return list.toString();
    }
}

class FruitBox<T extends Fruit> extends Box<T> {
}

class Fruit {
    String name;
    int weight;

    Fruit(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public String toString() {
        return name + " " + weight;
    }
}

class Apple extends Fruit {
    Apple(String name, int weight) {
        super(name, weight);
    }
}

class Grape extends Fruit {
    Grape(String name, int weight) {
        super(name, weight);
    }
}

class Juice {
    String name;

    Juice(String name) {
        this.name = name + "Juice";
    }

    public String toString() {
        return name;
    }
}

class Juicer {
    /*
     * static Juice makeJuice(FruitBox<? extends Object> box)로 할 경우 box의 요소가 Fruit의
     * 자손이라는 보장이 없다. 하지만 여기서는 제네릭 클래스 FruitBox를 <T extends Fruit>으로 제한했기 때문에 문제 없다.
     */
    static Juice makeJuice(FruitBox<? extends Fruit> box) { // FruitBox<Fruit/Apple/Grape>
        String tmp = "";
        for (Fruit f : box.getList()) {
            tmp += f + " ";
        }
        return new Juice(tmp);
    }
}

/*
 * public static <T> void sort(List<T> list, Comparator<? super T> c)
 * sort(List<Fruit>, list, Comparator<? super Fruit> c) :
 * Comparator<Object/Fruit> sort(List<Apple>, list, Comparator<? super Apple> c)
 * : Comparator<Object/Fruit/Apple> sort(List<Grape>, list, Comparator<? super
 * Grape> c) : Comparator<Object/Fruit/Grape> → List를 정렬하기 위해 Comparator를 구현할 경우
 * 동일한 조상(Fruit)으로 구현하여 Fruit의 자손이 생길 때마다 구현해야 하는 번거로움을 해소한다.
 */
class FruitComp implements Comparator<Fruit> {

    @Override
    public int compare(Fruit o1, Fruit o2) {
        return o1.weight - o2.weight;
    }
}