08_인터페이스

1. 인터페이스: 소프트웨어의 접속기

인터페이스는 사전적인 의미로 두 장치를 연결하는 접속기를 말합니다. 이러한 개념이 소프트웨어 개발에서 파생되어 객체지향 프로그래밍 언어에서 "인터페이스"는 클래스 간의 상호 작용을 정의하거나, 클래스와 클라이언트 간의 계약을 명시하는 역할을 합니다.

주요 특징:
1. 추상 메소드의 집합: 인터페이스는 일반적으로 추상 메소드들의 집합을 정의하며, 구현을 갖지 않습니다.
2. 상수 (static final 필드): 상수 필드를 가질 수 있으며, 이는 인터페이스에서 정의된 값이 변경되지 않도록 합니다.
3. 다중 상속: 클래스는 다중 상속을 허용하지 않지만, 인터페이스는 다중 상속을 지원합니다.

예시:

// 인터페이스 선언
interface Connectable {
    void connect();
}

// 인터페이스를 구현하는 클래스
class Device implements Connectable {
    @Override
    public void connect() {
        System.out.println("Device connected");
    }
}

// 또 다른 인터페이스 구현
class Network implements Connectable {
    @Override
    public void connect() {
        System.out.println("Network connected");
    }
}

// 클라이언트 코드
public class Main {
    public static void main(String[] args) {
        Connectable device = new Device();
        device.connect(); // Device connected

        Connectable network = new Network();
        network.connect(); // Network connected
    }
}

인터페이스의 활용:

• 인터페이스를 통해 클래스 간의 표준화된 규약을 제공하여 유연성과 재사용성을 높임.
• 다중 상속을 지원하여 여러 개의 인터페이스를 구현할 수 있음.
• 클라이언트 코드에서는 다양한 클래스를 동일한 인터페이스로 다룰 수 있어 확장성이 증가함.

2. 인터페이스와 다형성

인터페이스는 객체지향 프로그래밍에서 다형성(Polymorphism)을 구현하는 주요 기술 중 하나입니다. 다형성은 코드의 유연성과 재사용성을 높이는데 기여하며, 인터페이스는 이러한 다형성을 가능케 하는 핵심 도구로 활용됩니다.

1. 다형성의 핵심 개념:

• 하나의 인터페이스로 여러 구현을 다룰 수 있다.
• 같은 메소드 호출이 다양한 구현체에서 다르게 작동할 수 있다.
• 코드의 확장성과 유지보수성을 향상시킨다.

2. 인터페이스를 통한 다형성:

• 인터페이스는 다형성을 실현하기 위해 추상 메소드의 집합을 정의한다.
• 하위 클래스에서는 해당 인터페이스를 구현하여 각자의 독특한 기능을 구현할 수 있다.

3. 예시:

// 다형성을 위한 인터페이스 선언
interface Shape {
    void draw();
}

// 인터페이스를 구현하는 다양한 도형 클래스
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Triangle");
    }
}

// 클라이언트 코드에서 다형성 활용
public class Main {
    public static void main(String[] args) {
        // 다양한 도형을 하나의 인터페이스로 다룰 수 있음
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();
        Shape triangle = new Triangle();

        // 인터페이스의 메소드를 통해 각 도형의 draw() 메소드 호출
        circle.draw(); // Drawing Circle
        rectangle.draw(); // Drawing Rectangle
        triangle.draw(); // Drawing Triangle
    }
}

4. 다형성의 장점:

• 클라이언트 코드는 인터페이스를 통해 객체를 다루기 때문에, 구현의 변화에 유연하게 대처할 수 있다.
• 새로운 도형 클래스를 추가하더라도 클라이언트 코드를 수정할 필요가 없다.
• 코드의 확장성과 유지보수성이 높아지며, 각 클래스는 자신의 역할에 집중할 수 있다.

3. 인터페이스 선언과 접근 제한자

1. 인터페이스 선언:

인터페이스는 클래스들이 구현해야 하는 메소드의 명세를 정의하는데 사용되며, 이를 선언할 때는 class 키워드 대신 interface 키워드를 사용합니다.

예시:

// 인터페이스 선언
public interface MyInterface {
    // 추상 메소드
    void abstractMethod();

    // 디폴트 메소드 (Java 8 이후에서 사용 가능)
    default void defaultMethod() {
        System.out.println("Default Method");
    }
}

2. 접근 제한자:

인터페이스 내부의 멤버들에는 기본적으로 public 접근 제한자가 적용됩니다. 또한, Java 9부터는 디폴트 메소드와 정적 메소드에 대해 private, private static, private default와 같은 제한자를 사용하여 접근 범위를 조절할 수 있습니다.

예시:

public interface MyInterface {
    // public 접근 제한자가 기본
    void abstractMethod();

    // 디폴트 메소드 (public 접근 제한자가 기본)
    default void defaultMethod() {
        System.out.println("Default Method");
    }

    // 정적 메소드 (public 접근 제한자가 기본)
    static void staticMethod() {
        System.out.println("Static Method");
    }

    // Java 9 이후에서 사용 가능한 private 메소드
    // (내부에서만 사용 가능)
    private void privateMethod() {
        System.out.println("Private Method");
    }
}

3. 정리:

• 인터페이스 선언: interface 키워드를 사용하여 추상 메소드의 집합을 정의하고, 기본적으로 public 접근 제한자가 적용됩니다.

• 디폴트 메소드: Java 8 이후에서 사용 가능하며, 기존의 인터페이스에 새로운 기능을 추가할 때 유용하게 활용됩니다.

• 정적 메소드: Java 8 이후에서 사용 가능하며, 특정 클래스에 종속되지 않는 기능을 제공할 때 사용됩니다.

