๋ธ๋ก๊ทธ ์ฎ๊ฒผ์ต๋๋ค! ๐ก integer.blog
์๋ฐ์ ์ ์(๋จ๊ถ์ฑ ์ ) ํ์ต๋ด์ฉ ์ ๋ฆฌ
1. ์ง๋ค๋ฆญ์ค(Generics)
์ง๋ค๋ฆญ์ค๋ ๋ค์ํ ํ์ ์ ๊ฐ์ฒด๋ค์ ๋ค๋ฃจ๋ ๋ฉ์๋๋ ์ปฌ๋ ์ ํด๋์ค์ ์ปดํ์ผ ์์ ํ์ ์ฒดํฌ๋ฅผ ํด์ฃผ๋ ๊ธฐ๋ฅ
๋ค์ ๋งํด, ๋ค๋ฃฐ ๊ฐ์ฒด์ ํ์ ์ ๋ฏธ๋ฆฌ ๋ช ์ํด์ค์ผ๋ก์จ ๋ฒ๊ฑฐ๋ก์ด ํ๋ณํ์ ์ค์ฌ์ค๋ค.
์ง๋ค๋ฆญ ํ์ ์ ํด๋์ค์ ๋ฉ์๋์ ์ ์ธํ ์ ์๋ค.
class Box<T> { // ์ง๋ค๋ฆญ ํ์
T๋ฅผ ์ ์ธ. T๋ ํ์
๋ณ์
T item;
void setItem(T item) {
this.item = item;
}
T getItem() {
return item;
}
}
์ง๋ค๋ฆญ ํด๋์ค๊ฐ ๋ Box ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋๋
๋ค์๊ณผ ๊ฐ์ด ์ฐธ์กฐ๋ณ์์ ์์ฑ์์ ํ์
T๋์ ์ฌ์ฉ๋ ์ค์ ํ์
์ ์ง์ ํด์ผ ํ๋ค.
Box<String> b = new Box<String>(); // ํ์
T๋์ ์ค์ ํ์
์ง์
b.setItem(new Object()); // ์๋ฌ. String ์ธ์ ํ์
์ ์ง์ ๋ถ๊ฐ
b.setItem("ABC"); // OK. String ํ์
์ด๋ฏ๋ก ๊ฐ๋ฅ
์๋ฅผ ๋ค์ด, Box
์ง๋ค๋ฆญ ํด๋์ค Box
์ปดํ์ผ ํ์ Box
2. ์ง๋ค๋ฆญ์ค ์ ํ
๋ชจ๋ ๊ฐ์ฒด์ ๋ํด ๋์ผํ๊ฒ ๋์ํด์ผํ๋ static๋ฉค๋ฒ์ ํ์ ๋ณ์ T๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
T๋ ์ธ์คํด์ค ๋ณ์๋ก ๊ฐ์ฃผ๋๊ธฐ ๋๋ฌธ์ด๋ค. (static ๋ฉค๋ฒ๋ ์ธ์คํด์ค ๋ณ์๋ฅผ ์ฐธ์กฐํ ์ ์๋ค.)์ง๋ค๋ฆญ ๋ฐฐ์ด ํ์ ์ ์ฐธ์กฐ๋ณ์๋ฅผ ์ ์ธํ๋ ๊ฒ์ ๊ฐ๋ฅํ์ง๋ง,
new T[10]
๊ณผ ๊ฐ์ด ๋ฐฐ์ด์ ์์ฑํ๋ ๊ฒ์ ์๋๋ค.
new ์ฐ์ฐ์ ๋๋ฌธ์ธ๋ฐ, ์ด ์ฐ์ฐ์๋ ์ปดํ์ผ ์์ ์ ํ์ T๊ฐ ๋ฌด์์ธ์ง ์ ํํ ์์์ผ ํ๋ค.
instanceof ์ฐ์ฐ์๋ ๊ฐ์ ์ด์ ๋ก T๋ฅผ ํผ์ฐ์ฐ์๋ก ์ฌ์ฉํ ์ ์๋ค.
3. ์ง๋ค๋ฆญ ํด๋์ค์ ๊ฐ์ฒด ์์ฑ๊ณผ ์ฌ์ฉ
Apple์ด Furuit์ ์์์ด๋ผ๊ณ ๊ฐ์ ํด๋
Box<Fruit> appleBox = new Box<Apple>(); // ์๋ฌ. ๋์
๋ ํ์
์ด ๋ค๋ฅด๋ค.
๋จ, ๋ ์ง๋ค๋ฆญ ํด๋์ค์ ํ์ ์ด ์์๊ด๊ณ์ ์๊ณ , ๋์ ๋ ํ์ ์ด ๊ฐ์ ๊ฒ์ ๊ด์ฐฎ๋ค.
Box<Apple> appleBox = new FruitBox<Apple>(); // OK. ๋คํ์ฑ
์์ฑ๋ Box
Box<Apple> appleBox = new Box<Apple>();
appleBox.add(new Apple()); // OK.
appleBox.add(new Grape()); // ์๋ฌ. Box<Apple>์๋ Apple ๊ฐ์ฒด์ Apple์ ์์๋ง ์ถ๊ฐ ๊ฐ๋ฅ
4. ์ ํ๋ ์ง๋ค๋ฆญ ํด๋์ค
์ง๋ค๋ฆญ ํ์
์ extends
๋ฅผ ์ฌ์ฉํ๋ฉด, ํน์ ํ์
์ ์์๋ค๋ง ๋์
ํ ์ ์๊ฒ ์ ํํ ์ ์๋ค.
class FruitBox<T extends Fruit> { //Fruit์ ์์๋ง ํ์
์ผ๋ก ์ง์ ๊ฐ๋ฅ
ArrayList<T> list = new ArrayList<T>();
...
}
์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํด์ผ ํ๋ค๋ ์ ์ฝ์ด ํ์ํ๋ค๋ฉด, ์ด๋๋ implements ๋์ extends
๋ฅผ ์ฌ์ฉํ๋ค.
interface Eatable {}
class FruitBox<T extends Eatable> {
...
}
ํด๋์ค Fruit์ ์์์ด๋ฉด์ Eatable ์ธํฐํ์ด์ค๋ ๊ตฌํํด์ผํ๋ฉด &
๊ธฐํธ๋ก ์ฐ๊ฒฐํ๋ค.
class FruitBox<T extends Fruit & Eatable> {
...
}
5. ์์ผ๋ ์นด๋
์ง๋ค๋ฆญ ํ์
์ ์ปดํ์ผ๋ฌ๊ฐ ์ปดํ์ผํ ๋๋ง ์ฌ์ฉํ๊ณ ์ ๊ฑฐํด๋ฒ๋ฆฐ๋ค.
๋๋ฌธ์ ์ง๋ค๋ฆญ ํ์
์ด ๋ค๋ฅธ ๊ฒ๋ง์ผ๋ก๋ Overloading์ด ์ฑ๋ฆฝํ์ง ์๊ณ ‘๋ฉ์๋ ์ค๋ณต ์ ์’๊ฐ ๋๋ค.
์ด๋ด ๋ ์ฌ์ฉํ๋ ๊ฒ์ด ์์ผ๋ ์นด๋์ด๋ฉฐ, ์์ผ๋ ์นด๋๋ ์ด๋ค ํ์
๋ ๋ ์ ์๋ค. ๊ธฐํธ ?
๋ก ํํํ๋ค.
?
๋ง์ผ๋ก๋ Objectํ์
๊ณผ ๋ค๋ฅผ ๊ฒ ์์ผ๋ฏ๋ก,
extends
์ super
๋ก ์ํ๊ณผ ํํ์ ์ ํํ ์ ์๋ค.
<? extends T> T์ ๊ทธ ์์๋ค๋ง ๊ฐ๋ฅ
<? super T> T์ ๊ทธ ์กฐ์๋ค๋ง ๊ฐ๋ฅ
<?> ๋ชจ๋ ํ์
๊ฐ๋ฅ. <? extends Object>์ ๋์ผ
์์ผ๋ ์นด๋์๋ &
์ ์ฌ์ฉํ ์ ์๋ค.
6. ์ง๋ค๋ฆญ ๋ฉ์๋
๋ฉ์๋์ ์ ์ธ๋ถ์ ์ง๋ค๋ฆญ ํ์ ์ด ์ ์ธ๋ ๋ฉ์๋๊ฐ ์ง๋ค๋ฆญ ๋ฉ์๋๋ค.
์ง๋ค๋ฆญ ๋ฉ์๋๋ ์ง๋ค๋ฆญ ํด๋์ค๊ฐ ์๋ ํด๋์ค์๋ ์ ์ํ ์ ์๋ค.
class FruitBox<T> {
...
static <T> void sort(List<T> list, Comparator<? super T> c) {
...
}
}
- ์ง๋ค๋ฆญ ํด๋์ค์ ์ ์๋ ํ์ ๋งค๊ฐ๋ณ์์ ์ง๋ค๋ฆญ ๋ฉ์๋์ ์ ์๋ ํ์ ๋งค๊ฐ๋ณ์๋ ์ ํ ๋ณ๊ฐ์ ๊ฒ์ด๋ค.
- static ๋ฉค๋ฒ์๋ ํ์
๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์์ง๋ง, ์ด์ฒ๋ผ ๋ฉ์๋์ ์ง๋ค๋ฆญ ํ์
์ ์ ์ธํ๊ณ ์ฌ์ฉํ๋ ๊ฒ์ ๊ฐ๋ฅํ๋ค.
- ๋ฉ์๋์ ์ ์ธ๋ ์ง๋ค๋ฆญ ํ์ ์ ์ง์ญ ๋ณ์๋ฅผ ์ ์ธํ ๊ฒ๊ณผ ๊ฐ๋ค๊ณ ์๊ฐํ๋ฉด ์ดํดํ๊ธฐ ์ฝ๋ค.
- ํ์ ๋งค๊ฐ๋ณ์๋ ๋ฉ์๋ ๋ด์์๋ง ์ง์ญ์ ์ผ๋ก ์ฌ์ฉ๋ ๊ฒ์ด๋ฏ๋ก ๋ฉ์๋๊ฐ static์ด๊ฑด ์๋๊ฑด ์๊ด์๋ค.
- ๊ฐ์ ์ด์ ๋ก, ๋ด๋ถ ํด๋์ค์ ์ ์ธ๋ ํ์
๋ฌธ์๊ฐ ์ธ๋ถ ํด๋์ค์ ํ์
๋ฌธ์์ ๊ฐ์๋ ๊ตฌ๋ณ๋ ์ ์๋ค.