제네릭(Generics) - 기본 개념

JDK 1.5부터 도입된 제네릭(Generics)에 대해서 알아보자.

'제네릭(Generic)을 사용하면 다양한 타입을 사용할 수 있다.' 정도로만 알고 있었는데 제대로 공부하려고 보니깐 생각보다 양이 많다. 쫌 많이 많다...

그래서 이번 글에서는 제네릭의 기번 개념에 대해서 알아보고 다음 글들을 통해 더 구체적으로 알아보는 것으로 하자. (이펙티브 자바 5장의 제네릭(아이템 26 ~ 아이템 33) 내용과 와일드카드 등의 내용을 추가적으로 다룰 예정이다.)

(이펙티브 자바 5장 제네릭 파트를 읽으려는데 이해가 잘 되지 않아서 제네릭의 기본부터 블로깅하고 있는 중이다...😅)

1. 제네릭(Generic) 개념 🧱

우리는 제네릭(Generics)을 그 어떠한 개념보다 자주 사용한다.

public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    ArrayList<String> names = new ArrayList<String>();
}

// ArrayList.java
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList의 꺾쇠괄호(< >)안에 클래스 내부에서 사용할 데이터 타입(Integer, String,..)을 지정해 주었다. 이것이 제네릭을 사용한 것이다.

제네릭은 클래스 내부에서 사용할 데이터 타입을 외부에서 지정하는 기법을 의미한다.

제네릭은 다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에 컴파일 시의 타입 체크(compile-time type check)를 해주는 기능을 제공한다. 객체의 타입을 컴파일 시에 체크하기 때문에 객체의 타입 안전성을 높이고 형변환의 번거로움이 줄어든다.

public static void main(String[] args) {

    ArrayList<Integer> nums = new ArrayList<>();

    // 1. 타입의 안정성을 제공
    nums.add(1);
    // nums.add("1"); // 컴파일 에러

    // 2. 형변환의 번거로움이 줄어듬
    Integer num = nums.get(0);
    // Integer num1 = (Integer) nums.get(0);
}

📌 제네릭의 장점

타입 안정성을 제공
타입체크와 형변환을 생략할 수 있으므로 코드가 간결해진다.

2. 제네릭 클래스 🔨

제네릭 타입은 클래스와 메서드에 선언할 수 있다. 먼저 클래스에 선언하는 제네릭 타입에 대해서 알아보자.

📙 1. 제네릭 클래스 선언

다음과 같이 기존 클래스 옆에 '<T>'를 붙여서 제네릭 클래스를 만들 수 있다.

// 기존코드
// 제네릭 클래스 X
public class Box {
    Object item;

    void setItem(Object item) {
        this.item = item;
    }
    Object getItem() {
        return item;
    }
}

// 제네릭 클래스 O
public class Box<T> {
    T item;

    void setItem(T item) {
        this.item = item;
    }
    T getItem() {
        return item;
    }
}

여기서 T는 타입 변수(Type Variable)라고 한다. 꼭 T만을 써야 하는 게 아니라 E, K, V, N,... 등 다른 기호를 사용해도 된다. 기호의 종류들만 다를 뿐 '임의의 참조형 타입'이라는 것을 의미한다는 것은 모두 같다.

하지만 아래와 같이 암묵적인 규칙이 존재하므로 상황에 맞게 의미하는 문자를 선택해서 사용하는 것이 좋다.

타입	설명
T	타입(Type)
E	요소(Element) ex. ArrayList<E>
K	키(Key) ex. Map<K, V>
V	값(Value)

제네릭 클래스를 이용하여 객체를 생성할 때는 참조변수와 생성자에 타입 T 대신에 사용될 실제 타입을 지정해 주면 된다.

public static void main(String[] args) {
    
    // 타입 변수로 String을 사용한 경우
    Box<String> boxString = new Box<String>();
    boxString.setItem("boxString");
    String findBoxStringItem = boxString.getItem();

    // 타입 변수로 Integer를 사용한 경우
    Box<Integer> boxInteger = new Box<Integer>();
    boxInteger.setItem(123);
    Integer findBoxIntegerItem = boxInteger.getItem();
}