• Java 9 이후의 private 메소드: 인터페이스 내에서만 사용되는 메소드로, 구현 세부 사항을 숨기고 내부 구현을 단순화합니다.

4. 추상 메소드: 선언부만 존재하는 메소드

1. 개념:

• 추상 메소드는 메소드의 선언부만 존재하고 중괄호({}) 내용이 없는 메소드를 말합니다.
• 구현은 없지만 메소드의 이름, 매개변수 및 반환 유형이 정의되어 있습니다.

2. 선언 방법:

• 추상 메소드는 abstract 키워드를 사용하여 선언됩니다.
• 추상 메소드가 포함된 클래스는 반드시 추상 클래스여야 합니다.

3. 역할:

• 추상 메소드는 하위 클래스에서 반드시 구현되어야 합니다.
• 추상 클래스를 상속받는 클래스에서는 추상 메소드를 반드시 오버라이딩하여 구현해야 합니다.

4. 예시:

// 추상 클래스 선언
abstract class Shape {
    // 추상 메소드 선언 (구현부 없음)
    abstract void draw();
}

// 추상 메소드를 구현한 구체적인 클래스
class Circle extends Shape {
    // 추상 메소드 구현
    @Override
    void draw() {
        System.out.println("Drawing Circle");
    }
}

5. 장점:

• 추상 메소드를 사용하면 하위 클래스에서 특정한 동작을 강제할 수 있습니다.
• 클래스 간의 계층 구조를 구성하여 코드의 재사용성과 확장성을 높일 수 있습니다.

5. 클래스 B가 인터페이스를 구현한 객체로 정의

1. 클래스 B의 역할:

• 클래스 B는 특정 인터페이스를 구현한 객체로 정의됩니다.

2. 인터페이스 구현:

• public class B implements 인터페이스명의 형태로 클래스 B가 특정 인터페이스를 구현함을 선언합니다.

3. 인터페이스 구현의 의미:

• 클래스 B는 해당 인터페이스에 정의된 추상 메소드들을 구현해야 합니다.
• 인터페이스를 구현함으로써 클래스 B는 해당 인터페이스의 규약에 따라 동작하도록 보장됩니다.

4. 예시 코드:

// 인터페이스 선언
interface MyInterface {
    void myMethod();
}

// 인터페이스를 구현하는 클래스 B
public class B implements MyInterface {
    // 인터페이스의 추상 메소드를 구현
    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod in class B");
    }

    // 클래스 B의 다른 메소드들
    public void anotherMethod() {
        System.out.println("Another method in class B");
    }
}

5. 클래스 B의 활용:

• 클래스 B는 MyInterface를 구현한 객체로 간주됩니다.
• 인터페이스의 메소드인 myMethod를 반드시 구현하고, 나머지 클래스의 메소드는 추가적으로 정의할 수 있습니다.

6. 장점:

• 클래스 B의 정의는 인터페이스의 규약을 따르며, 이를 통해 다형성과 코드의 유연성을 제공합니다.

6. implements 키워드의 역할 및 의미

1. 역할:

• implements 키워드는 클래스가 특정 인터페이스를 구현한다는 것을 나타내는 역할을 합니다.

2. 사용 목적:

• 클래스에서 인터페이스를 사용하고자 할 때, 해당 인터페이스를 구현하기 위해 implements 키워드를 사용합니다.

3. 표시의미:

• implements 키워드는 해당 클래스가 특정 인터페이스의 규약을 따르며, 해당 인터페이스에 정의된 추상 메소드를 구현하겠다는 의미를 갖습니다.

4. 추상 메소드의 재정의:

• 클래스가 인터페이스를 구현할 때, 해당 인터페이스에 선언된 추상 메소드들을 반드시 구현(재정의)해야 합니다.

5. 예시 코드:

// 인터페이스 선언
interface MyInterface {
    void myMethod();
}

// 클래스가 인터페이스를 구현
public class MyClass implements MyInterface {
    // 인터페이스의 추상 메소드를 재정의
    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod in MyClass");
    }

    // MyClass의 다른 메소드들
    public void anotherMethod() {
        System.out.println("Another method in MyClass");
    }
}

6. 재정의와 다형성:

• implements 키워드를 사용하여 인터페이스를 구현하면, 해당 클래스는 인터페이스의 메소드를 재정의함으로써 다형성을 구현할 수 있습니다.

7. 정리:

• implements 키워드를 통해 클래스는 특정 인터페이스를 구현하고, 해당 인터페이스의 규약을 준수하는 메소드들을 제공함으로써 다형성과 유연성을 제공합니다.

7. 인터페이스: 다양한 객체를 통일된 타입으로 다루기

1. 인터페이스의 타입:

• 인터페이스는 하나의 타입으로 취급되며, 객체들을 특정 규약에 따라 동일한 타입으로 묶을 수 있습니다.

2. 변수의 타입으로 활용:

• 인터페이스를 변수의 타입으로 사용하여 해당 인터페이스를 구현한 객체들을 참조할 수 있습니다.
• 변수가 가리키는 실제 객체의 구현 클래스에 따라 실행 시점에 다른 동작을 수행할 수 있습니다.

3. 다형성의 구현:

• 다양한 객체들을 동일한 인터페이스로 참조함으로써 다형성을 구현할 수 있습니다.
• 클라이언트 코드는 인터페이스의 메소드를 호출하면서, 실행 시점에 실제 객체의 메소드가 호출됩니다.

4. 예시 코드:

// 인터페이스 선언
interface MyInterface {
    void myMethod();
}

