인터페이스(Interface)

  JDK1.8부터 디폴트 메서드와 static 메서드도 인터페이스에서 사용할 수 있게 되었다.

  일단은 JDK1.8 이전의 인터페이스에 대해서 먼저 살펴보고, 그리고 JDK1.8에서 추가된 기능(디폴트 메서드, static 메서드)과 Java9부터 사용할 수 있는 private 메서드에 대해서 살펴보는 것으로 하자.

 

 

📙 1. 인터페이스란

  인터페이스란 일종의 추상클래스이다. 인터페이스는 추상클래스처럼 추상메서드를 갖지만 추상클래스보다 추상화 정도가 높아서 추상클래스와 달리 몸통을 갖춘 일반 메서드 또는 멤버변수를 구성원으로 가질 수 없다. 오직 추상메서드와 상수만을 멤버로만 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않는다.

 

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

 

 

📙 2. 인터페이스의 사용법

📌 1. 인터페이스 작성

public interface PlayingCard {

    public static final int SPADE = 4;

    public abstract String getCardNumber();
}

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

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

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

public 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 DIAMOND = 1;

    public abstract String getCardNumber();
    String getCardKind(); // public abstract String getCardKind();
}

📌 2. 구현

  인터페이스도 추상클래스처럼 상속받은 자손클래스가 오버라이딩을 통해 추상 메서드를 구현함으로써 사용할 수 있다. 다만 클래스는 확장한다는 의미의 키워드 'extends'를 사용하지만 인터페이스는 구현한다는 의미의 키워드 'implements'를 사용할 뿐이다.

public interface Movable {

    void move(int x, int y);
}

public class Player implements Movable {

    @Override
    public void move(int x, int y) {
        System.out.println("(" + x + ", " + y + ") 로 움직인다!");
    }
}

public static void main(String[] args) {
    Player player = new Player();
    player.move(1, 2); // (1, 2) 로 움직인다!
}

  한 가지 주의할 점은 move()를 오버라이딩할 때 접근 제어자를 반드시 public으로 해야 한다. Movable에서 'void move(int x, int y)'라고 선언하였지만 'public abstract'가 생략된 것이기 때문에 실제로는 'public abstract void move(int x, int y)'이다.

  오버라이딩 할 때는 조상의 메서드보다 넓은 범위의 접근 제어자를 지정해야 하기 때문에 move()를 구현할 때에는 접근 제어자를 반드시 public으로 해야 한다는 것이다.

📌 3. 상속

  인터페이스는 인터페이스로부터만 상속받을 수 있으며, 클래스와는 달리 다중상속, 즉 여러 개의 인터페이스로부터 상속을 받는 것이 가능하다. 

public interface Movable {

    void move(int x, int y);
}

public interface Attackable {

    void attack(Unit u);
}

public interface Fightable extends Movable, Attackable { }

 

 

📙 3. 인터페이스의 장점

📌 1. 표준화가 가능하다.

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

📌 2. 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다.

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

public interface Repairable { }

class SCV extends GroundUnit implements Repairable { }
class Tank extends GroundUnit implements Repairable { }
class Dropship extends AirUnit implements Repairable { }

  GroundUnit인 SCV와 Tank, 그리고 AirUnit인 DropShip이 서로 관계가 없는 클래스이지만 Repairable 인터페이스를 통해서 수리가 가능한 유닛이라고 관계를 맺어줄 수 있다.

 

📌 3. 독립적인 프로그래밍이 가능하다.

  인터페이스를 이용하면 클래스의 선언과 구현을 분리시킬 수 있기 때문에 실제구현에 독립적인 프로그램을 작성하는 것이 가능하다. 

  클래스와 클래스 간의 직접적인 관계를 인터페이스를 이용해서 간접적인 관계로 변경하면, 한 클래스의 변경이 관련된 다른 클래스에 영향을 미치지 않는 독립적인 프로그래밍이 가능하다.

