💚인터페이스(2)

1️⃣인터페이스 상속

 

인터페이스도 다른 인터페이스를 상속할 수 있으며, 클래스와는 달리 다중 상속이 가능하다. 자식 인터페이스의 구현 클래스는 자식 인터페이스의 메소드뿐만 아니라 부모 인터페이스의 추상 메소드까지 모두 재정의해야 한다. 그리고 구현 객체는 자식 인터페이스와 부모 인터페이스 변수에 대입 가능하다.

구현 객체가 자식 인터페이스 변수에 대입되면 부모와 자식 인터페이스의 추상메소드를 모두 호출할 수 있으나, 부모 인터페이스 변수에 대입되면 부모 인터페이스의 추상 메소드만 호출할 수 있다.

public interface InterfaceA {
    void methodA();
}

public interface InterfaceB {
    void methodB();
}

public interface InterfaceC extends InterfaceA, InterfaceB {
    void methodC();
}

public class InterfaceImpl implements InterfaceC {

    @Override
    public void methodA() {
        System.out.println("InterfaceC의 methodA");        
    }

    @Override
    public void methodB() {
        // TODO Auto-generated method stub
        System.out.println("InterfaceC의 methodB");        
        
    }

    @Override
    public void methodC() {
        // TODO Auto-generated method stub
        System.out.println("InterfaceC의 methodC");        
        
    }
    
}

public class ExtendsExample {
    public static void main(String[] args) {
        InterfaceImpl impl = new InterfaceImpl();

        InterfaceA a = impl;
        a.methodA();
        
        InterfaceB b = impl;
        b.methodB();

        InterfaceC c = impl;
        c.methodA();
        c.methodB();
        c.methodC();
    }
    
}

 

2️⃣타입 변환

 

인터페이스의 타입 변환은 인터페이스와 구현 클래스 간에 발생한다. 인터페이스 변수에 구현 객체를 대입하면 구현 객체는 인터페이스 타입으로 자동 타입 변환된다. 반대로 인터페이스 타입을 구현 클래스 타입으로 변환시킬 수 있는데, 이때는 강제 타입 변환이 필요하다.

 

➡ 자동 타입 변환이 일어나는 경우

구현 객체가 인터페이스 타입으로 자동변환되면 인터페이스에 선언된 메소드만 사용 가능

부모 클래스가 인터페이스를 구현하고 있다면 자식 클래스도 인터페이스 타입으로 자동 타입 변환될 수 있다.

 

➡ 강제 타입 변환

강제 타입 변환은 캐스팅 기호를 사용해서 인터페이스 타입을 구현 클래스 타입으로 변환시키는 것을 말한다. 

자동 타입 변환 후에 인터페이스에 선언된 메소드가 아닌 구현 객체에 선언된 메소드를 호출하고 싶다면 캐스팅 기호로 강제 타입 변환을 하면 된다.

3️⃣다형성

 

다형성이란 사용 방법은 동일하지만 다양한 결과가 나오는 것을 말한다. 

다음처럼 구현 객체가 B인지 C인지에 따라 객체 A의 메소드 호출 결과는 달라질 수 있다.

상속의 다형성과 마찬가지로 인터페이스 역시 다형성을 구현하기 위해 재정의와 자동 타입 변환 기능을 이용한다.

인터페이스의 추상 메소드는 구현 클래스에서 재정의를 해야 하며, 재정의되는 내용은 구현 클래스마다 다르다. 구현 객체는 인터페이스 타입으로 자동 타입 변환 되고, 인터페이스 메소드 호출시 구현 객체의 재정의된 메소드가 호출되어 다양한 실행 결과를 얻을 수 있다.

 

➡필드의 다형성

public class HankookTire implements Tire{

    @Override
    public void roll() {
        System.out.println("한국타이어가 굴러갑니다.");        
    }
    
}

public class KumhoTire implements Tire {

    @Override
    public void roll() {
        System.out.println("금호 타이어가 굴러갑니다.");        
    }
    
}

public class Car {
    Tire tire1 = new HankookTire();
    Tire tire2 = new HankookTire();

    void run() {
        tire1.roll();
        tire2.roll();
        
    }
}

public class CarExample {
    public static void main(String[] args) {
        Car myCar = new Car();

        myCar.run();
        //한국타이어가 굴러갑니다.
        //한국타이어가 굴러갑니다.

        myCar.tire1 = new KumhoTire();
        myCar.tire2 = new KumhoTire();

        myCar.run();
        //금호 타이어가 굴러갑니다.
        //금호 타이어가 굴러갑니다.
    }
}

 

➡매개변수의 다형성

 

메소드 호출 시 매개값을 다양화하기 위해 상속에서는 매개변수 타입을 부모 타입으로 선언하고 호출할 때에는 다양한 자식 객체를 대입했다. 이것은 자동 타입 변환 때문인데, 비슷한 원리로 매개변수 타입을 인터페이스로 선언하면 메소드 호출 시 다양한 구현 객체를 대입할 수 있다.

public class Car {
    void run(Tire tire) {
        tire.roll();
    }
}

public class CarExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        Tire tire1 = new KumhoTire();
        Tire tire2 = new HankookTire();

        myCar.run(tire1);//금호 타이어가 굴러갑니다.
        myCar.run(tire2);//한국타이어가 굴러갑니다.
    }
}

자동 타입 변환 -> 오버라이딩 메소드 호출 -> 다형성

 

4️⃣객체 타입 확인

 

instanceof 연산자는 인터페이스에서도 사용 가능하다.

public class Car {
    void run(Tire tire) {
        if(tire instanceof KumhoTire){
            tire.roll();
        } else {
            System.out.println("금호타이어만 사용가능합니다.");
        }
    }
}

public class CarExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        Tire tire1 = new KumhoTire();
        Tire tire2 = new HankookTire();

        myCar.run(tire1);//금호 타이어가 굴러갑니다.
        myCar.run(tire2);//금호타이어만 사용가능합니다.


    }
    
}

 

5️⃣봉인된 인터페이스

 

Java 15부터는 무분별한 자식 인터페이스 생성을 방지하기 위해 봉인된 인터페이스를 사용할 수 있다.

InterfaceA의 자식 인터페이스는 InterfaceB만 가능하고, 그 이외는 자식 인터페이스가 될 수 없도록 다음과 같이 InterfaceA를 선언할 수 있다.

public sealed interface InterfaceA permits InterfaceB {...}

봉인된 InterfaceA의 자식 InterfaceB는 non-sealed 키워드로 다음과 같이 선언하거나 sealed 키워드로 또 다른 봉인 인터페이스로 선언해야 함.

public non-sealed interface InterfaceB extends InterfaceA {...}

non-sealed는 봉인 해제를 의미하며, 따라서 InterfaceB는 자식 인터페이스를 가질 수 있다.

 

❕본 포스팅은 '이것이 자바다' 교재를 바탕으로 공부한 내용을 정리한 것입니다.