์๋
ํ์ธ์
์ค๋์ ์๋ฐ์ ์ถ์ํด๋์ค(abstract) ์ ์ธํฐํ์ด์ค(Interface) ๊ฐ๋จํ๊ฒ ์์๋ด์
์ฌ๋ฌ๋ถ๋ค ์ ๊ฐ ์ ์ผ ์ข์ํ๋ ์ธ์ด๋ ์๋ฐ์ธ๋ฐ์
๊ทธ ์ค ์ธํฐํ์ด์ค์ ์ถ์ํด๋์ค์ ํท๊ฐ๋ฆฌ๋ ๊ฐ๋ ์ด ๋ง์ ์ ๋ฆฌํด ๋ณด๊ณ ์ ๊ธ ๋จ๊ฒจ๋ด ๋๋ค~
์ ๋ธ๋ก๊ทธ๋ ์์ต ์ฐฝ์ถ์ ํ๊ณ ์์ง ์์ต๋๋ค
์ ๊ฐ ๊ณต๋ถํ๋ฉด์ ํธํ๊ฒ ๋ณด๊ณ ์ ๋ฆฌํ๋ ค๊ณ ๋ง๋ ๋ธ๋ก๊ทธ์ด๋ ๋ถ์กฑํ ์ ์ด ๋ง์ต๋๋ค
๊ถ๊ธํ์ ์ด๋ ์ฝ๋์ ์ค๋ฅ ๋ฐ๊ฒฌํ์๋ฉด ๋๊ธ ๋จ๊ฒจ์ฃผ์ธ์~ ์ธ์ ๋ ํ์์ ๋๋ค
1. ์ถ์ํด๋์ค(abstract class)
- ํ๋ ์ด์์ ์ถ์ ๋ฉ์๋ ํฌํจํ๋ ํด๋์ค
- ์ฆ ์์ฑ๋ ๋ฉ์๋, ๋ฏธ์์ฑ๋ ๋ฉ์๋ ๋ชจ๋ ๊ฐ์ง ์ ์์ <-> ์ธํฐํ์ด์ค๋ ๋ชจ๋ ๋ฉ์๋๊ฐ ์ถ์๋ฉ์๋๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ด์ผ ํจ
- ์ฌ๊ธฐ์ ์์ฑ๋ ๋ฉ์๋๋ ๋ฉ์๋ ์์ { } ์ค๊ดํธ๊ฐ ์๋๊ฒ. => ๊ตฌํ๋ ๊ฒ์ผ๋ก ๋ณธ๋ค
- ์ธ์คํดํธ๋ฅผ ์์ฑํ ์ ์๋ค. ์์ฑ์ ์์ฑ ํ ๋ New ํค์๋ ์ธ ์ ์๋ค๋ ๊ฒ์
- ์ถ์ ํด๋์ค๋ฅผ ์์ ๋ฐ์ ํด๋์ค๋ ๋ฏธ์์ฑ๋ ์ถ์ ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํด์ผ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค.
- ์ถ์๋ฉ์๋๋ ์ค๋ฒ๋ผ์ด๋ฉ์ ์ ์ ๋ก ํ๊ธฐ ๋๋ฌธ์ private ์ผ๋ก ์ ์ธํ ์ ์๋ค.
abstract class Animal {
abstract void makeSound(); // ์ค๊ดํธ ์์ด ์ธ๋ฏธ๋ก์ฝ๋ก ์ผ๋ก ๋๋์ผ ํจ
void breathe() {
System.out.println("Breathe in, breathe out.");
}
}
class Dog extends Animal {
void makeSound() {
System.out.printIn("Bark");
}
}
์ ์ฝ๋ ๊ธฐ๋ฐ์ผ๋ก ๋ฉ์ธ ์์ Animal a = new Animal(); ์์ฑํ ์ ์๋ค
๊ตฌํ์ด ์ ๋ ๋ฏธ์์ฑ ํด๋์ค์ด๊ธฐ ๋๋ฌธ์ด๋ค
Animal a = new Dog();
ํด๋น ์ฝ๋๋ ์ ์ ์๋ํ๋ค. ์๋ํ๋ฉด Dog ํด๋์ค๊ฐ
Animal ์์๋ฐ์์ ๊ตฌํ ํ๊ธฐ ๋๋ฌธ
2. ์ธํฐํ์ด์ค(Interface)
- ๋ชจ๋ ๋ฉ์๋๊ฐ ๊ตฌํ๋์ง ์์ ์ถ์ํด๋์ค์ ๊ทน๋จ
- ํด๋์ค๊ฐ ์ฌ์ฉํ๋ ๋ฉค๋ฒ ๋ณ์์ ๋ฉ์๋์ ์ํ ํ๋ง ์ ๊ณต
- class ํค์๋ ๋์ Interface ํค์๋ ์ฌ์ฉ
- ์ธํฐํ์ด์ค์ ์์์ extends ๊ฐ ์๋ implements ์ฌ์ฉ
- ์ธํฐํ์ด์ค๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค
- ์ธํฐํ์ด์ค๋ฅผ ์์ ๋ฐ์ผ๋ฉด ๋ชจ๋ ๋ฉ์๋๋ฅผ ๊ตฌํํด์ผ ํ๋ค. <<<
01. ๋ค์ ์๋ฐ ํ๋ก๊ทธ๋จ์ด ์ค๋ฅ ์์ด ์คํ๋๊ธฐ ์ํด ๋ฐ์ค ์น ๋ถ๋ถ์ ํ์ํ ํ๋ก๊ทธ๋จ ์ฝ๋๋?
abstract class Test {
int data = 100;
public abstract void printData();
}
class Inner {
Test test = new Test() {
public void printData() {
System.out.println(data);
}
}
public class Main {
public static void main(String[] args) {
Inner inner = new Inner();
___________printData();
}
}
์ ๋ต Inner.test
Inner class ๊ฐ ๊ฐ์ง๊ณ ์๋ ๊ฐ์ฒด test์ ์ ๊ทผ
04. ๋ค์ ์ถ์ํด๋์ค๋ฅผ ์ ์ํ ๋ ๋ฌธ๋ฒ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๋ถ๋ถ์ ๋ชจ๋ ๊ณ ๋ฅด์์ค.
abstract class Person {
private int age; // 1
public String name // 2
abstract public void setAge(int age); // 3
abstract public void setName(String name){}; // 4
private int getAge() { // 5
return this.age;
}
abstract private String getName(); // 6
}
4 : ์ค๊ดํธ๊ฐ ์์ผ๋ฉด ๊ตฌํ๋ ๊ฒ์ผ๋ก ๋ด. ์ถ์๋ฉ์๋๋ ์ค๊ดํธ ์๋ ๋ฉ์๋ ์ํ๋ง ์ฐ๊ณ ; ์ผ๋ก ๋๋์ผ ํจ
6 : ์ถ์๋ฉ์๋์๋ private ํค์๋ ์ธ ์ ์๋ค. ์? ํ์ ํด๋์ค์์ ์์๋ฐ์์ ๊ตฌํํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋จ
private ํ ๋ฉค๋ฒ๋ณ์๋ ์ผ๋ฐ ๋ฉ์๋๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
05. ๋ค์ Java ํ๋ก๊ทธ๋จ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์์ค
Interface A {
int a = 2;
}
class B implements A {
int b;
B(int i) { b = i * a }
int getb() { return b; }
}
class Test {
public static void main(String args[]) {
int a = 3;
B b1 = new B(1);
System.out.println( b1.getb() );
}
}
์ ๋ต : 2
๊ฐ๋จํ๋ฐ ํท๊ฐ๋ฆผ
๋ณ์ ์ด๋ฆ์ด ๊ฐ์ ๊ฒฝ์ฐ main ์์ญ์ ์ง์ญ๋ณ์์ ์ธํฐํ์ด์ค ์์ ๋ณ์ ์ค ์ด๋ค ๊ฐ์ ์ฐธ์กฐํด์ผ ํ๋์ง์ ๋ฌธ์
a = 3 (main ์์ญ์ ์ง์ญ๋ณ์)
์ธ์คํดํธ b1 ์ด ๊ฐ์ง ๋ณ์ a = 2, b = 1*2
์ 3์ด ์๋๊ณ 2์ธ๊ฐ? ํด๋์ค B๊ฐ ์ธํฐํ์ด์ค A๋ฅผ ์์๋ฐ์์ ๊ตฌํํ์ฌ ์ธ์คํด์ค b1์ ์์ฑํ๊ธฐ ๋๋ฌธ์ b1 ์ด ๊ฐ์ง๊ณ ์๋
a ๊ฐ์ ์จ์ผ ํจ.
07. ๋ค์ ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ ๋, ๋ฌธ๋ฒ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๋ถ๋ถ์ ๋ชจ๋ ๊ณ ๋ฅด์์ค.
interface InterfaceA {
int val1 = 0; // 1
private int val2 = 0; // 2
public void up(); // 3
public void down(); // 4
private void left(); // 5
public void right(){}; // 6
1 : ๋ณ์ ์ ์ธ ๊ฐ๋ฅ
2 : private keyword ์๋จ
3 : ๋ฉ์๋ ์ํ ๊ฐ๋ฅ
4 : ๋ฉ์๋ ์ํ ๊ฐ๋ฅ
5 : private keyword ์๋จ
6 : ์ค๊ดํธ ์ฐ๋ฉด ์๋จ. - ๊ตฌํ๋ ๊ฑธ๋ก ๋ณธ๋ค
08. ๋ค์ ์๋ฐ ์ฝ๋๋ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค. ์์ธ์ ๋ํด ์ฝ์ ํ์์ค
interface InterfaceA {
public void up();
public void down();
public void left();
}
class AB implements InterfaceA {
int value = 0;
public void up() {
value++;
}
public void down() {
value--;
}
public static void main(String[] args) {
AB ab = new AB();
ab.up();
ab.down();
}
}
์ ๋ต : AB ํด๋์ค์์ left ๋ฉ์๋๋ฅผ ๊ตฌํํ์ง ์์๊ธฐ ๋๋ฌธ
์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ผ๋ฉด ๋ชจ๋ ๋ฉ์๋๋ฅผ ๊ตฌํํด์ผ ํ๋ค