JAVA :: 제네릭스(Generics) 개념 정리

 

 

 

제네릭스(Generics)란?

다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에 컴파일 시 타입체크를 해주는 기능이다.

 

ArrayList같은 컬렉션 클래스는 다양한 종류의 객체를 담을 수 있는데 보통 한 종류의 객체만 담는다. 
한 종류의 객체만 담기를 원할 때 제네릭스를 사용하면 형변환을 안해도 되기 때문에 더 간단히 사용할 수 있다.

 

👉 제네릭스를 사용하지 않을 때

ArrayList<E> list = new ArrayList<E>();
list.add(10);
list.add("10");

String word = (String)list.get(1);

제네릭스를 사용하지 않으면 Object로 타입을 지정하고, 안에 있는 객체를 꺼낼 때마다 형변환을 해줘야한다. 

 

👉 제네릭스를 사용할 때

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

String word = list.get(0);

제네릭스를 사용한다면 타입지정을 해주고, 형변환을 사용하지 않아도 된다.
위에서 말했듯이 컬랙션 클래스는 보통 한 종류의 객체만 담기 때문에 제네릭스를 사용하는 것이 훨씬 편리하다.

 

 

 

✍ 제네릭스 사용 장점

• 타입 안정성을 제공한다. ( 코드를 잘못 입력하게 되면 컴파일 에러가 발생하므로 오류를 바로바로  체크 할 수 있다.)
• 타입체크와 형변환을 생략할 수 있으므로 코드가 간결해 진다.

 

 

 

[ 다형성 ]

제네릭 타입은 항상 같아야된다.

 

 

ArrayList<Tv> list = new ArrayList<Tv>(); --> OK

ArrayList<조상 클래스> list = new ArrayList<자손 클래스>(); --> ERROR

이렇게 제네릭 타입이 조상클래스와 자손클래스로 다르게 입력되어서는 안된다.
제네릭 클래스는 무조건 제네릭 타입이 일치해야된다.

 

 

하지만, 제네릭 클래스, 매개변수의 다형성은 성립한다.

 

 

👉 제네릭 클래스간의 다형성

 

List<Tv> list = new ArrayList<Tv>();
List<Tv> list = new LinkedList<Tv>(); --> 둘 다 OK

 

 

👉 매개변수의 다형성

 

ArrayList<조상클래스> list = new ArrayList<조상클래스>();
list.add(new 자손클래스()); --> OK

 

 

 

[ Iterator, HashMap with Generics ]

 

Iterator와 HashMap을 사용할 때도 제네릭스를 사용할 수 있다. 

 

 

⭐ Iterator 사용

이터레이터는 어떤 컬렉션인지 상관없이 값을 읽어올 때 사용하는 것이다!

 

메서드에는 hasNext(), next(), remove()가 있다.

 

• hasNext() : 읽어올 값이 있는지 없는지 판단해준다. (ture or false)
• next() : 다음으로 읽을 값을 반환해준다.
• remove() : next로 불러온 값 삭제해준다.

 

이터레이터와 제네릭스를 같이 사용한 예를 살펴보자면

 

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

Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String s = it.next();
    System.out.println(s);
    // 줄여서 System.out.println(it.next());도 가능
    
    //만약 제네릭스를 사용하지 않았다면 아래처럼 형변환해줘야됨
    String s = (String)it.next();
}

이렇게 제네릭스를 사용하면 형변환 과정 없이 값을 꺼낼 수 있다.

 

 

 

⭐ HashMap 사용

HashMap에는 get(), put(), remove() 메서드가 존재한다.

제네릭스를 사용하지 않으면 항상 형변환을 해야되는데 제네릭스를 사용하면 형변환 없이 간단하게 사용가능!

 

HashMap<String, 클래스 이름> map = new HashMap<>(); //<>여기 안에 는 생략 가능. 어차피 앞의 <>와 같아야 하기 때문에

map.put("key1", new 클래스이름("A", 1,2));

클래스 이름 c = map.get("key1");

// 제네릭스 사용하지 않았을 때

클래스 이름 c = (클래스 이름)map.get("key1"); //형변환

 

 

 

 

[ 제한된 제네릭스 ]

제네릭스는 한 종류의 타입만 저장할 수 있지만, 제한을 두면 여러 타입도 저장이 가능하다.

extends를 사용하면 해당 조상부터 그 자손들까지 저장할 수 있게 된다.

 

class Box<T extends Fruit>{}

Box<Apple> appleBox = new Box<Apple>(); --> OK

Fruit를 상속받는 자손들과 Fruit 클래스만 가능하다. 

 

 

 

 

[ 제네릭스 제약 ]

 

◼ static 멤버에는 타입 변수 사용 불가

class Box<T> {
    static T item;  --> ERROR
    static int compare(T t1, T t2){}  --> ERROR
}

 

 

 

◼ 배열 생성할 때 타입 변수 사용불가 (참조 변수는 가능)

class Box<T> {

    T[] toArray(){
        T[] tmpArr = new T[itemArr.length]; --> ERROR
        }
}

 

 

 

 

 

[ 와일드 카드 ]

 

와일드 카드를 사용하면 하나의 참조 변수로 대입된 타입이 다른 객체를 참조할 수 있다.

원래 규칙은 제네릭 타입이 항상 일치해야한다! 하지만 와일드 카드를 사용하면 괜찮다

 

◼ <? extends T>

T와 그 자손들만 가능하다.

 

ArrayList<? extends Fruit> list = new ArrayList<Apple>();

 

 

◼ <? super T>

T와 그 조상들만 가능하다.

ArrayList<? super Apple> list = new ArrayList<Fruit>();

 

 

◼ <?>

모두 다 가능하다. 

<? extends Object>와 같은 의미

 

 

 

 

 

[ 제네릭 메서드 ]

제네릭 메서드는 메서드를 호출 할때마다 다른 제네릭 타입을 대합할 수 있게 하는 것이다.

제네릭 타입의 선언 위치는 반환 타입 바로 앞에 선언하면 된다.

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

 

⭐ 제네릭 클래스에 정의된 타입 매개변수와 제네릭 메서드에 정의된 타입 매개변수는 모양은 같지만 전혀 다른 것이다!!

 

class Box<T> {
      static <T> void sort (List<T> list, Comparator<? super T> c)
}

위에 있는 T는 모양은 같지만 전혀 다른 역할을 한다!!
와일드 카드는 하나의 참조변수로 서로 다른 타입이 대입된 여러 제네릭 객체를 다루기 위한 것이고,
제네릭 메서드는 메서드를 호출 할 때마다 다른 제네릭 타입을 대합할 수 있게 한 것이다.

 

 

 

 

 

---

제네릭스를 사용할 일이 많아질 것 같아서 개념 정리를 한 번 해보았다...

익숙해지려면 오래걸릴 것 같지만 보고 또 보면서 정리해야겠다😃