[Java] 제네릭

출처

ChatGPT

---

제네릭의 존재 이유

1. 타입 안전성 강화

제네릭을 사용하면 컴파일러가 컴파일 시점에 잘못된 타입 사용을 검출할 수 있다. 이를 통해 런타입 예외를 주리고, 타입 변환(casting)에 관한 오류를 방지한다.

2. 코드 재사용성

동일한 코드가 다양한 데이터 타입과 함께 사용될 수 있어, 중복된 코드를 줄이고 유지보수성을 높인다.

3. 가독성 향상

제네릭을 사용하면 명확한 타입 정보를 재공해 코드의 가독성을 높일 수 있다.

 

제네릭 장점

1. 컴파일 시점의 타입 체크

제네릭을 사용하면 컴파일 시점에서 타입을 체크하며, 런타임에 발생할 수 있는 ClassCastException과 같은 예외를 줄일 수 있다.

2. 타입 변환의 필요성 제거

제네릭을 사용하면 객체를 삽입하거나 추출할 때 타입 변환을 수동으로 할 필요가 없어 코드가 간결해지고, 타입 변환에서 발생할 수 있는 오류를 방지할 수 있다.

3. 코드 재사용성

제네릭 클래스를 만들면 다양한 타입에 대해 재사용할 수 있어, 중복된 코드를 줄일 수 있다.

 

제네릭 단점

1. 타입 소거 Types Erasure

Java 제네릭은 런타임에 타입 정보가 소거되므로, 런타임에는 제네릭 타입 정보를 사용할 수 없다. 이로 인해 특정 상황에서 의도하지 않은 결과를 초래할 수 있다.

• 관련 글 -> [Java] 제네릭의 타입 소거 Type Erasure

2. 기본 데이터 타입 사용 제한

제네릭은 int, char 등 기본 데이터 타입(primitive type)을 직접 사용할 수 없다. 대신 Integer, Character와 같은 래퍼 클래스를 사용해야 한다.

• 관련 글 -> [Java] 왜 제네릭은 원시 타입을 사용할 수 없는가

3. 복잡한 제네릭 타입 선언

제네릭 타입이 복잡해지면 코드의 가독성이 떨어질 수 있다.

 

사용 시 주의해야 할 점

1. 제네릭 타입의 타입 매개변수는 런타임에 소거된다. 따라서 런타임에 타입 정보에 접근하려는 시도는 무의미하다. 예를 들어, 제네릭 배열 생성은 혀용되지 않는다.('new T[]'와 같은 형태)

2. 기본 데이터 타입 사용 불가 : 제네릭에서는 기본 데이터 타입(예 : int, char)을 사용할 수 없다. 대신 Integer, Character와 같은 레퍼 클래스를 사용해야 한다.

3. 제네릭 타입 캐스팅 주의 : 제네릭 타입의 객체를 raw type으로 캐스팅할 때는 경고가 발생할 수 있으며, 이는 런타임 예외를 유발할 수 있다.

 

예제 코드

import java.util.ArrayList;
import java.util.List;

// 제네릭 클래스를 정의합니다.
class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        // Integer 타입으로 제네릭 클래스 사용
        Box<Integer> integerBox = new Box<>();
        integerBox.setContent(123);
        Integer intValue = integerBox.getContent();
        System.out.println("Integer value: " + intValue);

        // String 타입으로 제네릭 클래스 사용
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello Generics");
        String strValue = stringBox.getContent();
        System.out.println("String value: " + strValue);

        // 제네릭 리스트를 사용하는 예제
        List<String> stringList = new ArrayList<>();
        stringList.add("Apple");
        stringList.add("Banana");

        for (String fruit : stringList) {
            System.out.println(fruit);
        }

        // 제네릭 메서드를 사용하는 예제
        System.out.println("Max of 3, 7, 5 is: " + getMax(3, 7, 5));
    }

    // 제네릭 메서드 정의
    public static <T extends Comparable<T>> T getMax(T x, T y, T z) {
        T max = x;
        if (y.compareTo(max) > 0) {
            max = y;
        }
        if (z.compareTo(max) > 0) {
            max = z;
        }
        return max;
    }
}

 

• Box 클래스: Box<T>는 제네릭 클래스로, 하나의 타입 매개변수 T를 사용한다. 이 클래스는 타입에 안전한 방식으로 객체를 저장하고 반환할 수 있다.
• 제네릭 리스트: List<String>은 제네릭 타입의 리스트다. 이 리스트는 String 타입만을 저장할 수 있으며, 타입 안정성을 제공한다.
• 제네릭 메서드: getMax 메서드는 제네릭 메서드로, <T extends Comparable<T>> 타입 매개변수를 사용하여 비교 가능한 타입만 사용할 수 있도록 제한한다. 이는 T 타입의 세 개의 인자를 받아 가장 큰 값을 반환한다.

 

제네릭 타입의 경계 Generic Type Bounds

1. 기본 개념

제너릭 타입 경계는 제네릭 클래스나 메서드를 정의할 대 타입 파라미터에 허용할 수 있는 상위 클래스나 인터페이스를 지정하는 것을 의미한다. 즉, 제네릭 타입의 파라미터가 특정 타입이거나 특정 타입의 서브타입이어야 한다는 제한을 설정하는 것이다.

 

제네릭 타입의 경계는 크게 두 가지로 나눌 수 있다.

• 상한 경계  Upper Bound : 타입 파라미터가 특정 타입의 하위 클래스(서브클래스)여야 함을 정의한다.
• 하한 경계 Lower Bounde : 타입 파라미터가 특정 타입의 상위 클래스(슈퍼클래스)여야 함을 정의한다.

