F013 - Generic

✍️ 국비 학원에서 프로젝트를 진행할 때 Map 자료구조가 뭔지도 몰랐던 시절, 서로 다른 객체를 Object 배열에 담아 직접 형변환을 해서 데이터를 조작했던 기억이 있는데, 이 때 형변환을 자꾸 잘못해서 런타임 에러가 계속 났던 경험이 생각났다.
과거에 마주했던 문제들을 상기하고, 왜 해당 개념이 필요한지 이번 학습을 통해 알아가는 시간을 가져보자.

---

Generic

Generic이란 단어의 사전적 의미는 '포괄적인' 이라는 뜻이다. 단어 뜻 그대로 클래스에 담길 객체나 메소드, 생성자의 매개 변수의 종류를 특정 클래스를 지정하는 것이 아니라, 포괄적인 의미의 단어를 사용해 담길 객체의 종류에 대해서 열어둔다는 의미로 사용한다.

즉, Generic은 컴파일 타임에서 클래스에 담길 객체의 형태에 해당 클래스에 담길 형태와 맞는지 확인하는 역할을 한다. 이는 개발자가 직접 형변환을 해야하는 수고로움을 덜고, 프로그램 컴파일 시에 형태를 확인하고 맞지 않을 경우 예외를 던지기 때문에 이를 해결하는 것도 런타임 시 예외를 던지는 것보다 훨씬 수월하다.

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

        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add("300");
				String value1 = (String) list.get(1);
        Integer value2 = (Integer) list.get(2);
        System.out.println("문자열 list[1] : " + value1);
        System.out.println("정수 list[2] : " + value2);
    }
}

위의 코드는 Generic이 등장하기 이전에 사용하던 방식의 코드를 간단하게 작성한 것이다. List 객체는 ArrayList 클래스로 구현되었지만 해당 리스트 내부에 어떤 타입의 데이터가 들어갈지 알 수 없는 상황이기 때문에 List 객체 내에는 아무런 참조 자료형으로 세팅될 수 있다.
(추후에 Collection.List 내부 구조에 대해 자세히 알아보자.)

ByteCode

...
  // access flags 0x9
  public static main([Ljava/lang/String;)V
   L0
    LINENUMBER 9 L0
    NEW java/util/ArrayList
    DUP
    INVOKESPECIAL java/util/ArrayList.<init> ()V
    ASTORE 1
   L1
    LINENUMBER 10 L1
    ALOAD 1
    BIPUSH 100
    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
    INVOKEINTERFACE java/util/List.add (Ljava/lang/Object;)Z (itf)
    POP
		...
   L4
    LINENUMBER 14 L4
    ALOAD 1
    ICONST_1
    INVOKEINTERFACE java/util/List.get (I)Ljava/lang/Object; (itf)
    CHECKCAST java/lang/String
    ASTORE 2
	  ...
}

ByteCode를 살펴보자. 해당 코드의 상단에 보면 List의 add() 메소드와 get() 메소드가 호출될 때 매개 변수의 인자로 설정한 리터럴 데이터가 컴파일러에 의해 Object로 변경되어 넘어가는 것을 확인 할 수 있다. 이는 모든 참조 자료형은 최상위 조상으로 Object를 상속 받고 있어 List에 담을 때, 담기는 객체들이 Object로 List에 담기는 것이다.

각기 다른 참조 자료형을 타입이 선언되지 않은 List에 담는 것은 생각보다 큰 문제는 아니지만, 해당 List에 담긴 값을 꺼내어 사용해야 하는 경우에는 큰 문제이다.

첫 번째 소스코드가 바로 문제의 예시인데, 어쨌든 집어 넣은 데이터는 Object로 동일하기 때문에 컴파일러는 문제라고 판단하지 않아 컴파일한 클래스 파일을 Runtime Data Area로 넘길 것이다. 이 때 문제가 발생하는데 main() 메소드 호출 시, list 변수의 데이터를 지역 변수로 선언할 value1, value2의 타입에 맞지 않게 캐스팅 했기 때문에 JVM은 ClassCastException 예외를 발생시킨다.

