์๋ก
์ด๋์ ๊ฐ ์๋ฐ๋ก ๋ง๋ ์ฝ๋๋ฅผ ๋ณธ ์ ์ด ์๋ค๋ฉด ArrayList <> ๊ฐ์ ํ์์ ๋ฌธ์ฅ์ ๋ณธ ์ ์ด ์์ ๊ฒ์ด๋ค.
์ <>์์ ๋ด๊ฐ ์ํ๋ ํ์ ์ ๋ฃ์ผ๋ฉด ๊ทธ ํ์ ์ ๋ง๋ ๊ฐ์ฒด๊ฐ ์์ฑ์ด ๋๋๋ฐ ์ด๋ฌํ ๋ฐฉ์์ด Generic์ด๋ค.
Generic
Generic์ ๋ฐ์ดํฐ ํ์์ ์์กดํ์ง ์๊ณ , ํ๋์ ๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ ๋ค๋ฅธ ๋ฐ์ดํฐ ํ์ ์ ๊ฐ์ง๋๋ก ํด์ฃผ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ด๊ฑธ ์กฐ๊ธ ๋ ์์ด ๋ณด์ด๊ฒ ํํํ์๋ฉด ์ปดํ์ผ ๋ ํ์ ์ ์ฒดํฌํ๊ฒ ํด์ฃผ๋ ๋ฐฉ๋ฒ์ด๋ค.
Generic์ ๊ฐ์ฒด์ ํ์ ์ ๋ํ ์์ ์ฑ์ ๋์ด๊ณ , ํ ๋ณํ์ ๋ฒ๊ฑฐ๋ก์์ ์ค์ด๊ธฐ ์ํด ์ฌ์ฉ๋๋ค.
๊ฐ ํ๋ฉด์ ์ธ ์ด์ ์ด์ง๋ง, ํ ๊ฐ์ง ์์๋ฅผ ๋ค์ด ์๊ฐํด ๋ณด๋ฉด ์ ์ฐ๋์ง ๋ฐ๋ก ์ดํดํ ์ ์๋ค.
์๋ก ์์ ์ธ๊ธํ ArrayList์ ํ์ ์ด ๋ง์ฝ ์ง์ ๋์ด ์๋ค๋ฉด, ๊ฐ๋ฐ์๋ ์๋ง์ ํ์ ์ ArrayList๋ฅผ ์ ์ํด์ผ ํ ๊ฒ์ด๋ค. ๋๋ฌด ๋นํจ์จ์ ์ด๊ณ ๊ท์ฐฎ๊ธฐ ๋๋ฌธ์ ๋์จ ๊ฑฐ๋ค.
public class GenericBox<T> { //<T>๋ก ๋ง๋ค์ด Generic์ผ๋ก!
private T some;
public GenericBox() {}
public GenericBox(T some) {
this.some = some;
}
public T getSome() {
return some;
}
public void setSome(T some) {
this.some = some;
}
}
public static void main(String[] args) {
GenericBox<String> gbox = new GenericBox<>();
gbox.setSome(1); // String์ผ๋ก ์ ์ ํ๊ธฐ ๋๋ฌธ์ ์๋ฌ ๋ฐ์
gbox.setSome("Generic Test");
System.out.println("๋ฌธ์์ด: " + gbox.getSome());
}
ํ์ง๋ง ์ฐ๋ฆฌ๋ ์ด์ ์ Object๋ผ๊ณ ํ๋ ์กฐ์๋ ํด๋์ค์ ๋ํด ๋ฐฐ์ ๋ค. Object๊ฐ ์ด๋ฐ ์ญํ ์ ์ถฉ๋ถํ ์ํํด ์ค ๊ฒ ๊ฐ์๋ฐ ์ด๋ค ์ฐจ์ด์ ์ด ์์๊น?
์ฒซ ๋ฒ์งธ๋ก Object๋ ์ฒ์ ์ ์ ๋ ๋ชจ๋ ํ์ ์ ๋ฐ์ ์ ์๊ฒ ํด ์ค ๊ฒ์ด๊ณ , Generic์ ์ฌ์ฉ์๊ฐ ํ์ํ ๋ ํ์ ์ ์ง์ ํ๊ณ ์ฌ์ฉํ๋ ๋ฐฉ์์ด๋ค. ์์ฝํ์๋ฉด Generic์ Object์ ๋ฌ๋ฆฌ ์ฌ์ฉ์๊ฐ ํ์ ์ ๊ฒฐ์ ํ๋ค.
๋ ๋ฒ์งธ๋ก ํ๋ณํ์ ์ฐจ์ด๊ฐ ์๋ค. ์๋ฅผ ๋ค์ด Object ํ์ ์ ์๋ฃ๊ตฌ์กฐ์ intํ ์ซ์๋ฅผ ํ๋ ๋ฃ์๋ค๊ณ ๊ฐ์ ํ์.
์ด ์ซ์๋ ๋์ค์ ์ฌ์ฉ์ ํ ๋ ๊บผ๋ด๋ ์ ์ธ๋ ํ์ ์ด Object์ด๊ธฐ ๋๋ฌธ์ ์ฌ์ฉํ ๋ ๋ค์ intํ์ผ๋ก ํ๋ณํ์ ํด์ฃผ์ด์ผ ํ๋ค. ํ์ง๋ง Generic์ ์๋ฃ๊ตฌ์กฐ์ ์ ์ธ ๋น์ int๋ฅผ ์ง์ ๋ ์ํ์ด๊ณ , ์ด์ ์ซ์๋ง ์ ์ฅ์ด ๊ฐ๋ฅํด์ง๊ธฐ ๋๋ฌธ์ ํ๋ณํ์ด ๋ฐ๋ก ํ์ ์์ด ํธํ๊ฒ ์ธ ์ ์๋ค๋ ์ฐจ์ด์ ์ด ์๋ค.
Generic ์ฃผ์์ฌํญ
1. ์ ๋ค๋ฆญ ํ์ ์ ๊ฐ์ฒด๋ ์์ฑ์ด ์๋๋ค.
2. Static์ด๋์ ๊ฐ์ด ์ฌ์ฉ ๋ชปํ๋ค.
- ์ด๋ ์ฌ์ฉ์๊ฐ ํ์ ์ ์ง์ด๋ฃ๊ธฐ ์ ์ ์ธ์ด ๋์ด๋ฒ๋ฆฌ๊ธฐ ๋๋ฌธ์ด๋ค.
3. ํ์ ์ ๋ฃ์ด๋ ๊ฐ์ฒด๋ ์์๊ด๊ณ๋ผ๋ ์ฐธ์กฐํ ์ ์๋ค. -> ํ์ ์ ๋ฌด์กฐ๊ฑด ์ผ์นํด์ผ ํ๋ค.
ex) Box <A> box = new Box <B>(); ์์ A์ B๊ฐ ์์๊ด๊ณ์๋ ์ฑ๋ฆฝ์ด ์๋๋ค.
4. ๋ฐฐ์ด๊ณผ Generic์ ๊ฐ์ด ๋ชป ์ด๋ค. (์ฌ์ค ๊ฐ๋ฅ์ ํ์ง๋ง ์ ์ฐ๋ ๊ฒ์ด ์ข๋ค.)
- ๋ฐฐ์ด์ ๋ฐํ์์ ์ค์ฒดํ๊ฐ ๋๊ณ , Generic์ ๋ฐํ์ ๋ ํ์ ์ด ์๊ฑฐ๋๋ฏ๋ก, ํ์ ์ ์์ ์ฑ์ ๋ณด์ฅํ ์ ์๋ค.
Generic Method
๋ง ๊ทธ๋๋ก ํ๋ผ๋ฏธํฐ์ ๋ฆฌํด ํ์ ์ Generic ํ์์ผ๋ก ๊ฐ์ง๊ณ ์๋ ๋ฉ์๋์ด๋ค.
์ด ์์์ ๊ฐ์ด ์ฌ์ฉํ๋ฉด ๋๊ณ ๋ฉ์๋๊ฐ ํธ์ถ๋๋ ์์ ์์ <P>์ ํ์ ์ ๊ฒฐ์ ํ๋ค.
๊ณต๋ณ? ๋ถ๊ณต๋ณ?
Generic์ ๋ํ ์ ๋ณด๋ฅผ ์ด๋์ ์ฐพ์๋ณด๊ฒ ๋๋ฉด ๊ณต๋ณ, ๋น๊ณต๋ณ์ด๋ผ๋ ๋ง์ด ๊ฐํน ๋ณด์ผ ๊ฒ์ด๋ค. ๊ณต๋ณ๊ณผ ๋ถ๊ณต๋ณ์ ๋ค์๊ณผ ๊ฐ์ด ์ ์ํ๋ค.
๊ณต๋ณ: A๊ฐ B์ ํ์ ํ์ ์ผ ๋, T <A>๊ฐ T <B>์ ํ์ ํ์ ์ด๋ฉด T๋ ๊ณต๋ณ
๋ถ๊ณต๋ณ: A๊ฐ B์ ํ์ ํ์ ์ผ ๋, T<A>๊ฐ T<B>์ ํ์ ํ์ ์ด ์๋๋ผ๋ฉด T๋ ๋ถ๊ณต๋ณ
์ฐ๋ฆฌ๊ฐ ๋ณธ Generic์ ๋ถ๊ณต๋ณ์ด๊ณ , ๋ฐฐ์ด์ ๊ณต๋ณ์ด๋ผ๊ณ ๋ณด๋ฉด ๋๋ค.
void GenericTest(){
Integer[] integers = {1,2,3};
printArray(integers);
ArrayList<Integer> list = new ArrayList<>();
printlist(list); // Integer์ ๋ถ๋ชจ ํด๋์ค์ Object๊ฐ ์์ง๋ง ๋ถ๊ณต๋ณ์ด๊ธฐ์ ๋ถ๊ฐ๋ฅ
}
void printArray(Object[] arr){
for (Object o : arr) System.out.println(o);
}
void printlist(Collection<Object> arr){
for (Object o : arr) System.out.println(o);
}
์ด๋ฌ๋ฉด ์คํ๋ ค Generic์ ์จ์ผ ํ ์ด์ ๊ฐ ์ฌ๋ผ์ง์ง ์์๊น? ํด์ ๋์จ ๊ฒ ์์ผ๋์นด๋๋ผ๋ ๊ฒ์ด๋ค.
์์ผ๋์นด๋ <?>
์๊ธด ๊ฑฐ ๊ฐ์ด ๋ฌด์จ ํ์ ์ธ์ง ๋ชจ๋ฅผ ๋ ์ฌ์ฉํ๋(๋ชจ๋ ํ์ ์ ๋์ ํ ์ ์๋) ํ์ ์ด๋ค.
๋ถ๊ณต๋ณ์ธ Generic์ ํ์ ์ ์์ผ๋์นด๋๋ก ์ฒ๋ฆฌํ๊ฒ ๋๋ฉด์, ์์ ๊ฐ์ ์๋ฌ๋ฅผ ํด๊ฒฐํ ์ ์๊ฒ ๋์๋ค.
ํ์ง๋ง ์์ผ๋์นด๋๋ฅผ ์ด์ฉํด ArrayList๋ฅผ ๋ง๋ค๊ฒ ๋๋ค๋ฉด, ์ด๋ค ํด๋์ค๋ ์ง ๋ค์ด๊ฐ ๋ฒ๋ฆฌ๊ธฐ ๋๋ฌธ์ ํ์ ์์ ์ฑ์ด ๊นจ์ง๊ฒ ๋์ด ์์๋ฅผ ์ถ๊ฐํ๋ ์ฐ์ฐ์ ์๋ฌ๋ฅผ ๋ฐ์์ํค๊ฒ ๋๋ค.
๊ทธ๋์ JAVA์์๋ ์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์์ผ๋์นด๋์ ๋ฒ์๋ฅผ ์ง์ ํด ์ฃผ๋ ๊ธฐ๋ฅ์ ๊ตฌํํ์๋๋ฐ, ์ํ์ ๊ณผ ํํ์ ์ ์ด์ฉํด ์์ผ๋์นด๋์ ๋ฒ์ฃผ๋ฅผ ์กฐ์ ํ ์ ์๊ฒ ๋์๋ค.
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] Lambda (0) | 2024.07.24 |
---|---|
[JAVA] Comparable? Comparator? (3) | 2024.07.23 |
[JAVA] ์ถ์ (1) | 2024.07.20 |
[JAVA] ๋คํ์ฑ (2) | 2024.07.18 |
[JAVA] ์ฝ๋ ์ธ ์์ฑํ ๊ฒ๋ค (0) | 2024.07.17 |