Generic을 사용하는 이유

-클래스, 인터페이스, 메서드를 정의할 때 타입을 파라미터로 사용

Generic을 사용할 때 장점

-컴파일 할 때 강력한 타입 체크를 할 수 있다.
-형변환 코드를 없앤다.

ex1)

Geniric을 사용하지 않는 경우

public class SimpleBox {

	private Object object;
    
    public void set(Object object) {
    	this.object = object;
    }
    
    public void get() {
    	return object;
    }
}

public class GenericTest {
	
    public static void main(String[] args){
    	SimpleBox box = new SimpleBox();
        box.set(5);//promotion Integer->Object
        Integer n1 = (Integer) box.get();//type casting, Object -> Integer
        box.set("iu");
        String s1 = (String) box.get();
    }
}

ex2)

Geniric을 사용하는 경우

public class Box<T> {

	private T t;
    
    public void set(T t) {
    	this.t = t;
    }
    
    public T get() {
    	return t;
    }
}

public class GenericTest {
	
    public static void main(String[] args){
    	Box<Integer> integerBox = new Box<Integer>();
        integerBox.set(5);
        Integer n2 = integerBox.get();//타입 캐스팅이 필요없음
        
        Box<String> stringBox = new Box<>();//type inference(타입 추정)
        stringBox.set("iu");
        String s2 = stringBox.get();
  		
        //Generics에 타입 인자를 넣지 않는다(raw type)
        //원래부터 Generics가 아닌 것은 raw type가 아님
        Box rawBox = new Box();
        rawBox.set(5);
        Integer n3 = (Integer) rawBox.get();
    }
}

ex)3

//Pair.class
public class Pair<K, V> {

    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Pair{" +
                "key=" + key +
                ", value=" + value +
                '}';
    }
}

//MultipleTypeParametersTest.class
public class MultipleTypeParametersTest {

    public static void main(String[] args) {
        Pair<String, Integer> p1 = new Pair<>("Even",8);
        Pair<String, String> p2 = new Pair<>("hello","world");
        System.out.printf("key=%s, value=%s\n", p1.getKey(), p1.getValue());
        System.out.printf("key=%s, value=%s\n", p2.getKey(), p2.getValue());

        System.out.println(p1.toString());
        System.out.println(p2);
    }
}

//Util.class
public class Util {

    //Generics 메서드, 리턴 타입 앞에 타입 파라미터를 쓴다.
    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) &&
                p1.getValue().equals(p2.getValue());
    }
}

//UtilTest.class
public class UtilTest {
    public static void main(String[] args) {

        Pair<Integer, String> p1 = new Pair<>(1, "apple");
        Pair<Integer, String> p2 = new Pair<>(2, "pear");
        boolean isSame = Util.compare(p1, p2);// type inference(타입 추정)

        System.out.println(isSame);
    }
}