자바 고급 제네릭 (Advanced Generics)

목차
1. 고급 제네릭이란 무엇인가?
2. 제네릭의 필요성 복습
3. 와일드카드(Wildcards)
   - 한정된 와일드카드(Upper Bounded Wildcards)
   - 하한정 와일드카드(Lower Bounded Wildcards)
   - 무한정 와일드카드(Unbounded Wildcards)
4. 제네릭 메서드(Generic Methods)
   - 제네릭 메서드 정의 및 사용
   - 타입 추론(Type Inference)
5. 제네릭 클래스의 계층 구조
   - 상속에서의 제네릭
   - 제네릭과 인터페이스
6. 제네릭과 배열
   - 제네릭 배열 생성의 문제점
   - 제네릭 배열의 우회 방법
7. 제네릭의 타입 소거(Type Erasure)
   - 타입 소거 개념 이해
   - 타입 소거의 영향과 한계
8. 재귀적 제네릭 바운드(Recursive Generics)
   - 재귀적 타입 바운드(Recursive Type Bound)
   - 예제: Comparable 인터페이스 구현
9. 제네릭의 실제 활용 사례
   - 컬렉션 API에서의 고급 제네릭 사용
   - 실무 코드에서의 고급 제네릭 활용
10. 예제와 분석
11. 결론 및 추가 학습 자료

---

1. 고급 제네릭이란 무엇인가?

고급 제네릭(Advanced Generics)은 자바의 제네릭 기능을 더욱 심화하여, 복잡한 타입 시스템을 효과적으로 활용하고, 코드의 재사용성을 극대화하는 기법을 의미합니다. 제네릭은 자바의 강력한 기능 중 하나로, 타입 안전성을 보장하면서 코드의 유연성을 높여줍니다. 이번 글에서는 자바 제네릭의 고급 기능과 사용 방법을 살펴보겠습니다.

---

2. 제네릭의 필요성 복습

제네릭은 타입 안정성을 보장하면서 코드의 재사용성을 높이기 위해 도입되었습니다. 제네릭을 사용하면 컴파일 시점에서 타입 검사를 수행할 수 있으며, 이를 통해 런타임 오류를 줄일 수 있습니다. 또한, 제네릭을 통해 여러 타입에 대해 동일한 코드를 작성할 수 있어, 코드의 중복을 줄이고 유지 보수성을 높일 수 있습니다.

예제 코드:

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

public class GenericExample {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");

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

설명:
- 제네릭을 사용하여 'List'를 'String' 타입으로 지정함으로써, 컴파일 시점에 타입 안정성을 보장받을 수 있습니다.

---

3. 와일드카드(Wildcards)

와일드카드는 제네릭 타입을 보다 유연하게 사용할 수 있도록 도와주는 기능입니다. 와일드카드를 사용하면 제네릭 타입을 매개변수화된 형태로 받아들일 수 있으며, 이를 통해 다양한 타입을 처리할 수 있습니다.

한정된 와일드카드(Upper Bounded Wildcards)

한정된 와일드카드는 '? extends Type' 문법을 사용하여 특정 타입의 하위 클래스만 허용할 수 있습니다.

예제 코드:

import java.util.List;

public class UpperBoundWildcardExample {
    public static void printNumbers(List<? extends Number> list) {
        for (Number n : list) {
            System.out.println(n);
        }
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<Double> doubleList = List.of(1.1, 2.2, 3.3);

        printNumbers(intList);
        printNumbers(doubleList);
    }
}

설명:
- 'List<? extends Number>'는 'Number'의 하위 타입을 가진 리스트를 매개변수로 받아들일 수 있습니다.
- 'Integer'와 'Double' 리스트 모두 'printNumbers()' 메서드에 전달될 수 있습니다.

하한정 와일드카드(Lower Bounded Wildcards)

하한정 와일드카드는 '? super Type' 문법을 사용하여 특정 타입의 상위 클래스만 허용할 수 있습니다.

예제 코드:

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

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

