[Java] Java Generic(제네릭)

• 이 글은 "자바 온라인 스터디"에서 공부한 내용을 작성하였습니다.

Generic이란?

• Integer형 배열, String형 배열 등등 배열에 포함되는 원소의 타입마다 추가, 삭제, 정렬과 같은 함수를 정의하고 사용하는 것은 분명 비효율적일 것입니다.

• 자바의 Generic은 데이터의 타입을 일반화한다는 의미로 클래스나 메소드 정의 시 일반화하여 사용할 데이터 타입을 컴파일 시에 미리 지정하는 방법입니다.

• JDK1.5 부터 Generic을 사용가능하며, 컴파일 시 타입이 정해지기 때문에, 클래스나 메소드 내부에 사용될 데이터의 타입 안정성을 높일 수 있습니다.

• JDK1.5 이전에는 Object 타입을 사용하여 원하는 객체의 타입으로 캐스팅하여 사용해야만 했고, 잘못된 캐스팅으로 인해 런타임 오류 발생할 가능성이 있습니다.

  public class Example {
    public static void main(String[] args) {
  
        // JDK 1.5 이전
        ArrayList arrayList = new ArrayList();
        arrayList.add("Hello");
        String str = (String)arrayList.get(0);      // 캐스팅 안할 시, 컴파일 오류 
        System.out.println("Not Generic : "+str);
  
        ArrayList<String> stringArrayList = new ArrayList<>();
        stringArrayList.add("World");
        String str2 = stringArrayList.get(0);       // 캐스팅 상관 없다. => 타입 안전성 제공
        System.out.println("Generic : "+str2);
    }
  }

