[Java] 변성 Variance

출처

ChatGPT

---

변성(Variance)은 제네릭 타입이 상속 관계에서 어떻게 동작하는지, 즉 타입 간의 상속 관계가 제네릭 타입에서도 그대로 유지될 수 있는지에 대한 개념을 의미한다. 변성은 객체 지향 프로그래밍에서 제네릭 타입의 안전한 사용을 위하 중요하다. 변성은 크게 공변성(Convariance), 반공변성(Contravariance), 그리고 무공변성(Invariance)으로 나눌 수 있다.

 

1. 변성의 종류

1. 공변성 Convariance

정의

공변성은 제네릭 타입이 특정 타입의 하위 타입 관계를 그대로 유지하는 것을 의미한다.

 

그러니까, A 타입과 A 타입를 상속받은 A'타입이 있고, B 타입과 B 타입을 상속받은 B' 타입이 있다면, A<? extends B> 변수에 A'<B'> 객체를 넣을 수 있다는 것이다.

예시

만약 Apple이 Fruit의 하위 타입이라면, List<Apple>도 List<Fruit>의 하위 타입으로 간주될 수 있는 상황이다.

사용 사례

자바에서는 공변성을 지원하기 위해 상한 경계 와일드 카드(? extendsd T)를 사용한다. 이는 특정 제네릭 타입이 특정 상위 클래스의 서브타입(하위 타입)들만 허용한다는 것을 의미한다.

List<? extends Fruit> fruits = new ArrayList<Apple>();

 

위 코드에서 List<? extends Fruit>는 Fruit의 하위 타입들(Apple, Orange 등)의 리스트로 사용할 수 있다.

제약

공변성에서는 리스트에 새로운 요소를 추가할 수 없다. 왜냐하면 실제 타입이 정확히 무엇인지 컴파일러가 알 수 없기 때문이다.

리스트에 새로운 요소를 추가할 때 타입 안전성을 유지하기 위해, 자바는 공병성에 의해 정의된 리스트에 새로운 요소를 추가하는 것을 제한한다.

 

- 예제

List<? extends Fruit> fruits = new ArrayList<Apple>();

// fruits.add(new Apple());  // 컴파일 오류
// fruits.add(new Fruit());  // 컴파일 오류

 

위 코드에서 fruits 리스트는 Fruit의 하위 타입들로 제한되기 때문에 Apple 타입의 리스트로 초기화되었다. 그러나 fruits 리스트에 새로운 요소를 추가하려고 할 때, 컴파일 오류가 발생한다. 왜 그런지 알아보겠다.

 

 

- 타입 안전성 문제

fruits의 선언 타입은 List<? extends Fruit>로, 이는 Fruit의 하위 타입을 의미한다. 이 시점에서 자바 컴파일러는 fruits 리스트가 실제로 어떤 하위 타입(Apple, Orange 등)의 리스트인지 정확히 알 수 없다.

만약 fruits 리스트에 new Apple()을 추가한다고 가정해 보자. fruits가 List<Orange>로 초기화되었다면, Apple 객체를 Orange 객체로 취급하게 되어 타입 불일치 문제가 발생한다. 따라서, 컴파일러는 fruits 리스트에 Apple 객체를 추가하는 것을 허용하지 않는다.

- 컴파일러의 타입 추론 제한: List<? extends Fruit>는 컴파일러에게 "이 리스트는 Fruit의 하위 타입으로 구성되어 있다"고 알려준다. 그러나 이 리스트가 어떤 특정한 하위 타입의 리스트인지 알 수 없기 때문에, 컴파일러는 타입 안전성을 보장하기 위해 요소 추가를 막다.

 

따라서, 공변성에서는 새로운 요소를 추가하는 것이 제한된다. 리스트의 특정 타입을 정확히 알 수 없는 경우가 많기 때문에, 이로 인해 발생할 수 있는 잠재적인 타입 불일치와 같은 문제를 방지하기 위해서이다.

 

공변성의 Practical 사용 사례

공변성은 일반적으로 읽기 전용 상황에서 유용하다. 예를 들어, 메서드가 제네릭 리스트를 인자로 받아 리스트의 요소를 순회하거나 읽기만 할 때, 공변성을 사용하는 것이 적절하다. 이렇게 하면 하위 타입의 요소를 포함하는 리스트도 상위 타입의 리스트로 취급할 수 있어 유연성이 높아진다.