📌 4. 개발시간을 단축시킬 수 있다.

  일단 인터페이스가 작성되면, 이를 사용해서 프로그램을 작성하는 것이 가능하다. 메서드를 호출하는 쪽에서는 메서드의 내용에 관계없이 선언부만 알면 되기 때문이다.

  그리고 동시에 다른 한쪽에서는 인터페이스를 구현하는 클래스를 작성하게 되면, 인터페이스를 구현하는 클래스가 작성될 때까지 기다리지 않고도 양쪽에서 동시에 개발을 진행할 수 있다.

 

 

📙 4. 인터페이스를 사용하는 이유

  지금까지 인터페이스의 특징과 구현하는 방법, 장점 등 인터페이스에 대한 일반적인 사항들에 대해서 모두 살펴보았다.

  하지만 '인터페이스란 도대체 무엇인가?'라는 의문은 여전히 남아있을 것이다. 그래서 이번에는 인터페이스의 규칙이나 활용이 아닌, 본질적인 측면에 대해서 한번 살펴보자.

  인터페이스를 이해하기 위해서 아래 2가지 사항을 염두에 두고 있어야 한다.

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

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

class A {
    public void methodA(B b) {
        b.methodB();
    }
}

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

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

  클래스 A와 클래스 B는 서로 직접적인 관계가 있다. 클래스 A를 작성하려면 클래스 B가 작성되어 있어야 하고, 클래스 B의 methodB()의 선언부가 변경되면 이를 사용하는 클래스 A도 변경되어야 한다.

  즉, 직접적인 관계의 두 클래스는 한쪽(Provider)이 변경되면 다른 한쪽(User)도 변경되어야 한다는 단점이 있다.

 

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

class A {

    // 클래스 B대신 인터페이스 I를 이용
    public void methodA(I i) {
        i.methodB();
    }
}

interface I {
    public abstract void methodB();
}

class B implements I{

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

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

  이렇게 작성하면 클래스 A와 클래스 B는 'A-B'의 직접적인 관계에서 'A-I-B'의 간접적인 관계로 바뀌게 된다. 클래스 A는 인터페이스를 통해 실제로 사용하는 클래스의 이름을 몰라도 되고 심지어는 실제로 구현된 클래스가 존재하지 않아도 문제 되지 않는다.

 

  main코드에서 확인할 수 있듯이 지금은 매개변수를 통해서 인터페이스 I를 구현한 클래스의 인스턴스를 동적으로 제공받고 있다. 하지만 아래와 같이 제3의 클래스를 통해서 제공받을 수 있다. (JDBC의 DriverManager 클래스가 이런 방식으로 되어 있다.)

class A {

    // 제 3의 클래스의 메서드를 통해서 클래스의 인스턴스를 얻어온다.
    public void methodA() {
        I i = InstanceManager.getInstance();
        i.methodB();
    }
}

interface I {
    public abstract void methodB();
}

class B implements I {

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

class InstanceManager {

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

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

  이렇게 하면 인스턴스를 직접 생성하지 않고, getInstance()라는 메서드를 통해 제공받는다. 그러면 나중에 다른 클래스의 인스턴스로 변경되어도 A클래스의 변경 없이 getInstance()만 변경하면 된다는 장점이 있다.

class InstanceManager {

    public static I getInstance() {
        return new B();
        
        // return new C(); // 변경 가능
        // return new D(); // 변경 가능
    }
}

 

 

📙 5. 디폴트 메서드 & static 메서드 (from JDK1.8)

  JDK1.8부터 생긴 기능들에 대해서 알아보자. 원래는 인터페이스에 추상 메서드만 선언할 수 있는데, JDK1.8부터 디폴트 메서드와 static메서드도 추가할 수 있게 되었다.

📌 1. 디폴트 메서드

