지네릭스(Generics) 핵심 정리하기 - 지네릭 클래스

 

자바 입문 레벨에서 개발자 문서를 보거나 github의 다른 코드들을 보다 보면 Box<T>와 같은 낯선 형태의 문장을 만나게 된다. 이러한 것들이 지네릭스인데 남궁성 저자의 자바의 정석을 참고하여 입문수준에서 간단하게 살펴보고자 한다.
어렵다면 강조된 내용만 봐도 대충 감을 잡을 수 있다.

 

 

| 지네릭스란?

지네릭스는 다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에 컴파일 시 의 타입체크(compile-time type check)를 해주는 기능이다. 객체의 타입을 컴파일 시에 체크하기 때문에 객체의 타입 안전성을 높이고 형변환의 번거로움이 줄어든다.

-자바의 정석

 

1. 컴파일 시 의 타입체크(compile-time type check)

지네릭스를 사용하면, 컬렉션에 저장되는 객체의 타입을 컴파일 시점에 체크한다. 이는 잘못된 타입의 객체가 추가되는 것을 방지하여 실행시간(runtime)의 'ClassCastException'을 예방한다.

 예를 들어, List<String>은 문자열만을 요소로 가질 수 있으며, 컴파일러는 이 리스트에 문자열이 아닌 다른 타입의 객체가 추가되려고 할 때 컴파일 오류를 발생시킨다.

 

2. 객체 타입의 안전성(Type Safety)

지네릭스를 사용함으로써, 컬렉션에서의 객체를 읽어올 때 명시적인 형변환이 필요 없게 된다. 컴파일러가 이미 요소의 타입을 알고 있기 때문에, 올바른 타입의 객체만이 처리될 것임을 보장하기 때문이다. 이는 프로극램의 안전성을 올려준다.

 

3. 형변환의 번거로움 감소

지네릭스를 사용하지 않는 경우, 컬렉션에서 객체를 꺼낼 때마다 해당 객체를 적절한 타입으로 형변환해야한다. 이는 코드를 번거롭게 만들 뿐만 아니라, 잘못된 타입으로의 형변환 가능성을 내포하고 있어 오류의 가능성을 높인다. 지네릭스를 사용하면 이러한 형변환이 불필요해지므로, 코드가 더 간결하고 안전해진다.

 

// 지네릭스 없이 컬렉션을 사용할 때
List list = new ArrayList();
list.add("hello");
String str = (String) list.get(0); // 명시적 형변환 필요

//지네릭스를 사용할 때
List<String> list = new ArrayList<>();
list.add("hello");
String str = list.get(0); // 형변환 불필요

 

 

 

▶ 간단히 말하자면 다룰 객체의 타입을 미리 명시해줌으로써 번거로운 형변환을 줄여준다는 의미이다.

 

 

 

| 지네릭 클래스 선언하고 사용하기

지네릭 타입은 클래스와 메서드에 선언할 수 있다. 이번 포스트에서는 클래스 위주로 알아보려고 한다.

지네릭스를 사용하여 Box 클래스를 변경하는 예이다. Box 클래스가 다양한 타입의 객체를 저장할 수 있도록 클래스 옆에 <T>를 붙이면된다. <T>는 파라미터 타입을 나타내며 Box 클래스를 사용할 때 구체적인 타입으로 대체된다. (ex. Box<String>, Box<Integer>). 이렇게 하면 Box 클래스는 다양한 타입의 객체를 저장할 수 있게 된다. 

• <T> : 타입변수(type variable). 임의의 참조형 타입을 의미한다. T말고도 다른 것을 사용해도 된다(ex. ArrayList<E>, Map<K,V>)

//일반 클래스
public class Box {
    Object item;
    void setItem(Object item){ this.item = item;}
     Object getItem(){return item;}
}

//지네릭스 클래스로 변환
public class Box<T> {    
    private T item;    
    public void setItem(T item){this.item = item; }
        public T getItem(){ return item;}
}

 

