자바(Java) - 객체 지향 프로그래밍 (14) 다중 인터페이스와 상속

다중 인터페이스와 상속이 동시에 적용될 수도 있다.

(이론적으로 인터페이스 상속은 무한히 가능, 상속은 하나만)

 

• 에어컨 인터페이스 (ON/OFF, 온도 설정)
• 자율운전 인터페이스
• 접근제한자는 protected

AirCon

public interface AirCon {
    int MAX_TEMP = 30;
    int MIN_TEMP = 0;

    void airConON();
    void airConOFF();
    void setAirConTemp(int tmp);
}

• int MAX_TEMP, int MIN_TEMP
  인터페이스 內 필드는 인스턴스 필드 X, 인터페이스 소속O
  앞에 public final static이 숨겨져 있음
• void airConON();
  자동으로 추상메소드가 되며 앞에 abstract 숨겨져 있음

AutoDrive

public interface AutoDrive {
    void autoDrvieON();
    void autoDriveOFF();
}

Car

public class Car {
    protected int speed;
    protected String color;
    protected String year;

    public Car() {
        this.speed = 150;
        this.color = "white";
        this.year = "2022";
    }
}

• protected int speed;
  인스턴스 필드, 객체 소속
  protected 접근 제한자는 동일 패키지 혹은 상속 관계에서 접근 가능

SportsCar

public class SportsCar extends Car implements AirCon, AutoDrive{
    private boolean isAirCon; // ON/OFF
    private int setTemp;
    private boolean isAutoDrive;
    private boolean isTurbo;

    public SportsCar(boolean isAirCon, int setTemp, boolean isAutoDrive, int speed, String color,
              String year, boolean isTurbo) {
        this.isAirCon = isAirCon;
        this.setTemp = setTemp;
        this.isAutoDrive = isAutoDrive;
        this.speed = speed;
        this.color = color;
        this.year = year;
        this.isTurbo = isTurbo;
    }
    public void viewInfo() {
        String airConStr = (isAirCon) ? "ON" : "OFF";
        String autoStr = (isAutoDrive) ? "ON" : "OFF";
        String turboStr = (isTurbo) ? "ON" : "OFF";
        System.out.println("속도 : " + speed);
        System.out.println("색상 : " + color);
        System.out.println("연도 : " + year);
        System.out.println("에어컨 : " + airConStr);
        System.out.println("자율주행 : " + autoStr);
        System.out.println("온도 : " + setTemp);
        System.out.println("터보모드 : " + isTurbo);
    }

    @Override
    public void airConON() {
        System.out.println("에어컨을 켰습니다.");
    }

    @Override
    public void airConOFF() {
        System.out.println("에어컨을 껐습니다.");
    }

    @Override
    public void setAirConTemp(int tmp) {
        System.out.println("에어컨 설정 온도를 " + tmp + "로 변경 하였습니다.");
    }

    @Override
    public void autoDrvieON() {
        System.out.println("자율 주행 모드를 켰습니다.");
    }

    @Override
    public void autoDriveOFF() {
        System.out.println("자율 주행 모드를 껐습니다.");
    }
}

인터페이스와 상속이 동시에 적용 가능하다는 것을 아는 것이 중요
그다지 중요한 예제코드는 아님.

Main

public class Main {
    public static void main(String[] args) {
        SportsCar sportsCar = new SportsCar(true, 20, true, 100,
                "black","2023",false);
        sportsCar.viewInfo();
    }
}

속도 : 100
색상 : black
연도 : 2023
에어컨 : ON
자율주행 : ON
온도 : 20
터보모드 : false

인터페이스 활용

한 클래스가 여러 클래스로 부터 상속을 받으면 여러가지 문제 발생
자바는 이런 문제를 해결하기 위해 한 클래스가 여러 인터페이스를 구현할 수 있음.

Buy

public interface Buy {
    void buy();
    default void order() {
        System.out.println("구매 주문");
    }
}

• 인터페이스는 구현부를 가질 수 없지만 예외적으로 default 메소드는 구현부{}가 있음.
  이론적으로는 각 인터페이스가 중복된 default 메소드를 가질 수 있다.
  다만, 이럴 경우 나타날 수 있는 문제는 아래 코드를 통해 확인

Sell

public interface Sell {
    void sell();
    default void order() {
        System.out.println("판매 주문");
    }
}

Customer

public class Customer implements Buy, Sell{
    @Override
    public void buy() {
        System.out.println("구매하기");
    }

    @Override
    public void order() {
        System.out.println("고객 주문");
    }

    @Override
    public void sell() {
        System.out.println("판매하기");
    }
}

• 원래 default 메소드는 자식 클래스에서 오버라이딩을 해도 되고, 안해도 되지만 각 인터페이스에서 같은 메소드를 default 하면 자식 클래스에서 모순이 생겨버림.
• 따라서, 모순을 피하기 위해 해당 메소드를 반드시 오버라이딩 해줘야 함.
  위의 default void order(){} 메소드 처럼..(각 자식 클래스에서 오버라이딩 안하면 오류뜸)

자식 클래스에서 오버라이딩 하는 순간 부모 클래스에 있는 default 메소드는 사라져 버림.
Main2 클래스에서 확인 가능!

Main1

public class Main {
    public static void main(String[] args) {
        // 1번
        Customer customer = new Customer();
        Buy buyer = customer;
        buyer.buy();

        // 2번
        Buy buyer2 = new Customer();
        buyer2.buy();

        // 3번
        Sell sell = customer;
        sell.sell();
        
        // 4번
        Customer customer1 = (Customer) sell;
        customer1.buy();
        customer1.sell();
    }
}

1. Buy buyer = customer;
   Customer 타입의 customer 참조변수를 Buy 인터페이스형 buyer 참조변수에 대입(casting 발생)
   Buy와 Customer가 상속 관계로 있기 때문에 형변환 가능함.
   buyer.buy(); buyer는 Buy 인터페이스의 메소드만 호출 가능
2. Buy buyer2 = new Customer();
   1번, 2번 같음
3. Sell sell = customer;
   1번과 같이 부모에서 자식으로의 형변환은 자동으로 일어남
   sell.sell(); 이것도 1번과 같이 Sell 인터페이스가 알고있는 메소드만 접근 가능
4. Customer customer1 = (Customer) sell;
   다시 역으로 형변환, 자식이 부모로 변환할 때는 명시적으로 해야 함.
   이를 '다운 캐스팅'이라고 한다.

Main2

public class Main2 {
    public static void main(String[] args) {
        Customer customer = new Customer();

        Buy buyer = customer;
        buyer.buy();
        buyer.order(); // Customer 클래스에서 재정의된 메소드가 호출 됨.

        Sell seller = customer;
        seller.order(); // 동일
    }
}

구매하기
고객 주문
고객 주문

• 앞서 말했던 것 처럼 Customer 클래스가 Buy, Sell 두 인터페이스를 구현하고 Buy 인터페이스와 Sell 인터페이스에 똑같은 default order() 메소드를 가지는 경우 문제가 된다.
• 이 경우, 상속받는 Customer 클래스에서 재정의해서 사용해야 함.

재정의한 뒤 main에서 각 인터페이스 객체를 생성해서 메소드를 호출하면
자식 클래스에서 재정의한 메소드가 호출됨