java

Java 자바 제네릭(Generic) 개념과 문법 알아보기

by

제네릭(Generic)이란?

자바 제네릭은 코드의 재사용성을 높이고 타입 안전성을 보장하는 중요한 개념입니다. 이 블로그 글에서는 자바 제네릭의 개념, 장점, 제약 조건, 그리고 다양한 사용 사례를 깊이 있게 탐구해 보겠습니다. 예제와 설명을 통해 제네릭이 왜 자바 프로그래밍에 필수적인지를 알아봅시다.

제네릭은 자바 5에서 도입된 기능으로, 클래스나 메서드에서 사용할 수 있는 타입을 일반화(generic)하여 코드의 재사용성을 높이는 것을 목표로 합니다. 제네릭을 사용하면 특정 클래스나 메서드를 다양한 타입에 대해 안전하게 사용할 수 있습니다. 예를 들어, List나 Map 같은 컬렉션 프레임워크의 클래스들이 대표적인 제네릭 클래스입니다.

기본적인 예제를 통해 제네릭의 개념을 이해해 보겠습니다.

Java
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");
Java

위의 코드에서 List<String>은 문자열 타입만 저장할 수 있는 리스트를 의미합니다. 제네릭을 사용하지 않으면 컴파일 타임에 타입을 검사할 수 없어 런타임 오류가 발생할 위험이 있지만, 제네릭을 사용함으로써 이러한 문제를 방지할 수 있습니다.

제네릭의 장점

타입 안정성 (Type Safety)

제네릭을 사용하면 코드에서 다루는 데이터 타입을 명시적으로 지정할 수 있습니다. 이렇게 하면 컴파일 타임에 타입 오류를 방지할 수 있어 코드의 안전성이 크게 향상됩니다.

Java
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add("Hello"); // 컴파일 오류 발생
Java

위의 코드에서 List<Integer>는 정수만 저장할 수 있으므로 문자열을 추가하려고 하면 컴파일 오류가 발생합니다. 이는 타입 안정성을 보장하여 런타임 오류를 줄이는 효과가 있습니다.

코드 재사용성 (Reusability)

제네릭을 사용하면 데이터 타입에 구애받지 않는 범용적인 코드를 작성할 수 있습니다. 예를 들어, 아래와 같은 제네릭 클래스를 정의할 수 있습니다.

Java
public class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }
}
Java

위의 Box<T> 클래스는 어떤 타입의 객체든 저장할 수 있습니다. T는 타입 파라미터로, 이 클래스를 사용할 때 구체적인 타입으로 대체됩니다.

Java
Box<String> stringBox = new Box<>();
stringBox.setItem("Hello Generics");
System.out.println(stringBox.getItem());

Box<Integer> intBox = new Box<>();
intBox.setItem(123);
System.out.println(intBox.getItem());
Java

이렇게 하면 동일한 클래스를 사용해 다양한 타입의 데이터를 다룰 수 있어 코드의 재사용성이 크게 향상됩니다.

코드의 가독성 (Readability)

제네릭을 사용하면 코드의 의도를 명확하게 전달할 수 있어 가독성이 향상됩니다. 예를 들어, List<String>은 해당 리스트가 문자열을 저장한다는 것을 명확하게 보여주므로, 코드 리뷰나 유지보수 시 이해하기 쉽습니다. 이는 협업하는 팀원들이나 후속 작업을 진행하는 개발자들에게 큰 도움이 됩니다.

제네릭 메서드와 와일드카드

제네릭 메서드

제네릭은 클래스뿐만 아니라 메서드에도 적용할 수 있습니다. 이를 통해 메서드에서 사용할 타입을 호출 시점에 지정할 수 있습니다.

Java
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"};

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

위의 코드에서 printArray 메서드는 어떤 타입의 배열이든 출력할 수 있도록 정의되었습니다. 메서드 선언부의 <T>는 타입 파라미터를 정의하며, 메서드에서 사용될 타입을 일반화합니다.

와일드카드 (?)

