[Java] 13. 제네릭 (2) - 3~5

13.3 제네릭 메소드

* 제네릭 메소드 : 타입 파라미터를 가지고 있는 메소드
    - 타입 파라미터가 메소드 선언부에 정의됨 (<- 제네릭 타입과 차이!)
    - 객체 타입에 상관없는 유연한 메소드 정의 가능

    - 리턴 타입 앞에 <> 기호를 추가하고 타입 파라미터를 정의함

    - 리턴 타입, 매개변수 타입에서 사용함

구분	제네릭 타입	제네릭 메소드
정의 위치	클래스, 인터페이스 선언부에 <T> 등으로 명시	메소드 선언부에 <T> 등으로 명시
적용 범위	해당 클래스/인터페이스 내에서 멤버 변수, 메소드 등 전체	해당 메소드 내부에서만 사용, 메소드 시그니처에만 영향
예시	class Box<T> { T value; }	<T> void print(T item) {...}
재사용성	하나의 타입에 여러 데이터 타입을 적용할 수 있음	하나의 메소드에서 여러 데이터 타입 처리 가능
인스턴스 생성	Box<Integer> intBox = new Box<>();	print(123); print("hello"); 등 다양한 타입 사용 가능
제네릭 타입 사용	참조 변수에서 타입 지정, 타입 일관성 확보	매 호출마다 타입 추론, 유연하게 사용 가능

 

• 제네릭 타입
  • 클래스나 인터페이스 전체에 걸쳐 타입 파라미터를 사용함
  • 예시: Box<T>는 Box라는 클래스에서 T라는 타입을 내부에 걸쳐 계속 사용함
  • 주로 자료구조 클래스(ArrayList, HashMap 등)에서 많이 사용되며, 생성할 때 타입을 한번 정하면 해당 인스턴스에서 내내 그 타입만 사용함
• 제네릭 메소드
  • 메소드 선언에만 타입 파라미터를 사용함(메소드 시그니처 왼쪽에 <T> 등 명시).
  • 클래스의 제네릭 타입과 별개로, 메소드마다 독립적으로 다양한 타입을 처리 가능
  • 예시처럼 print(T item)은 호출할 때마다 int, String 등 어떤 타입이든 쓸 수 있음

// 제네릭 타입 예시
class Box<T> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}

// 제네릭 메소드 예시
class Util {
    public static <T> void print(T item) { System.out.println(item); }
}

 

• Box<Integer>, Box<String>처럼 각각 타입별 인스턴스 생성.
• Util.print(100); Util.print("hi");처럼 다양한 타입의 값을 메소드로 출력 가능.
• 핵심
  • "타입 전체에 적용" → 제네릭 타입
  • "메소드 안에서만 적용" → 제네릭 메소드

 

public <A, B, ...> 리턴타입 메소드명(매개변수, ...) { ... }
      //타입 파라미터 정의

 

    (예) boxing() 메소드에서 타입 파라미터로 <T>를 정의하고, 매개변수 타입과 리턴 타입에서 T를 사용
            (리턴 타입 : T를 내용물로 갖는 Box 객체)

public <T> Box<T> boxing(T t) { ... }

• public : 접근 제어자
• <T> : 제네릭 타입 파라미터(타입 변수)선언   <-- 이 부분이 있으면 이 메소드는 제네릭 메소드임
  • 이 메소드가 T라는 임의의 타입을 사용할 수 있다는 뜻
  • 메소드의 반환 타입 바로 앞에 위치해야 함
• Box<T> : 리턴 타입
  • 이 메소드는 Box<T> 객체를 반환한다는 뜻
  • T가 어떤 타입이 되는지는 메소드 호출 시에 결정됨
• boxing : 메소드 이름
• (T t) : 파라미터(매개변수) 선언
  • 이 메소드는 하나의 파라미터 t를 받는데, 이 t의 타입 역시 T임
  • boxing(100) 이면 T는 Integer로 자동 추론됨

public <T> Box<T> boxing(T t) {
    Box<T> box = new Box<>();
    box.set(t);
    return box;
}

 

    - 파라미터로 받은 t를 담고 있는 Box<T> 객체를 만들어 반환함

Box<Integer> intBox = boxing(123);
Box<String> strBox = boxing("hello");

 

     - 호출할 때 넘기는 값에 따라 T가 바뀌고, 그에 맞춰 리턴값의 타입이 바뀜

 

• <T> : "이 함수 안에선 임의로 T라는 타입을 쓸 수 있다"는 선언
• Box<T> boxing(T t) : "T 타입 값을 받아서, 그 타입을 담는 Box 객체를 반환한다"

• t의 타입 추론: 메소드 호출 시, 전달된 인수로부터 → 컴파일 타임에 결정됨
• 코드 실행(런타임) 중에는 타입에 관련해 추가 추론이 일어나지 않고, 이미 컴파일러가 확정한 타입으로 처리함

    -> 호출할 때 어떤 값을 넘기느냐에 따라 컴파일과정에서 자동으로 타입이 정해져서 타입 안전성을 확보하게 됨

 

    (예 2) 제네릭 메소드 선언, 호출