// 인터페이스를 구현하는 클래스
class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod in MyClass");
    }

    // MyClass의 다른 메소드들
    public void anotherMethod() {
        System.out.println("Another method in MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스를 타입으로 사용하는 변수 선언
        MyInterface myObject = new MyClass();

        // 인터페이스의 메소드 호출
        myObject.myMethod(); // 출력: Implementation of myMethod in MyClass

        // myObject는 MyInterface 타입이지만, MyClass의 다른 메소드는 호출할 수 없음
        // myObject.anotherMethod(); // 에러: cannot find symbol
    }
}

5. 장점:

• 클라이언트 코드는 구현 클래스의 세부 사항을 몰라도 인터페이스를 통해 객체를 다룰 수 있습니다.
• 코드의 유연성과 확장성을 제공하며, 새로운 구현 클래스를 추가하거나 변경해도 기존 코드를 수정할 필요가 없습니다.

8. 인터페이스 변수에 구현 객체 대입: 다형성 활용

1. 다형성을 통한 유연한 객체 대입:

• 인터페이스를 사용하여 다양한 구현 객체를 하나의 타입으로 다룰 수 있습니다.
• 다형성을 활용하여 인터페이스 변수에 구현 객체를 대입함으로써, 실행 시점에 실제 객체의 동작을 다르게 지정할 수 있습니다.

2. 예시 코드:

// 인터페이스 선언
interface MyInterface {
    void myMethod();
}

// 인터페이스를 구현하는 클래스 A
class ClassA implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod in ClassA");
    }
}

// 인터페이스를 구현하는 클래스 B
class ClassB implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("Implementation of myMethod in ClassB");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스 변수에 구현 객체 대입
        MyInterface objectA = new ClassA();
        MyInterface objectB = new ClassB();

        // 다형성을 활용한 메소드 호출
        objectA.myMethod(); // 출력: Implementation of myMethod in ClassA
        objectB.myMethod(); // 출력: Implementation of myMethod in ClassB
    }
}

3. 장점:

• 코드의 유연성을 높여 새로운 구현 클래스를 추가하거나 기존 클래스를 변경할 때 기존 코드에 영향을 미치지 않습니다.
• 클라이언트 코드는 인터페이스를 통해 객체를 다루므로, 실제 객체의 세부 사항에 대한 지식이 없어도 됩니다.
• 다양한 객체를 효과적으로 다룰 수 있어 모듈화와 재사용성이 증가합니다.

9. 인터페이스의 불변 상수 필드: public static final

1. 상수 필드 선언:

• 인터페이스는 public static final 특성을 갖는 불변의 상수 필드를 선언할 수 있습니다.
• 상수는 반드시 초기화되어야 하며, 변경할 수 없는 값으로 사용됩니다.

2. 상수 필드의 특성:

• public static final로 선언된 상수 필드는 모든 구현 클래스에서 동일한 값을 가지며, 변경될 수 없습니다.
• 상수는 인터페이스를 통해 공유되며, 해당 인터페이스를 구현한 클래스에서 참조할 수 있습니다.

3. 예시 코드:

// 인터페이스 선언 (상수 필드를 갖는)
interface MyInterface {
    // 불변의 상수 필드 선언
    public static final int MAX_VALUE = 100;
    public static final String DEFAULT_NAME = "Default";
}

// 인터페이스를 구현하는 클래스
class MyClass implements MyInterface {
    // MyClass에서는 MyInterface의 상수 필드를 참조할 수 있음
    public void printConstants() {
        System.out.println("Max Value: " + MAX_VALUE);
        System.out.println("Default Name: " + DEFAULT_NAME);
    }
}

public class Main {
    public static void main(String[] args) {
        // MyClass의 객체 생성
        MyClass myObject = new MyClass();

        // 상수 필드 출력
        myObject.printConstants();
    }
}

4. 장점 및 활용:

• 인터페이스를 통해 상수를 정의하면 코드의 중복을 방지하고, 유지보수성을 높일 수 있습니다.
• 인터페이스를 구현한 클래스들은 공통된 상수를 사용할 수 있어 코드 일관성을 유지할 수 있습니다.
• 상수는 주로 프로그램에서 사용되는 고정된 값을 나타내는데 활용됩니다.

10. 인터페이스 상수: 구현 객체와 무관한 직접 접근

1. 구현 객체와 무관한 상수:

• 인터페이스에 선언된 상수는 구현 객체와 관련이 없이 인터페이스에 직접 소속된 멤버입니다.
• 따라서 구현 객체를 생성하지 않고도 인터페이스로 직접 상수값에 접근할 수 있습니다.

2. 직접 접근의 특성:

• 구현 객체를 생성하지 않고도 인터페이스명을 통해 상수에 접근할 수 있습니다.
• 상수는 모든 구현 클래스에서 동일한 값을 갖기 때문에 구현 객체의 생성과 무관하게 사용할 수 있습니다.

3. 예시 코드:

// 인터페이스 선언 (상수 필드를 갖는)
interface MyInterface {
    // 불변의 상수 필드 선언
    public static final int MAX_VALUE = 100;
    public static final String DEFAULT_NAME = "Default";
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스 상수 직접 접근
        System.out.println("Max Value: " + MyInterface.MAX_VALUE);
        System.out.println("Default Name: " + MyInterface.DEFAULT_NAME);
    }
}

4. 장점 및 활용:

• 구현 객체를 생성하지 않고도 인터페이스를 통해 상수값에 직접 접근할 수 있어 간편하게 사용 가능합니다.
• 상수는 인터페이스에 속하므로 인터페이스의 변경 없이 상수값을 사용할 수 있습니다.
• 코드의 중복을 방지하고 유지보수성을 높이는데 기여합니다.

11. 인터페이스의 추상 메소드: 구현 클래스의 재정의

1. 추상 메소드의 선언:

• 인터페이스는 추상 메소드를 선언할 수 있습니다.
• 이 추상 메소드는 구현 클래스에서 반드시 재정의(구현)되어야 합니다.