    public static void main(String[] args) {
        List<Number> numList = new ArrayList<>();
        addIntegers(numList);

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

설명:
- 'List<? super Integer>'는 'Integer'의 상위 타입을 가진 리스트를 매개변수로 받아들일 수 있습니다.
- 'Number' 타입의 리스트에 'Integer' 값을 추가할 수 있습니다.

무한정 와일드카드(Unbounded Wildcards)

무한정 와일드카드는 '?'를 사용하여 모든 타입을 받아들일 수 있습니다.

예제 코드:

import java.util.List;

public class UnboundedWildcardExample {
    public static void printList(List<?> list) {
        for (Object elem : list) {
            System.out.println(elem);
        }
    }

    public static void main(String[] args) {
        List<String> stringList = List.of("Hello", "World");
        List<Integer> intList = List.of(1, 2, 3);

        printList(stringList);
        printList(intList);
    }
}

설명:
- 'List<?>'는 모든 타입의 리스트를 받아들일 수 있습니다.
- 'printList()' 메서드는 'String' 리스트와 'Integer' 리스트를 모두 처리할 수 있습니다.

---

4. 제네릭 메서드(Generic Methods)

제네릭 메서드는 메서드에 제네릭 타입을 사용하여 다양한 타입의 입력을 처리할 수 있도록 하는 기능입니다.

제네릭 메서드 정의 및 사용

제네릭 메서드는 메서드 이름 앞에 타입 매개변수를 선언하여 정의됩니다.

예제 코드:

public class GenericMethodExample {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"A", "B", "C", "D"};

        printArray(intArray);
        printArray(strArray);
    }
}

설명:
- '<T>'는 제네릭 타입 매개변수를 의미하며, 'printArray()' 메서드는 다양한 타입의 배열을 처리할 수 있습니다.

타입 추론(Type Inference)

컴파일러는 제네릭 메서드 호출 시 타입을 추론할 수 있으며, 명시적인 타입 선언 없이도 사용할 수 있습니다.

예제 코드:

public class TypeInferenceExample {
    public static <T> T getFirstElement(T[] array) {
        return array[0];
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"A", "B", "C"};

        Integer firstInt = getFirstElement(intArray);
        String firstStr = getFirstElement(strArray);

        System.out.println("First Integer: " + firstInt);
        System.out.println("First String: " + firstStr);
    }
}

설명:
- 컴파일러는 'getFirstElement(intArray)' 호출에서 타입을 'Integer'로 추론하며, 'getFirstElement(strArray)' 호출에서는 'String'으로 추론합니다.

---

5. 제네릭 클래스의 계층 구조

제네릭은 클래스 상속과 인터페이스 구현에서도 사용할 수 있으며, 이를 통해 코드의 유연성을 높일 수 있습니다.

상속에서의 제네릭

제네릭 클래스를 상속받을 때는 타입 매개변수를 그대로 사용할 수도 있고, 구체적인 타입으로 지정할 수도 있습니다.

예제 코드:

class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

class NumberBox extends Box<Number> {
    // Number 타입만 다룰 수 있는 Box
}

public class GenericInheritanceExample {
    public static void main(String[] args) {
        NumberBox numBox = new NumberBox();
        numBox.setValue(42);
        System.out.println("Value: " + numBox.getValue());
    }
}

설명:
- 'NumberBox' 클래스는 'Box<Number>'를 상속받아 'Number' 타입만 다룰 수 있습니다.

제네릭과 인터페이스

인터페이스에서도 제네릭을 사용할 수 있으며, 이를 통해 다양한 타입의 구현을 지원할 수 있습니다.

예제 코드:

interface Container<T> {
    void add(T element);
    T get();
}

class StringContainer implements Container<String> {
    private String value;

    @Override
    public void add(String element) {
        this.value = element;
    }

    @Override
    public String get() {
        return value;
    }
}

public class GenericInterfaceExample {
    public static void main(String[] args) {
        StringContainer container = new StringContainer();
        container.add("Hello");
        System.out.println("Value: " + container.get());
    }
}

설명:
- 'Container' 인터페이스는 제네릭 타입을 사용하여 다양한 타입의 구현을 지원합니다.
- 'StringContainer'는 'String' 타입에 특화된 구현을 제공합니다.

---

6. 제네릭과 배열

제네릭과 배열은 함께 사용할 때 몇 가지 제약이 있습니다. 자바에서는 제네릭 타입의 배열을 직접 생성할 수 없습니다.

제네릭 배열 생성의 문제점