이렇게 단순한 형변환으로 인해 런타임 시 예외가 발생하는 것은 애플리케이션 운영에 있어 큰 문제이다. 때문에 Generic은 이러한 문제를 해결하고, 옳지 않은 타입을 대입 했을 때 컴파일 에러를 발생시켜 애플리케이션 운영 이전에 개발자가 문제의 영역을 사전에 수정 할 수 있다.

Java 5 이후에 등장한 Generic은 다양한 클래스에 정의되어 있는데 대표적인 예가 자주 사용하는 ArrayList<E> 클래스이다. 그렇다면 <> 안에 들어있는 각기 다른 캐릭터는 무엇을 의미할까?

Generic Type

사실 Generic의 <> 안에는 어떤 문자를 넣어도 상관없이 사용 가능하다.

public class Generic<Type> {
        public Type type;

        public Generic(Type type) {
            this.type = type;
        }
    }

하지만 이렇게 통일성 없는 문자로 Generic 타입을 명세하면 의미가 왜곡되거나 의도와는 다르게 해당 클래스가 사용될 수 있다. 이러한 부분에서 발생하는 문제를 사전에 예방하기 위해 몇 가지 규칙이 존재한다.

✔️ E : Element의 약자. 요소의 의미를 가지며 주로 Java Collection에서 주로 사용된다.

✔️ T : Type

✔️ N : Number

✔️ V : Value

✔️ K : Key

✔️ S, U, V : 두 번째, 세 번째로 정의하는 Generic

해당 규칙을 꼭 지켜야 할 의무는 없지만 누구나 이해하기 쉬우려면 따르는 것이 좋겠다. 그런데 종종 Generic에 ? 로 설정되어 있는 것을 볼 수 있는데 ? 가 의미하는 것은 무엇이고 어떤 용도로 사용될까?

Wild Card '?'

public class WildCardTest {
    public static void main(String[] args) {
        WildCardTest test = new WildCardTest();

        ArrayList<Integer> arr = new ArrayList<Integer>();
        arr.add(1);
        arr.add(2);
        arr.add(3);
        test.wildCardTest(arr);

        List<String> linked = new LinkedList<String>();
        linked.add("a");
        linked.add("b");
        linked.add("c");
        test.wildCardTest(linked);
    }

    public void wildCardTest(List<?> list) {
        System.out.println("현재 클래스 : " + list.getClass());
        for (Object obj : list) {
            System.out.println(obj.getClass());
        }
    }
}
/*
	현재 클래스 : class java.util.ArrayList
	class java.lang.Integer
	class java.lang.Integer
	class java.lang.Integer

	현재 클래스 : class java.util.LinkedList
	class java.lang.String
	class java.lang.String
	class java.lang.String
*/

Generic은 메소드의 매개 변수 인자로 받는 객체 중, Generic이 정의되어 있는 객체의 타입에도 적용 할 수 있다.

WildCardTest 클래스에 정의된 wildCardTest 메소드를 확인해보자. 매개 변수 인자로 받는 List 객체의 타입이 ? 로 선언되어 있는데, ? 는 Wild Card의 의미로 사용된다. 이를 통해서 객체가 Generic이 정의가 되어 있다면 매개 변수에서도 Generic을 정의 할 수 있다는 것을 알 수 있다.

그래서 main() 메소드에 정의된 ArrayList와 LinkedList의 타입이 다르지만 wildCardTest() 메소드에 매개 변수로 넣어도 별다른 컴파일 에러나 런타임 에러 없이 실행된다.

다만 매개 변수를 ? 로 정의 할 경우, 메소드 스코프 내에서 매개 변수 객체는 Object로 정의되기에 객체의 타입이 어떤 타입인지 알고 있다면 instanceof 예약어를 이용해 해당 타입이 맞는지 검증을 한 후에 사용하는 것이 좋다.