와일드카드는 제네릭 타입에 대한 유연성을 제공하기 위해 사용됩니다. 예를 들어, List<?>는 어떤 타입이든 담을 수 있는 리스트를 의미합니다.

  • List<?>: 임의의 타입의 리스트를 나타내며, 타입을 알 수 없는 경우에 사용합니다.
  • List<? extends Number>: Number 또는 그 하위 클래스만 담을 수 있습니다.
  • List<? super Integer>: Integer 또는 그 상위 클래스만 담을 수 있습니다.

와일드카드를 사용하여 더 유연하게 제네릭 타입을 처리할 수 있습니다. 예를 들어, 다음과 같은 메서드는 숫자 리스트를 인자로 받아서 처리할 수 있습니다.

Java
public static void printNumbers(List<? extends Number> numbers) {
    for (Number number : numbers) {
        System.out.println(number);
    }
}
Java

이 메서드는 List<Integer>, List<Double> 등 다양한 숫자 리스트를 인자로 받을 수 있습니다.

와일드카드의 한정 (extends와 super)

와일드카드는 상한 제한(extends)과 하한 제한(super)을 사용할 수 있습니다. 이를 통해 제네릭 타입의 범위를 제어하고, 보다 유연하면서도 안전한 코드를 작성할 수 있습니다.

  • 상한 제한 (extends): 주로 읽기 전용 데이터를 처리할 때 사용됩니다. 예를 들어, List<? extends Number>는 Number의 서브타입만을 처리하므로, 이 리스트에 데이터를 추가하는 것은 불가능하지만 읽기는 가능합니다.
  • 하한 제한 (super): 주로 데이터를 추가하는 용도로 사용됩니다. 예를 들어, List<? super Integer>는 Integer의 슈퍼타입에 데이터를 추가하는 것이 가능합니다.

이와 같은 한정 키워드를 적절히 사용하면 메서드가 특정 조건에서만 동작하도록 제어할 수 있어 코드의 안정성이 높아집니다.

제네릭의 제약 사항

타입 소거 (Type Erasure)

자바에서 제네릭은 컴파일 시 타입 검사 후 타입 정보를 제거하는 타입 소거 방식을 사용합니다. 따라서 런타임에는 제네릭 타입 정보가 사라지며, 이는 일부 상황에서 타입 캐스팅 문제를 발생시킬 수 있습니다.

Java
List<String> stringList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();

if (stringList.getClass() == intList.getClass()) {
    System.out.println("동일한 클래스입니다."); // 출력됨
}
Java

위 예제에서 List<String>과 List<Integer>는 런타임 시 동일한 List 클래스로 인식됩니다. 이는 타입 소거로 인해 발생하는 현상입니다.

기본 타입 사용 불가

제네릭에는 기본 타입(primitive type)을 사용할 수 없습니다. 예를 들어, List<int>와 같은 선언은 불가능합니다. 대신, 래퍼 클래스(Integer, Double 등)를 사용해야 합니다.

Java
List<Integer> intList = new ArrayList<>();
intList.add(10); // 가능
Java

이는 제네릭이 객체 타입을 기대하기 때문이며, 기본 타입은 래퍼 클래스로 감싸져야 합니다.

정적 컨텍스트에서의 타입 파라미터 사용 제한

제네릭 타입 파라미터는 정적(static) 변수나 메서드에서 사용할 수 없습니다. 이는 정적 멤버가 클래스 수준에서 공유되기 때문에, 특정 인스턴스에 종속된 제네릭 타입을 사용할 수 없기 때문입니다.

Java
public class GenericClass<T> {
    private static T instance; // 컴파일 오류 발생

    public static T getInstance() { // 컴파일 오류 발생
        return instance;
    }
}
Java

이러한 제약을 피하기 위해서는 정적 멤버에서 제네릭을 사용하지 않거나, 정적 메서드에 제네릭 타입 파라미터를 직접 정의해야 합니다.

제네릭과 컬렉션 프레임워크