2. 구현 클래스의 의무:

• 구현 클래스는 인터페이스에 선언된 추상 메소드를 반드시 구현해야 합니다.
• 추상 메소드를 구현함으로써 인터페이스에 정의된 동작을 실제로 구현합니다.

3. 예시 코드:

// 인터페이스 선언 (추상 메소드를 갖는)
interface MyInterface {
    // 추상 메소드 선언
    void myAbstractMethod();
}

// 인터페이스를 구현하는 클래스
class MyClass implements MyInterface {
    // 인터페이스의 추상 메소드를 구현
    @Override
    public void myAbstractMethod() {
        System.out.println("Implementation of myAbstractMethod in MyClass");
    }

    // MyClass의 다른 메소드들
    public void anotherMethod() {
        System.out.println("Another method in MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스를 구현한 객체 생성
        MyClass myObject = new MyClass();

        // 추상 메소드 호출
        myObject.myAbstractMethod(); // 출력: Implementation of myAbstractMethod in MyClass

        // MyClass의 다른 메소드 호출
        myObject.anotherMethod(); // 출력: Another method in MyClass
    }
}

4. 장점 및 활용:

• 인터페이스의 추상 메소드를 통해 공통적인 동작을 규정하고, 구현 클래스에서 실제 구현을 제공함으로써 일관성을 유지할 수 있습니다.
• 다양한 구현 클래스에서 동일한 인터페이스를 통해 호출할 수 있어 다형성을 활용할 수 있습니다.

12. 인터페이스의 추상 메소드 재정의 시 주의사항: 접근 제한자

1. 기본적인 public 접근 제한:

• 인터페이스의 추상 메소드는 기본적으로 public 접근 제한을 갖습니다.
• 구현 클래스에서 해당 메소드를 재정의할 때, 접근 제한자는 더 낮은 수준으로 설정할 수 없습니다.

2. 재정의 메소드에 public 추가:

• 구현 클래스에서 추상 메소드를 재정의할 때는 반드시 public 접근 제한자를 명시해야 합니다.
• 재정의 메소드의 접근 제한자는 인터페이스의 추상 메소드의 접근 제한자를 따라야 합니다.

3. 예시 코드:

// 인터페이스 선언 (추상 메소드를 갖는)
interface MyInterface {
    // 추상 메소드 선언 (기본적으로 public)
    void myAbstractMethod();
}

// 인터페이스를 구현하는 클래스
class MyClass implements MyInterface {
    // 인터페이스의 추상 메소드를 구현 (public 추가)
    @Override
    public void myAbstractMethod() {
        System.out.println("Implementation of myAbstractMethod in MyClass");
    }

    // MyClass의 다른 메소드들
    public void anotherMethod() {
        System.out.println("Another method in MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스를 구현한 객체 생성
        MyClass myObject = new MyClass();

        // 추상 메소드 호출
        myObject.myAbstractMethod(); // 출력: Implementation of myAbstractMethod in MyClass
    }
}

4. 재정의의 명시성과 일관성:

• @Override 어노테이션을 사용하여 메소드의 명시성을 강조하면서, 일관된 코드 스타일을 유지할 수 있습니다.
• 인터페이스의 추상 메소드와 구현 클래스의 재정의 메소드의 접근 제한자를 동일하게 유지하여 코드의 일관성을 유지할 수 있습니다.

13. 인터페이스 변수와 다형성: 구현 객체에 따라 실행 내용이 달라지는 추상 메소드 호출

1. 인터페이스 변수의 다형성:

• 구현 객체가 인터페이스 타입의 변수에 대입되면, 해당 변수를 통해 구현 객체의 메소드를 호출할 수 있습니다.
• 이때, 어떤 구현 객체가 대입되었는지에 따라 실행 내용이 달라집니다.

2. 다양한 실행 내용:

• 동일한 인터페이스를 구현하는 다양한 구현 객체들은 추상 메소드를 각자의 방식으로 구현하고 있습니다.
• 인터페이스 변수를 통해 메소드를 호출하면, 대입된 구현 객체의 구현이 실행됩니다.

3. 예시 코드:

// 인터페이스 선언 (추상 메소드를 갖는)
interface MyInterface {
    // 추상 메소드 선언
    void myAbstractMethod();
}

// 구현 클래스 A
class ClassA implements MyInterface {
    @Override
    public void myAbstractMethod() {
        System.out.println("Implementation in ClassA");
    }
}

// 구현 클래스 B
class ClassB implements MyInterface {
    @Override
    public void myAbstractMethod() {
        System.out.println("Implementation in ClassB");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스 변수에 구현 객체 대입
        MyInterface objA = new ClassA();
        MyInterface objB = new ClassB();

        // 다형성을 통한 메소드 호출
        objA.myAbstractMethod(); // 출력: Implementation in ClassA
        objB.myAbstractMethod(); // 출력: Implementation in ClassB
    }
}

4. 다형성의 장점:

• 동일한 인터페이스를 구현하는 여러 클래스를 동일한 타입으로 다룰 수 있어 코드의 유연성이 증가합니다.
• 새로운 구현 클래스를 추가하거나 기존 클래스를 변경해도 클라이언트 코드 수정 없이 활용할 수 있습니다.

14. 인터페이스의 디폴트 메소드: 실행 코드를 갖는 인터페이스 멤버

1. 디폴트 메소드의 선언:

• 디폴트 메소드는 인터페이스에서 실행 코드를 갖는 메소드를 의미합니다.
• 디폴트 메소드는 default 키워드를 사용하여 선언됩니다.

2. 실행 코드 포함:

• 디폴트 메소드는 추상 메소드와 달리 실행 코드를 포함할 수 있습니다.
• 이로 인해 인터페이스의 메소드가 새로 추가되어도 기존 구현 클래스에 영향을 덜 주고 확장성을 제공합니다.

3. 예시 코드:

// 인터페이스 선언 (디폴트 메소드를 갖는)
interface MyInterface {
    // 추상 메소드 선언
    void myAbstractMethod();

