[Java] Generic

목차

1. Generic
2. 사용예제
3. wild card
4. PECS

---

Generic

💡 클래스 내부에서 사용할 데이터 타입을 외부에서 지정하는 기법, 즉 타입의 변수화

ArrayList<String> list = new ArrayList<>();

• 여기서 타입을 지정하는 < > 가 제네릭

---

타입 매개변수 <T>

• 구체화: 인스턴스 생성 시 타입 지정 → 제네릭 타입 전파

• 타입 파라미터 생략 가능 (생성자 타입 추론)

• Reference 타입만 가능 (원시 타입 X)

• Java 제네릭은 컴파일 타임 타입소거(Type Erasure) 기반
  primitive 사용 불가 → Wrapper(Integer 등) 자동 박싱으로 실무 불편 거의 없음

• 제네릭 타입 변수 관례

  • : 타입
  • : 요소 ex) List
  • : 키 ex) Map<k,v>
  • : 리턴 값 또는 매핑된 값(Variable)
  • : 숫자
  • <S, U, V> : 2번째, 3번쨰, 4번째에 선언된 타입

---

사용 이유

• 컴파일 시 타입 검사 → 런타임 예외 방지
• 불필요한 캐스팅 제거 → 성능 및 가독성 향상

---

주의사항

제네릭 타입 자체는 생성 불가

• T는 컴파일 타임에만 존재, 런타임 소거. JVM이 실제 타입을 알 수 없어 new T()를 만들 수 없음

T item = new T();      // 불가
T[] arr = new T[10];   // 불가

static 에 제네릭 사용 불가

• 클래스 레벨에서 공유, 객체마다 다른 T 타입 가질 수 있음 -> 타입 안정성 보장

제네릭 클래스 배열 생성 불가(선언은 가능)

---

기본 예시

class FruitBox<T> {
    List<T> fruits = new ArrayList<>();
    public void add(T fruit) {
        fruits.add(fruit);
    }
}

FruitBox<Integer> intBox = new FruitBox<>();
FruitBox<Double> doubleBox = new FruitBox<>();
FruitBox<String> strBox = new FruitBox<>();
FruitBox<Apple> appleBox = new FruitBox<>();

---

사용 예제

복수 타입 파라미터

class Apple {}
class Banana {}

class FruitBox<T, U> {
    List<T> apples = new ArrayList<>();
    List<U> bananas = new ArrayList<>();

    public void add(T apple, U banana) {
        apples.add(apple);
        bananas.add(banana);
    }
}

---

중첩 타입 파라미터

ArrayList<LinkedList<String>> list = new ArrayList<>();
LinkedList<String> node1 = new LinkedList<>();
node1.add("aa"); node1.add("bb");

---

제네릭 인터페이스

• 인터페이스를 implements 한 클래스에서도 오버라이딩한 메서드를 제네릭 타입에 맞춰서 똑같이 구현해야함

interface ISample<T> {
    void addElement(T t, int index);
    T getElement(int index);
}

---

제네릭 함수형 인터페이스

• 람다 표현식의 함수형 인터페이스 숙지 필요

interface IAdd<T> { T add(T x, T y); }
IAdd<Integer> sum = (x, y) -> x + y;

---

제네릭 메서드

• 메서드 선언부에 가 선언된 메서드: 클래스에서 설정된 타입을 받아오는 것이 아닌 직접 메서드에서 동적으로 타입을 받아와 사용할 수 있는 독립적으로 운용가능한 제네릭메서드
  • 제네릭 클래스에 정의된 타입 매개변수와 제네릭 메서드에 정의된 타입 매개변수는 별개
  • 호출 역시 메서드 왼쪽
  • 컴파일러가 제네릭 타입에 들어갈 데이터 타입을 메소드의 매개변수를 통해 추정할 수 있기 때문에, 대부분의 경우 제네릭 메서드의 타입 파라미터를 생략하고 호출가능
  • 처음 제네릭 클래스를 인스턴스화하면, 클래스 타입 매개변수에 전달한 타입에 따라 제네릭 메소드도 타입이 정해짐. 그런데 만일 제네릭 메서드를 호출할때 직접 타입 파라미터를 다르게 지정해주거나, 다른 타입의 데이터를 매개변수에 넘긴하면 독립적인 타입을 가진 제네릭 메서드로 운용

class Box<T> {
    public <U> void print(U value) { System.out.println(value); }
}

// 실제 사용
  class FruitBox<T> {

    // 클래스의 타입 파라미터를 받아와 사용하는 일반 메서드
    public T addBox(T x, T y) {
        // ...
    }

    // 독립적으로 타입 할당 운영되는 제네릭 메서드
    public static <T> T addBoxStatic(T x, T y) {
        // ...
    }
  }
  FruitBox.<Integer>addBoxStatic(1, 2);
  FruitBox.<String>addBoxStatic("안녕", "잘가");

    // 메서드의 제네릭 타입 생략
  FruitBox.addBoxStatic(1, 2);
  FruitBox.addBoxStatic("안녕", "잘가");

---

제한된 타입 매개변수 (Bounded Type)

