Bounded Type Parameters
๋งค๊ฐ๋ณ์ํ๋ ํ์ (Parameterized Type) ์ ์ธ์๋ก ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ์๋ ํด๋น ํ์ ์ ์ ํํ๊ธฐ ์ํ ๊ฒฝ์ฐ๊ฐ ์์ ์ ์๋ค.
๊ฐ๋ น ์ซ์๋ก๋ง ์์ฉํ๋ ๋ฉ์๋์ ๊ฒฝ์ฐ Number ํ์ ์ ์ธ์คํด์ค ํน์ ๊ทธ์ ๋ํ ํ์ ํด๋์ค๋ง ํ์ฉํ๋ ค๊ณ ํ ๋ ํจ๊ณผ์ ์ด๋ค.
public class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
public <U extends Number> void inspect(U u) {
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<>();
integerBox.set(new Integer(10));
integerBox.set("some text"); // error: this is still String!
}
}
์ ์ฝ๋๋ Number
์ ํ์ ํด๋์ค๋ง ๋ฐ๊ฒ ๋ ํ๋ผ๋ฉํฐ ํ์
์ ์ ํํด๋์๋๋ฐ ๋ฌธ์์ด ์ ํ์ ๋งค๊ฐ๋ณ์๋ฅผ ๋๊ฒจ์ ์๋ฌ๊ฐ ๋ฐ์ํ์๋ค.
์ถ๊ฐ์ ์ผ๋ก ์๋์ ๊ฐ์ด ์ ๋ค๋ฆญ ํ์ ์ ํํํ ์ ์๋ค.
public class NaturalNumber<T extends Integer> {
private T n;
public NaturalNumber(T n) {
this.n = n;
}
public boolean isEven() {
return n.intValue() % 2 == 0;
}
}
isEven()
๋ฉ์๋์์ ์ฌ์ฉ์ค์ธ n
๋ณ์๋ Integer
ํด๋์ค์ ์ ์๋ ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
Generic
Covariant & Contravariant๊ณต๋ณ (covariant)
ํจ๊ป(ๅ
ฑ) ๋ณํ(่ฎ)๋ค ๋ผ๋ ๋ป์ผ๋ก a
๊ฐ A
์ ํ์ ํ์
์ด๋ผ๋ฉด a[]
๋ A[]
ํ์ ํ์
์ด ๋๋ค.
๋ฆฌ์ค์ฝํ ์นํ ์์น ์ด ์ ์ฉ๋ ์ฌ๋ก๋ก ์์ (ํ์) ํด๋์ค๋ ์ธ์ ๋ ๋ถ๋ชจ (๊ธฐ๋ฐ) ํ์
๊ณผ ํธํ์ด ๋์ด์ผ ํ๋ค๋ผ๋ ํน์ง์ด ์๋ค. <? extends T>
์ด๋ ์๋ฅผ ๋ค๋ฉด ๋ฐฐ์ด์ ๊ณต๋ณ ํ์
์ผ๋ก ๋ถ๋ชจ์ Super[]
์ ํ์
์ด ์์๋๋ Sub[]
๊ณผ ํ์
ํธํ์ด ๊ฐ๋ฅํ๋ค.
๋ฐ๊ณต๋ณ (contravariant)
์ถ์์ ์ธ ๋ฐฉํฅ์ผ๋ก ํ์
๋ณํ์ ํ์ฉ ํ๋๊ฒ <? super T>
๋ฌด๊ณต๋ณ (๋ถ๊ณต๋ณ : invariant)
์ค๋ก์ง ์๊ธฐ ํ์
๋ง ํ์ฉํ๋ ๊ฒ์ด๋ค. <T>
์ ๋ค๋ฆญ (๋งค๊ฐ๋ณ์ํ ํ์
: Parameterized Types) ์ด ๋ํ์ ์ด๋ฉฐ ์๋ก ๋ค๋ฅธ ํ์
List<Type1>
์ List<Type2>
์ ์์ํ์
๋ ํ์ํ์
๋ ์๋๋ค.
์ด๋ ์ ๋ค๋ฆญ์ ์๊ฑฐ ํ์ (Type Erasure) ์ ์ํด ๋ํ๋๋ ํ์ ์ด๋ค.
์ฐธ๊ณ ์๋ฃ
Multiple Bounds
๋งค๊ฐ๋ณ์ ์ ํ์ ๋๊ฐ์ด์ ์ ํ์ ์ผ๋ก ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ๋ค.
<T extends A & B & C>
์์ T
๋ A
B
C
์ ๊ฐ๊ฐ์ ๋ชจ๋ ์๋ธํ์
์ด๋ค.
๋ง์ฝ A
B
C
์ค ํ๋๊ฐ ํด๋์ค์ธ ๊ฒฝ์ฐ์๋ ๋ฐ๋์ ํด๋น ํด๋์ค๋ฅผ ๋จผ์ ๊ธฐ์
ํด์ผ ํ๋ค.
Class A { /* statement */ }
interface B { /* statement */ }
interface C { /* statement */ }
class D <T extends A & B & C> { /* ... */ }
class E <T extends C & B & A> { /* ... */ } // compile error
์ ์ฝ๋์ E
ํด๋์ค๋ A
๊ฐ ๋จผ์ ์ฌ์ฉ๋์ด์ผ ํ๋ค.
โ Generic Methods PECS โ