[Java] 제네릭(generic)의 개념과 활용법

1. 제네릭(generic)이란?

자바에서 제네릭(generic)이란 데이터의 타입(data type)을 일반화한다(generalize)는 것을 의미합니다.

제네릭(Generic)은 Java 프로그래밍 언어에서 타입(type)의 파라미터화를 가능하게 하는 언어 기능입니다.

이는 클래스, 인터페이스, 메소드를 정의할 때 타입을 하나의 파라미터처럼 취급할 수 있게 해 줍니다.

즉, 구체적인 타입을 명시하지 않고도 타입을 사용할 수 있는 방법을 제공합니다.

 

 

 

2. 제네릭 사용 시 얻을 수 있는 이점

1) 타입 안정성 :  제네릭을 사용하면 컴파일 시점에 타입 체크를 할 수 있어서 런타임에 발생할 수 있는 ClassCastException과 같은 오류를 방지할 수 있습니다.

2) 코드의 재사용성 증가 

3) 유지보수성 향상

 

 

 

3. 제네릭 사용법

타입 매개변수를 꺾쇠괄호(< >) 안에 지정하여 선언합니다.

 

 

 

 

4. 제네릭을 사용하지 않은 코드 VS 제네릭 사용한 코드

 

4-1) 코드 중복 문제

 

*제네릭을 사용하지 않은 코드

package Day10_Generic;

public class _01_Generics {
    public static void main(String[] args) {
        int[] iArr = {1,2,3,4,5};
        double[] dArr = {1.0,2.0,3.0,4.0,5.0};
        String[] sArr = {"A","B","C","D","E"};

		//문제점 1.
        //타입에 따라 메서드를 따로 선언해서 사용하고 있다.
        //추후 타입이 추가되면 메서드를 또 만들어야한다.
        printIntArr(iArr);
        printDoubleArr(dArr);
        printStringArr(sArr);

    }

	//문제점 2.
    //코드가 중복되고 있다.
    //비효율적인 코드로 보인다.
    private static void printStringArr(String[] sArr) {
        for (String i: sArr) {
            System.out.print(i+ " ");
        }
    }

    private static void printDoubleArr(double[] dArr) {
        for (double i: dArr) {
            System.out.print(i+ " ");
        }
    }

    private static void printIntArr(int[] iArr) {
        for (int i: iArr) {
            System.out.print(i+ " ");
        }
    }
}

 

주석에도 설명을 달아놨지만, 타입의 갯수만큼 메서드를 생성해야하는 코드입니다.

따라서 코드 중복도 보입니다.

 

 

*제네릭을 사용한 코드

package Day10_Generic;

public class _01_Generics {
    public static void main(String[] args) {
	    Integer[] wrapiArr = {1,2,3,4,5};
        Double[] wrapdArr = {1.0,2.0,3.0,4.0,5.0};
        String[] sArr = {"A","B","C","D","E"};

        //제네릭스가 지원하는 건 객체!
        //기본자료형은 쓸 수 없다. 래퍼클래스를 써야된다. 첫문자가 대문자!
        printAnyArr(wrapiArr);
        printAnyArr(wrapdArr);
        printAnyArr(sArr);
    }

    // T : Type
    private static <T> void printAnyArr(T[] arr){
        for (T t: arr) {
            System.out.print(t+ " ");
        }
    }
}

 

훨씬 코드가 깔끔해 졌습니다.

타입의 갯수만큼 메서드를 만들지 않아도 됩니다.

유지보수성도 향상되고 코드의 중복도 없앴습니다.

 

다만, 주의해야할 점은 제네릭이 지원하는 건 객체라는 것입니다.

int, double등은 기본자료형이기 때문에 래퍼클래스로 값을 넘겨줘야 제네릭을 활용할 수 있습니다.

 

 

4-2) 코드 중복 및 형변환 실수

 

*제네릭을 사용하지 않은 코드

/*클래스 : CoffeeByNumber*/

public class CoffeeByNumber {
    public int waitingNumber;

    public CoffeeByNumber(int waitingNumber) {
        this.waitingNumber = waitingNumber;
    }

    public void ready(){
        System.out.println("커피 준비 완료: "+ waitingNumber);
    }

}


/*클래스 : CoffeeByNickname*/

package Day10_Generic.coffee;

public class CoffeeByNickname {
    public String nickname;


    public CoffeeByNickname(String nickname) {
        this.nickname = nickname;
    }

    public void ready(){
        System.out.println("커피 준비 완료 : " + nickname);
    }
}


/*클래스 : CoffeeByName*/

package Day10_Generic.coffee;

public class CoffeeByName {
    public Object name;

    public CoffeeByName(Object name) {
        this.name = name;
    }

    public void ready(){
        System.out.println("커피 준비 완료 : "+name);
    }

}


/*main메서드*/