제네릭이 도입되기 이전의 코드와 호환을 위해, 제네릭 클래스인데도 다음과 같이 예전의 방식으로 객체를 생성하는 것이 허용된다.

public static void main(String[] args) {

    // 예전의 방식으로 객체를 생성
    Box boxPast = new Box();
    boxPast.setItem("123");
    Object findBoxPastItem = boxPast.getItem();
}

하지만, 해당 방법은 단지 제네릭이 도입되기 이전의 코드와 호환성을 위한 것이므로 해당 방법의 사용은 지양하도록 하자.

📙 2. 제네릭 용어

제네릭에 대해서 어느 정도 감이 잡혔고 더 많은 개념을 알기 위해 지금 타이밍에 제네릭의 용어를 한번 짚고 넘어가자. 용어는 다음과 같다.

Box<T>
제네릭 클래스
'T의 Box' 또는 'T Box'라고 읽는다.
T
타입 변수 또는 타입 매개변수(T는 타입문자)
Box
원시 타입(Raw Type)

제네릭 타입 호출
타입 매개변수(T)에 타입을 지정하는 것
매개변수화된 타입(Parameterized Type)
지정된 타입(위의 그림에서는 String)
용어가 좀 길기 때문에 이번 글에서는 '대입된 타입'이라고 사용하자.

📙 3. 제네릭 제한

제네릭 클래스는 다음과 같은 2가지 상황에서 사용할 수 없다.

📌 1. static멤버에 타입 변수 T를 사용할 수 없다.

static멤버는 모든 객체에 대해 동일하게 동작해야 한다.

T는 인스턴스 변수로 간주되고, static 멤버는 인스턴스 변수를 참조할 수 없으므로 static 멤버에 타입 변수 T를 사용할 수 없다.

class Box<T> {
    static T item; // 에러
    static int compare(T t1, T t2) {}; // 에러
}

📌 2. 제네릭 타입의 배열을 생성할 수 없다.

제네릭 배열 타입의 참조변수를 선언하는 것은 가능하지만, 'new T[100]'과 같이 배열을 생성하는 것은 안 된다.

class Box<T> {

    // T타입의 배열을 위한 참조 변수
    T[] itemArr; // OK

    T[] toArray() {
        // 제네릭 타입의 배열 생성
        T[] tmpArr = new T[itemArr.length]; // 에러

        return tmpArr;
    }
}

제네릭 배열을 생성할 수 없는 것은 new연산자 때문이다. new 연산자는 컴파일 시점에 타입 T가 무엇인지 정확히 알아야 한다.

하지만 위의 코드에서 Box<T>클래스를 컴파일하는 시점에 T가 어떤 타입이 될지 전혀 알 수 없다.

📙 4. 제네릭 클래스의 객체 생성과 사용

Box<T>가 다음과 같이 정의되어 있다고 하자.

class Box<T> {
    ArrayList<T> list = new ArrayList<T>();

    void add(T item) {
        list.add(item);
    }

    T get(int i){
        return list.get(i);
    }

    ArrayList<T> getList() {
        return list;
    }

    int size() {
        return list.size();
    }

    public String toString() {
        return list.toString();
    }
}

제네릭 클래스의 객체를 생성하고 사용할 때 다음의 규칙을 주의해서 생성 및 사용을 하면 된다. (Apple이 Fruit의 자손이라고 가정한다.)

📌 1. 참조변수와 생성자에 대입된 타입(매개변수화된 타입)은 일치해야 한다.

public static void main(String[] args) {

    // OK
    Box<Apple> appleBox = new Box<Apple>();
    // 에러
    Box<Apple> appleBox = new Box<Grape>();
}

📌 2. 추정이 가능한 타입 생략 가능(JDK 1.7부터)

public static void main(String[] args) {

    // OK
    Box<Apple> appleBox = new Box<Apple>();
    // OK // 생략 가능
    Box<Apple> appleBox = new Box<>();
}

📌 3. 다형성을 사용하는 경우

public static void main(String[] args) {

    // 예시 1
    Box<Apple> appleBox = new FruitBox<Apple>();
    // 예시 2
    Box<Fruit> fruitBox = new Box<Fruit>();
    fruitBox.add(new Fruit());
    fruitBox.add(new Apple());
}

📙 5. 제한된 제네릭 클래스