    // 디폴트 메소드 선언
    default void myDefaultMethod() {
        System.out.println("Default implementation in MyInterface");
    }
}

// 인터페이스를 구현하는 클래스
class MyClass implements MyInterface {
    // 추상 메소드의 구현
    @Override
    public void myAbstractMethod() {
        System.out.println("Implementation of myAbstractMethod in MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스를 구현한 객체 생성
        MyClass myObject = new MyClass();

        // 추상 메소드 호출
        myObject.myAbstractMethod(); // 출력: Implementation of myAbstractMethod in MyClass

        // 디폴트 메소드 호출
        myObject.myDefaultMethod(); // 출력: Default implementation in MyInterface
    }
}

4. 장점 및 활용:

• 디폴트 메소드를 통해 새로운 메소드를 추가하거나 변경할 때, 기존 구현 클래스에 영향을 최소화할 수 있습니다.
• 인터페이스를 사용하는 모든 클래스들이 해당 디폴트 메소드를 활용할 수 있어 코드의 일관성을 유지할 수 있습니다.
• 디폴트 메소드를 통해 인터페이스를 확장하면서도 하위 호환성을 유지할 수 있습니다.

15. 디폴트 메소드의 재정의: 구현 클래스에서의 수정

1. 구현 클래스에서 디폴트 메소드 재정의:

• 구현 클래스에서는 인터페이스의 디폴트 메소드를 재정의(override)하여 자신에게 맞게 수정할 수 있습니다.
• 재정의된 디폴트 메소드가 구현 클래스에서 호출됩니다.

2. 메소드 재정의의 명시성:

• 디폴트 메소드를 재정의할 때는 @Override 어노테이션을 사용하여 명시성을 강조합니다.
• 재정의 메소드의 접근 제한자는 디폴트 메소드의 접근 제한자보다 넓거나 같아야 합니다.

3. 예시 코드:

// 인터페이스 선언 (디폴트 메소드를 갖는)
interface MyInterface {
    // 디폴트 메소드 선언
    default void myDefaultMethod() {
        System.out.println("Default implementation in MyInterface");
    }
}

// 인터페이스를 구현하는 클래스
class MyClass implements MyInterface {
    // 디폴트 메소드의 재정의
    @Override
    public void myDefaultMethod() {
        System.out.println("Custom implementation in MyClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스를 구현한 객체 생성
        MyClass myObject = new MyClass();

        // 디폴트 메소드 호출 (구현 클래스에서 재정의된 메소드 실행)
        myObject.myDefaultMethod(); // 출력: Custom implementation in MyClass
    }
}

4. 재정의의 활용:

• 디폴트 메소드를 재정의함으로써 인터페이스의 기본 동작을 수정하거나 새로운 동작을 추가할 수 있습니다.
• 구현 클래스에서는 자신의 상황에 맞게 디폴트 메소드를 재정의하여 사용할 수 있습니다.
• 인터페이스를 수정 없이 새로운 동작을 추가할 수 있는 유연성을 제공합니다.

16. 인터페이스의 정적 메소드: 구현 객체 없이 호출 가능

1. 정적 메소드의 선언:

• 인터페이스에서는 정적 메소드를 선언할 수 있습니다.
• 정적 메소드는 static 키워드를 사용하여 선언되며, 구현 객체 없이도 인터페이스를 통해 직접 호출할 수 있습니다.

2. 구현 객체의 필요 없음:

• 추상 메소드와 디폴트 메소드는 구현 객체가 필요한 반면, 정적 메소드는 구현 객체 없이도 호출이 가능합니다.
• 정적 메소드는 주로 특정한 연산이나 기능을 제공하거나, 인터페이스 자체의 동작과 무관한 기능을 제공하는 데 사용됩니다.

3. 예시 코드:

// 인터페이스 선언 (정적 메소드를 갖는)
interface MyInterface {
    // 정적 메소드 선언
    static void myStaticMethod() {
        System.out.println("Static method in MyInterface");
    }
}

public class Main {
    public static void main(String[] args) {
        // 정적 메소드 호출 (구현 객체 없이 인터페이스를 통해 직접 호출)
        MyInterface.myStaticMethod(); // 출력: Static method in MyInterface
    }
}

4. 정적 메소드의 활용:

• 특정 기능을 독립적으로 제공하거나, 유틸리티 기능을 구현할 때 정적 메소드를 활용할 수 있습니다.
• 구현 객체가 필요 없이 인터페이스명을 통해 바로 호출할 수 있어 편리하게 사용할 수 있습니다.
• 인터페이스의 확장성과 유연성을 제공합니다.

17. 인터페이스의 private 메소드: 구현 객체와 무관한 및 필요한 메소드

1. private 메소드의 선언:

• 인터페이스에서는 private 메소드를 선언할 수 있습니다.
• private 메소드는 구현 객체 외부에서 직접 접근할 수 없으며, 주로 구현 객체 내부에서 필요한 도우미 메소드로 사용됩니다.

2. private 정적 메소드의 선언:

• private 정적 메소드도 인터페이스에서 선언할 수 있습니다.
• private 정적 메소드는 구현 객체가 필요하지 않는 독립적인 기능을 제공하는데 활용됩니다.

3. private 메소드의 활용:

• 주로 복잡한 로직을 처리하는데 필요한 도우미 메소드나 중복 코드를 줄이는 용도로 private 메소드를 활용할 수 있습니다.
• 구현 객체 외부에서 직접 접근할 수 없으므로, 내부 구현의 세부사항을 숨기고 인터페이스의 명확성을 유지할 수 있습니다.

4. 예시 코드:

// 인터페이스 선언 (private 메소드를 갖는)
interface MyInterface {
    // 추상 메소드
    void myAbstractMethod();

