JAVA 제네릭(Generics) 클래스와 메소드

JAVA 제네릭(Generics) 클래스와 메소드

📝 다루는 내용

• 제네릭의 정의
• 제네릭 클래스
• 제네릭 메소드
• 제네릭 제한(extends, super)
• 와일드 카드
• 제네릭 예 - Collections.sort()

 

제네릭(Generics) 이란?

제네릭은 클래스, 메소드에서 사용할 데이터 타입을 나중에 확정하는 기법이다. 나중에라는 말은 클래스나 메소드를 선언할 때가 아닌 사용할 때, 즉 인스턴스를 생성할 때나 메소드를 호출할 때 정한다는 의미이다.

제네릭의 사용 방법과 특징은 메소드의 매개변수와 굉장히 유사한데, 메소드의 매개변수가 '값'과 관련되어 있다면 제네릭은 데이터의 '타입'과 관련이 있다.

 

따라서 클래스와 메소드가 다양한 타입을 다룰 수 있는데 이를 제네릭을 사용하지 않고 구현하고자 하면 방법은 두 가지이다.

Object 타입을 사용하던지, 동일한 메커니즘을 가진 클래스와 메소드를 여러 개 정의하던지.

일단 Object를 사용하면 코드 중복은 막을 수 있겠지만 객체의 타입을 컴파일 타임에 체크할 수 없다는 제약사항이 생기고 이로 인해 런타임에 타입으로 인한 오류가 발생할 수 있다.

 

제네릭을 사용하면 Object를 사용할 때와 달리 객체의 타입을 컴파일 타임에 체크할 수 있어서 타입 안정성(type safety)를 높이고 형변환의 번거로움이 줄어든다는 장점이 있다.

 

타입 안정성(type safety)
- 의도하지 않은 타입의 객체가 저장되는 것을 막는다.
- 저장된 객체를 꺼내올 때 다른 타입으로 잘못 형변환하여 발생할 수 있는 오류를 줄인다.

 

제네릭의 장점
- 타입 안정성
- 코드가 간결해진다.

 

JAVA의 제네릭은 C++의 템플릿 클래스와 유사한 개념이라고 한다.

 

제네릭 클래스

제네릭은 클래스와 메소드에서 사용할 수 있는데 제네릭 타입을 선언한 클래스를 제네릭 클래스라 한다.

 

public class Box<T> {
    
    private T item;

    public T getItem() {
        return item;
    }

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

클래스에서 사용하려면 클래스 명 우측에 <>를 사용해서 선언한다.

 

public class Box<M, I> {

    private M material;
    private I item;

    public M getMaterial() {
        return material;
    }

    public void setMaterial(M material) {
        this.material = material;
    }

    public I getItem() {
        return item;
    }

    public void setItem(I item) {
        this.item = item;
    }
}

또한 ,(콤마)로 구분해서 여러 개를 선언할 수 있다.

 

Box<Paper, String> box = new Box<Paper, String>();
Box<Paper, String> box = new Box<>();   // JDK1.7부터 생략 가능
Box box = new Box();    // Object로 간주

제네릭 클래스는 이렇게 사용할 수 있다.

JDK1.7부터 생성자의 <>에 타입을 생략할 수 있다.

제네릭은 JDK1.5부터 도입되었는데 하위 호환을 위해 타입을 지정하지 않고도 객체를 생성할 수 있으며 이런 경우 타입은 Object로 간주된다.

주의해야 할 점은 참조변수에서 지정한 타입과 생성자에서 지정한 타입은 반드시 일치해야 한다.

두 타입이 서로 상속관계에 있다 해도 타입이 다르면 컴파일 에러가 발생한다.

예를 들어 Cardboard 클래스가 Paper의 자식 클래스라고 해서 Box<Paper> box = new Box<Cardboard>();는 불가능하다.

 

제네릭 메소드

제네릭은 클래스 레벨에서만 사용할 수 있는게 아니라 메소드 레벨에서도 사용할 수 있다.

제네릭 타입을 선언한 메소드를 제네릭 메소드라 한다.

클래스의 제네릭 타입이 전역 변수처럼 사용된다면 메소드의 제네릭 타입은 해당 메소드 안에서만 사용할 수 있는 지역성을 갖는다.

 

public class CoffeeMachine {

