โ 1. ์ถ์ํด๋์ค
public abstract class Animal {
public abstract void run(); // ์ถ์ ๋ฉ์๋
public void eat() { // ์ผ๋ฐ ๋ฉ์๋
System.out.println("This animal eats food.");
}
}
- ์ถ์ ํด๋์ค๋ class ์์ abstract ํค์๋๋ฅผ ๋ถํ ํด๋์ค๋ฅผ ์๋ฏธํ๋ค.
- abstract ํค์๋๋ฅผ ๋ช ์ํ๋ฉด ํด๋น ํด๋์ค๋ ๊ฐ์ฒด ์์ฑ์ด ๋ถ๊ฐ๋ฅํ ํด๋์ค๊ฐ ๋๋ฉฐ, ์์์ผ๋ก๋ง ์ด์ฉ์ด ๊ฐ๋ฅํด์ง๋ค.
- ์ถ์ํด๋์ค ๋ด๋ถ์๋ ๋ฉค๋ฒ ๋ณ์๋ฅผ ๊ฐ์ง ์ ์๋ค.
- ์ถ์ํด๋์ค์๋ ์ถ์๋ฉ์๋, ์ผ๋ฐ๋ฉ์๋ ๋ ๋ค ๋ง๋ค ์ ์๋ค.
- ๊ตฌํ ํด๋์ค๊ฐ ์์์ ๋ฐ๊ฒ๋๋ฉด, ์ถ์ ๋ฉ์๋๋ ๋ฐ๋์ ๊ตฌํ์ ํด์ผํ๊ณ , ์ผ๋ฐ ๋ฉ์๋๋ ์์๊ณผ ๋์ผํ ๊ตฌ์กฐ๋ฅผ ๊ฐ๋๋ค.
- ๋ง์ง๋ง์ผ๋ก, ์ถ์ํด๋์ค๋ extends๋ฅผ ํ์ฉํ ์์ ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์, ๋จ์ผ ์์๋ง ๊ฐ๋ฅํ๋ค
์ฐธ๊ณ ์ฌํญ
- ์ถ์ํด๋์ค๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์์๋ง ๊ฐ๋ฅํ๊ณ new ๊ฐ์ฒด ์์ฑ์ด ๋ถ๊ฐ๋ฅํ์ง๋ง, ์์ฑ์๋ ๊ฐ์ง ์ ์์.
- ์ด์ ๋, ์ถ์ํด๋์ค๋ ํ๋์ ๋ฉค๋ฒ๋ณ์๋ฅผ ๊ฐ์ง ์ ์์ผ๋ฏ๋ก, ์์ฑ์๋ฅผ ํตํด ํ๋๋ฅผ ์ด๊ธฐํ ํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
- ์ฆ, ์์ํด๋์ค์ ํ๋์ ๊ฐ์ ๋ฃ๊ธฐ ์ํด์ ์์ฑ์๋ฅผ ์ด์ฉํด ๊ฐ์ ์ด๊ธฐํ ํ ๋ ์ฌ์ฉ์ด ๋๋ค.
์ถ์ ํด๋์ค ์ฌ์ฉ ์ด์
- ์ฌ๋ฌ ๊ด๋ จ ํด๋์ค๋ค์ด ๊ณตํต์ผ๋ก ๊ฐ์ ธ์ผ ํ ๋ฉ์๋์ ํ๋๋ฅผ ์ ์ํ ๋ ์ฌ์ฉ์ด ๋๋ค.
- ์ถ์ ํด๋์ค๋ ๊ฐ์ฒด ์์ฑ์ด ๋ถ๊ฐ๋ฅํ๊ธฐ์ ๋ฌด์กฐ๊ฑด ์์์ ๋ฐ์์ผํ๋ ๊ตฌ์กฐ๊ฐ ํ์ฑ์ด ๋๋ค.
- ์ด๋ง์์ฆ์จ, ์์์ ๋ฌด์กฐ๊ฑด ๋ฐ๊ฒ ํ์ฌ, ์ค๊ณ๋ฅผ ๋ช ํํ ํ๊ณ , ์ผ๊ด๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ ํ๊ฒ ํ๊ธฐ ์ํด์ ์ฌ์ฉ์ด ๋๋ค๋ ๋ง์ด๋ค.
โ 2. ์ถ์๋ฉ์๋
public abstract class Animal {
public abstract void run(); // ์ถ์ ๋ฉ์๋
public void eat() { // ์ผ๋ฐ ๋ฉ์๋
System.out.println("This animal eats food.");
}
}
- abstract ํค์๋๊ฐ ๋ถ์ ๋ฉ์๋๋ฅผ ์๋ฏธํ๋ค.
- ์ถ์ํด๋์ค ๋ด๋ถ์์๋ง ์ถ์๋ฉ์๋๋ฅผ ๋ง๋ค ์ ์์ผ๋ฉฐ, ์ผ๋ฐ ํด๋์ค์์ ๋ง๋ค๋ ค๊ณ ํ๋ฉด ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฌ๋ค.
- ๊ตฌํํ๋ ํ์ ํด๋์ค๊ฐ ์ถ์๋ฉ์๋๋ฅผ ๋ฐ๋์ ๊ตฌํ์ ํด์ค์ผํ๋ฉฐ, ๊ตฌํ์ ์ํ๋ฉด ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฌ๋ค.
- ํ์ํด๋์ค๊ฐ ์ถ์ํด๋์ค์ผ ๊ฒฝ์ฐ ์ถ์๋ฉ์๋๋ฅผ ๊ตฌํ์ ํด๋ ๋๊ณ ์ํด๋ ๋๋ค.
- ๋ง์ฝ ์ํ๊ฒ ๋๋ค๋ฉด ๊ตฌํ ํด๋์ค ์ฆ, ์์์ ๋ฐ๋ ํ์ ํด๋์ค๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ์๋ ๋ฐ๋์ ํด์ค์ผ ํ๋ค.
์ฐธ๊ณ ์ฌํญ
- private ์ ๊ทผ ์ ์ด์๋ ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค.
- ๋ํดํธ ์ ๊ทผ ์ ์ด์๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํ์ง๋ง, ํด๋น ํจํค์ง ๋ด๋ถ์ ์์ผ๋ฉด ์์ ๋ฐ๋ ํด๋์ค์์ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ธ.
- protected ์ ๊ทผ ์ ์ด์๋ ์์์ ๋ฐ๋์ ๋ฐ๊ธฐ ๋๋ฌธ์ ์ค๋ฅ ์์ด ์ด์ฉ์ด ๊ฐ๋ฅํ๋ค.
โ 3. ์ธํฐํ์ด์ค
public interface A {
void hello();
default void defaultMethod() {
System.out.println("default method");
}
static void staticMethod() {
System.out.println("static method");
}
}
- ํด๋์ค๊ฐ ๊ตฌํํด์ผ ํ ๊ธฐ๋ฅ์ ๋ช ์ธ ์ฆ, ๋ฉ์๋๋ฅผ ์ ์ํ๋ ์ถ์์ ์ธ ํ์ ์ ์๋ฏธํ๋ค.
- ์ธํฐํ์ด์ค๋ ์ด ๋ฉ์๋๋ค์ ๋ฐ๋์ ๊ตฌํํด์ผ ํ๋ค ๋ผ๋ ๊ท์น์ ์ ํด ๊ตฌํ์ ๊ฐ์ ํ ํ๊ธฐ ์ํ ๋๊ตฌ์ด๋ค.
- ์ธํฐํ์ด์ค์๋ ์์ฑ์๊ฐ ์์ผ๋ฉฐ, ๋ค์ค ์์์ด ๊ฐ๋ฅํ๋ค.
ํน์ง
- ๊ตฌํํ๋ ํด๋์ค์์ implements ํค์๋๋ฅผ ์ด์ฉํด ๊ตฌํ์ ํ ์ ์๋ค.
- ๊ธฐ๋ณธ์ ์ผ๋ก class ๋์ interface ํค์๋๋ฅผ ์ด์ฉํด ํด๋์ค๋ฅผ ๋ช ์ํด์ ๋ง๋ค ์ ์๋ค.
- ์ธํฐํ์ด์ค์๋ ์์ฑ์๊ฐ ์์ผ๋ฉฐ, ๋ค์ค ์์ ์ฆ, ๋ค์ค ๊ตฌํ์ด ๊ฐ๋ฅํ๋ค.
- ๋ฉ์๋๋ ์ด 3๊ฐ ์ถ์๋ฉ์๋, default ์ธ์คํด์ค ๋ฉ์๋, static ํด๋์ค ๋ฉ์๋๋ฅผ ๋ง๋ค ์ ์๋ค.
- ์ธํฐํ์ด์ค์์๋ ๋ฉค๋ฒ ๋ณ์ ์ฆ, ํ๋์ ๋ณ์๋ฅผ ์ ์ธ ํ ์ ์๋ค.
์ฐธ๊ณ ์ฌํญ
- ์ฌ์ค interface ํค์๋ ์์ abstract ํค์๋๊ฐ ์กด์ฌํ๋ฉฐ, ํด๋น ๋ถ๋ถ์ ์๋ต ํ ์ ์์ผ๋ฉฐ, ์ปดํ์ผ ๋ ์๋์ผ๋ก ๋ค์ด๊ฐ๋ค.
- ๋ชจ๋ ๋ฉ์๋์๋ public ์ ๊ทผ ์ ์ด์๋ง์ด ๋ค์ด๊ฐ๊ฒ ๋๋ค. ์ด ๋ถ๋ถ์ ์๋ต์ด ๊ฐ๋ฅํ๋ฉฐ, ์๋์ผ๋ก ๋ค์ด๊ฐ๋ค.
- ์ถ์ ๋ฉ์๋์๋ ์๋์ผ๋ก abstract ํค์๋๊ฐ ๋ถ๊ฒ ๋๋ค. ๋ถํ๋ ๋๊ณ ์๋ถํ๋ ๋๋ค.
- ์ธํฐํ์ด์ค์ ์ด๋ฆ์ ๋ณดํต ํ์ฉ์ฌ๋ก ์ด๋ค. ์ฆ, ํ์ฉ์ฌ์ ํํ๋ก์จ ์ด์ฉ์ ํ๋๊ฒ ์ผ๋ฐ์ ์ด๋ค.
โ 4. default ํค์๋ ( ๋ฉ์๋ )
- ํ์ฌ ์๋ฐ์์ default ํค์๋๋ ์ธํฐํ์ด์ค์์๋ง ์ฌ์ฉ์ ํ ์ ์๋ ํค์๋์ด๋ค.
- defaultํค์๋๋ ์ธํฐํ์ด์ค ๋ด๋ถ์ ์ธ์คํด์ค ๋ฉ์๋ ์ฆ, ๊ตฌํ ๋ฉ์๋๋ฅผ ๋ง๋ค ๋ ์ฌ์ฉ์ด ๋๋ค.
public interface A {
public default void defaultMethod() {
System.out.println("default A");
}
}
// case 1
public class B implements A {
// ๋ฉ์๋๋ฅผ ์ฌ์ ์ ํ์ง ์์๋ ๋ด๋ถ์์ ํธ์ถ์ด ๊ฐ๋ฅ
public void test() {
defaultMethode(); // ์ค๋ฅx
}
}
// case 2
public class B implements A {
// ์ฌ์ ์ ๋ํ ๊ฐ๋ฅํจ.
@Override
public void defaultMethod() {
System.out.println("overring defaultMethod");
}
}
- default ๋ฉ์๋๋ ๊ตฌํ ๊ณผ์ ์์ ํ๋์ ํด๋์ค๋ง ์์์ ๋ฐ์ผ๋ฉด, ์์๊ณผ ๋์ผํ๊ฒ ๋ฉ์๋๋ฅผ ํ์ํด๋์ค์ ํฌํจ์์ผ์ค๋ค.
(1) interface ๋ค์ค ์์ ์ผ์ด์ค์ผ ๊ฒฝ์ฐ default ๋ฉ์๋
public interface A {
public default void defaultMethod() {
System.out.println("default A");
}
}
public interface B {
public default void test() {
System.out.println("default B");
}
}
// case 1 : ์ง์ ์ฌ์ ์ํด์ ๊ตฌํ์ ํ๋ ๋ฐฉ์
public class C implements A, B {
@Override
public void defaultMethod() {
System.out.println("overring defaultMethod");
}
}
// case 2 : ์์ ํด๋์ค ์ด๋ค ๋ฉ์๋๋ฅผ ํธ์ถํ ์ง ์ง์ ๋ช
์ํ๋ ๋ฐฉ์
public class C implements A, B {
@Override
public void defaultMethod() {
A.super.defaultMethod(); // A ํด๋์ค์ ๋ฉ์๋ ํธ์ถ
B.super.defaultMethod(); // B ํด๋์ค์ ๋ฉ์๋ ํธ์ถ
// ํ๋ ๋๋ ๋ ๋ค ํธ์ถ์ด ๊ฐ๋ฅํ๋ค๋ ํน์ง์ด ์์.
}
}
- ๋ค์ค ์์์ ๋ฐ๋ ๊ณผ์ ์์ ๋์ผํ ๋ํดํธ ๋ฉ์๋๋ฅผ ์์ ๋ฐ์ ๋๋ ๋ฐ๋์ ์ฌ์ ์(Overriding)์ ํด์ผํ๋ค.
- ์ด์ ๋, ์ปดํ์ผ๋ฌ๊ฐ ๋ค์ค ์์๊ณผ์ ์์ ์ด๋ค ๋ฉ์๋๋ฅผ ์๋ ํฌํจ์์ผ์ค์ง ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์ ์ง์ ์ฌ์ ์ํด์ ๋ช ์ํด์ผ ํ๋ค.
- ์ฌ์ ์ํ ๋ฉ์๋ ๋ด๋ถ์ ์์ ์ฝ๋์ ๊ฐ์ด ๋ฉ์๋๋ฅผ ํธ์ถ ํ ์ ์๊ณ , ๋๋ ์ฌ์ ์๋ก ๋ฎ์ด๋ฒ๋ฆด ์ ์๋ค.
(2) default ๋ฉ์๋ ์ฌ์ฉ์ด์
- ์ธํฐํ์ด์ค๋ ๊ตฌํ์ ๊ฐ์ ํ๋ค. ์ฆ, ๊ตฌํ์ ํ์ง ์์ผ๋ฉด ์ปดํ์ผ ๊ณผ์ ์์ ์๋ฌ๋ฅผ ๋ด๋ฑ๋๋ค๋ ์๋ฏธ์ด๋ค.
- ์ด๋ฌํ ๊ณผ์ ๋๋ฌธ์ ๊ฐ๋ฐ์๊ฐ ์ธํฐํ์ด์ค์ ์ฝ๋๋ฅผ ์ถ๊ฐํ ๊ฒฝ์ฐ ๊ธฐ์กด์ ๊ตฌํํ๊ณ ์๋ ํด๋์ค์๋ ์ค๋ฅ๋ฅผ ๋ด๋ฑ๋๋ค.
- ์ด๋ ๊ธฐ ๋๋ฌธ์ default ๋ฉ์๋๋ฅผ ํ์ฉํด์ ๋ฐ๋์ ๊ตฌํ์ ํ์ง ์์๋ ํฌํจ์ด ๋ ์ ์๋๋ก ํ๋ฉด ์ค๋ฅ๊ฐ ๋์ง ์๋๋ค.
- ์์ธ ์ผ์ด์ค๋ก๋ ๋ค์ค ์์์ ๋ฐ๋๋ฐ, ๋์ผํ ๋ฉ์๋๊ฐ ์๋ ๊ฒฝ์ฐ๋ก ์ด๋๋ ์ง์ ๊ตฌํ ํด๋์ค ์์ ์ ํด์ผํ๋ค.
'โJava > ๐Java Programming' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์ต๋ช ํด๋์ค(Anonymous Class) (1) | 2025.05.22 |
---|---|
[Java] ๋คํ์ฑ(polymorphism) (1) | 2025.05.22 |
[Java] Enum ์ฝ๊ฒ ์ดํดํ๊ธฐ (1) | 2025.05.05 |
[Java] JVM๊ณผ ์๋ฐ ์คํ ์๋ฆฌ (1) | 2025.04.14 |
[Java] Java์ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ด๋? (0) | 2025.03.06 |