지네릭 클래스를 사용할 때는 다음과 같이 참조변수와 생성자 타입 T대신 사용될 실제 타입을 지정해줘야 한다.

실제 IDE에서 지정된 타입 이외의 타입을 사용할 경우 에러가 발생한다.

public class Box<T> {

    private T item;

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

    public T getItem(){
        return item;
    }

    public static void main(String[] args) {
        Box<String> b = new Box<String>();
        b.setItem(new Object()); // 에러. String 타입 외 지정불가
        b.setItem("Planet"); // O. String 지정가능
        String item = b.getItem(); // 형변환 불필요
    }
}

 

 

 

 

 

 

 

| 지네릭 주요 용어 정리

• Box<T> : 지네릭 클래스. 'T의 Box' 또는 'T Box'라고 읽는다.
• T : 타입변수 혹은 타입 매개변수(T는 타입 문자).
• Box : 원시타입

 

• 대입된 타입 : 지네릭 클래스에 지정된 타입.
• 지네릭 타입 호출 : 매개변수에 타입을 지정하는 것.

 

 

 

| 지네릭스 사용의 제한

1. static 멤버에는 타입 변수 T를 선언할 수 없다.

static 멤버는 모든 객체에 대해 동일하게 동작해야하므로 static 멤버에 타입 변수 T를 사용할 수 없다. T는 인스턴스변수로 간주되기 때문이다. static 멤버는 대입된 타입의 종류에 관계없이 동일하여야 한다.

 

2. 지네릭 타입의 배열을 생성할 수 없다.

지네릭 배열 타입의 참조변수를 선언하는 것은 가능하지만 'new T[10]'과 같이 배열을 생성하는 것은 안된다. 

지네릭 배열을 생성할 수 없는 것은 new 연산자이다. 이 연산자는 컴파일 시점에 타입 T가 무엇인지 정확하게 알아야한다. 그러나 아래 코드에서 T의 실제 타입을 컴파일 시점에 알 수 없다.

public class GenericArray<T> {
    private T[] array; // 가능
    
    public GenericArray(int size) {
         array = new T[size]; // 컴파일 에러: Generic array creation
       
    }
}

 

 

 

| 지네릭 클래스의 객체 생성과 사용

아래 코드는 지네릭 클래스의 객체 생성과 사용을 보여주는 예시이다. 아래 코드에서 주의 깊게 봐야 할 내용은 다음과 같다

• JDK 1.7부터는 추정이 가능한 경우 타입을 생략할 수 있게 되었다. 참조변수의 타입만으로부터 Box의 대입된 타입을 알 수 있으므로 new 연산자 다음의 지네릭 타입 호출에서는 T를 생략가능하다.
• 다형성의 원칙에 따라 Java에서 하위 클래스의 인스턴스는 상위 클래스 타입을 참조변수로 참조할 수 있다. 따라서 Fruit을 상속한 Apple은 Fruit을 참조변수로 사용할 수 있는 것이다. ( fruitBox.add(new Apple()); )
• 그러나 Fruit은 Apple의 상위 타입이므로 하위 타입을 참조변수로 사용하 ㄹ수 없다. ( appleBox.add(new Fruit());  )

package generics;

import java.util.ArrayList;

// 기본 클래스 정의
class Fruit { public String toString(){return "Fruit";}}
class Apple extends Fruit { public String toString(){return "Apple";}}
class Grape extends Fruit { public String toString(){return "Grape";}}
class Toy { public String toString(){return "Toy";}}