    public <T> Coffee makeCoffee(T capsule) {

        return new Coffee(capsule);
    }
}

제네릭 타입을 메소드에서 선언할 때는 접근제한자와 반환타입 사이에 선언한다.

 

CoffeeMachine coffeeMachine = new CoffeeMachine();
Colombian capsule = new Colombian();
coffeeMachine.<Colombian>makeCoffee(capsule);
coffeeMachine.makeCoffee(capsule);  // 타입 추정 가능하므로 생략 가능

제네릭 메소드를 호출할 때는 메소드 명 앞에 <>로 타입을 지정해줘야 하지만 컴파일러가 타입을 추정할 수 있는 경우엔 생략할 수 있다.

대부분의 경우 컴파일러가 타입을 추정할 수 있다.

 

제네릭 제한

제네릭을 사용하면 사용할 때 타입을 지정하게 되는데, '어떤 타입이 올 수 있는지'를 제한하지 않으면 말 그대로 오만가지 타입이 올 수 있다. 따라서 자바는 extends, super 키워드를 통해 이를 문법적으로 제한할 수 있는 기능을 제공한다.

 

class BoxMaterial { }
class Paper { }
class Plastic { }

public class Box<M> {

    private M material;

    public static void main(String[] args) {

        Box<Water> box = new Box<>();   // 타입 M에 제한이 없으므로 어떤 타입이든 지정 가능
    }
}

 

class BoxMaterial { }
class Paper extends BoxMaterial { }
class Plastic extends BoxMaterial { }

public class Box<M extends BoxMaterial> {

    private M material;

    public static void main(String[] args) {

        Box<Water> waterBox = new Box<>();   // 불가. BoxMaterial과 자식 타입만 가능
        Box<Paper> paperBox = new Box<>();
        Box<Plastic> plasticBox = new Box<>();
    }
}

M extends BoxMaterial과 같이 선언함으로써 M에는 모든 타입이 아닌 BoxMaterial과 그 자식 클래스만 올 수 있다.

extends 뒤에 오는 타입이 인터페이스여도 동일하게 extends 키워드를 사용한다.

 

class BoxMaterial implements Hard { }
class Paper extends BoxMaterial { }
class Plastic extends BoxMaterial { }
public interface Hard { }

public class Box<M extends BoxMaterial & Hard> {

    private M material;

    public static void main(String[] args) {

        Box<Paper> paperBox = new Box<>();
        Box<Plastic> plasticBox = new Box<>();
    }
}

extends 뒤에 여러 타입을 지정하려면 '&'를 사용한다.

M extends BoxMaterial & Hard는 Box의 material 필드가 BoxMaterial이면서 Hard를 구현한 타입만 지정할 수 있도록 제한한 것이다.

타입을 제한함으로써 잘못된 타입을 지정하면 타입 에러를 컴파일 타임에 검출해서 런타임 에러를 방지한다.

 

class BoxMaterial {

    public String printInfo() {
        return "";
    }
}

public class Paper extends BoxMaterial {

    @Override
    public String printInfo() {
        return "종이";
    }
}

public class Plastic extends BoxMaterial {

    @Override
    public String printInfo() {
        return "플라스틱";
    }
}

public class Box<M extends BoxMaterial> {

    private M material;

    public Box(M material) {
        this.material = material;
    }

    public void printInfo() {
        System.out.println(material.printInfo() + " 상자입니다.");
    }

    public static void main(String[] args) {

        Box<Paper> paperBox = new Box<>(new Paper());
        paperBox.printInfo();
        Box<Plastic> plasticBox = new Box<>(new Plastic());
        plasticBox.printInfo();
    }
}

또한 타입을 제한하지 않으면 Box 클래스 내에서 material 필드를 이용해 호출할 수 있는 메소드는 Object의 메소드밖에 없지만 타입을 제한하면 해당 타입의 메소드를 사용할 수 있다.

 

extends를 사용함으로써 해당 타입의 자손 타입만 올 수 있도록 하므로 상한(upper bound)를 제한한다면 super는 반대로 하한(lower bound)를 제한한다. 즉 T super BoxMaterial은 BoxMaterial의 조상 타입만 올 수 있도록 제한한다. 그 외의 차이점은 없다.

 

와일드 카드

class Fruit {

    String name;

    @Override
    public String toString() {
        return name;
    }
}

class Apple extends Fruit {

    public Apple() {
        this.name = "사과";
    }
}

class Banana extends Fruit {

    public Banana() {
        this.name = "바나나";
    }
}

class FruitCup<T extends Fruit> {

    List<T> fruits;

    public FruitCup() {
        fruits = new ArrayList<>();
    }

    public void addFruit(T fruit) {
        fruits.add(fruit);
    }

    public List<T> getFruits() {
        return fruits;
    }
}

public class Juicer {

    public static Juice makeJuice(FruitCup<Fruit> fruitCup) {
        return new Juice(fruitCup.getFruits());
    }