제네릭 배열은 타입 안정성을 보장할 수 없기 때문에 컴파일러에서 직접적인 생성을 허용하지 않습니다.

잘못된 코드 예제:

public class GenericArrayExample<T> {
    private T[] array;

    public GenericArrayExample(int size) {
        array = new T[size]; // 컴파일 오류
    }
}

설명:
- 제네릭 배열을 직접 생성하려고 하면 컴파일 오류가 발생합니다.

제네릭 배열의 우회 방법

제네릭 배열을 생성할 때는 'Object' 배열을 생성한 후 캐스팅하는 방법을 사용할 수 있습니다.

예제 코드:

public class GenericArrayExample<T> {
    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArrayExample(int size) {
        array = (T[]) new Object[size];
    }

    public void set(int index, T value) {
        array[index] = value;
    }

    public T get(int index) {
        return array[index];
    }

    public static void main(String[] args) {
        GenericArrayExample<String> stringArray = new GenericArrayExample<>(10);
        stringArray.set(0, "Hello");
        System.out.println("First element: " + stringArray.get(0));
    }
}

설명:
- 제네릭 배열을 'Object' 배열로 생성한 후 캐스팅하여 사용할 수 있습니다.
- '@SuppressWarnings("unchecked")'는 컴파일러 경고를 억제하기 위해 사용됩니다.

---

7. 제네릭의 타입 소거(Type Erasure)

제네릭의 타입 소거는 자바 컴파일러가 제네릭 타입을 실제 타입으로 변환하는 과정입니다. 이 과정에서 제네릭 타입 정보는 소거되며, 런타임에는 구체적인 타입 정보가 사라집니다.

타입 소거 개념 이해

타입 소거는 컴파일 시점에 제네릭 타입이 제거되고, 대신에 'Object'나 경계 타입으로 변환되는 과정을 의미합니다.

예제 코드:

public class TypeErasureExample {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        Box<String> strBox = new Box<>();

        System.out.println(intBox.getClass() == strBox.getClass()); // true
    }
}

class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

설명:
- 제네릭 타입 정보는 컴파일 시점에 소거되며, 'Box<Integer>'와 'Box<String>'은 런타임에 동일한 클래스 타입을 가집니다.

타입 소거의 영향과 한계

타입 소거로 인해 제네릭 타입 정보는 런타임에 알 수 없으며, 이는 리플렉션 사용 시 제약이 될 수 있습니다.

예제 코드:

import java.lang.reflect.Method;

public class TypeErasureReflectionExample {
    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Container.class.getMethod("add", Object.class);
        System.out.println("Parameter type: " + method.getParameterTypes()[0]);
    }
}

class Container<T> {
    public void add(T element) {
        // 메서드 구현
    }
}

설명:
- 'Container' 클래스의 'add' 메서드에서 제네릭 타입 정보는 런타임에 'Object'로 소거됩니다.

---

8. 재귀적 제네릭 바운드(Recursive Generics)

재귀적 제네릭 바운드는 타입 매개변수를 자신의 타입으로 제한하는 기법으로, 주로 비교 연산이나 제네릭 타입의 계층 구조에서 사용됩니다.

재귀적 타입 바운드(Recursive Type Bound)

재귀적 타입 바운드는 '<T extends Comparable<T>>'와 같이 자신의 타입을 상위 타입으로 지정하는 제네릭 바운드를 의미합니다.

예제 코드:

public class RecursiveGenericExample<T extends Comparable<T>> {
    private T value;

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

    public boolean isGreaterThan(T other) {
        return value.compareTo(other) > 0;
    }

    public static void main(String[] args) {
        RecursiveGenericExample<Integer> example = new RecursiveGenericExample<>(10);
        System.out.println(example.isGreaterThan(5)); // true
    }
}

설명:
- 'T extends Comparable<T>'는 'T' 타입이 자신과 비교 가능한 타입임을 보장합니다.
- 'isGreaterThan()' 메서드는 재귀적 타입 바운드를 사용하여 'T' 타입의 값을 비교합니다.

---

9. 제네릭의 실제 활용 사례

제네릭은 자바의 컬렉션 API를 비롯해 다양한 라이브러리에서 널리 사용됩니다. 고급 제네릭을 사용하면 코드의 유연성과 재사용성을 극대화할 수 있습니다.

