[JAVA] Override ์ดํดํ๊ธฐ

๋ฌธ์
class A extends Alphabet์ผ ๋,
Alphabet a = new A() ํ๋ฉด... ์ด๋ค ์ผ์ด ๋ฒ์ด์ง๊น์??
์ค๋ ์์๋ด
์๋ค.. (์ ์ฒ๊ธฐ ์ํ์ผ๋ก ์ธํ ๋ฐ์ฑ๊ณผ ๋ณต์ต ์ค ^___^)
`Alphabet a = new A()` ์ฝ๋๊ฐ ์คํ๋ ๋, ์ด ํ ์ค ๋ด์์๋ ๋ค์๊ณผ ๊ฐ์ ์์๋ก ์คํ์ด ์ด๋ค์ง๋๋ค.
1. new A()
- new๋ผ๋ ํค์๋๋ฅผ ๋ถ์ฌ ๊ฐ์ฒด์ ๊ณต๊ฐ์ ๋ง๋ค๊ณ ,
- A() :์์ฑ์๊ฐ non-staticํ ๊ฐ์ฒด์ ๋ํด ๋ํดํธ ์ด๊ธฐํ๋ฅผ ์งํํฉ๋๋ค.
- ์ด๋ ์์ฑ์ ์์ ๋ค์ด์๋ super()๋ฅผ ํ๊ณ ์ํผํด๋์ค๋ฅผ ํ๊ณ ํ๊ณ ์ฌ๋ผ๊ฐ๋ฉฐ, ์ฒ์ ๋ณด๋ ํด๋์ค๋ฉด ๋ก๋ํด์ค๊ณ , ์ด๋ฏธ ๋ก๋๋์ด ์์ผ๋ฉด ๋ฉ์๋ ์๋ฆฌ์ด์์ ์ฐพ์์ ์ฐ๊ฒฐํฉ๋๋ค. ๊ทธ ๋ค ๋ชจ๋ ํด๋์ค์ ์์ ํด๋์ค์ธ Object์์ ๋ซํ์ ์๋๋ก ๋ด๋ ค์ค๋ฉฐ ์ฌ๊ท์ ์ผ๋ก ๋ช ์์ ์ด๊ธฐํ๊ฐ ์งํ๋ฉ๋๋ค.
2. Alphabet a
3. a = ๋ช
์์ ์ด๊ธฐํ
์ฌ๊ธฐ์ ํ์
์ Alphabet์ด๊ณ , ๊ฐ์ฒด(์ค๋ธ์ ํธ)๋ A์
๋๋ค. (๊ฐ์ฒด๋ ์์ฑ์๋ฅผ ๋ณด๊ณ ์ ํ๊ณ , ํ์
์ ๋งจ ์์ ์ ์ธํ ๊ฒ์ ๋ณด๊ณ ๊ฒฐ์ ๋ฉ๋๋ค.)
A ๊ฐ์ฒด๊ฐ ๊ฐ์ง ์ ์๋ ํ์
์ ์์ ๊ณผ ๋์ผํ ํ์
์ด๊ฑฐ๋, ๊ทธ ์์ ์ํผ ํ์
๋ง ๊ฐ๋ฅํฉ๋๋ค. ์ด ๊ฒฝ์ฐ๋ A, Alphabet, Object๊ฐ ๊ฐ๋ฅํ ํ์
์ด๊ฒ ์ง์!
ํ์ง๋ง Alphabet a= new A()๋ผ ์ ์ธํ์ผ๋.. A๊ฐ์ฒด์ ๋ํํ์
์ Alphabet์ด๋ผ๊ณ ์ ์ธํ ๊ฒ์
๋๋ค!
์ฌ๊ธฐ์ ๋ํํ์
์ด๋, ์ด๋ค ๊ธฐ์ค์ผ๋ก ์ด ๊ฐ์ฒด๋ฅผ ๋ํ ๊ฒ์ธ๊ฐ?๋ผ๋ ๊ฐ๋ฐ์์ ์์ง์
๋๋ค .
๋ฐ๋ผ์ JVM์ ๊ฐ๋ฐ์์ ์์ง๋ฅผ ์ด์ด๋ฐ์, A๊ฐ์ฒด๋ฅผ Aํ์
์ด ์๋ ๋ํํ์
์ผ๋ก ๋ถ๋ฅด๊ฒ ๋ค๊ณ ์ดํดํฉ๋๋ค.
๊ทธ๋์ ์ด๋ค ์ผ์ด ์ผ์ด๋๋๋ฉด,
Alphabet์๋ ์๊ณ A์๋ง ์๋ ๋ฉ์๋๋ ๋ณ์์๋ ์ ๊ทผํ ์ ์์ต๋๋ค. (์ด๊ฑธ shadowing์ด๋ผ๊ณ ๋ ํฉ๋๋ค.)
ํ์ง๋ง!!!
์ค๋ฒ๋ผ์ด๋ฉ์ ๊ฐ๋ ค์ง์ง ์์ต๋๋ค (<-- ์ด๊ฒ ๊ธ์ ์์ฑํ๋ ํต์ฌ์
๋๋ค๐)
์ค๋ฒ๋ผ์ด๋ฉ์ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ ๊ฒ์
๋๋ค.
๋ณธ์ธ์ด ์ค๋ฒ๋ผ์ด๋ฉ์ ํ๋์ง ์ฝ๊ฒ ํ์ธํ๊ธฐ ์ํด์๋ ๋ฉ์๋ ์์ @Override ์ด๋
ธํ
์ด์
์ ์จ๋ณด๋ฉด ๋ฉ๋๋ค.
์ค๋ฒ๋ผ์ด๋ฉ์ ํ๊ฒ ๋๋ฉด JVM์ shadowing ์ฒ๋ฆฌ์์ ์ ์ธ๊ฐ ๋ฉ๋๋ค.
์๋๋ ๊ฐ์ฒด์ ๋ํํ์
์ ๋ฐ๊พธ๋ฉด ๋ฐ๋ ํ์
์ผ๋ก ์ทจ๊ธํด์ค์ผ ํ๋๋ฐ, ์์ธ์ ์ผ๋ก ์ค๋ฒ๋ผ์ด๋ฉํ ๊ฒ๋ค์ ์ฒ๋ฆฌํ์ง ์๊ฒ ๋ค๋ ์๋ฏธ์
๋๋ค.
๊ทธ๋ผ ๋์ฒด ์? ์ด๋ฐ ์ฒ๋ฆฌ๋ฅผ ํ๋ ๊ฑธ๊น์?
์ด๊ฑด ๊ฐ์ฒด์งํฅ์ ์ฝ๋๋ฅผ ์ํด์์
๋๋ค.... ์ด์ ๋ฅผ ์๊ณ ๋ณด๋ฉด ๋ฌด๋ฆ์ ํ..! ๋จธ๋ฆฌ๋ฅผ ํ..! ์น๋ ๊ฐ์ฒด์งํฅ์ ์ธ๊ณ.... ๐
(์กด๊ฒฝ์ค๋ฝ์ต๋๋ค...!)
์๋ฌดํผ ์์๋ฅผ ํตํด ์ค๋ฒ๋ผ์ด๋ฉ์ด shadowing์์ ์ ์ธ๋๋ฉด์ ์ป๋ ์ด์ ์ ์์๋ด
์๋ค.
๊ฐ ์ํ๋ฒณ๋ง๋ค ์ด๋ฆ์ ๋ถ๋ฌ์ค์ผํ๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค.
๊ทผ๋ฐ ์ํ๋ฒณ์ 26์๋ฆฌ์ง์?
๋ง์ฝ ์ค๋ฒ๋ผ์ด๋ฉ์ด ์๋ค๋ฉด ๊ฐ๊ฐ ์ค๋ฒ๋ก๋ฉ์ ํตํด ๊ฐ ์ํ๋ฒณ์ ์ด๋ฆ์ ๋ถ๋ฌ์ค์ผํ์ ๊ฒ๋๋ค. 26๊ฐ๋ฅผ ๊ฐ๊ฐ.. ํ๋ํ๋...
public void info(A word){
System.out.println("Aa");
}
public void info(B word){
System.out.println("Bb");
}
public void info(C word){
System.out.println("Cc");
}
...
ํ์ง๋ง ์ด๋ ๊ฒ ์ฐ๋ฉด ํ์ฅ์ฑ์ด ๋จ์ด์ง๊ธฐ ๋๋ฌธ์, ์์์ ์งํฅํ ์ฝ๋๋ฅผ ์ฐ๊ฒ ๋ฉ๋๋ค.
public void info(Alphabet word){
if(word instance.of(A)){
System.out.println("Aa");
} else if(word instance.of(B)){
System.out.println("Bb");
} else if(word instance.of(C)){
System.out.println("Cc");
} else
...
}
ํ์ง๋ง ์์์ ํ๋ค๋ณด๋ฉด ์ํผ ํ์
์ผ๋ก ๋ฐ์๋ค์ผ ์ ๋ฐ์ ์๊ณ , ์ผ๊ด์ ์ธ ์ฒ๋ฆฌ๋ฅผ ํ๊ธฐ ์ด๋ ค์์ง๋๋ค.
์ํผํ์
์ผ๋ก ๋ฐ๋๋ค๋ ๊ฒ์๋ ์ํผํ์
์ผ๋ก ์ฌ์ฉํ๊ฒ ๋ค๋ ์๋๊ฐ ์๋๋ฐ, ๊ฐ ํ์
๋ณ๋ก ๋ค๋ฅธ ๋์์ ํ๋๋ก ๋ง๋๋ ค๋ฉด ๋งค๋ฒ ํ์
์ฒดํน์ ํ ์ ๋ฐ์ ์๊ณ , ์ฝ๋๊ฐ ๋ณต์กํ๊ณ ์์ ์ฑ์ด ๋จ์ด์ง๊ฒ ๋ฉ๋๋ค.
๊ทธ๋ฌ๋ ์๋ฐ์ ๋คํ์ฑ๊ณผ ์ค๋ฒ๋ผ์ด๋ฉ์ ํ์ฉํ๋ฉด ์ด ์ฝ๋๋ฅผ ์์ฃผ ๊ฐ๋จํ๊ฒ ๋ง๋ค ์ ์์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๊ทธ๋ ๊ฒ ์ฐ๋ ๊ฒ์ด ๊ฐ์ฒด์งํฅ์
๋๋ค!
class Alphabet{
public void info(){}
}
class A extends Alphabet{
@Override
public void info(){
System.out.println("Aa");
}
}
class B extends Alphabet{
@Override
public void info(){
System.out.println("Bb");
}
}
...
public void info(Alphabet word){
word.info();
}
๋จ์ํ Alphabet ์ํผํ์
์ผ๋ก ๋ฐ๊ณ ๊ฐ์ ๋ฉ์๋๋ง ํธ์ถํ์์๋, word๊ฐ A๊ฐ์ฒด๋ผ๋ฉด Aa๋ฅผ ์ถ๋ ฅํ๊ณ B๊ฐ์ฒด๋ผ๋ฉด Bb๋ฅผ ์ถ๋ ฅํ๊ฒ ๋ ๊ฒ์
๋๋ค!
์ด๊ฒ ์ค๋ฒ๋ผ์ด๋ฉ์ ํตํด ์ป์ ์ ์๋ ์ต๊ณ ์ด์ ์ด์ง์๐
๊ทธ ์์ ์๋ฌด๋ฐ ๋ฉ์๋๊ฐ ์๋๋ผ๋ ํด๋์ค/์ธํฐํ์ด์ค๊ฐ ์๋ ๊ฒ ์์ฒด์ ๊ฐ์น๋ฅผ ์๋ ๊ฒ์ด ์ง์ ํ ๊ฐ์ฒด์งํฅ์ ์์์
๋๋ค. ์ด๋ป๊ฒ ์ค๊ณํ๋๋์ ๋ฐ๋ผ ์ ์ง๋ณด์์ฑ์ด ๋ฌ๋ผ์ง๊ณ , ๊ทธ์ ๋ฐ๋ผ ์ถ์ ํ๋ฆฌํฐ๊ฐ ๋ฌ๋ผ์ง ์ ์๊ธฐ ๋๋ฌธ์ด์ฃ !
์ค๋ฒ๋ผ์ด๋ฉ์ ํตํด ๋ฐฐ์ฐ๋ ๊ฐ์ฒด์งํฅ์ ๊ฐ์น...๐ ์ฐธ ๋ฉ์ ธ์
๊ฒฐ๋ก
์ด์ ๋ค์ ์ฒ์์ผ๋ก ๋์๊ฐ์ ๊ฒฐ๋ก !
class A extends Alphabet์ผ ๋,
Alphabet a = new A() ํ๋ฉด
A๋ฅผ Alphabet ์ทจ๊ธํ์ง๋ง,
A๊ฐ ์ค๋ฒ๋ผ์ด๋ฉํ ๊ฒ์ ์ค๋ฒ๋ผ์ด๋ฉํ A์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค!!!
* ์ด๋ฒ ๊ธฐ์ฌ๋ 1ํ๊ธฐ ๋ ๋ฐฐ์ ๋ ๋ด์ฉ์ ํ ๋๋ก ์์ฑ๋์์ต๋๋ค๐ 19๋ฐ์ ์๋ JES ๊ต์๋๊ป ๋ค์ ํ ๋ฒ ๊ฐ์ฌ๋๋ฆฌ๋ฉฐ...๐