public void printFruits(List<? extends Fruit> fruits) {
    for (Fruit fruit : fruits) {
        System.out.println(fruit);
    }
}

 

위 메서드는 Fruit의 하위 타입들을 포함하는 리스트를 인자로 받을 수 있고, 요소들을 안전하게 출력할 수 있다.

 

2. 반공변성 Contravariance

정의

반공변성은 제네릭 타입이 특정 타입의 상위 타입 관계를 유지하는 것을 의미한다.

 

그러니까, A 타입과 A 타입를 상속받은 A'타입이 있고, B 타입과 B 타입을 상속받은 B' 타입이 있다면, A<? super B'> 변수에 A'<B> 객체를 넣을 수 있다는 것이다.

예시

만약 Fruit이 Apple의 상위 타입이라면, List<Fruit>도 List<Apple>의 상위 타입으로 간주될 수 있는 상황이다.

사용 사례

자바에서는 반공변성을 지원하기 위해 하한 경계 와일드카드(? super T)를 사용한다. 이는 특정 제네릭 타입이 특정 하위 클래스의 슈퍼타입(상위 타입)들만 허용한다는 것을 의미한다.

List<? super Apple> apples = new ArrayList<Fruit>();

 

위 코드에서 List<? super Apple>는 Apple의 상위 타입들(Fruit, Object 등)의 리스트로 사용할 수 있다.

 

제약

반공변성에서는 리스트에서 값을 꺼낼 때 타입이 정확히 무엇인지 알 수 없으므로, 상위 타입으로만 다룰 수 있다.

 

List<? super T>를 사용할 때, 리스트에 값을 추가하는 것은 가능하지만, 값을 꺼낼 때는 다음과 같은 제약이 있다.

 

- 타입 정보의 상실

List<? super T> 는 T의 하위 타입을 수용할 수 있는 리스트이다. 이 경우, 리스트에 담겨 있는 객체는 T 또는 T의 상위 타입일 수 있다. 즉, 리스트에 T 객체를 추가할 수 있지만, 리스트에서 꺼낼 대에는 그 객체의 정확한 타입을 알 수 없다.

- 타입의 불확실성

List<? super T>에서 값을 꺼낼 때, 꺼낸 객체의 타입은 Object로 제한된다. 이는 리스트가 T의 하위 타입뿐만 아니라 T의 상위 타입도 수용할 수 있기 때문이다. 따라서, 꺼낸 객체가 T의 서브타입인지 아닌지 알 수 없기 때문에, 해당 객체를 T로 안전하게 캐스팅할 수 없다. 

 

-예제

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

public class ContravarianceExample {

    public static void main(String[] args) {
        List<? super Integer> list = new ArrayList<>();
        list.add(1);  // Integer를 추가할 수 있음
        list.add(2);  // Integer를 추가할 수 있음

        Object obj = list.get(0);  // 꺼낸 값의 타입은 Object로 제한됨
        // Integer number = list.get(0);  // 컴파일 오류: 정확한 타입을 알 수 없기 때문

        System.out.println(obj);  // 출력: 1
    }
}

 

 

값 추가:

• list.add(1)과 list.add(2)는 가능하며, Integer를 List<? super Integer>에 추가할 수 있다.

값 꺼내기:

• Object obj = list.get(0)은 가능하며, get 메서드는 리스트에 있는 값을 Object로 반환한다. 이는 리스트에 저장된 객체의 타입이 정확히 무엇인지 알 수 없기 때문이다.
• Integer number = list.get(0)은 컴파일 오류를 발생시킨다. list.get(0)이 반환하는 값이 Integer일 수도 있지만, Object로 반환되기 때문에 Integer로 직접 캐스팅할 수 없다. 정확한 타입을 알 수 없기 때문에 안전하지 않다.

 

비공변성의 Practical 사용 사례

타입을 상위 타입으로 다루면서 유연한 코드를 작성할 때 효과적이다.

 

예시 1 : 이벤트 리스트와 콜백

이벤트 리스너나 콜백 패턴에서 반공변성을 활용할 수 있다. 이러한 패턴은 특정 타입의 이벤트를 처리하는 핸들러를 등록하는 경우가 많다.