또한, ? 은 매개 변수뿐만 아니라 지역 변수나 필드에서도 선언은 가능하다. 하지만 해당 영역에서 사용할 경우 타입 안정성이 떨어지기 때문에 컴파일 에러를 발생시키는데, 그 이유는 객체의 타입이 무엇인지 알지 못하기 때문이다. 즉, ? 은 인자로 넘어온 데이터를 읽는 것은 가능하지만 쓰는 것은 불가능하다.

public class WildCardTest {
	
		public List<?> list;

    public static void main(String[] args) {
        WildCardTest test = new WildCardTest();
				...
				test.list.add("1"); // 컴파일 에러 발생
    }
...
}
/*
	java: no suitable method found for add(int)
	    method java.util.Collection.add(capture#1 of ?) is not applicable
	      (argument mismatch; int cannot be converted to capture#1 of ?)
	    method java.util.List.add(capture#1 of ?) is not applicable
	      (argument mismatch; int cannot be converted to capture#1 of ?)
*/

Bounded Wild Card

public class BoundedWildCardTest {

    public static void main(String[] args) {
        List<Parent> parents = new ArrayList<>();
        parents.add(new Parent(1));
        parents.add(new Parent(2));
        parents.add(new Child(3));

        List<Child> children = new ArrayList<>();
        children.add(new Child(1));
        children.add(new Child(2));
        children.add(new Child(3));

        List<String> stringList = new ArrayList<>();
        stringList.add("a");
        stringList.add("b");
        stringList.add("c");

        BoundedWildCardTest test = new BoundedWildCardTest();
        test.boundedTest(parents);
        test.boundedTest(children);
        test.boundedTest(stringList); // 컴파일 에러 발생
    }

    public void boundedTest(List<? extends Parent> list) {
        System.out.println(list.getClass());

        for (Parent obj : list) {
            System.out.println(obj.toString());
        }
    }
}

앞에서 ?(이하 Wild Card)에 대해서 공부했다. Wild Card는 어떤 타입의 인자가 와도 관계가 없어 어떤 관점에서는 편할지 몰라도, 다른 관점에서 바라본다면 적절한 통제가 이뤄지지 않기 때문에 예상하지 못한 문제가 발생할 수 있다.

이러한 Wild Card를 어느정도 통제하기 위해 extends 라는 예약어가 존재하는데, 이는 Bounded Wild Card라고 하며, 클래스 상속의 개념처럼 지정된 클래스를 포함하여 하위 클래스만 허용 할 수 있도록 한다.

위 코드를 확인해보면, boundedTest() 메소드의 매개 변수로 List 객체를 받는데, 이 때 <? extends Parent>로 타입의 제한이 정의되어 있다. 이는 List 객체의 타입이 Parent 객체를 포함한 하위 자식 객체들만 매개 변수로 허용하겠다는 의미이기 때문에, String 타입의 List 객체는 boundedTest() 메소드의 매개 변수 인자로 설정 할 수 없다.

또한 Bounded Wild Card에는 extends 와 반대되는 super 예약어가 존재한다. 해당 Bounded Wild Card는 Lower Bounded Card, extends의 경우는 Higher Wild Card라고 칭한다.

📍 Higher Bounded Card : 타입의 대상이 될 객체의 자식 객체들까지 타입으로 허용 할 수 있다.

📍 Lower Bounded Card : 타입의 대상이 될 객체의 부모 객체들까지 타입으로 허용 할 수 있다.

Generic Method

public class BoundedWildCardTest {

    public static void main(String[] args) {
        List<Parent> parents = new ArrayList<>();
        ...

        List<Child> children = new ArrayList<>();
        ...

        List<String> stringList = new ArrayList<>();
        ...

        BoundedWildCardTest test = new BoundedWildCardTest();

        test.genericMethod(parents, new Parent(4));
        test.genericMethod(children, new Child(4));
        test.genericMethod(stringList, "abc");
    }

    public <T> void genericMethod(List<T> list, T type) {
        System.out.println("리스트 타입 : " + list.getClass());
        System.out.println("T : " + type.getClass());

        list.add(type);

        for (Object obj : list) {
            System.out.println(obj.toString());
        }
    }
}