모든 종류의 타입을 이용하여 타입 문자를 지정할 수 있다.

모든 종류의 타입으로 타입 문자를 지정할 수 있는 것이 아닌, 제한된 타입의 종류로 타입 문자를 지정할 수 있도록 하는 방법을 알아보도록 하자.

'extends'를 사용하면 특정 타입과 특정 타입의 자손들만 대입할 수 있도록 제한할 수 있다.

public class Fruit {
}

public class Apple extends Fruit{
}

public class FruitBox<T extends Fruit> {
    ArrayList<T> list = new ArrayList<>();
}

public static void main(String[] args) {
    FruitBox<Fruit> fruitBox = new FruitBox<>();
    FruitBox<Apple> appleBox = new FruitBox<>();
}

인터페이스를 구현해야 한다는 제약이 필요하다면 아래와 같이 사용할 수 있다. (implements가 아니라 extends라는 점을 주의하자.)

interface Eatable {}
class FruitBox<T extends Eatable> { ... }

Fruit의 자손이면서 Eatable 인터페이스도 구현해야 한다면 '&'를 이용하여 표현할 수 있다.

class FruitBox<T extends Fruit & Eatable> { ... }

3. 와일드카드 🔧

매개변수에 과일박스(FruitBox)를 대입하면 주스(Juice)를 만들어서 반환하는 Juicer라는 클래스가 있고, 이 클래스에 과일을 주스로 만들어서 반환하는 makeJuice()라는 static 메서드가 있다고 하자.

public class Juicer {
    static Juice makeJuice(FruitBox<Fruit> box) {
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }
}

매개변수로 Fruit만 사용하는 것이 아닌 다양한 타입을 사용할 수 있도록 제네릭을 이용하려고 한다. 하지만 아래와 같은 문제가 있다.

Juicer 클래스는 제네릭 클래스가 아니다.
Juicer 클래스가 제네릭 클래스라고 해도, static 메서드에는 타입 매개변수 T를 매개변수에 사용할 수 없다.

그래서 어쩔 수 없이 아래와 같이 여러 가지 타입의 매개변수를 갖는 makeJuice()를 만들었다고 하자.

// 메서드 중복 정의
public class Juicer {
    static Juice makeJuice(FruitBox<Fruit> box) {
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }
    
    static Juice makeJuice(FruitBox<Apple> box) {
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }
}

이렇게 오버로딩을 하면 컴파일 에러가 난다. 제네릭 타입이 다르다는 것만으로는 오버로딩이 성립하지 않기 때문이다. 제네릭 타입은 컴파일러가 컴파일할 때만 사용하고 제거하기 때문에 위의 두 메서드는 오버로딩이 아니라 '메서드 중복 정의'이다.

이런 경우에 사용하기 위해서 만들어진 것이 '와일드카드'이다. 기호는 '?'이고, 와일드카드는 어떠한 타입도 가능하다.

하지만 '?'으로는 Object 타입과 다를 게 없으므로 일반적으로 'extends'와 'super'를 이용하여 상환(upper bound)과 하한(lower bound)을 두면서 사용할 수 있다.

와일드카드에서의 규칙은 아래와 같다.

<?>
타입 제한 없음
모든 타입이 가능
<? extends Object>와 동일
<? extends T>
와일드카드의 상한 제한
T와 그 자손들만 가능
<? super T>
와일드카드의 하한 제한
T와 그 조상들만 가능

📙 1. <? extends T>

먼저 'extends'를 사용하는 경우를 살펴보자. Juicer 클래스에 extends를 사용하면 문제의 상황을 해결할 수 있다.

public class Juicer {

    static Juice makeJuice(FruitBox<? extends Fruit> box) {
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }
}

public static void main(String[] args) {
    FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
    FruitBox<Apple> appleBox = new FruitBox<Apple>();

    System.out.println(Juicer.makeJuice(fruitBox));
    System.out.println(Juicer.makeJuice(appleBox));
}

📙 2. <? super T>

'super'를 사용한 경우도 살펴보자. Fruit가 있고 자손 클래스로 Apple과 Grape가 있다고 하자.

public class Fruit {
    String name;
    int weight;

    public Fruit(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }
}