• 참조(https://coding-factory.tistory.com/573)

Generic 클래스

자바의 제너릭 클래스의 기본 Syntax는 다음과 같습니다.

public class Box<T>{
    private T t;
}

위 예제에서 사용된 T를 타입 변수라고 하며, 임의의 참조형 타입을 의미합니다. 타입의 매개변수의 이름은 아무거나 들어가도 상관없지만, 공식문서의 Name Convention을 따르는 게 좋습니다.

• E : 주로 자바 Collection framework에 사용되는 Element
• K : map에서 매개변수로 사용되는 Key
• V : map에서 매개변수로 사용되는 Value
• N : 숫자를 나타내는 Number
• T : 일반적으로 사용하는 제네릭 Type
• S : 두번째로 사용하는 일반 제네릭 Type
• U : 세번째로 사용하는 일반 제네릭 Type
• V : 네번째로 사용하는 일반 제네릭 Type

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Example {
    public static void main(String[] args) {
        Box<Integer, String> box = new Box<Integer, String>();
        box.add(Integer.valueOf(10),"Hello World");
        System.out.printf("Integer Value :%d\n", box.getFirst());
        System.out.printf("String Value :%s\n", box.getSecond());

        Pair<String, Integer> pair = new Pair<>();
        pair.addKeyValue("1", Integer.valueOf(10));
        System.out.printf("(Pair)Integer Value :%d\n", pair.getValue("1"));

        CustomList<Box> list = new CustomList<Box>();
        list.addItem(box);
        System.out.printf("(CustomList)Integer Value :%d\n", list.getItem(0).getFirst());
    }
}

class Box<T, S> {
    private T t;
    private S s;

    public void add(T t, S s) {
        this.t = t;
        this.s = s;
    }

    public T getFirst() {
        return t;
    }

    public S getSecond() {
        return s;
    }
}

class Pair<K,V>{
    private Map<K,V> map = new HashMap<K,V>();

    public void addKeyValue(K key, V value) {
        map.put(key, value);
    }

    public V getValue(K key) {
        return map.get(key);
    }
}

class CustomList<E>{
    private List<E> list = new ArrayList<E>();

    public void addItem(E value) {
        list.add(value);
    }

    public E getItem(int index) {
        return list.get(index);
    }
}

위의 예시는 공식문서의 예제를 가지고 왔습니다. 다음과 같은 Name Convention을 따르면 되고, 몇 가지 주의할 점으로는 Generic 타입으로는 Primitive Type은 사용할 수 없습니다. 즉, int 형과 같은 기본형 타입은 사용할 수 없고 Interger와 같은 참조형 타입을 사용할 수 있습니다. 또한, Pair부분에서 new로 할당하는 부분에서는 타입을 명시하지 않았지만 오류는 나타나지 않았습니다. 자바 7버전 이후로는 타입 추론이 가능하여 new 뒤에서는 생략이 가능합니다.

Generic 인터페이스

public class Example {
    public static void main(String[] args) {
        GenericClass genericClass = new GenericClass();
        System.out.println(genericClass.print());
        // Hello world
    }
}

class GenericClass implements GenericInterface<String>{
    @Override
    public String print() {
        return "Hello world";
    }
}

interface GenericInterface<T>{
    T print();
}

인터페이스도 클래스와 동일하게 인터페이스명 옆에 타입 변수를 지정하여 사용할 수 있습니다.

Generic 메소드

Generic 메소드를 사용하여 메소드의 파라미터에 여러 타입을 대입하도록 할 수 있습니다. Generic 메소드에 전달된 매개변수의 타입을 기반으로 컴파일러는 적절히 메소드 호출을 처리합니다.

• 제네릭 메소드의 타입변수는 리턴 타입 앞에 선언되어야 합니다.
• 타입변수는 여러 개를 가질 수 있으며, 기본 Name Convention을 따릅니다.
• 일반 클래스에서 제네릭 메소드를 선언할 수 있고, 타입변수는 동일하게 기본형은 안되고, 참조형만 가능합니다.

import java.util.ArrayList;
import java.util.Arrays;

public class Example {

    public static <E> void printArray(ArrayList<E> array){
        for(E element : array){
            System.out.print(element+" ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayList<Integer> integerArrayList = new ArrayList<>(Arrays.asList(1,2,3,4,5));
        ArrayList<Double> doubleArrayList = new ArrayList<>(Arrays.asList(1.1,2.2,3.3,4.4,5.5));
        ArrayList<Character> characterArrayList = new ArrayList<>(Arrays.asList('a','b','c','d','e'));

        printArray(integerArrayList);
        printArray(doubleArrayList);
        printArray(characterArrayList);
    }
}

Bounded Type

클래스, 인터페이스, 메소드를 제네릭으로 작성할 때, 타입 변수를 제한하기 위해서는 Bounded Type으로 선언해야 합니다.
<T extends 상위타입> 으로 타입변수를 지정하여 상위타입의 하위클래스로만 제한할 수 있습니다.

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

        // bounded 내의 타입이 아니여서 컴파일 오류 발생
        // BoundedGeneric<String> boundedGeneric = new BoundedGeneric<String>();

        BoundedGeneric<Integer> boundedGeneric = new BoundedGeneric<>();
        boundedGeneric.setT(Integer.valueOf(10));
        boundedGeneric.print();

    }
}

class BoundedGeneric<T extends Number>{
    T t;

    public void print(){
        System.out.println(t);
    }

    public void setT(T t){
        this.t = t;
    }
}

WildCard

자바에서 와일드 카드란 제네릭 메소드에서 매개변수를 받을 때, 타입변수가 아닌 ? 를 사용하여 매개변수의 타입을 제한하는 것을 말합니다.

import java.util.Arrays;
import java.util.List;

public class Example {

    public static double sum(List<? extends Number> numberlist){
        double sum = 0.0;

        for(Number n : numberlist){
            sum+=n.doubleValue();
        }
        return sum;
    }
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1,2,3);
        System.out.println("sum : "+sum(integerList));      // 6.0

        List<Double> doubleList = Arrays.asList(1.1,2.2,3.3);
        System.out.println("sum : "+sum(doubleList));       // 6.6

    }
}