  조상 클래스에 새로운 메서드를 추가하는 것은 별로 큰 문제가 되지 않지만, 인터페이스의 경우에는 큰 문제가 된다. 인터페이스에 메서드를 추가한다는 것은, 추상 메서드를 추가한다는 것이고, 이 인터페이스를 구현한 기존의 모든 클래스들이 새로 추가된 메서드를 구현해야 하기 때문이다.

 

  이를 해결하고자 디폴트 메서드(default method)라는 것이 나왔다.

  디폴트 메서드는 추상 메서드의 기본적인 구현을 제공하는 메서드로, 추상 메서드가 아니기 때문에 디폴트 메서드가 새로 추가되어도 해당 인터페이스를 구현한 클래스를 변경하지 않아도 된다.

public interface MyInterface {

    void walk();
    default void fly() {
        System.out.println("Let's Fly!!");
    };
}

  디폴트 메서드 역시 접근 제어자가 public이며, 생략가능하다.

 

  새로 추가된 디폴트 메서드가 기존의 메서드와 이름이 중복되어 충돌하는 경우가 발생한다. 이 충돌을 해결하는 규칙은 다음과 같다.

• 여러 인터페이스의 디폴트 메서드 간의 충돌
  인터페이스를 구현한 클래스에서 디폴트 메서드를 오버라이딩해야 한다.
• 디폴트 메서드와 조상 클래스의 메서드 간의 충돌
  조상 클래스의 메서드가 상속되고, 디폴트 메서드는 무시된다.

  이러한 점을 고려하기 번거롭다면, 그냥 필요한 쪽의 메서드와 같은 내용으로 오버라이딩하면 된다.

📌 2. static 메서드

  사실 static 메서드는 인스턴스와 관계가 없는 독립적인 메서드이기 때문에 예전부터 인터페이스에 추가하지 못할 이유가 없었다. 그러나 자바를 보다 쉽게 배울 수 있도록 규칙을 단순히 할 필요가 있어서 인터페이스의 모든 메서드는 추상 메서드이어야 한다는 규칙에 예외를 두지 않았다.

  그래서 인터페이스와 관련된 static 메서드는 별도의 클래스에 따로 두어야 했다. (java.util.Collection 인터페이스와 Collections 클래스)

 

  JDK1.8부터 인터페이스에서도 static 메서드를 사용할 수 있게 되었다. 인터페이스 전용 static 메서드라고 해서 일반 클래스의 static 메서드와 다른 것이 없고 같은 방법으로 사용하면 된다.

public interface MyInterface {

    public static void explain() {
        System.out.println("MyInterface의 explain() 메서드입니다.");
    }
}

public static void main(String[] args) {
    MyInterface.explain();
}

 

 

📙 6. private 메서드 (from Java9)

  자바 9부터 인터페이스에서 private 메서드를 사용할 수 있게 되었다. 인터페이스에 default, static 메서드가 생긴 이후, 이러한 메서드들의 로직을 공통화하고 재사용하기 위해 생긴 메서드다.
  private 메서드도 구현부를 가져야 한다. 단, private 메서드는 인터페이스 내부에서만 돌아가는 코드이다. 인터페이스를 구현한 클래스에서 사용하거나 재정의 할 수 없다.

  따라서 인터페이스 내부에서 private 메서드를 호출할 때, default 메서드 내부에서 호출해야 하며, 만일 private static 키워드를 붙인 메서드는 static 메서드에서만 호출이 가능하다.

public interface MyInterface {

    default void callPrivateMethod() {
        privateMethod();
    }

    private void privateMethod() {
        System.out.println("private 메서드입니다.");
    }

    static void callPrivateStaticMethod() {
        privateStaticMethod();
    }

    private static void privateStaticMethod() {
        System.out.println("private static 메서드입니다.");
    }
}

 

해당 글은
남궁성 님의 '자바의 정석',
geeksforgeeks 의 'Private Methods in Java 9 Interfaces',
Inpa 님의 '인터페이스(Interface) 문법 & 활용 - 완벽 가이드'
를 참고하였습니다.