    public static void main(String[] args) {

        FruitCup<Fruit> fruitCup = new FruitCup<>();
        fruitCup.addFruit(new Apple());
        fruitCup.addFruit(new Banana());

        System.out.println(Juicer.makeJuice(fruitCup).toString());
    }
}

 

🖥 실행 결과

Juice{fruits=[사과, 바나나]}

Process finished with exit code 0

 

위 코드에서 Juicer 클래스의 makeJuice 메소드는 FruitCup<Fruit> 타입의 매개변수를 받는다.

FruitCup<Apple> appleCup = new FruitCup<>();
appleCup.addFruit(new Apple());
System.out.println(Juicer.makeJuice(appleCup).toString());  // 불가

Apple, Banana는 Fruit의 자손이지만 FruitCup<Apple>, FruitCup<Banana>는 makeJuice의 인자로 전달할 수 없다.

메소드에서 지정한 FruitCup<Fruit> 타입만이 인자가 될 수 있다.

 

makeJuice 메소드가 Fruit 뿐만 아니라 Fruit의 자식인 Apple, Banana와 같은 제네릭 타입의 FruitCup을 매개변수로 받으려면 메소드 레벨에서 제네릭 타입을 선언하던지(제네릭 메소드), '와일드 카드'를 사용할 수 있다.

제네릭에서 와일드 카드는 '?' 기호를 사용하며 의미 그대로 어떤 타입도 될 수 있다.

'?'만 사용하면 Object 타입과 다를게 없으므로 제네릭 제한에서 사용하는 extends, super 키워드를 함께 사용한다.

 

<? extends T>
T와 그 자손 타입만 가능(upper bound)

<? super T>
T와 그 조상 타입만 가능(lower bound)

<?>
제한 없이 모든 타입이 가능. <? extneds Object>와 동일한 표현

 

와일드 카드를 사용해 변경한 코드는 다음과 같다.

class Fruit {

    String name;

    @Override
    public String toString() {
        return name;
    }
}

class Apple extends Fruit {

    public Apple() {
        this.name = "사과";
    }
}

class Banana extends Fruit {

    public Banana() {
        this.name = "바나나";
    }
}

class FruitCup<T extends Fruit> {

    List<T> fruits;

    public FruitCup() {
        fruits = new ArrayList<>();
    }

    public void addFruit(T fruit) {
        fruits.add(fruit);
    }

    public List<T> getFruits() {
        return fruits;
    }
}

public class Juicer {

    public static Juice makeJuice(FruitCup<? extends Fruit> fruitCup) {
        return new Juice(fruitCup.getFruits());
    }

    public static void main(String[] args) {

        FruitCup<Fruit> fruitCup = new FruitCup<>();
        fruitCup.addFruit(new Apple());
        fruitCup.addFruit(new Banana());
        System.out.println(Juicer.makeJuice(fruitCup).toString());

        FruitCup<Apple> appleCup = new FruitCup<>();
        appleCup.addFruit(new Apple());
        appleCup.addFruit(new Apple());
        appleCup.addFruit(new Apple());
        System.out.println(Juicer.makeJuice(appleCup).toString());
    }
}

 

🖥 실행 결과

Juice{fruits=[사과, 바나나]}
Juice{fruits=[사과, 사과, 사과]}

Process finished with exit code 0

 

추가로 와일드 카드를 사용하지 않고 지네릭 메소드로 변경하면 다음과 같다.

public static Juice makeJuice(FruitCup<? extends Fruit> fruitCup) {
    return new Juice(fruitCup.getFruits());
}

⬇️

public static <T extends Fruit> Juice makeJuice(FruitCup<T> fruitCup) {
        return new Juice(fruitCup.getFruits());
}

어떤 방법을 사용하든 동일한 동작을 한다.

 

제네릭의 예 - Collections.sort()

자바의 Collections는 요소를 정렬하는 static 메소드 sort()를 제공하는데, 이 메소드가 제네릭 타입을 사용하는 제네릭 메소드의 예 중 하나이다.

 

Collection.sort(List, Comparator)의 선언부

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

List<T>와 Comparator<? super T> 타입의 두 개의 매개변수를 받는 sort() 메소드이다.

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

Comparator는 <? super T>라는 제네릭 타입이 선언돼 있는데, 이는 정렬 대상 요소들의 타입 혹은 그 조상 타입의 Comparator를 매개변수로 한다는 뜻이다.

 

Collection.sort(List)의 선언부

public static <T extends Comparable<? super T>> void sort(List<T> list)

List<T> 한 개를 매개변수로 받는 sort() 메소드이다.

타입 T를 요소로 하는 List를 넘기면 되는데, T 또는 그 조상 클래스가 Comparable을 구현해야 한다는 의미이다.