제네릭이란?
제네릭 사용의 장점
제네릭 사용 방법
- 제네릭 타입
- 클래스 및 인터페이스 선언
  - 기본적인 제네릭 타입의 클래스 , 인터페이스 선언
  - 제네릭 타입인자 두 개 선언
제네릭 메소드
<?> : 와일드 카드(Wild card)
extends 와 super
제네릭 사용 예시
- 제네릭 클래스 예시
- 제네릭 메소드 예시

제네릭이란?

클래스 내부에서 지정하는 것이 아닌 외부에서 사용자에 의해 지정되는 것을 의미함.

제네릭 사용의 장점

타입 안정성 보장
- 컴파일 시점에서 타입 에러를 잡아내 런타임 시에 발생할 수 있는 에러를 방지
코드 재사용성 증가
- 코드 작성할 때 타입을 지정할 필요가 없으므로 다양한 타입에 대해 재사용성이 높아짐.
코드 가독성 향상
- 코드를 더 직관적으로 작성할 수 있음.
형 변환 제거
- 형변환을 제거할 수 있어서 코드가 더 깔끔해지고 간결해짐.
컬렉션에서 유용함
- 컬렉션은 다양한 타입을 담을 수 있어야하므로 제네릭의 타입안정성과 형변환 제거로 코드가 더 깔끔해짐
자료구조에서의 활용
- 자료구조에서도 다양한 타입에 대해 유연하게 대처가능. Stack클래스를 구현할 때 사용하면 다양한 타입의 요소를 담을 수 있는 스택을 구현할 수 있음.

제네릭 사용 방법

제네릭 타입

타입	설명
<\T>	Type
<\E>	Element
<\K>	Key
<\V>	Value
<\N>	Number

클래스 및 인터페이스 선언

기본적인 제네릭 타입의 클래스 , 인터페이스 선언

public class ClassName <T> {...}
public Interface InterfaceName <T> {...}

T타입은 해당 블럭 {…}안에서 유효함.

제네릭 타입인자 두 개 선언

public class ClassName <T,K> {...}
public Interface InterfaceName <T,K> {...}

//대표적으로 타입인자 두 개 받는 컬렉션 : HashMap
public class HashMap<K,V> {...}

데이터 타입을 외부로부터 지정할 수 있음.

위처럼 생성된 제네릭 클래스를 사용하고 싶다? → 객체 생성을 할 때 구체적인 타입을 명시해주어야 함.

public class ClassName <T,K> {...}

public class Main {
	public static void main(String[] args){
		ClassName<String, Integer> a = new ClassName<String, Integer>();
	}
}

주의! 타입 파라미터로 명시할 수 있는 것은 참조 타입(Reference Type)밖에 올 수 없음

즉, int, double, char 같은 primitive type은 불가. 그래서 int형 double형 등 primitive Type의 경우 Integer, Double 같은 Wrapper Type으로 쓰는 이유가 바로 위와같은 이유다.

또한 바꿔 말하면 참조 타입이 올 수 있다는 것은 사용자가 정의한 클래스도 타입으로 올 수 있다는 것이다.

public class ClassName <T> {...}

public class Student {...}

public class Main {
	public static void main(String[] args){
		ClassName<Student> a = new ClassName<Student>();
	}
}

제네릭 메소드

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

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

public <T> T genericMethod(T o){
	...
}
[접근 제어자] <제네릭타입> [리턴타입] [메소드명]([파라미터타입] [파라미터]){
		//텍스트
}

<?> : 와일드 카드(Wild card)

타입 파라미터를 구체적으로 제한

public static <T extends Number> int compare(T t1, T t2) {
			// extends를 이용해 타입 제한
	double v1 = t1.doubleValue(); 
	double v2 = t2.doubleValue();
	return Double.compare(v1, v2);
}

와일드카드(wild card)란 이름에 제한을 두지 않음을 표현하는 데 사용되는 기호를 의미함.

extends 와 super

? extends T : 상한 경계 ? super T : 하한 경계 단, 경계를 지정하고 K는 특정 타입으로 지정이 되지만, ?는 타입이 지정되지 않는다.

<?>

타입 변수에 모든 타입을 사용할 수 있음. (<? extends Object>와 같은 의미 )