이벤트 리스터 정의

interface EventListener<T> {
    void handleEvent(T event);
}

 

다양한 이벤트 핸들러 등록

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

public class EventDispatcher {

    private List<EventListener<? super Integer>> listeners = new ArrayList<>();

    // 핸들러 추가 메서드
    public void addListener(EventListener<? super Integer> listener) {
        listeners.add(listener);
    }

    // 이벤트 발생 메서드
    public void dispatchEvent(Integer event) {
        for (EventListener<? super Integer> listener : listeners) {
            listener.handleEvent(event);
        }
    }
    
    public static void main(String[] args) {
        EventDispatcher dispatcher = new EventDispatcher();
        
        // Integer 이벤트를 처리하는 리스너 등록
        dispatcher.addListener(new EventListener<Integer>() {
            @Override
            public void handleEvent(Integer event) {
                System.out.println("Integer Event: " + event);
            }
        });

        // Number 이벤트를 처리하는 리스너 등록
        dispatcher.addListener(new EventListener<Number>() {
            @Override
            public void handleEvent(Number event) {
                System.out.println("Number Event: " + event);
            }
        });

        dispatcher.dispatchEvent(42); // Integer 이벤트 발생
    }
}

 

위 코드에서 EventDispatcher는 EventListener<? super Integer> 타입의 리스너를 등록할 수 있다. 이는 Integer뿐만 아니라 Number와 같은 Integer의 상위 타입을 처리하는 리스너도 수용할 수 있게 한다. 이로 인해 코드의 유연성이 높아지고 다양한 타입의 리스너를 등록할 수 있다.

3. 무공변성 Invariance

정의

무공변성은 제네릭 타입이 특정 타입의 상위 또는 하위 관계를 허용하지 않는 것을 의미한다. 즉, 제네릭 타입에 대해 정확히 일치하는 타입만 사용해야 한다.

예시

List<Fruit>는 List<Apple>의 하위 타입도 아니고 상위 타입도 아니다. 두 제네릭 타입은 서로 전혀 관련이 없다.

List<Fruit> fruits = new ArrayList<Fruit>(); // 정확히 일치해야만 합니다.

 

 

위 코드에서 List<Fruit>는 List<Apple>로 대체될 수 없다. 무공변성에서는 제네릭 타입의 상속 관계가 유지되지 않는다.

 

2. 변성이 존재하는 이유

변성은 제네릭 타입이 상속 구조와 함께 사용될 대의 안전성을 보장하기 위해 필요하다. 변성을 적절히 사용하지 않으면 타입 안정성이 깨질 수 있으며, 이는 런타임 예외나 타입 불일치 오류를 유발할 수 있다. 따라서 자바에서는 제네릭 타입에 대한 변성을 명시적으로 표현하여 개발자가 타입 안전성을 유지하면서 제네릭을 사용할 수 있도록 한다.

 

1. 공변성과 타입 안전성

공변성은 자네릭 타입이 상속 계층에서 하위 타입으로 확장될 때 유용하다. 예를 들어, List<? extends Number>는 Number의 하위 타입들에 대한 리스트를 안전하게 처리할 수 있다. 하지만 리스트에 새로운 요소를 추가할 때는 안전하지 않을 수 있으므로 읽기 전용 리스트에 줄 사용된다.

2. 반공변성과 유연성

반공변성은 제네릭 타입이 상속 계층에서 상위 타입으로 확장될 때 유용하다. 예를 들어, Comparator<? super Integer>는 Integer의 상위 타입들에 대한 비교기를 사용하여 객체들을 비교할 수 있다. 이는 비교기의 유연성을 증가시킨다.

 

3. 실제 예시

공변성과 반공변성은 자바의 컬렉션 프레임워크에서 자주 사용된다. 예를 들어, Collections.copy 메소드는 공변성과 반공변성 모두를 사용해 매우 유연하게 동작한다.

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (int i = 0; i < src.size(); i++) {
        dest.set(i, src.get(i));
    }
}

 

위 메소드는 src 리스트에서 데이터를 읽고, dest 리스트로 복사한다. src는 T의 하위 타입의 리스트로 제한되며, dest는 T의 상위 타입의 리스트로 제한된다. 이 메소드는 매우 유연하며, 다양한 타입의 리스트를 복사할 때 사용될 수 있다.