• 타입 한정 키워드, extends - <T extends [제한 타입]> - 일반 클래스, 추상 클래스, 인터페이스 모두 가능 - extends는 클래스 1개만, 인터페이스는 여러 개 가능 - 다중 타입 한정 시 & 연산자 사용 - 재귀적 타입 한정: Comparable - <E extends Comparable>

class A {}
interface B {}


class Sample<T extends A & B> {}
class Box<T extends Comparable<T>> {}

제네릭 형변환

• 제네릭 서브 타입간 형변환 불가. 전달받은 그 타입으로만 서로 캐스팅 가능
  • 원소 - 원소 o <-> 객체 - 객체 x

---

wild card

💡변성(Variance): 타입 간 상속 관계가 제네릭에서 어떻게 반영되는가
공변성: 서로 다른 타입간에 함계 변할 수 있다는 특징(Liskov 치환 원칙)

---

공변 : S 가 T 의 하위 타입이면, S[] 는 T[] 의 하위 타입이다. List 는 List 의 하위 타입이다.

반공변 : S 가 T의 하위 텍스트타입이면, T[] 는 S[] 의 하위 타입이다. (공변의 반대). List 는 List 의 하위 타입이다. (공변의 반대)

무공변 / 불공변 : S 와 T 는 서로 관계가 없다. List 와 List 는 서로 다른 타입이다.

공변 / 반공변 / 무공변

  // 공변성
Object[] Covariance = new Integer[10];

// 반공변성
Integer[] Contravariance = (Integer[]) Covariance;

  // 공변성
ArrayList<Object> Covariance = new ArrayList<Integer>();

// 반공변성
ArrayList<Integer> Contravariance = new ArrayList<Object>();

제네릭 타입에 대해서 공변성 / 반공변성을 지원하지 않음

• 객체 타입, 제네릭 클래스는 다형성 지원. 제네릭 타입은 무공변, 전달받은 타입으로만 서로 캐스팅 가능
• object[] 같은 경우 문제 없음, List 같은 경우 업, 다운캐스팅 x. 고정된 타입만 가능 -> 제네릭 와일드 카드

  ---

  배열 공변성 문제

  Object[] numbers = new Integer[10];
  List<Object> list = new ArrayList<Integer>(); // 컴파일 에러
  numbers[0] = "text"; // 런타임 에러

  ---

  제네릭에서 와일드카드로 해결

  List<Integer> ints = Arrays.asList(1,2,3);
  List<? extends Number> nums = ints;

  ---

  와일드카드 종류

  <?> (Unbounded)

  • 모든 클래스나 인터페이스 타입이 올 수 있음. 읽기 전용, null만 삽입 가능

  <? extends T> (상한 제한)

  • Upper Bounded Wildcards (상위 클래스 제한). 읽기 전용, 상위 타입이나 상위 타입의 하위 타입만 올 수 있음.
  • GET은 상위타입으로, SET은 불가 -> GET 안전

  <? super T> (하한 제한)

  • Lower Bounded Wildcards (하위 클래스 제한). 하위 타입이나 하위 타입의 상위 타입만 올 수 있음.
  • GET은 최상위 타입으로. SET은 U와 U의 자손타입으로. -> 쓰기 가능, SET 안전

  ---

  사용지점 변성 (use-site variance)

  • 타입 매개변수 지점에 변성 정하는 자바의 방식
  • Kotlin, Scala는 선언지점 변성(declaration-site variance)을 사용

  List<out T>
  List<in T>

  ---

  PECS

  Producer Extends, Consumer Super

  • 와일드 타입의 객체를 생성, 만들 때는 extends(GET), 사용, 소비 시 super 사용(SET)
    • extends, super 사용 시기 규정
    • 오라클에서는 in, out 개념으로 설명. extends -> in, super -> out
  • 제네릭 타입 제한

  ---

  Producer — extends (읽기 전용)

  void printAll(List<? extends Number> list) {
      for (Number n : list) System.out.println(n);
  }

  ---

  Consumer — super (쓰기 가능)

  void addNumbers(List<? super Integer> list) {
      list.add(10);
      list.add(20);
  }

  ---

  참고 내용

  • 와일드카드는 설계가 아닌 사용을 위한 것

    • 클래스나 인터페이스 제네릭 설계 시 사용불가
    • 이미 만들어진 제네릭 클래스나 메서드 사용 시 이용

  • T extends 타입, ? extends U 차이점

    • 제네릭 클래스 설계 <-> 이미 만들어진 재네릭 클래스 인스턴스화 후 사용 시 타입파라미터 넘겨줄 때 작성

  • T super 타입: 무수히 많은 자바의 클래스와 인터페이스 올 수 있기때문에 사용 x

  • ? 와 object 차이: null 만 넣을 수 있음 <-> object 하위 타입 모두 넣을 수 있음
    | 타입 | 넣기(set) | 읽기(get) | 사용 목적 |
    | -------------- | ----------- | --------------- | ---------------- |
    | List<?> | null만 가능 | Object 타입으로 GET | 읽기 전용, 확장성 |
    | List<Object> | 모든 타입 넣기 가능 | Object로 GET | 실제 Object 타입 컬렉션 |

  ---

  🔗 참고

  • ☕ 자바 제네릭(Generics) 개념 & 문법 정복하기

  • ☕ 자바 제네릭의 공변성 & 와일드카드 완벽 이해