자바 제네릭Java generic - 제네릭 타입 class<T> 와 interface<T> / 멀티타입 파라미터 class<K,V>, interface<K,V> / 메소드 <T, R> R method( T t)

안녕하세요 알통몬입니다. 공감 및 댓글은 포스팅 하는데 아주아주 큰 힘이 됩니다!! 포스팅 내용이 찾아주신 분들께 도움이 되길 바라며 더 깔끔하고 좋은 포스팅을 만들어 나가겠습니다^^

이번 포스팅에서는 자바 제네릭에 대해 공부하겠습니다.

먼저 제네릭을 사용하는 이유는 잘못된 타입이 사용될 수 있는 문제를 

컴파일 과정에서 제거할 수 있도록 하기 위해서 입니다.

제네릭을 사용한 코드가 사용하지 않은 코드보다 좋은 점이 있는데요.

 => 컴파일 시에 강한 타입 체크를 할 수 있고, 타입 변환(Casting)을 제거합니다.

제네릭을 사용하지 않은 코드의 경우 불필요한 타입 변환을 하므로 프로그램 성능에 좋지 않은 영향을 미칩니다.

ex)

List list = new ArrayList();

list.add("tistory");

String str = (String)list.get(0);

위 코드를 제네릭을 사영하게 되면 타입변환이 필요없어집니다.

ex) 

List<String> list = new ArrayList<String>();

list.add("tistory");

String star = list.get(0);

제네릭 타입

class<T>

 ex) public class 클래스이름<T> { ... }

interface<T>

ex) public interface 인터페이스 이름<T> { ... }

위 코드에서 T처럼 타입 파라미터의 경우는 일반적으로 알파벳 대문자 한글자로 표현합니다.

그럼 여기서 의문이 생길 수 있습니다. 왜 굳이 제네릭을 사용해야하지???

예를 들어보겠습니다.

Object 타입을 사용하면 모든 종류의 자바 객체를 저장할 수 있습니다.

하지만 여기서 단점이 생기는데요.

값을 저장할 때 혹은 불러올 때 타입 변환을 해야합니다.

위에서 말했듯이 이런 타입 변환이 자주 일아나면 프로그램 성능에 좋지 않습니다.

제네릭 타입 이용 클래스 =>

public class Box<T> {

    private T t;

   

    public void setT(T t) {

        this.t = t;

    }  

 

    public T getT() { 

        return t;

    }

   

실행 예제를 보겠습니다.

public class GenericExample {

    public static void main(String[] args) {

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

        b1.setT("tistory");

        String str = b1.getT();

        Box<Integer> b2 = new Box<Integer>();

        b2.setT(2);

        int val = b2.getT();

    }

}

예제처럼 제네릭의 경우 클래스 설계 시 구체적인 타입을 명시하지 않고

실제 클래스가 사용될 때 구체적 타입을 저장함으로써 타입변환을 최소화합니다.

다음으로 멀타타입 파라미터에 대해 보겠습니다.

제네릭은 여러 타입의 파라미터를 선언할 수 있습니다.

class<K,V,...> or interface<K, V, ...>

예제)

멀티 타입 제네릭 클래스

public class<P, O> {

    private P phone;

    private O os;

    public void setPhone(P phone) { 

        this.phone = phone;

    }

    public void setOs(O os) {

        this.os = os;

    }

    public P getPhone() {

       return this.phone;

    }

    public O getOs() {

        return this.os;

    }

다음은 실행 클래스입니다.

public class PhoneOsExample {

    public static void main(String[] args) {

        Phone<LG, String> p1 = new Phone<LG, String>();

        p1.setPhone(new LG());

        p1.setOs("Android");

        LG lg = p1.getPhone();

        String os = p1.getOs();

        Phone<Apple, String> p2 = new Phone<Apple, String>();

        p2.setPhone(new Apple());

        p2.setOs("ios");

        Apple apple = p2.getPhone();

        String os2 = p2.getOs();

    }

}

위 예제에서 제네릭 타입의 변수 선언과 객체 셍성을 동시에 할 때 보면

타입 파라미터 선언자리에 구체적인 타입을 정의하는 부분이 중복되는 것을 볼 수 있습니다.

그래서 자바에서는 타입 파라미터의 중복 기술을 줄이기 위해 다이아몬드 연산자 => <>를 제공합니다.

자바 7 이후부터는 

Phone<LG, String> p1 = new Phone<>();

처럼 사용 가능합니다.

마지막으로 제네릭 메소드에 대해 공부하겠습니다.

제네릭 메소드란 >> 매개 타입, 리턴 타입으로 타입 파라미터를 갖는 메소드입니다.

선언 방법 :

public <타입파라미터,...> 리턴타입 메소드명(매개변수) { ... }

ex) public <T> Box<T> boxing(T t) { ... }

호출 방법에는 두가지 방식이 있습니다.

코드에서 구체적인 타입을 명시적으로 지정하거나,

컴파일러가 매개값의 타입을 보고 구체적인 타입을 추정하도록 할 수 있습니다.

ex)

리턴타입 변수 = <구체적 메소드> 메소드명(매개값);

Box<Integer> b1 = <Integer>Box(100);

리턴타입 변수 = 메소드명(매개값);

Box<Integer> b2 = Box(100);

예제를 보겠습니다.

public class Util {

    public static <T> Box<T> boxing(T t) {

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

        box.set(t);

        return box;

    }

}

제네릭 클래스 =>

public class Box<T> {

    private T t;

    public T getT() { 

        return this.t;

    }

    public void setT(T t) {

        this.t = t;

    }

마지막으로 실행 클래스 입니다.

public class GenericMethodExample {

    public static void main(String[] args) {

        Box<Integer> b1 = Util.<Integer>boxing(10);

        int val1 = b1.getT();

        Box<String> b2 = Util.<String>boxing("알통몬");

        String val2 = b2.getT();

    }

}

이상입니다.