์์์ Java OOP ํจ๋ฌ๋ค์์ ๋ํด ์ด์ผ๊ธฐํ ๋ ์ผ๋ฐ์ ์ผ๋ก ๋ถ๋ชจ ํด๋์ค๋ฅผ ์์์, ์ฆ ์์ ํด๋์ค๋ก ํ์ฅํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ๊ทธ๋ฌ๋ Java implements ํค์๋๋ฅผ ๋ฐ๊ฒฌํ๋ฉด ๋ค๋ฅธ ์์ค์ ์ถ์ํ๋ก ์ด๋ํ์ฌ Java์์ ์ธํฐํ์ด์ค ์์
์ ์์ํ๋ค๋ ์๋ฏธ์
๋๋ค. ์ฐ๋ฆฌ๋ ์ธํฐํ์ด์ค๊ฐ ๋ฌด์์ธ์ง, ๋ฌด์์ ์ํ ๊ฒ์ธ์ง, ์ด๋ป๊ฒ ๊ตฌํ๋๋์ง์ ๋ํด ์ด์ผ๊ธฐํ ๊ฒ์
๋๋ค.
์ธํฐํ์ด์ค ๋ฐ ๊ตฌํ์ด๋ ๋ฌด์์ ๋๊น
"์ธํฐํ์ด์ค"๋ผ๋ ๋จ์ด๋ฅผ ๋ง์ด ๋ค์ด๋ณด์ จ์ ๊ฒ์ ๋๋ค. ์๋ฅผ ๋ค์ด ์ปดํจํฐ์๋ ์ ๋ ฅ ์ธํฐํ์ด์ค(๋ง์ฐ์ค ๋ฐ ํค๋ณด๋)๊ฐ ์๊ณ ๋ง์ ํ๋ก๊ทธ๋จ์๋ ์ฌ์ฉ์ ์ธํฐํ์ด์ค๊ฐ ์์ต๋๋ค. ๊ฐ์ฅ ๋์ ์๋ฏธ์์ ์ธํฐํ์ด์ค๋ ์ํธ ์์ฉํ๋ ๋ ๋น์ฌ์ ๊ฐ์ ๋งํฌ์ ๋๋ค. ์๋ฅผ ๋ค์ด ๋์ผํ ํค๋ณด๋ ๋๋ TV ๋ฆฌ๋ชจ์ฝ์ ๋๋ค. ํ๋ก๊ทธ๋๋ฐ, ํนํ Java์์ ์ธํฐํ์ด์ค๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค๊ฐ ์ํํ ์์ ์ ์ง์ ํ๋ ํน์ ๊ณ์ฝ์ ๋๋ค. ์ธํฐํ์ด์ค๋ ๋์๋ง ์ ์ํฉ๋๋ค. ๊ทธ๊ฒ์ ๊ตฌํํ ๊ฐ์ฒด์ ๋ํด์๋ ์๋ฌด ๋ง๋ ํ์ง ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ด Java์์ ์ธํฐํ์ด์ค๋ฅผ ์ ์ธํ ์ ์์ต๋๋ค.public interface MyInterface {
// constants declaration
// methods without implementation
// static methods
// default methods (default)
// private methods
}
๋ค์์ Java ๊ตฌํ ์ ๊ตฌ๋ฌธ์
๋๋ค .
public class MyClass implements MyInterface{
//implementing the methods of MyInterface
//Other code
}
์ธํฐํ์ด์ค๋ ์ง์ ํ์ง ์๊ณ ๋์์ ์ค๋ช
ํฉ๋๋ค. ์๋ฅผ ๋ค์ด "์์ง์"๊ณผ ๊ฐ์ ๋์์ ์์ ๊ฑฐ, ์ฌ๋, ์๋์ฐจ, ๊ฐ์ ๋ฌผ ๋ฑ ๋ค์ํ ์ ํ์ ๊ฐ์ฒด์ ์ ์ฉ๋ ์ ์์ต๋๋ค. ํค์์น๋ ํ๋์ ์ค๋ฆฌ, ๋ฐฐ, ๋ฌผ๊ณ ๊ธฐ์ ํ๋์ด ๋ ์ ์๋ค. ์ด ๋ฌผ์ฒด๋ค์ ์์ง์ด๊ฑฐ๋ ํค์์น ์ ์๋ค๋ ๊ฒ ์ธ์๋ ๊ณตํต์ ์ด ์์ต๋๋ค. ์, ์์๊ณผ์ ์์ง์์ ๋งค์ฐ ๋ค๋ฆ
๋๋ค. ๊ทธ๋ฌ๋ Java์์๋ Duck , Boat , Fish ํด๋์ค๋ฅผ ๋ง๋ค๊ณ ์์ ๊ธฐ๋ฅ์ ๊ตฌํํ๋๋ก ํ ์ ์์ต๋๋ค. ์ฌ๊ธฐ์์ Java ๊ตฌํ ํค์๋๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
ํค์๋ ์ ๊ตฌํ
public interface Swimmable {
void moveForward();
void TurnRight();
void TurnLeft();
}
๋ณด์๋ค์ํผ ๋ฉ์๋ ์์ฒด๋ ๊ตฌํ๋์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ์ด ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค๊ฐ ์ง์ ์ผ๋ก ํค์์น ์ ์์ ๋ฟ๋ง ์๋๋ผ ์ค๋ฅธ์ชฝ๊ณผ ์ผ์ชฝ์ผ๋ก ํ์ ํ ์ ์์ด์ผ ํ๋ค๊ณ ์ ์ธํ์ต๋๋ค. ์ด ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค๋ฅผ ๋ง๋ค์ด ๋ด
์๋ค.
public class Duck implements Swimmable {
//implementing the methods
public void moveForward() {
System.out.println(" Quack, I am moving forward...");
}
public void TurnRight(){
System.out.println("I am turning right...");
}
public void TurnLeft(){
System.out.println("I am turning left...");
}
public void Stop() {
System.out.println("Quack. I am relaxing on the surface of the water...");
}
}
public class Fish implements Swimmable {
public void moveForward() {
System.out.println("I am moving forward...");
}
public void TurnRight(){
System.out.println("I am turning right...");
}
public void TurnLeft() {
System.out.println("I am turning left...");
}
public void turnUp(){
System.out.println("I am turning up...");
}
public void turnDown(){
System.out.println("I am turning down...");
}
public void Stop() {
System.out.println("I am relaxing somewhere under the water surface...");
}
}
Swimmable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ๋ชจ๋ ํด๋์ค๋ ๊ณ์ฝ์ ๋ฐ๋ผ ์์ผ๋ก ํค์์น ์ ์์ด์ผ ํ๊ณ ( moveForward() ๋ฉ์๋ ๊ตฌํ) ์ค๋ฅธ์ชฝ๊ณผ ์ผ์ชฝ์ผ๋ก ํ์ ํ ์ ์์ด์ผ ํฉ๋๋ค. ์ด๋ฌํ ๋ฐฉ๋ฒ์ ๊ตฌํ์ด ํ์ํฉ๋๋ค. ์ค๋ฆฌ์ ๋ฌผ๊ณ ๊ธฐ๋ ๋ค๋ฅด๊ฒ ํค์์น๋ค. ๋ฌผ๊ณ ๊ธฐ๊ฐ ์์๋๋ก ํค์์น ์ ์๋ ๊ธฐ๋ฅ์ ๊ตฌํํ๋ ๋ ๊ฐ์ง ์ถ๊ฐ ๋ฉ์๋๊ฐ ์๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค. Swimmable ์ธํฐํ์ด์ค์๋ ์ด ๊ธฐ๋ฅ์ด ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์๋ฅผ ๋ค์ด Tuna ๋๋ Salmon๊ณผ ๊ฐ์ Fish ํด๋์ค์ ์์์ ๋ง๋ค๋ฉด ๋ชจ๋ "Fish"์ ๋ง์ฐฌ๊ฐ์ง๋ก ์์๋๋ก ํค์์น ์ ์์ต๋๋ค. Java์ ๋ค์ค ์ธํฐํ์ด์ค
์ด๋ฏธ ์๊ณ ๊ณ์๊ฒ ์ง๋ง Java๋ ๋ค์ค ์์์ ์ง์ํ์ง ์์ต๋๋ค. ์ฆ, ํ๋์ ํด๋์ค๋ ํ๋์ ์ํผํด๋์ค์์๋ง ์์๋ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ํด๋์ค๊ฐ ์ฌ๋ฌ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ ์๊ธฐ ๋๋ฌธ์ ์ด๋ค ๋ฐฉ์์ผ๋ก๋ Java์์ "๋ค์ค ์์"์ ์ฌ์ฉํ ์ ์์ต๋๋ค.To implement multiple interfaces, use the next syntax:
interface MyFirstInterface {
public void myMethod();
}
interface MySecondInterface {
public void myOtherMethod();
}
// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
public void myMethod() {
//method implementation
}
public void myOtherMethod() {
//method implementation
}
}
๋ค์ค ์ธํฐํ์ด์ค ์
์ค๋ฆฌ๋ ํค์์น ์ ์์ ๋ฟ๋ง ์๋๋ผ ๋ ์๋ ์๋ค๋ ๊ฒ์ ๊ธฐ์ตํ์ญ์์ค. ๋นํ ์ธํฐํ์ด์ค๋ฅผ ์์ฑํ๊ณ ์ค๋ฆฌ์ ๊ตฌํํด ๋ด ์๋ค.public interface Flyable {
double startAge = 0.1;
void fly();
}
public class Duck implements Swimmable, Flyable {
public void moveForward() {
System.out.println(" Quack, I am moving forward...");
}
public void TurnRight(){
System.out.println("I am turning right...");
}
public void TurnLeft(){
System.out.println("I am turning left...");
}
public void Stop() {
System.out.println("Quack. I am relaxing on the surface of the water...");
}
public void fly(){
System.out.println("I am flying!!!");
}
}
๊ทธ๋ฆฌ๊ณ ๋ค์ ์ธํฐํ์ด์ค๋ฅผ ์์ฑํ๋ ์ด์ ๋ฅผ ๊ธฐ์ตํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์, ๋นํ๊ธฐ, ์ค์นด์ด ๋ค์ด๋ฒ, ๋ฏผ๋ค๋ ์ ์ํด ๊ตฌํ๋๋ค๋ฉด ๊ทธ๋ค์ ๋นํ์ ์์ ํ ๋ค๋ฅผ ๊ฒ์
๋๋ค.
GO TO FULL VERSION