인터페이스 여러가지 요소와 인터페이스의 상속

인터페이스의 여러가지 요소.

추상 메서드 (Abstract Methods).
인터페이스는 하나 이상의 추상 메서드를 선언할 수 있습니다.
추상 메서드는 구현 내용이 없으며, 인터페이스를 구현하는 클래스에서 반드시 구현되어야 합니다.
예: void method1();

상수 (Constants).
인터페이스는 상수를 선언할 수 있습니다.
상수는 public, static, final로 선언되어야 하며, 인터페이스를 구현하는 클래스에서 상수를 사용할 수 있습니다.
예: public static final int MAX_VALUE = 100;

디폴트 메서드 (Default Methods).
Java 8부터 도입된 개념으로, 인터페이스에서 메서드의 기본 구현을 제공할 수 있습니다.
인터페이스를 구현하는 클래스에서 이 디폴트 메서드를 오버라이딩할 수도 있고, 그대로 사용할 수도 있습니다.
예: default void method2() { // 구현 내용 }

정적 메서드 (Static Methods).
Java 8부터 도입된 개념으로, 인터페이스에서 정적 메서드를 선언할 수 있습니다.
정적 메서드는 public으로 선언되어야 하며, 인터페이스의 이름으로 직접 호출할 수 있습니다.
예: public static void method3() { // 구현 내용 }

프라이빗 메서드 (Private Methods).
Java 9부터 도입된 개념으로, 인터페이스에서 프라이빗 메서드를 선언할 수 있습니다.
프라이빗 메서드는 인터페이스 내부에서만 사용될 수 있으며, 다른 메서드들의 보조 역할을 수행합니다.
예: private void helperMethod() { // 구현 내용 }

public interface MyInterface {
    // 추상 메서드
    void method1();

    // 상수
    int MAX_VALUE = 100;

    // 디폴트 메서드
    default void method2() {
        System.out.println("Default method");
    }

    // 정적 메서드
    static void method3() {
        System.out.println("Static method");
    }

    // 프라이빗 메서드
    private void privateMethod() {
        System.out.println("Private method");
    }

    default void helperMethod() {
        privateMethod();
        System.out.println("Helper method");
    }
}

public class MyClass implements MyInterface {
    // 인터페이스의 추상 메서드 구현
    public void method1() {
        System.out.println("Method 1");
    }

    public static void main(String[] args) {
        MyClass myObj = new MyClass();

        // 추상 메서드 호출
        myObj.method1();

        // 디폴트 메서드 호출
        myObj.method2();

        // 정적 메서드 호출
        MyInterface.method3();

        // 상수 사용
        int maxValue = MyInterface.MAX_VALUE;

        // 프라이빗 메서드는 인터페이스 외부에서 직접 호출할 수 없지만, 디폴트 메서드를 통해 간접적으로 호출될 수 있습니다.
        myObj.helperMethod();
    }
}

 

Java에서는 클래스가 여러 개의 인터페이스를 구현할 수 있습니다. 이를 통해 다중 상속의 효과를 얻을 수 있으며, 클래스는 각 인터페이스의 모든 요구사항을 충족시켜야 합니다.

public interface InterfaceA {
    void methodA();
}

public interface InterfaceB {
    void methodB();
}

public class MyClass implements InterfaceA, InterfaceB {
    public void methodA() {
        System.out.println("Implementation of methodA");
    }

    public void methodB() {
        System.out.println("Implementation of methodB");
    }

    public static void main(String[] args) {
        MyClass myObj = new MyClass();

        // InterfaceA의 메서드 호출
        myObj.methodA();

        // InterfaceB의 메서드 호출
        myObj.methodB();
    }
}

 

인터페이스의 상속.

Java에서는 인터페이스도 다른 인터페이스를 상속할 수 있습니다. 이를 통해 인터페이스 간에 관계를 형성하고, 상속받은 인터페이스의 메서드와 상수를 사용할 수 있습니다. 인터페이스의 상속은 extends 키워드를 사용하여 수행됩니다.
 
인터페이스의 상속을 통해 코드의 재사용성을 높일 수 있고, 다양한 인터페이스를 함께 조합하여 필요한 기능을 제공할 수 있습니다.

public interface ParentInterface {
    void parentMethod();
}

public interface ChildInterface extends ParentInterface {
    void childMethod();
}

public class MyClass implements ChildInterface {
    public void parentMethod() {
        System.out.println("Implementation of parentMethod");
    }

    public void childMethod() {
        System.out.println("Implementation of childMethod");
    }

    public static void main(String[] args) {
        MyClass myObj = new MyClass();

        myObj.parentMethod();
        myObj.childMethod();
    }
}

 

클래스 상속과 인터페이스 구현 함께 쓰기.

Java에서는 클래스 상속과 인터페이스 구현을 함께 사용할 수 있습니다. 클래스 상속은 extends 키워드를 사용하고, 인터페이스 구현은 implements 키워드를 사용합니다. 이를 통해 클래스는 다른 클래스를 상속받고, 동시에 하나 이상의 인터페이스를 구현할 수 있습니다. 

public class ParentClass {
    public void parentMethod() {
        System.out.println("Parent method");
    }
}

public interface InterfaceA {
    void methodA();
}

public interface InterfaceB {
    void methodB();
}

public class ChildClass extends ParentClass implements InterfaceA, InterfaceB {
    public void methodA() {
        System.out.println("Implementation of methodA");
    }

    public void methodB() {
        System.out.println("Implementation of methodB");
    }

    public static void main(String[] args) {
        ChildClass childObj = new ChildClass();

        childObj.parentMethod();
        childObj.methodA();
        childObj.methodB();
    }
}