<? extends T>

T 타입과 T 타입을 상속받는 자손 클래스 타입만을 사용할 수 있음.

<? super T>

T 타입과 T 타입이 상속받은 조상 클래스 타입만을 사용할 수 있음.

<K extends T>

T와 T의 자손 타입만 가능 (K는 들어오는 타입으로 지정됨.)

<K super T>

T와 T의 부모(조상) 타입만 가능 (K는 들어오는 타입으로 지정됨.)

/*
 * Number와 이를 상속하는 Integer, Short, Double, Long 등의
 * 타입이 지정될 수 있으며, 객체 혹은 메소드를 호출 할 경우 K는
 * 지정된 타입으로 변환이 된다.
 */
<K extends Number>
 
 
/*
 * Number와 이를 상속하는 Integer, Short, Double, Long 등의
 * 타입이 지정될 수 있으며, 객체 혹은 메소드를 호출 할 경우 지정 되는 타입이 없어
 * 타입 참조를 할 수는 없다.
 */
<? extends T>	// T와 T의 자손 타입만 가능

?(물음표)

와일드 카드 <?> 은 <? extends Object> 와 같다.

[Object는 자바에서의 모든 API 및 사용자 클래스의 최상위 타입이다. ]

public class ClassName { ... }public class ClassName extends Object { ... }

기본적으로 public class ClassName extends Object {} 를 묵시적으로 상속받는 것이나 다름이 없음!

한마디로 <?>은 어떤 타입이든 상관 없다는 의미.

=> 데이터가 아닌 '기능'의 사용에만 관심이 있는 경우에 <?>로 사용할 수 있음

제네릭 사용 예시

제네릭 클래스 예시

타입인자 1개

class ClassName<E>{
	private E element;  //제네릭 타입 변수 선언

	void set(E element) {   // 제네릭 매개변수 메소드
		this.element = element;
	}

	E get(){  // 제네릭 타입 반환 메소드
	return element;
	}

}
public class Main {
	public static void main(String[] args){
		ClassName<String> a = new ClassName<String>();
		ClassName<String> b = new ClassName<String>();

		a.set("10");
		b.set(10);

		System.out.println("a data : " + a.get());
		//반환된 변수의 타입 출력
		System.out.println("a E Type : " + a.get().getClass().getName());

		System.out.println("b data : " + b.get());
		//반환된 변수의 타입 출력
		System.out.println("b E Type : " + b.get().getClass().getName());

		}
	}

ClassName이란 객체를 생성할 때 <> 안에 타입 파라미터(Type parameter) E 를 지정.

a객체의 ClassName의 E 제네릭 타입은 String으로 모두 변환된다.

b객체의 ClassName의 E 제네릭 타입은 Integer으로 모두 변환된다.

실제로 위 코드를 실행시키면 다음과 같이 출력된다.

타입인자 2개

class ClassName<K,V>{
	private K first;  //K 제네릭 타입
	private V second; //V 제네릭 타입

	void set(K first,V second) {   // 제네릭 매개변수 메소드
		this.first = first;
		this.second = second;
	}

	K getfirst(){  // 제네릭 타입 반환 메소드
	return first;
	}

	V getsecond(){
	return second;
	}
}

public class Main {
	public static void main(String[] args){
		ClassName<String,Integer> a = new ClassName<String,Integer>();

		a.set("10",10);

		System.out.println("first data : " + a.getfirst());
		//반환된 변수의 타입 출력
		System.out.println("K Type : " + a.getfirst().getClass().getName());

		System.out.println("second data : " + second.getsecond());
		//반환된 변수의 타입 출력
		System.out.println("V Type : " + b.getseconde().getClass().getName());

		}
	}

결과

제네릭 메소드 예시

메소드 한정 제네릭 사용하는 방법

// 매개 변수 타입: T
// 리턴 타입: Box<T>
public <T> Box<T> boxing(T t) {
    Box<T> box = new Box<T>();
    box.set(t);
    return box;
}
//호
public class BoxingMethodExample {
	public static void main(String[] args) {
		Box<Integer> box1 = <Integer>boxing(100);
		int intValue = box1.get();
		
		Box<String> box2 = boxing("홍길동");
		String strValue = box2.get();
	}
}

[JAVA] Generic