
๐ก์ค๋ฒ๋ก๋ฉ(Overloading) ์ด๋?
- overload์ ์ฌ์ ์ ์ธ ์๋ฏธ๋ ๊ณผ์ ํ๋ค. ๋ถ๋ด์ ๋ง์ด ์ง์ฐ๋ค ๋ผ๋ ๋ป์ ๊ฐ์ง๊ณ ์๋ค.
- ์๋ฐ์์๋ ์๋ ํ ํด๋์ค ๋ด์ ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ๋ ์ด์ ๊ฐ์ง ์ ์๋ค. ํ์ง๋ง ์๋ ์กฐ๊ฑด๋ง ์งํจ๋ค๋ฉด ํ๋์ ํด๋์ค์ ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ ๊ฐ ์ ์ํ์ฌ ๊ตฌํ์ด ๊ฐ๋ฅํ๋ค.
- ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ ์ฌ์ฉํจ์ผ๋ก์จ ๋ฉ์๋์ ์ฌ์ฉ๋๋ ์ด๋ฆ์ ์ ์ฝํ ์ ์๋ค.
- ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ์ ๋ฌํด์ผ ํ ๋งค๊ฐ ๋ณ์์ ํ์ ์ด๋ ๊ฐ์์ ๋ํด ํฌ๊ฒ ์ ๊ฒฝ ์ฐ์ง ์๊ณ ํธ์ถํ ์ ์๊ฒ ๋๋ค.
- ์ค๋ฒ๋ก๋ฉ์ ๋ํ์ ์ธ ๋ฉ์๋๋ก๋ println() ๋ฉ์๋๋ฅผ ๋ค ์ ์๋ค.
์ค๋ฒ๋ก๋ฉ์ ์กฐ๊ฑด
โ ํ ํด๋์ค ๋ด์์ ๋ฉ์๋ ๋ช ์ด ๋์ผํด์ผ ํ๋ค.
โก ๋งค๊ฐ๋ณ์์ ๊ฐ์ ๋๋ ํ์ ์ด ๋ฌ๋ผ์ผ ํ๋ค.
โข ๋งค๊ฐ๋ณ์๋ ๊ฐ๊ณ ๋ฆฌํดํ์ ์ด ๋ค๋ฅธ ๊ฒฝ์ฐ๋ ์ค๋ฒ๋ก๋ฉ์ด ์ฑ๋ฆฝ๋์ง ์๋๋ค.
(๋ฆฌํด ํ์ ์ ์ค๋ฒ๋ก๋ฉ์ ๊ตฌํํ๋๋ฐ ์๋ฌด๋ฐ ์ํฅ์ ์ฃผ์ง ์๋๋ค.)
์ค๋ฒ๋ก๋ฉ ์ฌ์ฉ ์
์ค๋ฒ๋ก๋ฉ โ ,โก๋ฒ์ ์กฐ๊ฑด์ ์ฑ๋ฆฝํ๋ ์๋ ์๋์ ๊ฐ๋ค.
class Overloading {
//๋ฉ์๋๋ช
print(๋งค๊ฐ๋ณ์ ํ๊ฐ) ๊ธฐ์ค
void print(int a) {
System.out.println(a);
}
//๋ฉ์๋๋ช
๋์ผ (๋งค๊ฐ๋ณ์ ํ์
๋ณ๊ฒฝ)
void print(String s) {
System.out.println(s);
}
//๋ฉ์๋๋ช
๋์ผ (๋งค๊ฐ๋ณ์ ๊ฐ์ ๋ณ๊ฒฝ)
void print(int a, int b) {
System.out.println(a * b);
}
//๋ฉ์๋๋ช
๋์ผ (๋งค๊ฐ๋ณ์ ํ์
๊ฐ์ ๋ณ๊ฒฝ)
void print(String s, int a) {
System.out.println(s + a);
}
}
public class Test {
public static void main(String[] args) {
Overloading ol = new Overloading();
ol.print(1);
ol.print("a");
ol.print(2, 3);
ol.print("b", 4);
}
}
<์ถ๋ ฅ ๊ฒฐ๊ณผ>
1
a
6
b4
์ฐ์ ๋ฉ์๋๋ช ์ print๋ก ๋ชจ๋ ๊ฐ๋ค. ์ฒ์ ๋งค๊ฐ๋ณ์๋ int ํ์ ์ผ๋ก ๊ฐ์๋ ํ ๊ฐ๋ค. ๊ทธ๋ฆฌ๊ณ ์ฒซ ๋ฒ์งธ์ ๋ ๋ฒ์งธ๋ ๋งค๊ฐ๋ณ์ ํ์ ์ด ๋ค๋ฅด๋ค. ์ดํ ์ธ ๋ฒ์งธ๋ถํฐ๋ ๋งค๊ฐ๋ณ์์ ๊ฐ์๊ฐ ๋ค๋ฅด๋ค. ์ด๋ ๊ฒ ๋งค๊ฐ๋ณ์ ํ์ ๊ณผ ๊ฐ์๊ฐ ๋ฌ๋ผ์ผ ์ค๋ฒ๋ก๋ฉ์ด ์ฑ๋ฆฝ๋๋ค.
์ค๋ฒ๋ก๋ฉ โข๋ฒ ์กฐ๊ฑด์ ์๋ ์๋์ ๊ฐ๋ค.
class Overloading {
// ๋ฆฌํดํ์
์ด ๋ฌ๋ผ๋ ์ค๋ฒ๋ก๋ฉ์ ์ฑ๋ฆฝ๋๋ค.
int print(int a, int b) {
return a > b ? a : b;
}
//๋งค๊ฐ๋ณ์๋ ๊ฐ์ง๋ง ๋ฆฌํดํ์
์ด ๋ค๋ฅธ ๊ฒฝ์ฐ
// void print(int a, int b) {
// }
//๋ฆฌํดํ์
์ด ๋ค๋ฅธ๊ฒฝ์ฐ๋ ์๊ด์์
double print(double a, double b) {
return a > b ? a : b;
}
}
public class Test {
public static void main(String[] args) {
Overloading ol = new Overloading();
System.out.println(ol.print(2, 3));
System.out.println(ol.print(3.0, 5.5));
}
}
<์ถ๋ ฅ ๊ฒฐ๊ณผ>
3
5.5
์ฒซ ๋ฒ์งธ๋ก ์ ์ธ๋ ๋ฉ์๋๋ฅผ ๋ณด๋ฉด ๋ฐํ ํ์ ์ด int ํ์ ์ด๋ค. ๋๋ฒ์งธ๋ ๋งค๊ฐ๋ณ์๋ ๊ฐ์ง๋ง ๋ฐํํ์ ๋ง ๋ค๋ฅด๊ฒ ํ๋ค. ์ด๋ฐ๊ฒฝ์ฐ์๋ ์ค๋ฅ๊ฐ ๋๋ค. ์ฆ, ์ค๋ฒ๋ก๋ฉ์ด ์ฑ๋ฆฝ๋์ง ์๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ธ๋ฒ์งธ๋ ๋ฐํํ์ ์ด ๋ค๋ฅด์ง๋ง ์ค๋ฒ๋ก๋ฉ์ ์ฑ๋ฆฝ๋๋ค. ์ฆ, ๋ฐํ ํ์ ์ ์ค๋ฒ๋ก๋ฉ์ ๊ตฌํํ๋๋ฐ ์๋ฌด๋ฐ ์ํฅ์ ์ฃผ์ง ์๋๋ค.
๐ก์ค๋ฒ๋ผ์ด๋ฉ(Overriding) ์ด๋?
- override์ ์ฌ์ ์ ์๋ฏธ๋ '~์์ ๋ฎ์ด์ฐ๋ค', '~์ ์ฐ์ ํ๋ค'๋ผ๋ ๋ป์ ๊ฐ์ง๊ณ ์๋ค.
- ์์๋ฐ์ ๋ถ๋ชจ ํด๋์ค์์ ์ด๋ฏธ ์ ์๋ ๋ฉ์๋๋ฅผ ์์ ํด๋์ค์์ ์ฌ์ ์ ํ๋ ๊ฒ์ ๋งํ๋ค. (๋จ, private ์ ์ธ)
- ์์ ํด๋์ค์์ ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ฉด ๋ถ๋ชจ ํด๋์ค์ ๋ฉ์๋๊ฐ ์๋ ์์ํด๋์ค์ ๋ฉ์๋๊ฐ ์คํ๋๋ค. ์ฆ, ์ฌ์ ์๋ ๋ฉ์๋๊ฐ ์ฐ์ ๊ถ์ ๊ฐ์ง๋ค.
- @Override๋ผ๋ ์ด๋ ธํ ์ด์ ์ ์ฌ์ฉํ๋ค. ์ด๋ ธํ ์ด์ (Annotation)์ ์ฌ์ฉํ๋ฉด ์ค๋ฒ๋ผ์ด๋ฉ์ ๊ฒ์ฆํ๋ ๊ธฐ๋ฅ์ ํ๋ค.
- ์ค๋ฒ๋ผ์ด๋ฉ์ ๋ํ์ ์ธ ์๋ก๋ Object ํด๋์ค์ toString() ๋ฉ์๋์ด๋ค.
์ค๋ฒ๋ผ์ด๋ฉ ์กฐ๊ฑด
โ ๋ถ๋ชจ ํด๋์ค์ ๋ฉ์๋์ ๋ฉ์๋ ์ด๋ฆ์ด ๋์ผํด์ผ ํ๋ค.
โก ๋งค๊ฐ๋ณ์์ ํ์ , ๊ฐ์, ์์๊ฐ ์ผ์นํด์ผ ํ๋ค.
โข ๋ฆฌํด ํ์ ์ด ๋์ผํด์ผ ํ๋ค.
โฃ ์ ๊ทผ ์ ํ์๋ ๋ถ๋ชจ ํด๋์ค์ ๋ฉ์๋์ ๊ฐ๊ฑฐ๋ ๋ ๋์ ๋ฒ์์ด์ผ ํ๋ค.
โค ๋ถ๋ชจ ๋ฉ์๋์ ์์ธ์ ๊ฐ๊ฑฐ๋ ์์ธ์ ๊ฐ์๋ฅผ ์ค์ผ ์ ์๋ค.
์ค๋ฒ๋ผ์ด๋ฉ ์ฌ์ฉ ์
์ค๋ฒ๋ผ์ด๋ฉ์ ์ฌ์ฉ ์๋ ์๋์ ๊ฐ๋ค.
class Person {
void print() {
System.out.println("Personํด๋์ค์ print()๋ฉ์๋");
}
}
class Student extends Person {
@Override
public void print() {
System.out.println("Studentํด๋์ค์ print()๋ฉ์๋");
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
Student st = new Student();
p.print();
st.print();
}
}
<์ถ๋ ฅ ๊ฒฐ๊ณผ>
Personํด๋์ค์ print()๋ฉ์๋
Studentํด๋์ค์ print()๋ฉ์๋
๋ถ๋ชจ ํด๋์ค์ธ Personํด๋์ค์์ ๋ฉ์๋๋ฅผ ํ๋ ์ ์ธํด์ฃผ์๋ค. ์ ๊ทผ์ ํ์๋ ๊ธฐ์ฌ ํ์ง ์์ผ๋ฉด (default)๊ฐ์ด๋ค. ์ด์ ์์ ํด๋์ค์ธ Student ํด๋์ค์ Personํด๋์ค๋ฅผ ์์ ๋ฐ์ ํ ๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ์ ์์ฑํ๋ค.
@Override๋ผ๋ ์ด๋ ธํ ์ด์ ์ ๊ธฐ์ ํ ํ, โฃ์กฐ๊ฑด์ ๋ฐ๋ผ (default) ๊ฐ๋ณด๋ค๋ ํฐ ๋ฒ์์ธ public์ ์ฌ์ฉํ๋ค. (protected๋ ์ฌ์ฉ ๊ฐ๋ฅ) ๊ทธ๋ฆฌ๊ณ โ ,โก,โข๋ฒ์ ์กฐ๊ฑด์ ๋ง์ถฐ ์์ฑํด ์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ โค๋ฒ ์กฐ๊ฑด์ ๋ถ๋ชจ ํด๋์ค์์ ์ด๋ค ์์ธ๋ฅผ throws ํ๋ค๊ณ ํ๋ฉด, ์์ ํด๋์ค์์๋ ๊ทธ ์์ธ๋ณด๋ค ๋ ํฐ ๋ฒ์์ ์์ธ๋ฅผ throws ํ ์ ์๋ค๋ ๊ฒ์ด๋ค.
๐ก์ค๋ฒ๋ก๋ฉ(Overloading)๊ณผ ์ค๋ฒ๋ผ์ด๋ฉ(Overriding)์ ์ฐจ์ด์
์ค๋ฒ๋ก๋ฉ๊ณผ ์ค๋ฒ๋ผ์ด๋ฉ์ ์ด๋ฆ์ ๋น์ทํ์ง๋ง ๊ฐ๋ ์ ํ์คํ ๋ค๋ฅด๋ค. ๋ ๊ฐ์ ์ฐจ์ด์ ์ ์๋ ํ๋ก ์ ๋ฆฌํ๋ค.
| ๊ตฌ๋ถ | ์ค๋ฒ๋ก๋ฉ (Overloading) |
์ค๋ฒ๋ผ์ด๋ฉ (Overriding) |
| ์ ์ | ํ ํด๋์ค๋ด์ ๋์ผํ ๋ฉ์๋๋ช ์ผ๋ก ๊ธฐ์ ํ๋ ๊ฒ | ์์ ๋ฐ์ ๋ถ๋ชจํด๋์ค์ ์ ์๋์ด ์๋ ๋ฉ์๋๋ฅผ ์์ ํด๋์ค์์ ์ฌ์ ์ํ๋ ๊ฒ |
| ์ ๊ทผ ์ ์ด์ | ๋ชจ๋ ์ ๊ทผ ์ ์ด์๋ฅผ ์ฌ์ฉํ ์ ์์ | ๋ถ๋ชจ ํด๋์ค์ ๋ฉ์๋์ ์ ๊ทผ์ ์ด์์ ๊ฐ๊ฑฐ๋ ๋ ๋์ ๋ฒ์์ด์ผ ํจ. |
| ๋ฆฌํด(๋ฐํ)ํ | ๋ฌ๋ผ๋ ๋จ | ๋์ผํด์ผ ํจ |
| ๋ฉ์๋๋ช | ๋์ผํด์ผ ํจ | ๋์ผํด์ผ ํจ |
| ๋งค๊ฐ๋ณ์ | ํ์ , ๊ฐ์, ์์๊ฐ ๋ฌ๋ผ์ผ๋ง ํจ | ํ์ , ๊ฐ์, ์์๊ฐ ๋์ผํด์ผ ํจ |
| ์ ์ฉ๋ฒ์ | ํ ํด๋์ค ๋ด์์ | ์์๊ด๊ณ์ผ ๋ |
๐Reference
https://hyoje420.tistory.com/14\
http://www.tcpschool.com/java/java_usingMethod_overloading
ํด๋น ๊ธ์ ์๋ฐ์ ํ์ตํ ๋ด์ฉ์ ๊ฐ์ธ์ ์ผ๋ก ์ ๋ฆฌํ ๊ธ์ ๋๋ค. ๋ง์ฝ ํ๋ฆฐ ๋ถ๋ถ์ด ์๋ค๋ฉด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์ธ์:D