1. 상한 경계 Upper Bound

상한 경계는 제네릭 타입 파라미터가 특정 클래스나 인터페이스를 상속받거나, 그 인터페이스를 구현하는 타입이어야 하다는 제한을 의미한다.

• 문법 : <T extends 상위타입>

예제

'<T extends Number>'는 제네릭 타입 T가 Number 클래스이거나 Number의 하위 클래스(Integer, Doubel, Float 등)여야 한다는 의미이다.

public class Box<T extends Number> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public double square() {
        return value.doubleValue() * value.doubleValue();
    }
}

 

위 코드에서 Box 클래스는 Number 타입의 상위 클래스(또는 인터페이스)를 가진 타입만을 허용한다. Number 클래스의 하위 타입인 Integer, Double 등을 사용할 수 있지만, String 등 다른 타입은 사용할 수 없다.

 

2. 하한 경계 Lower Bound

하한 경계는 제네릭 타입 파라미터가 특정 클래스의 상위 클래스여야 한다는 제한을 의미한다. 하한 경계는 주로 와일드카드(? super Type)와 함께 사용된다.

• 문법 : <T super 하위 타입> (일반적인 제네릭 선언에서는 직접 사용하지 않고, 메소드 매개변수에서 와일드카드 형태로 사용)

예제

'<? super 하위 타입>'는 제네릭 타입 파라미터가 Integer 클래스이거나 Integer의 상위 클래스여야 한다는 의미이다.

public static void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

 

위 코드에서 List<? super Integer>는 Integer 타입 또는 그 상위 타입을 요소로 가질 수 있는 리스트를 의미한다. 이는 리스트에 안전하게 Integer 또는 그 하위 타입의 객체를 추가할 수 있도록 한다.

 

2. 제네릭 타입 경계가 존재하는 이유

1. 타입 안전성 보장

타입 경계는 컴파일러가 제네릭 타입이 허용할 수 있는 타입을 제한하여 타입 안전성을 보장할 수 있도록 한다. 예를 들어, 상한 경계를 사용하면 잘못된 타입이 사용되는 것을 방지하고, 하한 경계를 하용하면 타입 안전성을 유지하면서 특정 타입의 인스턴만을 추가할 수 있다.

 

예시

만약 제네릭 타입에 경계를 지정하지 않으면, 잘못된 타입이 사용되어 런타임에 ClassCastException이 발생할 수 있다. 경계를 지정하면 컴파일러가 이 같은 오류를 미리 방지할 수 있다.

public <T extends Number> void process(T value) {
    double result = value.doubleValue() * 2;  // Number의 메소드 사용 가능
    System.out.println(result);
}

 

위 예제에서 T 타입 파라미터는 Number의 하위 타입이므로, Number 클래스에 정의된 doubleValue() 메소드를 안전하게 호출할 수 있다.

2. 제네릭 메소드의 유연성 증가

제네릭 타입에 상한이나 하한 경계를 지정하면, 제네릭 메소드의 사용 범위와 유연성을 크게 향상시킬 수 있다. 경계가 없는 경우보다 더 많은 타입을 안전하게 처리할 수 있다.

 

예시

상한 경계를 사용하여 제네릭 메소드를 설계하면, 그 메소드는 더 많은 타입을 받아들일 수 있으며, 메소드 내부에서 특정 타입에 종속적인 기능을 안전하게 사용할 수 있다.

public static <T extends Comparable<T>> T findMax(T a, T b) {
    return (a.compareTo(b) > 0) ? a : b;
}

 

위 예제에서 findMax 메소드는 Comparable 인터페이스를 구현하는 모든 타입에 대해 사용할 수 있다. 타입 파라미터 T에 상한 경계를 설정함으로써, 메소드 내부에서 compareTo 메소드를 안전하게 호출할 수 있게 된다.

3. 코드 재사용성과 유지보수성 향상

제네릭 타입 경계를 사용하면, 코드 재사용성을 높일 수 있으며, 유지보수성을 향상시킬 수 있다. 제네릭 클래스나 메소드가 특정 타입에 종속적이지 않기 때문에, 다양한 타입을 지원하는 더 일반적인 코드를 작성할 수 있다.

 

예시

여러 데이터 타입에 대해 동일한 로직을 적용해야 하는 경우, 제네릭 타입 경계를 사용하여 중복 코드를 줄이고, 재사용 가능한 메소드를 작성할 수 있다.

public static <T extends Number> double sum(List<T> list) {
    double sum = 0.0;
    for (T number : list) {
        sum += number.doubleValue();
    }
    return sum;
}

 

위 예제에서 sum 메소드는 Number의 하위 클래스(Integer, Double, Float, 등)로 구성된 리스트에 대해 사용할 수 있으며, 다양한 타입의 리스트에 대해 동일한 합산 로직을 재사용할 수 있다.

4. 타입 안전성을 유지하며 변성(Variance) 처리 가능

• 관련 글 -> [Java] 변성 Variance

제네릭 타입의 경계는 변성을 지원하는 데에도 중요한 역할을 한다. 상한 경계와 하한 경계를 이용하여 공변성(Covariance)와 반공변성(Contravariance)를 처리할 수 있다.

 

• 상한 경계(? extends T): 공변성 처리를 위해 사용된다. 예를 들어, 메소드 매개변수에서 제네릭 타입의 상위 경계를 정의하여, 해당 타입의 하위 타입 객체들을 안전하게 다룰 수 있다.
• 하한 경계(? super T): 반공변성 처리를 위해 사용된다. 메소드 매개변수에서 제네릭 타입의 하위 경계를 정의하여, 해당 타입의 상위 타입 객체들을 안전하게 다룰 수 있다.