public class Apple extends Fruit{
    public Apple(String name, int weight) {
        super(name, weight);
    }
}

public class Grape extends Fruit{
    public Grape(String name, int weight) {
        super(name, weight);
    }
}

Collections.sort()를 이용해서 appleBox와 grapeBox에 담긴 과일을 무게별로 정렬한다고 하자. Collections.sort()의 메서드 선언부는 다음과 같다.

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

첫 번째 매개변수는 정렬할 대상이고, 두 번째 매개변수는 정렬할 방법이 정의된 Comparator이다.

Collections.sort()가 와일드카드의 하한제한(<? super T>) 사용할 수 있도록 하고 있지만, 이것을 이용하지 않는다고 가정해 보자.

그러면 Collections.sort()를 사용할 때 타입을 명시하고 그에 해당하는 Comparator만 사용해야 할 것이다.

public class AppleComp implements Comparator<Apple> {

    @Override
    public int compare(Apple o1, Apple o2) {
        return Integer.compare(o1.weight, o2.weight);
    }
}

public class GrapeComp implements Comparator<Grape> {

    @Override
    public int compare(Grape o1, Grape o2) {
        return Integer.compare(o1.weight, o2.weight);
    }
}

public static void main(String[] args) {
    FruitBox<Apple> appleBox = new FruitBox<Apple>();
    FruitBox<Grape> grapeBox = new FruitBox<Grape>();

    appleBox.add(new Apple("GreenApple", 200));
    appleBox.add(new Apple("GreenApple", 100));

    grapeBox.add(new Grape("GreenApple", 200));
    grapeBox.add(new Grape("GreenApple", 100));

    Collections.sort(appleBox.getList(), new AppleComp());
    Collections.sort(grapeBox.getList(), new GrapeComp());
}

AppleComp와 GrapeComp는 타입만 다를 뿐 완전히 같은 코드이다.

이렇게 사용한다고 하면 코드 중복 문제뿐만 아니라 만약 새로운 Fruit의 자손이 생긴다면 계속해서 위와 같은 코드를 반복해서 만들어야 한다는 문제가 존재한다.

이를 해결하기 위해서 타입 매개 변수에 하한 제한의 와일드카드(<? super T>)를 활용해야 한다.

public class FruitComp implements Comparator<Fruit> {

    @Override
    public int compare(Fruit o1, Fruit o2) {
        return Integer.compare(o1.weight, o2.weight);
    }
}

public static void main(String[] args) {
    FruitBox<Apple> appleBox = new FruitBox<Apple>();
    FruitBox<Grape> grapeBox = new FruitBox<Grape>();

    appleBox.add(new Apple("GreenApple", 200));
    appleBox.add(new Apple("GreenApple", 100));

    grapeBox.add(new Grape("GreenApple", 200));
    grapeBox.add(new Grape("GreenApple", 100));

    Collections.sort(appleBox.getList(), new FruitComp());
    Collections.sort(grapeBox.getList(), new FruitComp());
}

이렇게 하면 AppleComp와 GrapeComp를 따로 사용하는 것이 아닌 FruitComp만을 이용해서 정렬이 가능하다.

이러한 장점 때문에 Comparator에는 항상 <? super T>가 습관적으로 따라붙게 된다.

4. 제네릭 메서드 🔩

제네릭 타입은 클래스와 메서드에 선언할 수 있다고 하였다. 지금까지는 클래스에 선언하는 제네릭 타입에 대해서 알아보았고, 이제부터는 메서드에 선언하는 제네릭 타입에 대해서 알아보자.

메서드에 타입 변수가 있다고 해서 그것이 제네릭 메서드는 아니다.

public class FruitBox<T> {

    // 제네릭 메서드 X
    // 타입 변수로 타입을 지정한 메서드 O
    public T addBox(T item){
        ...
    }
}

위의 코드는 단지 타입 변수로 타입을 지정한 메서드다. 제네릭 메서드가 아니다.

'제네릭 메서드'란 메서드의 선언부에 제네릭 타입이 선언된 메서드를 말한다. 즉, 메서드의 선언부에 <T>가 있어야 한다.

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

앞서 살펴본 것처럼, Collections.sort()가 바로 제네릭 메서드이다. 제네릭 타입의 선언 위치는 반환 타입 바로 앞에 위치한다.

