JAVA_Overriding & Overloading
๐ JAVA
๐ Overriding & Overloading
์ค๋ฒ๋ผ์ด๋ฉ ( Overriding )
Overriding ๋ ๋ฌด์์ผ๊น?
์์ ํด๋์ค๊ฐ ๊ฐ์ง๊ณ ์๋ ๋ฉค๋ฒ๋ณ์๋ฅผ ํ์ ํด๋์ค๋ก ์์๋๋ ๊ฒ ์ฒ๋ผ ๋ฉ์๋๋ ํ์ ํด๋์ค๋ก ์์๋์ด ํ์ ํด๋์ค์์ ์ฌ์ฉํ ์ ์๋ค.
๊ทธ๋ฐ๋ฐ ํ์ ํด๋์ค์์ ๋ฉ์๋๋ฅผ ์ฌ์ ์ ํด์ ์ฌ์ฉํ ์ ์๋ค. ์ด๊ฒ์ด ์ค๋ฒ๋ผ์ด๋ฉ์ด๋ค.
๊ฐ๋จํ๊ฒ ๋ฎ์ด์์ฐ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ์ฝ๋ค
์์ ๊ด๊ณ์ ์๋ ํด๋์ค ๊ฐ์ ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ฌ์ ์ ํ๋ ๊ธฐ์
๋ฉ์๋ ์ด๋ฆ์ด ๊ฐ๋๋ผ๋ ์ด๋ค ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋์ ๋ฐ๋ผ ์ถ๋ ฅ๋๋ ๊ฐ์ด ๋ฌ๋ผ์ง๋ค.
Overriding ์ ์กฐ๊ฑด
- ์์๊ด๊ณ์ผ ๋๋ง ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
- static ๋ฉ์๋๋ ํด๋์ค์ ์ํ๋ ๋ฉ์๋์ด๊ธฐ ๋๋ฌธ์ ์์๋์ง ์๊ณ ์ค๋ฒ๋ผ์ด๋ฉ ๋์ง๋ ์๋๋ค.
- final, private๋ฅผ ๊ฐ์ง ๋ฉ์๋๋ ์ฑ๋ฆฝ๋์ง ์๋๋ค.
- interface๋ฅผ ๊ตฌํํ์ฌ ์ค๋ฒ๋ผ์ด๋ฉ ํ ๋๋ ๋ฐ๋์ public ์ ๊ทผ ์ ์ด์๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
- ๋ฉ์๋ ์ด๋ฆ์ ๊ฐ์์ผ ํ๋ค.
- ๋งค๊ฐ๋ณ์์ ๊ฐ์, ์์, ํ์ ์ด ๊ฐ์์ผ ํ๋ค.
- ๋ฆฌํด ํ์ ๋ ๋์ผํด์ผ ํ๋ค.
- ์ ๊ทผ ์ฌํ์๋ ๋ถ๋ชจ ๋ณด๋ค ๋ฒ์๊ฐ ๋๊ฑฐ๋ ๊ฐ์์ผ ํ๋ค.
- ์กฐ์๋ณด๋ค ๋ ํฐ ์์ธ๋ ๋์ง ์ ์๋ค.
Overriding ์ ์ฅ์
- ๋ฉ์๋ ํ๋๋ก ์ฌ๋ฌ ๊ฐ์ฒด๋ฅผ ๋ค๋ฃจ๊ณ ๊ฐ์ฒด๋ง๋ค ๋ค๋ฅธ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์๋ค.
- ๊ฐ๋ ์ฑ์ด ์ฆ๊ฐํ๋ค.
- ์ค๋ฅ์ ๊ฐ๋ฅ์ฑ์ ์ค์ผ ์ ์๋ค.
- ๋ฉ์๋ ์ด๋ฆ์ ์ ์ฝํ ์ ์๋ค.
Overriding ์ค์ต
OverridingParent
public class OverridingParent {
String name;
// ๋ถ๋ชจ ๋ฉ์๋
void introduce(){
System.out.println("์ ๋ "+this.name+ "์
๋๋ค.");
}
}
Overriding
public class Overriding extends OverridingParent{
public String name_m;
public int age;
@Override
// ๋ถ๋ชจ์ ๋ฉ์๋๋ฅผ ์ฌ์ ์
public void introduce() {
System.out.println("์ ๋ "+ this.name_m + "์ด๊ณ ๋์ด๋ " + this.age + "์
๋๋ค.");
}
}
OverridingTest
public class OverridingTest {
public static void main(String[] args) {
// ์์ ํด๋์ค ๊ฐ์ฒด ์์ฑ
Overriding ov = new Overriding();
ov.name_m = "jack";
ov.age = 17;
// ์์ ํด๋์ค ๋ฉ์๋ ํธ์ถ
ov.introduce();
}
}
์คํ๊ฒฐ๊ณผ
์ ๋ jack์ด๊ณ ๋์ด๋ 17์
๋๋ค.
์ค๋ฒ๋ก๋ฉ ( Overloading )
Overloading ๋ ๋ฌด์์ผ๊น?
๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ๊ฐ๋ฅผ ๊ฐ์ง๋ฉด์ ๋งค๊ฐ๋ณ์์ ์ ํ๊ณผ ๊ฐ์๊ฐ ๋ค๋ฅด๋๋ก ํ๋ ๊ธฐ์
๋์ผํ ๊ธฐ๋ฅ์ ์ํํ๋ ๋ฉ์๋์ ์ถ๊ฐ ์์ฑ
๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ๋งค๊ฐ๋ณ์์ ๊ฐ์, ์์, ํ์
์ ๋ฐ๋ผ ๊ฐ๊ธฐ ๋ค๋ฅธ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค.
๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ๋ ์์ง๋ง ์์ฑ์ ์ค๋ฒ๋ก๋ฉ๋ ์๋ค.
์์ฑ์๋ฅผ ๋งค๊ฐ๋ณ์์ ๋ฐ๋ผ ๊ฐ๊ฐ ์ ์ํด์ฃผ๋ฉด ๋๋ค.
Overloading ์ ์กฐ๊ฑด
- ๋ฉ์๋ ์ด๋ฆ์ ๊ฐ์์ผ ํ๋ค.
- ๋งค๊ฐ๋ณ์์ ๊ฐ์, ์์๊ฐ ๋ฌ๋ผ์ผ ํ๋ค.
- ๋งค๊ฐ๋ณ์์ ํ์ ์ด ๋ฌ๋ผ์ผ ํ๋ค.
- ๋ฆฌํด ํ์ ์ ์๋ฏธ๊ฐ ์๋ค.
- ๋งค๊ฐ๋ณ์๋ ๊ฐ๊ณ ๋ฐํ ํ์ ์ด ๋ค๋ฅธ ๊ฒฝ์ฐ ์ค๋ฒ๋ก๋ฉ์ ์ฑ๋ฆฝ๋์ง ์๋๋ค.
Overloading ์ ์ฅ์
- ๊ฐ๋ ์ฑ์ด ์ฆ๊ฐํ๋ค.
- ์ค๋ฅ์ ๊ฐ๋ฅ์ฑ์ ์ค์ผ ์ ์๋ค.
- ๋ฉ์๋ ์ด๋ฆ์ ๋ณด๊ณ ๊ฐ์ ๊ธฐ๋ฅ์ด๋ผ๊ณ ์์ธกํ ์ ์๋ค.
- ๋ฉ์๋ ์ด๋ฆ์ ์ ์ฝ ํ ์ ์๋ค.
- ex) ๊ฐ์ฅ ๋ง์ด ์ฐ๋ println() ๋ ์ค๋ฒ๋ก๋ฉ์ ํตํ ๋ฉ์๋ ํธ์ถ์ด๋ค.
Overloading ์ค์ต
Overloading class
public class Overloading {
// ๋งค๊ฐ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ
void sum(){
System.out.println("๋งค๊ฐ๋ณ์ ์์");
}
// ๊ธฐ๋ณธ
void sum(int a, int b){
System.out.println(a+b);
}
// ๋งค๊ฐ๋ณ์ ์๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ
void sum(int a, int b, int c){
System.out.println(a+b);
}
// ๋งค๊ฐ๋ณ์ ํ์
์ด ๋ค๋ฅธ ๊ฒฝ์ฐ
void sum(double a, double b){
System.out.println(a+b);
}
}
OverloadingTest class
public class OverloadingTest {
public static void main(String[] args) {
Overloading ov = new Overloading();
// ๋งค๊ฐ๋ณ์๊ฐ ์๋ sum ํธ์ถ
ov.sum();
// sum(double a, double b) ํธ์ถ
ov.sum(1.5, 3.2);
// sum(int a, int b) ํธ์ถ
ov.sum(1,2);
// sum(int a, int b, int c) ํธ์ถ
ov.sum(2,3,4);
}
}
์คํ๊ฒฐ๊ณผ
๋งค๊ฐ๋ณ์ ์์
4.7
3
5
์ค๋ฒ๋ผ์ด๋ฉ ( Overriding ) vs ์ค๋ฒ๋ก๋ฉ ( Overloading ) ๋ง๋ฌด๋ฆฌ
๋คํ์ฑ์ ํ๋ก๊ทธ๋๋ฐ์์ ์๊ตฌํ๋ ์์ฃผ ์ค์ํ ํน์ฑ์ด๋ค.
๋คํ์ฑ์ด๋ ํ๋์ ํด๋์ค๋ ํจ์๊ฐ ๋ค์ํ ๋ฐฉ์์ผ๋ก ๋์ํ๋ ๊ฒ์ด๋ค.
์ค๋ฒ๋ผ์ด๋ฉ๊ณผ ์ค๋ฒ๋ก๋ฉ์ด ๋ํ์ ์ผ๋ก ๋คํ์ฑ์ ๋ํ๋ด๋ ๊ธฐ๋ฅ์ด๋ค.
์ค๋ฒ๋ผ์ด๋ฉ์ ์ฌ๋ฌ ํด๋์ค์ ๋ค๋ฅธ ๊ธฐ๋ฅ์ ํ๋์ ๋ฉ์๋๋ก ์ ์ดํ ์ ์์๊ณ ,
์ค๋ฒ๋ก๋ฉ์ ํ๋์ ๋ฉ์๋๋ก ์ฌ๋ฌ ๋์์ ํ ์ ์์๋ค.
๊ทธ๋์ ๋คํ์ฑ์ ํ๋ก๊ทธ๋๋ฐ์ ์์ด ํจ์จ์ฑ์ ์์ฃผ ๋์ฌ์ฃผ๋ ๊ฐ์ฒด์งํฅ๊ฐ๋
์ ์ค์ํ ํน์ง ์ค ํ๋์ด๋ค.
๋ฐ๋ผ์ ์ค๋ฒ๋ผ์ด๋ฉ๊ณผ ์ค๋ฒ๋ก๋ฉ๋ ์ค์ํ ํน์ง ์ค ํ๋์ด๋ค.
๋ฉด์ ์ ์์ฃผ ์ง๋ฌธํ๋ ๊ธฐ์ด์ ์ธ ์ง์ ์ค ํ๋์ด๋ค. ์ ์๊ณ ์์ด์ผ ํ๋ค !!
๐ ์ฐธ์กฐ
https://wooono.tistory.com/262
https://programmingnote.tistory.com/29