컬렉션 API에서의 고급 제네릭 사용

자바의 컬렉션 API는 제네릭을 통해 타입 안전성을 제공하며, 다양한 자료 구조를 유연하게 사용할 수 있습니다.

예제 코드:

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

public class CollectionGenericExample {
    public static void main(String[] args) {
        List<? extends Number> numbers = new ArrayList<>();
        // numbers.add(1); // 컴파일 오류: ? extends Number는 안전하지 않음

        List<? super Integer> integers = new ArrayList<>();
        integers.add(1); // 허용됨
    }
}

설명:
- 'List<? extends Number>'는 읽기 전용 리스트로 사용할 수 있으며, 추가 작업은 허용되지 않습니다.
- 'List<? super Integer>'는 'Integer' 타입의 값을 추가할 수 있습니다.

실무 코드에서의 고급 제네릭 활용

실무에서는 제네릭을 사용하여 코드의 재사용성을 극대화하고, 다양한 상황에 유연하게 대처할 수 있는 API를 설계합니다.

예제 코드:

public class Response<T> {
    private T data;
    private String message;
    private int statusCode;

    public Response(T data, String message, int statusCode) {
        this.data = data;
        this.message = message;
        this.statusCode = statusCode;
    }

    public T getData() {
        return data;
    }

    public String getMessage() {
        return message;
    }

    public int getStatusCode() {
        return statusCode;
    }

    public static void main(String[] args) {
        Response<String> response = new Response<>("Success", "Operation completed", 200);
        System.out.println("Response: " + response.getData());
    }
}

설명:
- 'Response' 클래스는 제네릭 타입을 사용하여 다양한 타입의 응답을 처리할 수 있습니다.

---

10. 예제와 분석

지금까지 배운 고급 제네릭의 개념을 종합적으로 적용한 예제를 살펴보겠습니다.

종합 예제:

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

public class AdvancedGenericsExample {

    // 제네릭 메서드
    public static <T> void reverse(List<T> list) {
        int size = list.size();
        for (int i = 0; i < size / 2; i++) {
            T temp = list.get(i);
            list.set(i, list.get(size - 1 - i));
            list.set(size - 1 - i, temp);
        }
    }

    // 와일드카드 사용
    public static void printNumbers(List<? extends Number> numbers) {
        for (Number number : numbers) {
            System.out.println("Number: " + number);
        }
    }

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

        reverse(intList);
       

 System.out.println("Reversed List: " + intList);

        printNumbers(intList);
    }
}

코드 분석:
- 'reverse()' 메서드는 제네릭 메서드로, 리스트의 요소를 뒤집습니다.
- 'printNumbers()' 메서드는 와일드카드를 사용하여 'Number' 타입의 하위 클래스 리스트를 출력합니다.

---

11. 결론 및 추가 학습 자료

이번 글에서는 자바의 고급 제네릭 기능에 대해 자세히 살펴보았습니다. 고급 제네릭은 코드의 유연성과 타입 안전성을 높여주며, 복잡한 타입 구조를 효과적으로 관리할 수 있게 해줍니다. 고급 제네릭을 잘 이해하고 활용하면, 다양한 상황에서 코드의 재사용성을 극대화할 수 있습니다.

추가 학습 자료:
- 자바 공식 문서: [Oracle Java Documentation - Generics](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
- 온라인 자바 튜토리얼: [Java - Generics](https://www.tutorialspoint.com/java/java_generics.htm)
- 자바 코딩 연습 사이트: [GeeksforGeeks - Generics in Java](https://www.geeksforgeeks.org/generics-in-java/)

고급 제네릭은 자바 프로그래밍에서 중요한 역할을 하며, 이를 잘 이해하고 활용하면 복잡한 애플리케이션에서도 효율적인 코드를 작성할 수 있습니다. 이번 기회를 통해 고급 제네릭의 개념과 활용 방법을 잘 이해하고, 실무에서 효과적으로 사용해보세요.

---

이제 자바의 고급 제네릭에 대해 자세히 이해하게 되었습니다. 다음 글에서는 자바의 또 다른 고급 기능에 대해 다루도록 하겠습니다. 자바의 더 깊은 이해를 위해 계속해서 학습해나가세요!