Wild Card 파트에서 Wild Card는 인자로 넘어온 데이터를 읽는 것은 가능하지만 쓰는 것은 불가능하다고 했다. 하지만 완전히 불가능한 것은 아니다. 메소드에 Generic Type을 지정한다면 매개 변수 인자로 전달된 객체의 쓰기가 가능하다.

Generic Type Erasure

앞서 공부한 내용을 다시 되짚어보자. Generic이 등장하기 전에는 형변환에 대한 타입 체크가 런타임에서 일어나기 때문에 많은 문제점을 발생시켜 이를 해결하기 위해서 Generic의 개념이 도입되었고, 등장 이후부터는 컴파일 타임에서 강한 타입 체크가 일어나 런타임 전에 문제를 해결 할 수 있게 되었다.

어떻게 Generic의 강한 타입 체크는 컴파일 시점에서 확인 할 수 있는 것일까? Generic은 소거 프로세스를 적용하여 작동되는데, 이는 컴파일 시점에서 타입 체크를 수행한 후 해당 객체의 타입 정보를 런타임 시점까지 가져가지 않는 것을 의미한다.

이를 Type Erasure라고 부르는데, 바이트 코드를 확인해보면 타입이 설정된 모든 객체들의 타입 정보가 존재하지 않는 것을 확인 할 수 있다.

...
	 L14
    LINENUMBER 26 L14
    ALOAD 4
    ALOAD 2
    INVOKEVIRTUAL generic/BoundedWildCardTest.boundedTest (Ljava/util/List;)V
   L15
    LINENUMBER 28 L15
    ALOAD 4
    ALOAD 1
    NEW generic/Parent
    DUP
    ICONST_4
    INVOKESPECIAL generic/Parent.<init> (I)V
    INVOKEVIRTUAL generic/BoundedWildCardTest.genericMethod (Ljava/util/List;Ljava/lang/Object;)V
...

Type Erasure는 아래와 같은 방식으로 컴파일 타임에서 타입 체크 수행 후, 객체의 타입을 소거한다.

💥 컴파일 시, Generic이 적용된 객체에서는 해당하는 타입 파라미터(void example(T t))나 Object로 변경해준다.

💥 만약 Generic Type이 Object로 변경되었다면 허용 가능한 타입에 제한이 없다는 의미(unbounded)로, Type Erasure 규칙에 대한 Generic이 적용 가능한 범위는 일반적인 클래스나 메소드 혹은 인터페이스만 해당된다.

💥 Generic은 포용성을 띄기 때문에, 다형싱이 깨질 수 있다. 때문에 앞서 배운 Generic Method를 활용하여 Bridge Method를 생성해 타입 지정을 대체한다.

💥만약 Generic이 Bounded 하게 설정될 경우, 컴파일러는 해당 객체의 타입을 Object가 아닌 Comparble<E>로 변경한다.

✔️ 제네릭을 사용하는 객체는 대부분 실체화 불가 타입, Object[] 같은 객체는 실체화 타입이라고 하는데, 실체화 타입의 경우 런타임 중 올바르지 않은 타입으로 캐스팅 될 경우 런타임 에러가 발생 할 수 있기 때문에 컴파일 타임에서 실체화하지 못하게 타입을 소거하는 리스트같은 실체화 불가 타입을 사용하는 것이 좋다.

---

🔥 주말에 진행하려 했던 내용인데, 주말에도 회사일을 하느라고 지금까지 붙잡고 있게 되었다.
하지만 그만큼 공부한 내용들을 머릿속으로 정리할 시간이 많았는데, 덕분에 최대한 내가 이해한 내용만으로 작성하려고 노력 할 수 있었다. 아직 Generic에 대해서 전부 아는 것은 아니지만 어느정도 머릿속에 구체화된 것 같아 기쁘다!

다음에 시간 여유가 생긴다면, Compable<E> 에 대해서도 공부를 해봐야겠다.

 

---

참고 문서

14주차 과제: 제네릭

자바의 제네릭 타입 소거, 리스트에 관하여 (Java Generics Type Erasure, List)