public class _02_GenericClass {
    public static void main(String[] args) {
    
        //int
        CoffeeByNumber c1 = new CoffeeByNumber(33);
        c1.ready();
        
        //String
        CoffeeByNickname c2 = new CoffeeByNickname("우루루파도");
        c2.ready();
        
        //-------------------------------//
        //Object
        CoffeeByName c3 = new CoffeeByName(34);
        c3.ready();
        CoffeeByName c4 = new CoffeeByName("돌맹이");
        c4.ready();

        //c3는 Object타입이기때문에 Integer객체로 박싱됐다.
        // (int)로 언박싱해줘야한다.
        int c3Name = (int)c3.name;
        System.out.println("주문 고객 번호 : "+c3Name);
        
        // c4.name은 Object 타입이지만, 실제로 저장된 값은 String이다.
        // 그러나 컴파일러는 이것을 알지 못하기 때문에
        // 이것이 String임을 명시적으로 알려주어야 한다.
        String c4Name = (String)c4.name;
        System.out.println("주문 고객 이름 : "+c4Name);

        //⭐⭐⭐⭐⭐Integer객체를 (String)으로 형변환하려고 하면
        //ClassCastException 에러가 난다.
		c4Name = (String)c3.name;

    }
}

 

위 코드는 스타벅스 예제입니다.

커피가 준비되면 주문번호로 불리거나 닉네임으로 불립니다.

 

1️⃣ 자료형에 따라 CoffeeByNumber, CoffeeByNickname 두 클래스로 나눴습니다.

자료형에 따라 클래스를 계속 추가해줘야하니 번거롭습니다.

2️⃣ Object타입으로 받으니 클래스 하나로도 가능합니다.

그런데, 두가지 문제점이 보이네요.

- name을 받아올 때, 매번 형변환을 해줘야 한다는 점.

- 형변환을 할 때, 바꿀 수 없는 것을 형변환하면 ClassCastException에러가 나올 수 있다는 점.

 

위 문제들을 제네릭 클래스로 해결할 수 있습니다. 

 

*제네릭 사용한 코드

/* 클래스 : Coffee */
public class Coffee <T>{
    public T name;

    public Coffee(T name) {
        this.name = name;
    }

    public void ready() {
        System.out.println("커피 준비 완료 : "+name);
    }
}

/* main메소드 */
public class _02_GenericClass {
    public static void main(String[] args) {

        Coffee<Integer> c5 = new Coffee<>(35);
        c5.ready();
        int c5Name = c5.name;
        System.out.println("주문 고객 번호 : "+ c5Name);
        
        Coffee<String> c6 = new Coffee<>("카카오");
        c6.ready();
        String c6Name = c6.name;
        System.out.println("주문 고객 번호 : "+ c6Name);
    }
}

 

형변환을 따로 명시하지 않아도 됩니다.

컴파일 시 타입 체크를 수행하여, (빨간밑줄)

런타임 시 발생할 수 있는  ClassCastException에러를 사전에 방지할 수 있습니다.

 

 

 

5. 제네릭 타입 제한하는 법

 

상속을 활용하여 타입을 제한할 수 있습니다.

바로 예제 코드로 이해해보겠습니다.

/*클래스 : User*/

public class User {
    public String name;

    public User(String name) {
        this.name = name;
    }

    public void addPoint(){
        System.out.println(this.name + "님 포인트 적립되었습니다.");
    }
}

/*클래스 : VIPUser*/

public class VIPUser extends User{

    public VIPUser(String name) {
        super("특별한"+name);
    }
}


/*클래스 : CoffeeByUser*/

public class CoffeeByUser <T extends User>{//User클래스만 T에 들어올 수 있다.

    public T user;

    public CoffeeByUser(T user) {
        this.user = user;
    }

    public void ready(){
        System.out.println("커피 준비 완료 : "+user.name);
        user.addPoint();
    }
}


/*main 메서드*/

public class _02_GenericClass {
    public static void main(String[] args) {

        CoffeeByUser<User> c7 = new CoffeeByUser<>(new User("강호동"));
        c7.ready();//User클래스

        CoffeeByUser<User> c8 = new CoffeeByUser<>(new VIPUser("서장훈"));
        c8.ready(); //User를 상속받은 클래스
        
        CoffeeByUser<User> c9 = new CoffeeByUser<>(new OtherType("뿡뿡이"));
        //new OtherType은 User클래스 또는 User클래스를 상속받은 클래스가 아니기에 에러가 납니다.
 }

 

 

 

6. 제네릭 여러개 사용하기

public class _02_GenericClass {
    public static void main(String[] args) {
    
        orderCoffee("우루루파도","카페라떼");
        
    }

    public static <T,V> void orderCoffee(T name,V coffee){
        System.out.println(coffee+" 준비 완료 : " + name);
    }
}

 

쉼표로 구분해서 쓰면 됩니다. 참 쉽죠.