제네릭

강의 사이트

http://tcpschool.com/

제네릭의 개념

1. 제네릭이란

• 제네릭이란 데이터의 타입을 일반화한다는 의미
• 클래스나 메서드에서 사용할 내우 데이터 타입을 컴파일 시에 미리 지정하는 방법
• 클래스나 메서드 내부에서 사용되는 객체의 타입 안정성을 높일 수 있다.
• 반환값에 대한 타입 변환 및 타입 검사에 들어가는 노력을 줄일 수 있다.

2. 제네릭의 선인 및 생성

class MyArray<T> {
    T element;
    
    void setElement(T element) { 
        this.element = element; 
    }
    
    T getElement() { 
        return element; 
    }
}

• 예제에서 T를 타입변수라고 하며, 임의의 참조형 타입을 의미
• 꼭 ‘T’뿐만 아니라 어떠한 문자를 사용해도 상관없으며, 여러 개의 타입 변수는 쉼표(,)로 구분하여 명시할 수 있다.
• 타입 변수는 클래스에서뿐만 아니라 메소드의 매개변수나 반환값으로도 사용할 수 있다.
• 위와 같이 선언된 제네릭 클래스(generic class)를 생성할 때에는 타입 변수 자리에 사용할 실제 타입을 명시해야 한다.

MyArray<Integer> myArr = new MyArray<Integer>();

• 위의 예제는 MyArray 클래스에 사용된 타입 변수로 Integer 타입을 사용하는 예제이다.
• 위처럼 제네릭 클래스를 생성할 때 사용할 실제 타입을 명시하면, 내부적으로는 정의된 타입 변수가 명시된 실제 타입으로 변환되어 처리된다.
• 자바에서 타입 변수 자리에 사용할 실제 타입을 명시할 때 기본 타입을 바로 사용할 수는 없다.
• 이때는 위 예제의 Integer와 같이 래퍼(wrapper) 클래스를 사용해야만 한다.

3. 제네릭의 제거 시기

• 자바 코드에서 선언되고 사용된 제네릭 타입은 컴파일 시 컴파일러에 의해 자동으로 검사되어 타입 변환된다.
• 그리고서 코드 내의 모든 제네릭 타입은 제거되어, 컴파일된 class 파일에는 어떠한 제네릭 타입도 포함되지 않게 된다.
• 이런식으로 작동하는 이유는 제네릭을 사용하지 않는 코드와의 호환성을 유지하기 위해서이다.

4. 타입 변수의 제한

• 제네릭은 ‘T’와 같은 타입 변수(type variable)를 사용하여 타입을 제한한다.
• 이때 extends 키워드를 사용하면 타입 변수에 특정 타입만을 사용하도록 제한할 수 있다.

class AnimalList<T extends LandAnimal> { ... }

• 위와 같이 클래스의 타입 변수에 제한을 걸어 놓으면 클래스 내부에서 사용된 모든 타입 변수에 제한이 걸린다.
• 이때에는 클래스가 아닌 인터페이스를 구현할 경우에도 implements 키워드가 아닌 extends 키워드를 사용해야만 한다.

interface WarmBlood { ... }

...

class AnimalList<T extends WarmBlood> { ... } // implements 키워드를 사용해서는 안됨.

• 클래스와 인터페이스를 동시에 상속받고 구현해야 한다면 엠퍼센트(&) 기호를 사용하면 된다.

class AnimalList<T extends LandAnimal & WarmBlood> { ... }

import java.util.*;

 

class LandAnimal { 
    public void crying() { 
    	System.out.println("육지동물"); 
	} 
}

class Cat extends LandAnimal { 
    public void crying() { 
        System.out.println("냐옹냐옹"); 
    } 
}

class Dog extends LandAnimal { 
    public void crying() { 
        System.out.println("멍멍"); 
    } 
}

class Sparrow { 
    public void crying() { 
        System.out.println("짹짹"); 
    } 
}

class AnimalList<T extends LandAnimal> {

    ArrayList<T> al = new ArrayList<T>();

    void add(T animal) { 
        al.add(animal); 
    }

    T get(int index) { 
        return al.get(index); 
    }

    boolean remove(T animal) { 
        return al.remove(animal); 
    }

    int size() { 
        return al.size(); 
    }
}

 

public class Generic02 {

    public static void main(String[] args) {

        AnimalList<LandAnimal> landAnimal = new AnimalList<>();

        landAnimal.add(new LandAnimal());
        landAnimal.add(new Cat());
        landAnimal.add(new Dog());

        // landAnimal.add(new Sparrow()); // 오류가 발생함.

        for (int i = 0; i < landAnimal.size() ; i++) {
            landAnimal.get(i).crying();
        }
    }
}

//육지동물
//냐옹냐옹
//멍멍

• 타입 변수의 다형성을 이용하여 AnimalList 클래스의 선언부에 명시한 ‘extends LandAnimal’ 구문을 생략해도 제대로 동작한다.
• 하지만 코드의 명확성을 위해서는 위와 같이 타입의 제한을 명시하는 편이 더 좋다.

5. 제네릭 메서드

• 제네릭 메소드란 메소드의 선언부에 타입 변수를 사용한 메소드를 의미
• 이때 타입 변수의 선언은 메소드 선언부에서 반환 타입 바로 앞에 위치

public static <T> void sort( ... ) { ... }

• 다음 예제의 제네릭 클래스에서 정의된 타입 변수 T와 제네릭 메소드에서 사용된 타입 변수 T는 전혀 별개의 것임을 주의해야한다.

class AnimalList<T> {

    ...

    public static <T> void sort(List<T> list, Comparator<? super T> comp) {

        ...

    }

    ...

}

6. 와일드카드의 사용

• 와일드카드(wild card)란 이름에 제한을 두지 않음을 표현하는 데 사용되는 기호를 의미
• 자바의 제네릭에서는 물음표(?) 기호를 사용하여 이러한 와일드카드를 사용할 수 있다.

<?>           // 타입 변수에 모든 타입을 사용할 수 있음.
<? extends T> // T 타입과 T 타입을 상속받는 자손 클래스 타입만을 사용할 수 있음.
<? super T>   // T 타입과 T 타입이 상속받은 조상 클래스 타입만을 사용할 수 있음.

import java.util.*;

class LandAnimal { 
    public void crying() { 
        System.out.println("육지동물"); 
    } 
}

class Cat extends LandAnimal { 
    public void crying() { 
        ystem.out.println("냐옹냐옹"); 
                         
    } 
}

class Dog extends LandAnimal { 
    public void crying() { 
        System.out.println("멍멍"); 
    } 
}

class Sparrow { 
    public void crying() { 
        System.out.println("짹짹"); 
    } 
}

class AnimalList<T> {

    ArrayList<T> al = new ArrayList<T>();

    public static void cryingAnimalList(AnimalList<? extends LandAnimal> al) {
        LandAnimal la = al.get(0);
        la.crying();
    }

    void add(T animal) { 
        al.add(animal); 
    }
    
    T get(int index) { 
        return al.get(index); 
    }
    
    boolean remove(T animal) { 
        return al.remove(animal); 
    }
    
    int size() { 
        return al.size(); 
    }
}

public class Generic03 {

    public static void main(String[] args) {
        AnimalList<Cat> catList = new AnimalList<Cat>();
        catList.add(new Cat());

        AnimalList<Dog> dogList = new AnimalList<Dog>();
        dogList.add(new Dog());

        AnimalList.cryingAnimalList(catList);
        AnimalList.cryingAnimalList(dogList);
    }
}

//냐옹냐옹
//멍멍