7. 인터페이스(interface)
   

7.1 인터페이스란?

인터페이스는 일종의 추상클래스이다. 인터페이스는 추상클래스처럼 추상메서드를 갖지만 추상클래스보다 추상화 정도가 높아서 추상클래스와 달리 몸통을 갖춘 일반 메서드 또는 멤버변수를 구성원으로 가질 수 없다. 
오직 추상메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않는다. 
추상클래스를 부분적으로만 완성된 '미완성 설계도'라고 한다면, 인터페이스는 구현된 것은 아무 것도 없고 밑그림만 그려져 있는 '기본 설계도'라 할 수 있다. 

추상클래스처럼 인터페이스도 완성되지 않은 불완전한 것이기 때문에 그 자체만으로 사용되기 보다는 다른 클래스를 작성하는데 도움 줄 목적으로 작성된다. 



7.2 인터페이스의 작성

인터페이스를 작성하는 것은 클래스를 작성하는 것과 같다. 다만 키워드로 class 대신 interface를 사용한다는 것만 다르다. 그리고 interface에도 클래스와 같이 접근제어자로 public 또는 default를 사용할 수 있다. 


interface 인터페이스이름 { 
      public static final 타입 상수이름 = 값; 
      public abstract 메서드이름(매개변수목록); 



일반적인 클래스의 멤버들과 달리 인터페이스의 멤버들은 다음과 같은 제약사항을 가지고 있다. 


- 모든 멤버변수는 public static final 이어야 하며, 이를 생략할 수 있다. 
- 모든 메서드는 public abstract 이어야 하며, 이를 생략할 수 있다. 

[참고]인터페이스에 정의된 모든 멤버에 예외없이 적용되는 사항이기 때문에 제어자를 생략할 수 있는 것이며, 편의상 생략하는 경우가 많다. 생략된 제어자는 컴파일시에 컴파일러가 자동적으로 추가해준다.



interface PlayingCard { 
      public static final int SPADE = 4; 
      final int DIAMOND = 3;             // public static final int DIAMOND=3; 
      static int HEART = 2;             // public static final int HEART=2; 
      int CLOVER = 1;                  // public static final int CLOVER=1; 

