Java 제네릭: 제네릭 클래스, 제네릭 인터페이스 및 제네릭 메서드

"Java 프로그래밍 사고(4판)"의 설명에 따르면 제네릭 출현 동기는 다음과 같습니다.

제네릭 출현에 기여한 이유는 여러 가지가 있으며, 그 중 가장 눈길을 끄는 이유는 바로 컨테이너 클래스를 생성하기 위해서입니다.

일반 클래스

컨테이너 클래스는 가장 재사용 가능한 클래스 라이브러리 중 하나로 간주되어야 합니다. 먼저 제네릭 없이 컨테이너 클래스를 정의하는 방법을 살펴보겠습니다.

public class Container {    
private String key;    
private String value;    
public Container(String k, String v) {
        key = k;        
        value = v;
    }    
    public String getKey() {        
        return key;
    }    
    public void setKey(String key) {        
        this.key = key;
    }    
    public String getValue() {        
        return value;
    }    
    public void setValue(String value) {        
       this.value = value;
    }
}

컨테이너 클래스는 키-값 쌍 쌍을 저장하지만 유형은 고정되어 있습니다. 문자열-정수 유형의 키-값 쌍을 생성하려면 현재 이 컨테이너에서는 불가능하며 사용자 정의해야 합니다. 그러면 분명히 재사용성이 매우 낮습니다.

물론 String 대신 Object를 사용할 수도 있는데, Java SE5 이전에는 Object가 모든 타입의 기본 클래스이기 때문에 직접 변환이 가능했습니다. 하지만 여전히 유형이 지정되어 있기 때문에 이러한 유연성으로는 충분하지 않지만 이번에는 지정된 유형이 더 높은 수준에 있으므로 유형을 지정하지 않는 것이 가능합니까? 런타임에 특정 유형이 무엇인지 알 수 있습니까?

그래서 제네릭이 등장했습니다.

public class Container<K, V> {    
private K key;    
private V value;    
public Container(K k, V v) {
        key = k;        
        value = v;
    }    
    public K getKey() {        
       return key;
    }    
    public void setKey(K key) {        
        this.key = key;
    }    
    public V getValue() {        
         return value;
    }    
    public void setValue(V value) {        
        this.value = value;
    }
}

컴파일 타임에는 K와 V의 구체적인 유형을 아는 것이 불가능합니다. 런타임에만 메모리가 실제로 유형에 따라 구성되고 할당됩니다. 컨테이너 클래스별로 현재 지원되는 다양한 유형을 확인할 수 있습니다.

public class Main {    
     public static void main(String[] args) {
        Container<String, String> c1 = new Container<String, String>("name", "findingsea");
        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}

출력:

name : findingsea
age : 24
1.1 : 2.2

일반 인터페이스

일반 인터페이스에서, 생성기 잘 이해하려면 다음 생성기 인터페이스 정의를 살펴보십시오.

public interface Generator<T> {    
   public T next();
}

그런 다음 이 인터페이스를 구현하는 생성기 클래스를 정의합니다.

public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override    
    public String next() {
        Random rand = new Random();        
        return fruits[rand.nextInt(3)];
    }
}

호출:

public class Main {    
      public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}

출력:

Banana
Banana
Pear
Banana

일반 메서드

기본 원칙은 가능할 때마다 일반 메서드를 사용해야 한다는 것입니다. 즉, 제네릭 메소드를 사용하는 것이 전체 클래스의 일반화를 대체할 수 있다면 제네릭 메소드 사용은 제한되어야 합니다. 간단한 일반 메소드의 정의를 살펴보겠습니다.

public class Main {    
     public static <T> void out(T t) {
        System.out.println(t);
    }    
    public static void main(String[] args) {        
       out("findingsea");        
       out(123);        
       out(11.11);        
       out(true);
    }
}

메소드의 매개변수가 완전히 일반화되어 있음을 알 수 있습니다. 이 프로세스에는 컴파일러의 유형 파생 및 자동 패키징이 포함됩니다. 즉, 원래 필요했습니다. 이제 컴파일러는 우리를 위해 유형을 판단하고 처리합니다. 이렇게 하면 메소드를 정의할 때 나중에 어떤 유형의 매개변수를 처리해야 하는지 고려할 필요가 없으므로 프로그래밍의 유연성이 크게 향상됩니다.

제네릭 메서드와 변수 매개변수의 또 다른 예를 살펴보세요.

public class Main {    
    public static <T> void out(T... args) {        
            for (T t : args) {
            System.out.println(t);
        }
    }    
    public static void main(String[] args) {        
         out("findingsea", 123, 11.11, true);
    }
}

출력은 이전 코드와 동일합니다. 제네릭이 변수 매개변수와 완벽하게 결합될 수 있음을 알 수 있습니다.