    // default 메소드
    default void myDefaultMethod() {
        // private 메소드 호출 (구현 객체가 필요한 메소드)
        myPrivateMethod();
        System.out.println("Default implementation in MyInterface");
    }

    // private 메소드 (구현 객체가 필요한)
    private void myPrivateMethod() {
        System.out.println("Private method in MyInterface");
    }

    // private 정적 메소드 (구현 객체가 필요하지 않는)
    private static void myStaticPrivateMethod() {
        System.out.println("Static private method in MyInterface");
    }
}

public class Main {
    public static void main(String[] args) {
        // 인터페이스를 구현한 객체 생성
        MyInterface myObject = new MyInterface() {
            // 추상 메소드의 구현
            @Override
            public void myAbstractMethod() {
                System.out.println("Implementation of myAbstractMethod");
            }
        };

        // default 메소드 호출
        myObject.myDefaultMethod(); // 출력: Private method in MyInterface, Default implementation in MyInterface

        // private 정적 메소드 호출 (인터페이스명을 통해 호출)
        MyInterface.myStaticPrivateMethod(); // 출력: Static private method in MyInterface
    }
}

5. private 메소드의 장점:

• 인터페이스의 구현 내부에서만 필요한 메소드를 구현하여 외부에서의 접근을 제한함으로써 구현 객체의 세부사항을 숨길 수 있습니다.
• 코드의 재사용성을 높이고 유지보수성을 개선할 수 있습니다.

18. 다중 인터페이스 구현: 여러 인터페이스 동시 구현

1. 다중 인터페이스 구현:

• 하나의 클래스나 객체가 여러 개의 인터페이스를 동시에 구현할 수 있습니다.
• implements 키워드를 사용하여 여러 인터페이스를 쉼표로 구분하여 나열합니다.

2. 구현 객체의 특성 활용:

• 여러 인터페이스를 구현하는 클래스는 각 인터페이스에 정의된 메소드들을 모두 구현해야 합니다.
• 구현 객체는 각 인터페이스의 특성을 모두 활용할 수 있습니다.

3. 예시 코드:

// 첫 번째 인터페이스 선언
interface InterfaceA {
    void methodA();
}

// 두 번째 인터페이스 선언
interface InterfaceB {
    void methodB();
}

// 다중 인터페이스를 구현하는 클래스
class MultiInterfaceClass implements InterfaceA, InterfaceB {
    // 첫 번째 인터페이스의 메소드 구현
    @Override
    public void methodA() {
        System.out.println("Implementation of methodA");
    }

    // 두 번째 인터페이스의 메소드 구현
    @Override
    public void methodB() {
        System.out.println("Implementation of methodB");
    }
}

public class Main {
    public static void main(String[] args) {
        // 다중 인터페이스를 구현한 객체 생성
        MultiInterfaceClass multiObject = new MultiInterfaceClass();

        // 각 인터페이스의 메소드 호출
        multiObject.methodA(); // 출력: Implementation of methodA
        multiObject.methodB(); // 출력: Implementation of methodB
    }
}

4. 장점 및 활용:

• 다중 인터페이스 구현을 통해 여러 기능을 하나의 클래스에서 동시에 활용할 수 있습니다.
• 클래스 간의 결합도를 낮추고 유연성을 제공합니다.
• 다양한 인터페이스들을 조합하여 필요에 따라 기능을 확장할 수 있습니다.

19. 인터페이스 간의 상속: 다중 상속 및 구현 클래스의 의무

1. 인터페이스 간의 상속:

• 인터페이스는 다른 인터페이스를 상속할 수 있습니다.
• 자바에서는 클래스와는 달리 다중 상속을 허용하며, 여러 인터페이스를 쉼표로 나열하여 상속할 수 있습니다.

2. 구현 클래스의 의무:

• 자식 인터페이스를 구현한 클래스는 자식 인터페이스의 메소드 뿐만 아니라 부모 인터페이스의 모든 추상 메소드를 재정의해야 합니다.
• 이는 자식 인터페이스가 부모 인터페이스의 모든 요구사항을 충족해야 함을 의미합니다.

3. 예시 코드:

// 부모 인터페이스 선언
interface ParentInterface {
    void parentMethod();
}

// 자식 인터페이스 선언 (부모 인터페이스를 상속)
interface ChildInterface extends ParentInterface {
    void childMethod();
}

// 구현 클래스 (자식 인터페이스 구현)
class ImplementingClass implements ChildInterface {
    // 자식 인터페이스의 메소드 구현
    @Override
    public void childMethod() {
        System.out.println("Implementation of childMethod");
    }