      public abstract String getCardNumber(); 
      String getCardKind();       // public abstract String getCardKind();로 간주된다. 






7.3 인터페이스의 상속

interface는 클래스가 아닌 인터페이스로부터만 상속받을 수 있으며, 클래스와는 달리 다중상속, 즉 여러 개의 인터페이스로부터 상속을 받는 것이 가능하다. 
[참고]클래스와는 달리 Object클래스와 같은 모든 인터페이스의 최고조상은 없다.



interface Movable { 
      /** 지정된 위치(x, y)로 이동하는 기능의 메서드 */ 
      void move(int x, int y);       


interface Attackable { 
      /** 지정된 대상(u)을 공격하는 기능의 메서드 */ 
      void attack(Unit u); 


interface Fightable extends Movable, Attackable { } 


클래스에서의 상속과 마찬가지로 자손인터페이스(Fightable)은 조상인터페이스(Movable, Attackable)에 정의된 멤버를 모두 상속받는다. 
그래서 Fightable자체에는 정의된 멤버가 하나도 없지만 조상인터페이스로 부터 상속받은 두 개의 추상메서드, move(int x, int y)와 attack(Unit u)를 멤버로 갖게 된다. 




7.4 인터페이스의 구현

추상클래스에서와 같이 인터페이스의 추상메서드를 몸통을 구현하는 자손클래스를 작성해야한다. 이때는 인터페이스를 '구현(implement)한다'고 하며 키워드 implements를 사용한다. 


class 클래스이름 implements 인터페이스이름 { 
      // 인터페이스에 정의된 추상메서드를 구현해야한다. 


class Fighter implements Fightable { 
      public void move() { /* 내용 생략*/ } 
      public void attack() { /* 내용 생략*/ } 


[참고]이 때 'Fighter클래스는 Fightable인터페이스를 구현한다.'라고 한다.

만일 구현하는 인터페이스의 메서드 중 일부만 구현한다면, 추상클래스로 선언되어야 한다. 


abstract class Fighter implements Fightable { 
     public void move() { /* 내용 생략*/ } 



그리고 다음과 같이 상속과 구현을 동시에 할 수도 있다. 


class Fighter extends Unit implements Fightable { 
      public void move(int x, int y) { /* 내용 생략 */
      public void attack(Unit u) { /* 내용 생략 */


[참고]인터페이스의 이름에는 주로 Fightable과 같이 '~ 를 할 수 있는'의 의미인 'able'로 끝나는 것들이 많은데, 그 이유는 어떠한 기능 또는 행위를 하는데 필요한 메서드를 제공한다는 의미를 강조하기 위해서이다. 또한 그 인터페이스를 구현한 클래스는 '~를 할 수 있는' 능력을 갖추었다는 의미이기도 하다. 
이름이 'able'로 끝나는 것은 인터페이스라고 쉽게 추측할 수 있지만, 모든 인터페이스의 이름이 반드시 'able'로 끝나야 하는 것은 아니다.


[예제7-23] FighterTest.java

class FighterTest 

      public static void main(String[] args) 
      { 
            Fighter f = new Fighter(); 

            if (f instanceof Unit)       {             
                  System.out.println("f는 Unit클래스의 자손입니다."); 
            } 
            if (f instanceof Fightable) {       
                  System.out.println("f는 Fightable인터페이스를 구현했습니다."); 
            } 
            if (f instanceof Movable) {             
                  System.out.println("f는 Movable인터페이스를 구현했습니다."); 
            } 
            if (f instanceof Attackable) {       
                  System.out.println("f는 Attackable인터페이스를 구현했습니다."); 
            } 
            if (f instanceof Object) {             
                  System.out.println("f는 Object클래스의 자손입니다."); 
            } 
      } 


class Fighter extends Unit implements Fightable { 
      public void move(int x, int y) { /* 내용 생략 */
      public void attack(Unit u) { /* 내용 생략 */


class Unit { 
int currentHP;             // 유닛의 체력 
int x;                   // 유닛의 위치(x좌표) 
int y;                   // 유닛의 위치(y좌표) 

interface Fightable extends Movable, Attackable { } 
interface Movable {       void move(int x, int y);       } 
interface Attackable {       void attack(Unit u); } 

[실행결과]
f는 Unit클래스의 자손입니다. 
f는 Fightable인터페이스를 구현했습니다. 
f는 Movable인터페이스를 구현했습니다. 
f는 Attackable인터페이스를 구현했습니다. 
f는 Object클래스의 자손입니다. 

예제에 사용된 클래스와 인터페이스간의 관계를 그려보면 다음과 같다. 

 

실제로 Fighter클래스는 Unit클래스로부터 상속받고 Fightable인터페이스만을 구현했지만, Unit클래스는 Object클래스의 자손이고, Fightable인터페이스는 Movable과 Attackable인터페이스의 자손이므로 Fighter클래스는 이 모든 클래스와 인터페이스의 자손이 되는 셈이다. 
인터페이스는 상속 대신 구현이라는 용어를 사용하지만, 인터페이스로부터 상속받은 추상메서드를 구현하는 것이기 때문에 인터페이스도 조금은 다른 의미의 조상이라고 할 수 있다. 

여기서 주의 깊게 봐두어야 할 것은 Movable인터페이스에 정의된 void move(int x, int y)를 Fighter클래스에서 구현할 때 접근제어자를 public으로 했다는 것이다. 


interface Movable { 
      void move(int x, int y);       


class Fighter extends Unit implements Fightable { 
      public void move(int x, int y) { /* 실제구현내용 생략 */
      public void attack(Unit u) { /* 실제구현내용 생략 */



오버라이딩을 할 때는 조상의 메서드보다 넓은 범위의 접근제어자를 지정해야한다는 것을 기억할 것이다. Movable인터페이스에 void move(int x, int y)와 같이 정의되어 있지만 사실public abstract가 생략된 것이기 때문에 실제로 public abstract void move(int x, int y)이다. 
따라서 이를 구현하는 Fighter클래스에서는 void move(int x, int y)의 접근제어자를 반드시 public으로 해야 하는 것이다.
 




7.5 인터페이스를 이용한 다중상속

두 조상으로부터 상속받는 멤버 중에서 멤버변수의 이름이 같거나 메서드의 선언부가 일치하고 구현 내용이 다르다면 이 두 조상으로부터 상속받는 자손클래스는 어느 조상의 것을 상속받게 되는 것인지 알 수 없다. 어느 한 쪽으로부터의 상속을 포기하던가, 이름이 충돌하지 않도록 조상클래스를 변경하는 수 밖에는 없다. 

자바에서는 이러한 충돌문제를 해결하기 위해서 단일 상속만을 허용하고, 인터페이스를 이용해서 단일 상속의 단점을 보완하도록 하였다. 

인터페이스는 상수만을 정의할 수 있으므로 조상클래스의 멤버변수와 충돌하는 경우는 극히 드물고 추상메서드는 구현내용이 전혀 없으므로 조상클래스의 메서드와 선언부가 일치하는 경우에는 당연히 조상클래스 쪽의 메서드를 상속받으면 되므로 문제되지 않는다. 
이렇게 해서 상속받는 멤버의 충돌은 피할 수 있지만, 다중상속의 장점을 잃게 된다는 것이 아쉽다. 

만일 두 개의 클래스로부터 상속을 받아야 할 상황이라면, 두 조상클래스 중에서 비중이 높은 쪽을 선택하고 다른 한쪽은 클래스 내부에 멤버로 포함시키는 방식으로 처리하거나 어느 한쪽을 필요한 부분을 뽑아서 인터페이스로 만든 다음 구현하도록 한다. 

다음과 같이 Tv클래스와 VCR클래스가 있을 때, TVCR클래스를 작성하기 위해 두 클래스로부터 상속을 받을 수만 있으면 좋겠지만 다중상속을 허용하지 않으므로, 한 쪽만 선택하여 상속받고 나머지 한 쪽은 클래스 내에 포함시켜서 내부적으로 인스턴스를 생성해서 사용하도록 한다. 


public class Tv { 
      protected boolean power; 
      protected int channel; 
      protected int volume; 
      public void power() { power = ! power;} 
      public void channelUp() { channel++;} 
      public void channelDown() { channel--;} 
      public void volumeUp() { volume++;} 
      public void volumeDown() { volume--;} 


public class VCR { 
      protected int counter;             // VCR의 카운터 
      public void play() { 
            // Tape을 재생한다. 
      } 
      public void stop() { 
            // 재생을 멈춘다. 
      } 
     public void reset() {             
           counter =0; 
     } 
     public int getCounter() { 
           return counter; 
     } 
     public void      setCounter(int c) { 
           counter = c; 
     } 



VCR클래스에 정의된 메서드와 일치하는 추상메서드를 갖는 인터페이스를 작성한다. 


public interface IVCR { 
      public void play(); 
      public void stop(); 
      public void reset(); 
     public int getCounter(); 
     public void setCounter(int c); 



이제 IVCR 인터페이스를 구현하고 Tv클래스로부터 상속받는 TVCR클래스를 작성한다. 이때 VCR클래스 타입의 참조변수를 멤버변수로 선언하여 IVCR인터페이스의 추상메서드를 구현하는데 사용한다. 


public class TVCR extends Tv implements IVCR { 
      VCR vcr = new VCR();       
      public void play() { 
            vcr.play();   // 코드를 작성하는 대신 VCR인스턴스의 메서드를 호출하면 된다. 
      } 
      public void stop() { 
            vcr.stop(); 
      } 
      public void reset() { 
           vcr.reset(); 
     } 
     public int getCounter() { 
          return vcr.getCounter(); 
     } 
     public void setCounter(int c) { 
          vcr.setCounter(c); 
     } 


IVCR인터페이스를 구현하기 위해서는 새로 메서드를 작성해야하는 부담이 있지만 이처럼 VCR클래스의 인스턴스를 사용하면 손쉽게 다중상속을 구현할 수 있다. 
또한 VCR클래스의 내용이 변경되어도 변경된 내용이 TVCR클래스에도 자동적으로 반영되는 효과도 얻을 수 있다. 

사실 인터페이스를 새로 작성하지 않고도 VCR클래스를 TVCR클래스에 포함시키는 것만으로도 충분하지만, 인터페이스를 이용하면 다형적 특성을 이용할 수 있다는 장점이 있다. 




7.6 인터페이스를 이용한 다형성

다형성에 대해 학습할 때 자손클래스의 인스턴스를 조상타입의 참조변수로 참조하는 것이 가능하다는 것을 배웠다. 
인터페이스 역시 이를 구현한 클래스의 조상이라 할 수 있으므로 해당 인터페이스 타입의 참조변수로 이를 구현한 클래스의 인스턴스를 참조할 수 있으며, 인터페이스 타입으로의 형변환도 가능하다. 
인터페이스 Fightable을 클래스 Fighter가 구현했을 때, 다음과 같이 Fighter인스턴스를 Fightable타입의 참조변수로 참조하는 것이 가능하다. 


Fightable f = (Fightable)new Fighter(); 
또는 
Fightable f = new Fighter(); 

[참고]물론 Fightable타입의 참조변수로는 인터페이스 Fightable에 정의된 멤버들만 호출이 가능하다.

따라서 인터페이스는 다음과 같이 메서드의 매개변수의 타입으로 사용될 수 있다. 


void attack(Fightable f) { 
     //... 



인터페이스 타입의 매개변수가 갖는 의미는 메서드 호출 시 해당 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공해야한다는 것이다.
그래서 attack메서드를 호출할 때는 매개변수로 Fightable인터페이스를 구현한 클래스의 인스턴스를 넘겨주어야 한다. 


class Fighter extends Unit implements Fightable { 
      public void move(int x, int y) { /* 내용 생략 */
      public void attack(Fightable f) { /* 내용 생략 */


위와 같이 Fightable인터페이스를 구현한 Fighter클래스가 있을 때, attack메서드의 매개변수로 Fighter인스턴스를 넘겨 줄 수 있다. 즉, attack(new Fighter())와 같이 할 수 있다는 것이다. 

그리고 다음과 같이 메서드의 리턴타입으로 인터페이스의 타입을 지정하는 것 역시 가능하다. 


Fightable method() { 
     // ... 
     return new Fighter(); 



리턴타입이 인터페이스라는 것은 메서드가 해당 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 것을 의미한다. 
위의 코드에서는 method()의 리턴타입이 Fightable인터페이스기 때문에 메서드의 return문에서Fightable인터페이스를 구현한 Fighter클래스의 인스턴스를 반환한다.
 

[예제7-24] ParserTest.java

class ParserTest { 
      public static void main(String args[]) { 
            Parseable parser = ParserManager.getParser("XML"); 
            parser.parse("document.xml"); 
            parser = ParserManager.getParser("HTML"); 
            parser.parse("document2.html"); 
      } 


interface Parseable { 
      public abstract void parse(String fileName);       // 구문 분석작업을 수행한다. 


class ParserManager { 
     // 리턴타입이 Parseable인터페이스이다. 
      public static Parseable getParser(String type) {       
            if(type.equals("XML")) { 
               return new XMLParser(); 
            } else { 
               Parseable p = new HTMLParser(); 
               return p; 
               // return new HTMLParser();       위의 두 줄을 간단히 할 수 있다. 
            } 
      } 


class XMLParser implements Parseable { 
      public void parse(String fileName) { 
          /* 구문 분석작업을 수행하는 코드를 적는다. */ 
            System.out.println(fileName + " - XML parsing completed."); 
      } 


class HTMLParser implements Parseable { 
      public void parse(String fileName) { 
          /* 구문 분석작업을 수행하는 코드를 적는다. */ 
            System.out.println(fileName + " - HTML parsing completed."); 
      } 

[실행결과]
document.xml - XML parsing completed. 
document2.html - HTML parsing completed. 

Parseable인터페이스는 구문분석(parsing)을 수행하는 기능을 구현할 목적으로 추상메서드 parse(String fileName)를 정의했다. 그리고 XMLParser클래스와 HTMLParser클래스는 Parseable인터페이스를 구현하였다. 
ParserManager클래스의 getParser메서드는 매개변수로 넘겨받는 type의 값에 따라 XMLParser인스턴스 또는 HTMLParser인스턴스를 반환한다. 

 

getParser메서드의 수행결과로 참조변수 parser는 XMLParser인스턴스의 주소값을 갖게 된다. 마치 Parseable parser = new XMLParser();이 수행된 것과 같다. 


parser.parse("document.xml"); 


참조변수 parser를 통해 parse()를 호출하면, parser가 참조하고 있는 XMLParser인스턴스의 parse메서드가 호출된다. 

만일 나중에 새로운 종류의 XML구문분석기 NewXMLPaser클래스가 나와도 ParserTest클래스는 변경할 필요없이 ParserManager클래스의 getParser메서드에서 return new XMLParser(); 대신 returnnew NewXMLParser();로 변경하기만 하면 된다. 

이러한 장점은 특히 분산환경 프로그래밍에서 그 위력을 발휘한다. 사용자 컴퓨터에 설치된 프로그램을 변경하지 않고, 서버측의 변경만으로도 사용자가 새로 개정된 프로그램을 사용하는 것이 가능하다. 




7.7 인터페이스의 장점

인터페이스를 사용하는 이유와 그 장점을 정리해 보면 다음과 같다. 


- 개발시간을 단축시킬 수 있다. 
- 표준화가 가능하다. 
- 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다. 
- 독립적인 프로그래밍이 가능하다. 


1. 개발시간을 단축시킬 수 있다.
일단 인터페이스가 작성되면, 이를 사용해서 프로그램을 작성하는 것이 가능하다. 메서드를 호출하는 쪽에서는 메서드의 내용에 관계없이 선언부만 알면 되기 때문이다. 
그리고 동시에 다른 한 쪽에서는 인터페이스를 구현하는 클래스를 작성하도록 하여, 인터페이스를 구현하는 클래스가 작성될 때까지 기다리지 않고도 양쪽에서 동시에 개발을 진행할 수 있다. 

2. 표준화가 가능하다.
프로젝트에 사용되는 기본 틀을 인터페이스로 작성한 다음 개발자들에게 인터페이스를 구현하여 프로그램을 작성하도록 함으로써 보다 일관되고 정형화된 프로그램의 개발이 가능하다. 

3. 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다.
서로 상속관계에 있지도 않고, 같은 조상클래스를 가지고 있지 않은 서로 아무런 관계도 없는 클래스들에게 하나의 인터페이스를 공통적으로 구현하도록 함으로써 관계를 맺어 줄 수 있다. 

4. 독립적인 프로그래밍이 가능하다.
인터페이스를 이용하면 클래스의 선언과 구현을 분리 시킬 수 있기 때문에 실제구현에 독립적인 프로그램을 작성하는 것이 가능하다. 클래스와 클래스간의 직접적인 관계를 인터페이스를 이용해서 간접적인 관계로 변경하면, 한 클래스의 변경이 관련된 다른 클래스에 영향을 미치지 않는 독립적인 프로그래밍이 가능하다. 
예를 들어 한 데이터베이스 회사가 제공하는 특정 데이터베이스를 사용하는데 필요한 클래스를 사용해서 프로그램을 작성했다면 이 프로그램은 다른 종류의 데이터베이스를 사용하기 위해서는 전체 프로그램 중에서 데이터베이스 관련된 부분은 모두 변경해야할 것이다. 

그러나 데이터베이스 관련 인터페이스를 정의하고 이를 이용해서 프로그램을 작성하면, 데이터베이스의 종류가 변경되더라도 프로그램을 변경하지 않도록 할 수 있다. 

단, 데이터베이스 회사에서 제공하는 클래스도 인터페이스를 구현하도록 요구해야한다. 데이터베이스를 이용한 응용프로그램을 작성하는 쪽에서는 인터페이스를 이용해서 프로그램을 작성하고, 데이터베이스 회사에서는 인터페이스를 구현한 클래스를 작성해서 제공해야한다.

실제로 자바에는 다수의 데이터베이스 관련 인터페이스를 제공하고 있으며, 프로그래머는 이 인터페이스를 이용해서 프로그래밍을 하면 특정 데이터베이스에 종속되지 않는 프로그램을 작성할 수 있다. 

게임 스타크래프드에 나오는 유닛을 클래스로 표현하고 이들간의 관계를 상속계층도로 표현해 보았다.

 

게임에 나오는 모든 유닛들의 최고 조상은 Unit클래스이고 유닛의 종류는 지상유닛(GoundUnit)과 공중유닛(AirUnit)으로 나뉘어진다.
그리고 지상유닛에는 Marine, SCV, Tank가 있고, 공중유닛으로는 DropShip이 있다. SCV에게 Tank와 DropShip과 같은 기계화 유닛을 수리할 수 있는 기능을 제공하기 위해 repair메서드를 정의한다면 다음과 같을 것이다. 


void repair(Tank t) { 
      // Tank를 수리한다. 


void repair(DropShip d) { 
      // DropShip을 수리한다. 
}


이런 식으로 수리가 가능한 유닛의 개수 만큼 다른 버젼의 오버로딩된 메서드를 정의해야할 것이다.

이것을 피하기 위해 매개변수의 타입을 이 들의 공통 조상으로 하면 좋겠지만 DropShip은 공통조상이 다르기 때문에 공통조상의 타입으로 메서드를 정의한다고 해도 최소한 2개의 메서드가 필요할 것이다.



void repair(GroundUnit gu) { 
      // 매개변수로 넘겨진 지상유닛(GroundUnit)을 수리한다. 


void repair(AirUnit au) { 
      // 매개변수로 넘겨진 공중유닛(AirUnit)을 수리한다. 
}


그리고 GroundUnit의 자손 중에는 Marine과 같이 기계화 유닛이 아닌 클래스도 포함될 수 있기 때문에 repair메서드의 매개변수 타입으로 GroundUnit은 부적합하다.
현재의 상속관계에서는 이들의 공통점은 없다. 이 때 인터페이스를 이용하면 기존의 상속체계를 유지하면서 이들 기계화 유닛에 공통점을 부여할 수 있다.
다음과 같이 Repairable이라는 인터페이스를 정의하고 수리가 가능한 기계화 유닛에게 이 인터페이스를 구현하도록 하면 된다.


interface Repairable {} 

class SCV extends GroundUnit implements Repairable { 
      //... 


class Tank extends GroundUnit implements Repairable 
      //... 


class DropShip extends AirUnit implements Repairable { 
      //... 
}


이제 이 세 개의 클래스에는 같은 인터페이스를 구현했다는 공통점이 생겼다. 인터페이스 Repairable에 정의된 것은 아무것도 없고, 단지 인스턴스의 타입체크에 사용된다.
Repairable인터페이스를 중심으로 상속계층도를 그려보면 다음과 같다.



그리고, repair메서드의 매개변수의 타입을 Repairable로 선언하면, 이 메서드의 매개변수로 Repairable인터페이스를 구현한 클래스의 인스턴스만 받아들여질 것이다.


void repair(Repairable r) { 
      // 매개변수로 넘겨받은 유닛을 수리한다. 
}


앞으로 새로운 클래스가 추가될 때, SCV의 repair메서드에 의해서 수리가 가능하도록 하려면 Repairable인터페이스를 구현하도록 하면 될 것이다. 

[예제7-25] RepairableTest.java

class RepairableTest 

      public static void main(String[] args) 
      { 
            Tank t = new Tank(); 
            DropShip d = new DropShip(); 

            Marine m = new Marine(); 
            SCV       s = new SCV(); 

            s.repair(t);       // SCV가 Tank를 수리하도록 한다. 
            s.repair(d); 
//             s.repair(m);       에러발생 : repair(Repairable) in SCV cannot be applied to (Marine) 
      } 


interface Repairable {} 
class GroundUnit extends Unit { 
      GroundUnit(int hp) { 
            super(hp); 
      } 


class AirUnit extends Unit { 
      AirUnit(int hp) { 
            super(hp); 
      } 


class Unit { 
      int hitPoint; 
      final int MAX_HP; 
      Unit(int hp) { 
            MAX_HP = hp; 
      } 
      //... 


class Tank extends GroundUnit implements Repairable { 
      Tank() { 
            super(150);             // Tank의 HP는 150이다. 
            hitPoint = MAX_HP; 
      } 

      public String toString() { 
            return "Tank"
      } 
      //... 


class DropShip extends AirUnit implements Repairable { 
      DropShip() { 
            super(125);             // Dropship의 HP는 125이다. 
            hitPoint = MAX_HP; 
      } 

      public String toString() { 
            return "DropShip"
      } 
      //... 


class Marine extends GroundUnit { 
      Marine() { 
            super(40); 
            hitPoint = MAX_HP; 
      } 
      //... 



class SCV extends GroundUnit implements Repairable{ 
      SCV() { 
            super(60); 
            hitPoint = MAX_HP; 
      } 

      void repair(Repairable r) { 
            if (r instanceof Unit) { 
                  Unit u = (Unit)r; 
                  while(u.hitPoint!=u.MAX_HP) { 
                        /* Unit의 HP를 증가시킨다. */ 
                        u.hitPoint++; 
                  } 
                  System.out.println( u.toString() + "의 수리가 끝났습니다."); 
            } 
      }       
      //... 
}
[실행결과]
Tank의 수리가 끝났습니다.
DropShip의 수리가 끝났습니다.


repair메서드의 매개변수 r은 Repairable타입이기 때문에 인터페이스 Repairable에 정의된 멤버만 사용할 수 있다.
그러나 Repairable에는 정의된 멤버가 없으므로 이 타입의 참조변수로는 할 수 있는 일은 아무 것도 없다.
그래서 instanceof연산자로 타입을 체크한 뒤 캐스팅하여 Unit클래스에 정의된 hitPoint와 MAX_HP를 사용할 수 있도록 하였다.
그 다음엔 유닛의 현재체력(hitPoint)이 유닛이 가질 수 있는 최고체력(MAX_HP)이 될 때까지 체력을 증가시키는 작업을 수행한다.

 Marine은 Repairable인터페이스를 구현하지 않았으므로 SCV클래스의 repair메서드의 매개변수로 Marine을 사용하면 컴파일 시에 에러가 발생한다.

이와 유사한 예를 한가지 더 들어보자. 게임 스타크래프트에 나오는 건물들을 클래스로 표현하고 이들의 관계를 상속계층도로 표현하였다.



건물을 표현하는 클래스 Academy, Bunker, Barrack, Factory가 있고 이들의 조상인 Building클래스가 있다고 하자. 이 때 Barrack클래스와 Factory클래스에 다음과 같은 내용의, 건물을 이동시킬수 있는, 새로운 메서드를 추가하고자 한다면 어떻게 해야할까? 


void liftOff() { /* 내용생략 */
void move(int x, int y) { /* 내용생략 */
void stop() { /* 내용생략 */
void land() { /* 내용생략 */}


Barrack클래스와 Factory클래스 모두 위의 코드를 적어주면 되긴 하지만, 코드가 중복된다는 단점이 있다. 그렇다고 해서 조상클래스인 Building클래스에 코드를 추가해주면, Building클래스의 다른 자손인 Academy와 Bunker클래스도 추가된 코드를 상속받으므로 안된다.
이런 경우에도 인터페이스를 이용해서 해결할 수가 있다. 우선 새로 추가하고자하는 메서드를 정의하는 인터페이스를 정의하고 이를 구현하는 클래스를 작성한다. 

interface Liftable { 
     /** 건물을 들어 올린다. */ 
     void liftOff(); 
     /** 건물을 이동한다. */ 
     void move(int x, int y); 
     /** 건물을 정지시킨다. */ 
     void stop(); 
     /** 건물을 착륙시킨다. */ 
     void land(); 


class LiftableImpl implements Liftable { 
     void liftOff() { /* 내용 생략 */
     void move(int x, int y) { /* 내용 생략 */ } 
     void stop() { /* 내용 생략 */ } 
     void land() { /* 내용 생략 */ } 



마지막으로 새로 작성된 인터페이스와 이를 구현한 클래스를 Barrack과 Factory클래스에 적용하면 된다. 


class Barrack extends Buildings implments Liftable { 
     LiftableImpl l = new LiftableImpl(); 
     void liftOff() { l.liftOff();} 
     void move(int x, int y) { l.move(x, y);} 
     void stop() { l.stop();} 
     void land() { l.land();} 
     void trainMarine() { /* 내용 생략 */ } 
     void trainMedic() { /* 내용 생략 */ } 
          // ... 


class Factory extends Buildings implments Liftable { 
     LiftableImpl l = new LiftableImpl(); 
     void liftOff() { l.liftOff();} 
     void move(int x, int y) { l.move(x, y);}      

     void stop() { l.stop();} 
     void land() { l.land();} 
     void trainMarine() { /* 내용 생략 */ } 
     void trainMedic() { /* 내용 생략 */ } 
     // ... 


Barrack클래스가 Liftable인터페이스를 구현하도록 하고, 인터페이스를 구현한 LiftableImpl클래스를 Barrack클래스에 포함시켜서 내부적으로 호출해서 사용하도록 한다.
이렇게 함으로써 같은 내용의 코드를 Barrack클래스와 Factory클래스에서 각각 작성하지 않고 LiftableImpl클래스 한 곳에서 관리할 수 있다. 그리고 작성된 Liftable인터페이스와 이를 구현한 LiftableImpl클래스는 후에 다시 재사용될 수 있을 것이다.

 





7.8 인터페이스의 이해


지금까지 인터페이스의 특징과 구현하는 방법, 장점 등 인터페이스에 대한 일반적인 사항들에 대해서 모두 살펴보았다. 하지만 '인터페이스란 도대체 무엇인가?'라는 의문은 여전히 남아있을 것이다. 이번 절에서는 인터페이스의 규칙이나 활용이 아닌, 본질적인 측면에 대해 살펴보자.

먼저 인터페이스를 이해하기 위해서는 다음의 두가지 사항을 반드시 염두에 두고 있어야 한다. 


- 클래스를 사용하는 쪽(User)과 클래스를 제공하는 쪽(Provider)이 있다.
- 메서드를 사용(호출)하는 쪽(User)에서는 사용하려는 메서드(Provider)의 
선언부만 알면 된다.(내용은 몰라도 된다.)


다음과 같이 클래스 A와 클래스 B가 있다고 하자. 


class A { 
      public static void main(String args[]) { 
            B b = new B(); 
            b.methodB(); 
      } 


class B { 
      public void methodB() { 
            System.out.println("methodB()"); 
      } 



클래스 A(User)는 클래스 B(Provider)의 인스턴스를 생성하고 메서드를 호출한다. 이것을 간단히 'A-B'라고 표현하자. 이 두 클래스는 서로 직접적인 관계에 있다.


이 경우 클래스 A를 작성하기 위해서는 클래스 B가 이미 작성되어 있어야 한다. 그리고 클래스 B의 methodB()의 선언부가 변경되면, 이를 사용하는 클래스 A도 변경되어야 한다.
이와 같이 직접적인 관계의 두 클래스는 한 쪽(Provider)가 변경되면 다른 한 쪽(User)도 변경되어야 한다는 단점이 있다.

그러나 클래스 A가 클래스 B를 직접 호출하지 않고 인터페이스를 매개체로 해서 클래스 A가 인터페이스를 통해서 클래스 B의 메서드에 접근하도록 하면, 클래스 B에 변경사항이 생기거나 클래스 B와 같은 기능의 다른 클래스로 대체 되어도 클래스 A는 전혀 영향을 받지 않도록 하는 것이 가능하다.

두 클래스간의 관계를 간접적으로 변경하기 위해서는 먼저 인터페이스를 이용해서 클래스 B(Provider)의 선언과 구현을 분리해야한다.

먼저 다음과 같이 클래스 B에 정의된 메서드를 추상메서드로 정의하는 인터페이스 I를 정의한다.


interface I { 
     public abstract void methodB(); 



그 다음에는 클래스 B가 인터페이스 I를 구현하도록 한다. 


class B implements I 
     public void methodB() { 
           System.out.println("methodB in B class"); 
      } 



이제 클래스 A는 클래스 B 대신 인터페이스 I를 사용해서 작성할 수 있다.


class A { 
      public void methodA(I i) { 
            i.methodB(); 
      } 
}

[참고]methodA가 호출될 때 인터페이스 I를 구현한 클래스의 인스턴스(클래스 B의 인스턴스)를 제공받아야 한다.

클래스 A를 작성하는데 있어서 클래스 B가 사용되지 않았다는 점에 주목하자. 이제 클래스 A와 클래스 B는 'A-B'의 직접적인 관계에서 'A-I-B'의 간접적인 관계로 바뀐 것이다.



결국 클래스 A는 여전히 클래스 B의 메서드를 호출하지만, 클래스 A는 인터페이스 I하고만 직접적인 관계에 있기 때문에 클래스 B의 변경에 영향을 받지 않도록 하는 것이 가능하다.
클래스 A는 인터페이스를 통해 실제로 사용하는 클래스의 이름을 몰라도 되고 심지어는 실제로 구현된 클래스가 존재하지 않아도 문제되지 않는다.

클래스 A는 직접적인 관계에 있는 인터페이스 I의 영향만을 받는다. 

 

인터페이스 I는 실제구현 내용(클래스 B)을 감싸고 있는 껍데기이며, 클래스 A는 껍데기 안에 어떤 알맹이(클래스)가 들어 있는지 몰라도 된다.

[예제7-26] InterfaceTest.java

class A { 
      void autoPlay(I i) { 
            i.play(); 
     } 


interface I { 
      public abstract void play(); 


class B implements I { 
     public void play() { 
            System.out.println("play in B class"); 
      } 


class C implements I { 
     public void play() { 
            System.out.println("play in C class"); 
      } 


class InterfaceTest { 
      public static void main(String[] args) { 
            A a = new A(); 
            a.autoPlay(new B()); 
            a.autoPlay(new C()); 
      } 


[실행결과]
play in B class
play in C class
[참고]클래스 A를 작성하는데 클래스 B가 관련되지 않았다는 사실에 주목한다.

클래스 A가 인터페이스 I를 사용해서 작성되긴 하였지만, 이처럼 매개변수를 통해서 인터페이스 I를 구현한 클래스의 인스턴스를 동적으로 제공받아야 한다.
클래스 Thread의 생성자인 Thread(Runnable target)와 AWT컴포넌트의 addActionListener(ActionListener l)가 이런 방식으로 되어 있다.
[참고]Runnable과 ActionListener는 인터페이스이다.

이처럼 매개변수를 통해 동적으로 제공받을 수 도 있지만 다음과 같이 다른 제 3의 클래스를 통해서 제공받을 수도 있다. JDBC의 DriverManager클래스가 이런 방식으로 되어 있다.

[예제7-27] InterfaceTest2.java

class InterfaceTest2 { 
      public static void main(String[] args) { 
            A a = new A(); 
            a.methodA(); 
      } 


class A { 
      void methodA() { 
           I i = InstanceManager.getInstance(); 
            i.methodB(); 
      } 


interface I { 
      public abstract void methodB(); 


class B implements I { 
      public void methodB() { 
           System.out.println("methodB in B class"); 
      } 


class InstanceManager { 
      public static I getInstance() { 
            return new B(); 
      } 

[실행결과]
methodB in B class

출처 -  http://cafe.naver.com/javachobostudy 


'Development > Java' 카테고리의 다른 글

java 바이트코드 컨트롤 및 분석 - ASM  (0) 2012.03.19
패키지 이름 정의  (0) 2012.03.18
인터페이스(interface)  (0) 2012.03.18
DAO, DTO, VO  (2) 2012.03.16
Thread pool  (0) 2012.03.16
java 어노테이션(Annotation)  (0) 2012.03.14
Posted by linuxism