'제네릭 클래스에 정의된 타입 매개변수'와 '제네릭 메서드에 정의된 타입 매개변수'는 전혀 별개의 것이라는 것에 주의하자.

public class FruitBox<T> {

    ...
    // 1번 메서드
    // 제네릭 메서드 X
    // 타입 변수로 타입을 지정한 메서드 O
    // 클래스의 타입 파라미터를 받아와 사용하는 일반 메서드
    public T addBox(T item){
        ...
    }

    // 2번 메서드
    // 제네릭 메서드 O
    // 독립적으로 타입 할당 운영되는 제네릭 메서드
    static <T> void sort(List<T> list, Comparator<? super T> c) {
        ...
    }
}

1번 메서드는 제네릭 메서드가 아니고, 2번 메서드는 제네릭 메서드이다.

각각의 특징은 아래와 같다.

제네릭 메서드 X (1번 메서드)
클래스의 제네릭 <T>에서 설정된 타입을 받아와 반환 타입으로 사용할 뿐인 일반 메서드
제네릭 메서드 O (2번 메서드)
메서드에 <T> 제네릭을 설정함으로써 동적으로 타입을 받아와 사용할 수 있다.
독립적으로 운용 가능하다.

제네릭 클래스 FruitBox에 선언된 타입 매개변수 T와 제네릭 메서드 sort()에 선언된 타입 매개변수 T는 타입 문자만 같을 뿐 서로 다른 것이다.

제네릭 메서드를 사용하면 static을 이용할 수 있다는 것에 주목하자. static멤버에는 타입 매개변수를 사용할 수 없지만, 이처럼 제네릭 메서드에 제네릭 타입을 선언하고 사용하는 것은 가능하다.

메서드에 선언된 제네릭 타입은 지역 변수를 선언하는 것과 같다고 생각하면 이해하기 쉬울 것이다. 이 타입 매개변수는 메서드 내에서만 지역적으로 사용될 것이므로 메서드에 static을 붙일 수 있다.

앞서 살펴보았던 makeJuice()를 제네릭 메서드로 바꾸면 다음과 같다.

public class Juicer {
    // 기존
    static Juice makeJuice(FruitBox<? extends Fruit> box) {
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }

    // 제네릭 메서드 적용
    static <T extends Fruit> Juice makeJuice(FruitBox<T> box) {
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }
}

메서드 호출은 타입 변수에 타입을 대입함으로써 호출할 수 있다.

public static void main(String[] args) {
    FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
    FruitBox<Apple> appleBox = new FruitBox<Apple>();

    System.out.println(Juicer.<Fruit>makeJuice(fruitBox));
    System.out.println(Juicer.<Apple>makeJuice(appleBox));
}

fruitBox나 appleBox의 선언부를 통해서 대입된 타입을 컴파일러가 추정할 수 있다. 그래서 아래와 같이 타입을 생략해서 표현할 수도 있다.

public static void main(String[] args) {
    FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
    FruitBox<Apple> appleBox = new FruitBox<Apple>();

    System.out.println(Juicer.makeJuice(fruitBox));
    System.out.println(Juicer.makeJuice(appleBox));
}

지금까지 제네릭의 기본 개념들을 살펴보았다. 글의 서두에서도 말했듯이 제네릭의 내용이 생각보다 방대하다. 이번 글을 통해 기본 개념을 잘 익히고 계속해서 제네릭의 다른 내용들도 살펴볼 수 있도록 하자.

해당 글은
남궁성 님의 '자바의 정석',
Inpa 님의 '자바 제네릭(Generics) 개념 & 문법 정복하기'
를 참고하였습니다.

'📂 JAVA > 주요 개념' 카테고리의 다른 글

제네릭(Generics) - 공변(Covariant), 불공변(Invariant), 반공변(Contravariant) (0)	2023.05.29
형변환(캐스팅, Casting) - 업캐스팅(Up-Casting), 다운캐스팅(Down-Casting) (0)	2023.05.24
래퍼 클래스 (Wrapper Class) (0)	2023.05.09
clone() (0)	2023.04.07
얕은 복사(Shallow Copy) vs 깊은 복사(Deep Copy) (0)	2023.04.07