[Java] 인터페이스를 이용한 다형성과 활용

인터페이스의 다중 상속 

앞서 인터페이스는 다중상속이 가능하다고 했습니다. 

public interface Attackable {
	void attack(int power);
}

public interface Movable {
	void move(int m);
}

public interface Fightable extends Movable, Attackable {
    void attackAndMove(int power, int m);
}

• 클래스 상속과 마찬가지로 인터페이스도 부모 인터페이스에 정의된 멤버를 모두 상속받습니다.
• Fightable은 본인의 멤버 attackAndMove()와 부모 멤버의 attack(), move()를 멤버로 갖게 됨.

public class Fighter implements Fightable {

    @Override
    public void attack(int power) {

    }

    @Override
    public void attackAndMove(int power, int m) {

    }

    @Override
    public void move(int m) {

    }
}

• 이 때 부모의 접근 제어자는 public abstract가 생략된 것이기 때문에 (인터페이스의 특징) 클래스에서 구현할 때 부모의 제어자를 반드시 public으로 설정해야 합니다.

 

인터페이스에서는 다중상속으로 인한 문제가 없을까?

클래스에서 다중상속이 안되는 이유는 두 부모 클래스가 동일한 시그니처의 메소드를 갖고 자식이 이 두 클래스를 상속받는 경우, 자식 입장에서는 상속받을 때 어떤 클래스의 메소드를 상속받아야 하는 지 알 수 없습니다. 

 

하지만 인터페이스에서는 이 문제를 피해갈 수 있습니다. why ? 메소드가 정의되지 않았기 때문 

 

• 어차피 부모 메소드가 구현되지 않았기 때문에, 자식 클래스에서는 둘 중 어느 것을 상속 받아도 구현해주어야 하므로, 어떤 부모로부터 상속받았는지에 대해서는 알 필요가 없습니다.

public interface Mom {
    void giveMoney(int money);
}

public interface Father {
    void giveMoney(int money);
}

public class Child implements Father, Mom {
    @Override
    public void giveMoney(int money) {

    }
}

 

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

다형성에 대해 다룰 때 자식 클래스의 인스턴스를 부모타입의 참조변수로 참조하는 것이 가능하다고 했었습니다.

public class Tv {
	protected String model;
    
}

public class SmartTv extends Tv {
	protected String smartFunction;
    
   	private void printSmartFunction(){
    	System.out.println(this.smartFuntion);
    }
}

public class SmartTvTest {
	public static void main(String[] args){
 		Tv t = new SmartTv();   
    }
}

 

인터페이스 역시 이를 구현한 클래스의 조상이라 할 수 있으므로 해당 인터페이스 타입의 참조변수로 이를 구현한 클래스(자식)의 인스턴스를 참조할 수 있으며, 인터페이스 타입으로 형변환 또한 가능합니다.

public interface Fightable {
    void attack(int power);
}

public class Fighter implements Fightable{

    @Override
    public void attack(int power) {
        System.out.println(power + "의 데미지로 공격");
    }

}

public class FighterTest {
    public static void main(String[] args) {
        Fightable f = new Fighter();
        f.attack(50);
    }
}

 

실행 결과

50의 데미지로 공격

• 따라서 뿐만 아니라 Up-casting(부모 → 자식)도 가능합니다.

public class FighterTest {
    public static void main(String[] args) {
        Fightable f = (Fightable) new Fighter();
        f.attack(50);
    }
}

• 인터페이스는 다음과 같이 메소드의 매개변수의 타입으로 사용될 수 있습니다.

public interface Fightable {
    void attack(int power, Fightable f);

    String getName();
}

public class Fighter implements Fightable{
    private String name;

    public Fighter(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void attack(int power, Fightable f) {
        System.out.println("Fighter attack " + f.getName() + " with " + power);
    }

}

public class Boxer implements Fightable {

    private String name;

    public Boxer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void attack(int power, Fightable f) {
        System.out.println("Boxer attack " + f + " with " + power);
    }
}

public class FighterTest {
    public static void main(String[] args) {
        Fightable f = new Fighter("fighter1");
        f.attack(50, new Boxer("boxer1"));
    }
}

 

실행 결과

Fighter attack boxer1 with 50

 

리턴타입이 인터페이스일 때 

메소드의 리턴타입이 인터페이스 ▶︎ 메소드가 해당 인터페이스를 구현한 클래스의 인스턴스를 리턴합니다.

 

예시 코드

public interface Parseable {
    void parse(String fileName);
}

public class HTMLParser implements Parseable {