자바 컬렉션 프레임워크는 제네릭의 대표적인 활용 예입니다. 예를 들어 List<E>, Map<K, V> 등에서 E, K, V와 같은 타입 파라미터를 사용하여 컬렉션이 다루는 요소의 타입을 지정할 수 있습니다.

List와 Map의 제네릭 사용

List와 Map은 각각 요소의 타입을 제네릭으로 지정하여 타입 안전성을 보장합니다.

Java
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 85);
Java

위의 코드에서 List<String>은 문자열만 저장하며, Map<String, Integer>는 키가 문자열이고 값이 정수인 매핑을 저장합니다.

Set의 제네릭 사용

Set 인터페이스 역시 제네릭을 활용하여 타입 안정성을 제공합니다. HashSet, TreeSet 등의 클래스는 제네릭을 사용하여 특정 타입의 데이터를 중복 없이 저장합니다.

Java
Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Alice"); // 중복된 값은 저장되지 않음

for (String name : uniqueNames) {
    System.out.println(name);
}
Java

위 예제에서 Set<String>은 문자열 타입의 데이터를 중복 없이 저장하도록 보장합니다.

제네릭 타입의 고급 사용 예

제네릭은 단순히 컬렉션에만 사용되는 것이 아니라, 보다 복잡한 데이터 구조나 유틸리티 클래스를 작성할 때도 활용될 수 있습니다.

복수 타입 파라미터 사용

하나의 클래스나 메서드에서 여러 개의 타입 파라미터를 사용할 수 있습니다. 이를 통해 복잡한 데이터 구조를 더욱 유연하게 정의할 수 있습니다.

Java
public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}

public static void main(String[] args) {
    Pair<String, Integer> pair = new Pair<>("Age", 30);
    System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
}
Java

위 예제에서 Pair<K, V> 클래스는 두 개의 타입 파라미터를 사용하여 키-값 쌍을 저장합니다. 이를 통해 다양한 타입의 데이터를 쉽게 다룰 수 있습니다.

제네릭 인터페이스

제네릭은 인터페이스에도 적용될 수 있습니다. 예를 들어, Comparable<T> 인터페이스는 객체의 자연 순서를 정의하기 위해 제네릭을 사용합니다.

Java
public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}

public static void main(String[] args) {
    List<Person> people = new ArrayList<>();
    people.add(new Person("Alice", 25));
    people.add(new Person("Bob", 20));
    people.add(new Person("Charlie", 30));

    Collections.sort(people);
    for (Person person : people) {
        System.out.println(person.name + ", Age: " + person.age);
    }
}
Java

위 예제에서 Comparable<Person> 인터페이스를 구현하여 Person 객체의 나이를 기준으로 정렬할 수 있습니다. 제네릭을 사용함으로써 타입 안전성을 보장하면서도 유연한 정렬 기능을 제공할 수 있습니다.

결론

제네릭은 자바에서 코드의 재사용성을 높이고 타입 안전성을 보장하는 강력한 도구입니다. 제네릭을 통해 다양한 타입을 다룰 수 있는 유연한 클래스와 메서드를 작성할 수 있으며, 컴파일 타임에 타입 검사를 통해 안전한 코드를 작성할 수 있습니다. 제네릭의 개념과 활용 방식을 잘 이해하면, 더 안정적이고 유지보수하기 쉬운 코드를 작성할 수 있습니다.

제네릭을 활용하는 다양한 예제들을 직접 작성해 보면서 이해를 깊게 다져 보세요. 제네릭은 처음에는 어려울 수 있지만, 다양한 상황에서 적용해 보면 그 진가를 느낄 수 있을 것입니다. 또한, 제네릭의 고급 기능과 제약 사항을 이해하면 더욱 안전하고 효율적인 코드를 작성할 수 있습니다.

자바 제네릭은 코드 품질을 높이고, 유지보수성을 개선하며, 개발자가 타입 관련 문제로부터 자유로워질 수 있도록 도와줍니다. 이러한 이유로 제네릭을 깊이 이해하고 사용하는 것이 자바 개발자에게는 매우 중요한 기술이라고 할 수 있습니다.

Leave a Comment