    // 부모 인터페이스의 메소드 구현
    @Override
    public void parentMethod() {
        System.out.println("Implementation of parentMethod");
    }
}

public class Main {
    public static void main(String[] args) {
        // 구현 클래스 생성
        ImplementingClass obj = new ImplementingClass();

        // 자식 인터페이스의 메소드 호출
        obj.childMethod(); // 출력: Implementation of childMethod

        // 부모 인터페이스의 메소드 호출
        obj.parentMethod(); // 출력: Implementation of parentMethod
    }
}

4. 다중 상속의 활용:

• 다중 상속을 통해 여러 인터페이스의 기능을 하나의 클래스에서 동시에 활용할 수 있습니다.
• 다양한 기능을 조합하여 클래스를 구현할 때 다중 상속은 코드의 재사용성과 유연성을 제공합니다.
• 인터페이스 간의 관계를 이해하고 효과적으로 활용하기 위해 자식 인터페이스의 모든 메소드를 구현하는 것이 중요합니다.

20. 인터페이스 변수의 다형성: 메소드 호출 범위 제한

1. 자식 인터페이스 변수에 대입:

• 구현 객체가 자식 인터페이스 변수에 대입되면 자식 및 부모 인터페이스의 추상 메소드를 모두 호출할 수 있습니다.
• 변수의 타입이 실제 객체의 타입보다 상위 타입인 경우, 자동으로 다형성을 통해 부모 인터페이스의 메소드도 호출할 수 있습니다.

2. 부모 인터페이스 변수에 대입:

• 구현 객체가 부모 인터페이스 변수에 대입되면 부모 인터페이스에 선언된 추상 메소드만 호출할 수 있습니다.
• 변수의 타입이 구체적으로 명시된 경우, 해당 타입의 메소드만 호출할 수 있습니다.

3. 예시 코드:

// 부모 인터페이스 선언
interface ParentInterface {
    void parentMethod();
}

// 자식 인터페이스 선언 (부모 인터페이스를 상속)
interface ChildInterface extends ParentInterface {
    void childMethod();
}

// 구현 클래스 (자식 인터페이스 구현)
class ImplementingClass implements ChildInterface {
    // 자식 인터페이스의 메소드 구현
    @Override
    public void childMethod() {
        System.out.println("Implementation of childMethod");
    }

    // 부모 인터페이스의 메소드 구현
    @Override
    public void parentMethod() {
        System.out.println("Implementation of parentMethod");
    }
}

public class Main {
    public static void main(String[] args) {
        // 구현 객체를 자식 인터페이스 변수에 대입
        ChildInterface childVar = new ImplementingClass();

        // 자식 인터페이스의 메소드 호출
        childVar.childMethod(); // 출력: Implementation of childMethod

        // 부모 인터페이스의 메소드 호출 (다형성)
        childVar.parentMethod(); // 출력: Implementation of parentMethod

        // 구현 객체를 부모 인터페이스 변수에 대입
        ParentInterface parentVar = new ImplementingClass();

        // 자식 인터페이스의 메소드는 호출할 수 없음
        // parentVar.childMethod(); // 에러 발생

        // 부모 인터페이스의 메소드 호출
        parentVar.parentMethod(); // 출력: Implementation of parentMethod
    }
}

4. 다형성의 활용:

• 다형성을 활용하면 변수의 타입에 따라 다양한 메소드를 호출할 수 있어 유연성을 제공합니다.
• 부모 인터페이스 변수를 통해 일부 메소드만 사용할 수 있지만, 자식 인터페이스 변수를 통해 다양한 기능을 활용할 수 있습니다.

21. 인터페이스의 타입 변환: 자동 타입 변환과 강제 타입 변환

1. 자동 타입 변환:

• 구현 클래스가 인터페이스를 구현했을 경우, 구현 객체는 해당 인터페이스로 자동 타입 변환이 가능합니다.
• 부모 타입으로 자동 변환되어, 부모 인터페이스에 선언된 메소드만 호출할 수 있습니다.

2. 강제 타입 변환:

• 자동 타입 변환이 이루어진 상태에서, 다시 원래의 구현 클래스 타입으로 돌리는 것을 강제 타입 변환이라고 합니다.
• 강제 타입 변환은 명시적으로 타입을 지정하며, 부모 타입에서 자식 타입으로 변환됩니다.
• 주의해야 할 점은 이 과정에서 발생할 수 있는 ClassCastException 등의 예외를 처리해야 합니다.

3. 예시 코드:

// 부모 인터페이스 선언
interface ParentInterface {
    void parentMethod();
}

// 구현 클래스 (인터페이스 구현)
class ImplementingClass implements ParentInterface {
    // 부모 인터페이스의 메소드 구현
    @Override
    public void parentMethod() {
        System.out.println("Implementation of parentMethod");
    }