    @Override
    public void parse(String fileName) {
        System.out.println(fileName + " HTML Parsing");
    }
}

public class XMLParser implements Parseable {

    @Override
    public void parse(String fileName) {
        System.out.println(fileName + " XML Parsing");
    }
}

public class ParserManager {

    public static Parseable getParser(String type) {
        if (type.equals("XML")) {
            return new XMLParser();
        } else{
            return new HTMLParser();
        }
    }
}

public class ParserTest {
    public static void main(String[] args) {
        Parseable pm = ParserManager.getParser("XML");
        pm.parse("doc.xml");
    }
}

위 코드에서 추후 새로운 종류의 XML Parser 클래스가 나와도 아래 코드와 같이 리턴 부분만 변경하면 됩니다.

if (type.equals("XML")) {
//    return new XMLParser();
  	return new NewXMLParser();  
}

 

인터페이스의 장점

• 개발 시간 단축
  • 인터페이스가 작성되면 선언부만 알면 이를 사용해서 프로그램을 작성하는 것이 가능
• 표준화 가능
  • 프로젝트에 사용되는 기본 틀을 인터페이스로 작성한 다음, 개발자들에게 인터페이스를 구현하여 프로그램을 작성하도록 함으로써 보다 일관되고 정형화된 프로그램의 개발이 가능
• 서로 관게없는 클래스들에게 관계를 맺어줄 수 있음
  • 상속관계에 있지도 않고, 같은 부모 클래스를 가지고 있지 않은 서로 아무 관계도 없는 클래스들에게 하나의 인터페이스를 공통적으로 구현하도록 하여 관계를 맺어줄 수 있습니다.

 

인터페이스 - 추상클래스 - 구현 클래스 디자인 패턴

인터페이스와 구현 클래스 사이에 추상 클래스를 하나 두고 이 추상 클래스에 구현 클래스의 공통, 중복 부분들을 모아두는 패턴입니다.

예시

public interface Animal {
    void walk();
    void run();
    void sleep();
    void eat();
}

public class Lion implements Animal {

    private String sex; // 중복
    private String color; // 중복

    public String getSex() { // 중복
        return sex;
    }

    public String getColor() { // 중복
        return color;
    }

    @Override
    public void walk() {
        System.out.println("Lion WALK");
    }

    @Override
    public void run() {
        System.out.println("Lion RUN");
    }
    
    @Override
    public void sleep() {
        System.out.println("Lion SLEEP");
    }

    @Override
    public void eat() {
        System.out.println("Lion EAT");
    }
}

public class Tiger implements Animal{

    private String sex; // 중복
    private String color; // 중복

    public String getSex() { // 중복
        return sex;
    }

    public String getColor() { // 중복
        return color;
    }

    @Override
    public void walk() {
        System.out.println("Tiger WALK");
    }

    @Override
    public void run() {
        System.out.println("Tiger RUN");

    }

    @Override
    public void sleep() {
        System.out.println("TIGER SLEEP");
    }

    @Override
    public void eat() {
        System.out.println("TIGER EAT");
    }
}

 

Tiger와 Lion 클래스를 보면 sex, color,  getSex(), getColor() 코드의 중복이 발생하는데 이 때 중복 멤버들을 추상클래스를 만들어 중복을 제거할 수 있습니다.

package aboutInterface.test3;

public abstract class Mammal implements Animal{

    private String sex; // 중복
    private String color; // 중복

    public String getSex() { // 중복
        return sex;
    }

    public String getColor() { // 중복
        return color;
    }
}

 

이 디자인 패턴은 중복 제거에 효과적이지만, 클래스 상속을 기반으로 하고 있기 때문에 다른 클래스를 상속받아야 하는 경우에는 클래스는 다중상속이 안되기 때문에 이 패턴을 사용할 수 없습니다. 

---

<참고 자료>

 

☕ 인터페이스 vs 추상클래스 용도 차이점 - 완벽 이해

 

[Java] 인터페이스(interface) 총 정리