매개변수로 List numberlist로 선언되었다고 가정해보면, String으로 구성된 리스트, Character로 구성된 리스트가 매개변수로 대입이 되더라도 오류가 나타나지 않습니다. 만약 메소드에서 Number 한에서만 호출할 수 있는 메소드를 실행한다면 String, Character로 구성된 리스트가 대입될 경우 런타임 오류가 발생하게 됩니다.
이것을 방지하기 위해서 WildCard를 사용하여 Number의 자식클래스로만 이루어진 리스트만 대입을 받도록 제한을 두면 오류를 방지할 수 있습니다.

• <?> : 모든 클래스나 인터페이스 모두 올 수 있습니다.

• <? extends 상위타입> : 상위타입의 자식클래스만 가능합니다.

• <? super 하위타입> : 하위타입의 부모클래스만 가능합니다.

T extends vs ? extends

바운디드 타입과 와일드카드를 공부하면서 두 가지의 차이점이 궁금하였습니다. 저와 동일하게 질문한 글에서 답변 받은 내용으로 작성하였습니다.

private static <T extends Number> void processList(List<T> someList) {
    T n = someList.get(0);
    someList.add(1,n); //addition allowed.   
}

private static void processList2(List<? extends Number> someList) {
    Number n = someList.get(0);
    //someList.add(1,n);//Compilation error. Addition not allowed.
    processList(someList);//Helper method for capturing the wildcard
}

• 바운디드 타입의 매개변수는 element를 추가할 수 있지만, 와일드카드에서는 불가능합니다.
• 바운디드 타입은 T라는 타입변수를 가지고 있어 메소드 내에서 T를 정의하고 T 내부 클래스의 메소드를 호출하는 등의 작업을 수행할 수 있지만 와일드카드에서는 타입에 대한 핸들이 없기 때문에 작업을 수행할 수 없습니다.
• 참조(https://stackoverflow.com/questions/38944896/difference-between-bounded-type-parameter-t-extends-and-upper-bound-wildcard)

Erasure

제네릭 프로그래밍에서 일반적인 동작을 수행하기 위해서 컴파일러가 컴파일 타임에 제네릭 매개변수를 실제 클래스로 바꾸는 type erasure를 적용합니다. type erasure는 추가 클래스를 생성하지 않고 런타임 시 오버헤드가 일어나지 않도록 하게 해주는 프로세스입니다. 이로 인해 제네릭 프로그래밍에서의 타입 안정성을 강력하게 보장합니다.

Type Erasure rules

• bounded type으로 매개변수를 사용할 경우는 Generic type을 bounded type으로 변경합니다.
• 바운드 되지 않았다면 Generic type은 Object로 바꿉니다.
• 타입 안정성을 보장하기 위해 type cast를 추가합니다.
• 확장된 generic type에서 다형성을 유지하기 위한 bridge method를 실행합니다.
• 참조(https://www.tutorialspoint.com/java_generics/java_generics_quick_guide.htm)

public class Example {
   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<Double> doubleBox = new Box<Double>();

      integerBox.add(new Integer(10));
      doubleBox.add(new Double(10.0));

      System.out.printf("Integer Value :%d\n", integerBox.get());
      System.out.printf("Double Value :%s\n", doubleBox.get());
   }
}

class Box<T extends Number> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }   
}

다음은 제네릭을 이용한 코드입니다.

public static void main(String[] args) {
      Box integerBox = new Box();
      Box doubleBox = new Box();

      integerBox.add(new Integer(10));
      doubleBox.add(new Double(10.0));

      System.out.printf("Integer Value :%d\n", integerBox.get());
      System.out.printf("Double Value :%s\n", doubleBox.get());
   }
}

class Box {
   private Number t;

   public void add(Number t) {
      this.t = t;
   }

   public Number get() {
      return t;
   }   
}

자바 컴파일러는 Erasure rule에 맞게 generic type을 실제 클래스로 바꾸게 되고, 다음 코드와 같은 바이트코드를 생성하게 됩니다.