    // 구현 클래스 자체의 메소드
    void additionalMethod() {
        System.out.println("Additional method in ImplementingClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 구현 객체 생성
        ImplementingClass obj = new ImplementingClass();

        // 자동 타입 변환 (부모 인터페이스로)
        ParentInterface parentVar = obj;

        // 부모 인터페이스의 메소드 호출 (자동 타입 변환)
        parentVar.parentMethod(); // 출력: Implementation of parentMethod

        // 추가 메소드는 호출할 수 없음 (부모 인터페이스에 없는 메소드)
        // parentVar.additionalMethod(); // 에러 발생

        // 강제 타입 변환 (다시 구현 클래스로)
        ImplementingClass backToClass = (ImplementingClass) parentVar;

        // 구현 클래스의 메소드 호출 (강제 타입 변환 후)
        backToClass.additionalMethod(); // 출력: Additional method in ImplementingClass
    }
}

4. 다형성과 유연성 활용:

• 다형성을 통해 부모 인터페이스로 일반적인 동작을 처리하면서, 필요에 따라 구현 클래스의 고유한 메소드도 호출할 수 있습니다.
• 타입 변환은 유연성을 제공하며, 인터페이스를 통한 프로그래밍에서 자주 활용됩니다.

22. 매개변수의 다형성: 다양한 구현 객체 대입 가능

1. 매개변수의 다형성:

• 메소드의 매개변수 타입을 특정 인터페이스로 선언하면, 해당 인터페이스를 구현한 다양한 구현 객체를 매개변수로 전달할 수 있습니다.
• 이를 통해 다양한 구현 객체들을 하나의 메소드에서 활용할 수 있어 코드의 재사용성과 유연성을 높일 수 있습니다.

2. 예시 코드:

// 인터페이스 선언
interface MyInterface {
    void interfaceMethod();
}

// 구현 클래스1 (인터페이스 구현)
class Implementation1 implements MyInterface {
    @Override
    public void interfaceMethod() {
        System.out.println("Implementation1 of interfaceMethod");
    }
}

// 구현 클래스2 (인터페이스 구현)
class Implementation2 implements MyInterface {
    @Override
    public void interfaceMethod() {
        System.out.println("Implementation2 of interfaceMethod");
    }
}

// 메소드의 매개변수로 인터페이스 타입 지정
void myMethod(MyInterface param) {
    // 인터페이스의 메소드 호출
    param.interfaceMethod();
}

public class Main {
    public static void main(String[] args) {
        // 구현 객체1을 매개변수로 전달
        MyInterface obj1 = new Implementation1();
        myMethod(obj1); // 출력: Implementation1 of interfaceMethod

        // 구현 객체2를 매개변수로 전달
        MyInterface obj2 = new Implementation2();
        myMethod(obj2); // 출력: Implementation2 of interfaceMethod
    }
}

3. 다형성을 활용한 장점:

• 매개변수의 다형성을 활용하면 한 메소드가 여러 가지 구현 객체를 다룰 수 있어 유연하고 확장 가능한 코드를 작성할 수 있습니다.
• 구현 객체가 새롭게 추가되어도 메소드의 변경 없이 활용할 수 있어 유지보수성을 향상시킵니다.

23. 인터페이스에서의 타입 확인: instanceof 연산자 활용

1. instanceof 연산자:

• instanceof 연산자는 객체가 특정 클래스 또는 인터페이스의 인스턴스인지를 확인하는 데 사용됩니다.
• 인터페이스에서도 instanceof를 통해 해당 인터페이스를 구현한 객체인지를 확인할 수 있습니다.

2. 예시 코드:

// 인터페이스 선언
interface MyInterface {
    void interfaceMethod();
}

// 구현 클래스 (인터페이스 구현)
class ImplementationClass implements MyInterface {
    @Override
    public void interfaceMethod() {
        System.out.println("ImplementationClass of interfaceMethod");
    }

    // 클래스 자체의 메소드
    void additionalMethod() {
        System.out.println("Additional method in ImplementationClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // 구현 객체 생성
        MyInterface obj = new ImplementationClass();

        // instanceof를 통한 타입 확인
        if (obj instanceof MyInterface) {
            System.out.println("obj is an instance of MyInterface");
        }

        // 추가 메소드를 호출하기 위해 타입 변환
        if (obj instanceof ImplementationClass) {
            ImplementationClass implObj = (ImplementationClass) obj;
            implObj.additionalMethod(); // 출력: Additional method in ImplementationClass
        }
    }
}

3. 다형성과 instanceof 활용:

• 다형성을 활용하여 부모 타입의 변수로 다양한 구현 객체를 다룰 때, instanceof를 사용하여 실제 타입을 확인할 수 있습니다.
• 이를 통해 특정 인터페이스를 구현한 객체인지 확인하거나, 다양한 구현 클래스 중에서 특정 클래스의 인스턴스인지를 판단할 수 있습니다.

24. 봉인된 인터페이스와 non-sealed: 자식 인터페이스 생성 제어

1. 봉인된 인터페이스:

• Java 15부터 도입된 봉인된 인터페이스(Sealed Interface)를 사용하면 특정 인터페이스를 구현하는 자식 인터페이스의 생성을 제어할 수 있습니다.
• 봉인된 인터페이스는 특정한 자식 인터페이스들을 명시하고, 그 외에는 다른 인터페이스가 상속되지 못하도록 합니다.

2. non-sealed 키워드:

• 봉인된 인터페이스에서 특정 자식 인터페이스를 봉인 해제하려면 non-sealed 키워드를 사용합니다.
• non-sealed로 지정된 인터페이스는 해당 인터페이스를 상속하는 다양한 자식 인터페이스를 생성할 수 있습니다.

3. 예시 코드:

// 봉인된 인터페이스 선언
public sealed interface SealedInterface permits ChildInterface1, ChildInterface2 {
    void commonMethod();
}

// 봉인된 인터페이스의 봉인 해제 (non-sealed)
public non-sealed interface ChildInterface1 extends SealedInterface {
    void specificMethod1();
}

// 봉인된 인터페이스의 봉인 해제 (non-sealed)
public non-sealed interface ChildInterface2 extends SealedInterface {
    void specificMethod2();
}

// 봉인된 인터페이스의 자식 인터페이스 (non-sealed)
public non-sealed interface ChildInterface3 extends SealedInterface {
    void specificMethod3();
}

// 구현 클래스 (봉인된 인터페이스의 자식 인터페이스 구현)
class ImplementationClass1 implements ChildInterface1 {
    @Override
    public void commonMethod() {
        System.out.println("ImplementationClass1 of commonMethod");
    }

    @Override
    public void specificMethod1() {
        System.out.println("ImplementationClass1 of specificMethod1");
    }
}

public class Main {
    public static void main(String[] args) {
        // 구현 객체 생성
        ChildInterface1 obj1 = new ImplementationClass1();

        // 봉인된 인터페이스의 메소드 호출
        obj1.commonMethod();      // 출력: ImplementationClass1 of commonMethod
        obj1.specificMethod1();   // 출력: ImplementationClass1 of specificMethod1
    }
}

4. 봉인된 인터페이스와 non-sealed의 활용:

• 봉인된 인터페이스를 통해 특정한 자식 인터페이스들을 명시하고, 그 외에는 봉인을 해제하여 다양한 인터페이스를 생성할 수 있습니다.
• 이를 통해 인터페이스 간의 제약을 명확하게 설정하여 코드의 유지보수성을 높일 수 있습니다.