// 제네릭 Box 클래스 사용 예시
public class FruitBox1 {
    public static void main(String[] args) {
        // Fruit와 그 하위 타입을 저장할 수 있는 Box 생성
        Box<Fruit> fruitBox = new Box<>();
        // Apple 타입만 저장할 수 있는 Box 생성
        Box<Apple> appleBox = new Box<>();
        // Toy 타입을 저장할 수 있는 Box 생성
        Box<Toy> toyBox = new Box<>();
        // Box<Grape> grapeBox = new Box<Apple>(); // 컴파일 에러, 제네릭 타입 불일치

        // Fruit 객체 및 Fruit의 하위 타입 객체를 FruitBox에 추가
        fruitBox.add(new Fruit()); // Fruit 인스턴스 추가
        fruitBox.add(new Apple()); // Apple 인스턴스 추가, Apple은 Fruit의 하위 타입

        // AppleBox에 Apple 인스턴스 추가
        appleBox.add(new Apple());
        // appleBox.add(new Fruit()); // 컴파일 에러, Fruit은 Apple의 상위 타입이므로 추가 불가
        // appleBox.add(new Toy()); // 컴파일 에러, Toy는 Fruit 계층구조와 무관

        // Box 내용 출력
        System.out.println(fruitBox); // Fruit와 Apple 인스턴스가 포함된 리스트 출력
        System.out.println(appleBox); // Apple 인스턴스만 포함된 리스트 출력
    }
}

// 제네릭 Box 클래스 정의
class Box<T> {
    ArrayList<T> list = new ArrayList<T>(); // T 타입의 객체를 저장할 리스트
    
    void add(T item){ list.add(item);} // T 타입의 객체를 리스트에 추가
    T get(int i){ return list.get(i);} // 리스트에서 T 타입의 객체를 반환
    ArrayList<T> getList() {return list;} // 리스트 반환
    int size() { return list.size();} // 리스트의 크기 반환
    public String toString(){ return list.toString();} // 리스트의 문자열 표현 반환
}

 

 

| 제한된 지네릭 클래스

타입 매개변수 T에 지정할 수 있는 타입의 종류를 제한할 수 있다. 예를들어 fruitBox<T>라는 과일 박스 클래스에 오직 과일만 담도록 할 수 있다(제한 없이는 장난감도 담을 수 있다. fruitBox<Toy>).

 

• 다음 코드에서 볼 수 있듯 지네릭 타입에 'extends'를 사용하면 특정 타입의 자손들만 대입할 수 있게 제한할 수 있다.
• 클래스가 아니라 인터페이스를 구현해야 할 때도 implements가 아닌 extends를 사용한다.
• 클래스를 상속하면서 동시에 인터페이스도 구현해야한다면 '&' 기호를 쓴다.
  class FruitBox<T extends Fruit & Eatable> extends Box<T> {}

import java.util.ArrayList;

class Fruit implements Eatable {
	public String toString() { return "Fruit";}
}
class Apple extends Fruit { public String toString() { return "Apple";}}
class Grape extends Fruit { public String toString() { return "Grape";}}
class Toy		          { public String toString() { return "Toy"  ;}}

interface Eatable {}

class FruitBoxEx2 {
	public static void main(String[] args) {
		FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
		FruitBox<Apple> appleBox = new FruitBox<Apple>();
		FruitBox<Grape> grapeBox = new FruitBox<Grape>();
//		FruitBox<Grape> grapeBox = new FruitBox<Apple>(); // 에러. 타입 불일치
//		FruitBox<Toy>   toyBox    = new FruitBox<Toy>();   // 에러.

		fruitBox.add(new Fruit());
		fruitBox.add(new Apple());
		fruitBox.add(new Grape());
		appleBox.add(new Apple());
//		appleBox.add(new Grape()); // 에러. Grape는 Apple의 자손이 아님
		grapeBox.add(new Grape());

		System.out.println("fruitBox-"+fruitBox);
		System.out.println("appleBox-"+appleBox);
		System.out.println("grapeBox-"+grapeBox);
	}  // main
}

class FruitBox<T extends Fruit & Eatable> extends Box<T> {}

class Box<T> {
	ArrayList<T> list = new ArrayList<T>();
	void add(T item)  { list.add(item);      }
	T get(int i)      { return list.get(i); }
	int size()        { return list.size();  }
	public String toString() { return list.toString();}
}