public class Box<T> {
    //필드
    private T t;
    
    //getter 메소드
    public T get() {
        return t;
    }
    
    //setter 메소드
    public void set(T t) {
        this.t = t;
    }
}

public class GenericExample {
    //제네릭 메소드
    public static <T> Box<T> boxing (T t){ //타입 파라미터 T 정의
        Box<T> box = new Box<T>();
        box.set(t);
        return box;
    }
    
    public static void main(String[] args) {
        //제네릭 메소드 호출
        Box<Integer> box1 = boxing(100); //T를 Integer로 대체
        int intValue = box1.get();
        System.out.println(intValue);
        
        //제네릭 메소드 호출
        Box<String> box2 = boxing("홍길동"); //T를 String으로 대체
        String strValue = box2.get();
        System.out.println(strValue);
    }
}

 

    - 다른 예시들
    (예 3) swap - 배열의 두 값을 타입에 상관없이 비교 가능

public static <T> void swap(T[] arr, int i, int j) {
    T temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

     (예 4) 비교 - 여러 타입(T, V)의 값을 갖는 People 객체끼리 값이 같은지 비교할 때, 타입에 상관없이 사용

public static <T, V> boolean compare(People<T, V> p1, People<T, V> p2) {
    boolean nameCompare = p1.getName().equals(p2.getName());
    boolean ageCompare = p1.getAge().equals(p2.getAge());
    return nameCompare && ageCompare;
}

 

13.4 제한된 타입 파라미터

* 제한된 타입 파라미터 (bounded type parameter)
    - 타입 파라미터를 대체하는 구체적인 타입을 제한할 필요가 있는 경우가 존재
        (예: 숫자를 연산하는 제네릭 메소드는 대체 타입으로 Number 또는 자식 클래스로 제한)

public <T extends 상위타입> 리턴타입 메소드(매개변수, ... ) { ... }

    - 위의 상위타입은 클래스 뿐만 아니라 인터페이스도 가능 (<- 인터페이스라고 해서 implements를 사용하지 않음)

    (예 1) Number 타입과 자식 클래스에만 대체 가능한 타입 파라미터를 정의하기

public <T extends Number> boolean compare(T t1, T t2) {
    double v1 = t1.doubleValue();  //Number의 doubleValue() 메소드 사용
    double v2 = t2.doubleValue();  //Number의 doubleValue() 메소드 사용
    return (v1 == v2);
}

public static void main(String[] args) {
    //제네릭 메소드 호출
    boolean result1 = compare(10, 20);  //<- T를 Integer 타입으로 대체
    System.out.println(result1);
}

    - 타입 파라미터가 Number 타입으로 제한되면서 Object의 메소드뿐만 아니라 Number가 가지고 있는 메소드도 사용 가능

 

13.5 와일드카드 타입 파라미터

    - 제네릭 타입을 매개값이나 리턴 타입으로 사용할 때, 타입 파라미터로 ? (와일드카드)를 사용 가능
    * ? 와일드카드 : 범위에 있는 모든 타입으로 대체 가능하다는 표시

    1) 타입 파라미터의 대체 타입으로 Student와 자식 클래스만 가능하도록 매개변수 선언하기 => <? extends Student>

리턴타입 메소드명(제네릭타입<? extends Studnet> 변수) { ... }

    2) 타입 파라미터의 대체 타입으로 Worker과 부모 클래스만 가능하도록 매개변수 선언하기 => <? super Worker>

리턴타입 메소드명(제네릭타입<? super Worker> 변수) { ... }

    3) 타입 파라미터의 대체 타입으로 어떤 타입이든 가능하도록 매개변수 선언하기 => <?>

리턴타입 메소드명(제네릭타입<?> 변수) { ... }

 

    (예 1) 모든 사람 / 학생 / 일반인 에 따라 제한하기

public class Applicant<T> {
    public T kind;
    
    public Applicant(T kind) {
        this.kind = kind;
    }
}

public class Course {
    //모든 사람이 등록 가능
    public static void registerCourse1(Applicant<?> applicant) {
        System.out.println(applicant.kind.getClass().getSimpleName() + "1 등록");
    }
    
    //학생만 등록 가능
    public static void registerCourse2(Applicant<? extends Student> applicant) {
        System.out.println(applicant.kind.getClass().getSimpleName() + "2 등록");
    }
    
    //일반인만 등록 가능
    public static void registerCourse3(Applicant<? super Worker> applicant) {
        System.out.println(applicant.kind.getClass().getSimpleName() + "3 등록");
    }
}

public class GenericExample {
    public static void main(String[] args) {
        //모든 사람이 신청 가능
        Course.registerCourse1(new Applicant<Person>(new Person()));
        
        //학생만 신청 가능
        Course.registerCourse2(new Applicant<Student>(new Student()));
        
        //일반인만 신청 가능
        Course.registerCourse3(new Applicant<Worker>(new Worker()));
    }
}