추상화: Java의 인터페이스 디코딩-java지도 시간-php.cn

집

Java

java지도 시간

추상화: Java의 인터페이스 디코딩

Susan Sarandon

Nov 03, 2024 am 06:58 AM

Abstraction: Decoding Interfaces in Java

Java에서 인터페이스는 클래스가 준수해야 하는 계약 역할을 합니다. 인터페이스는 (메서드 시그니처를 통해) 무엇을 할 수 있는지에 대한 지식만 제공하고 수행 방법을 숨기므로(구현을 클래스에 맡김으로써) 인터페이스 구현) 추상화를 달성합니다. 무엇과 어떻게를 분리하는 것이 추상화의 핵심 아이디어입니다.

Java 8에서는 인터페이스가 순전히 추상적인 동작 이상으로 발전하여 기본 및 정적 메소드를 지원하여 유연성과 이전 버전과의 호환성을 향상시켰습니다.

이 게시물에서는 개념을 이해하는 데 도움이 되는 코드 예제를 통해 인터페이스와 주요 기능, 인터페이스와 추상 클래스 간의 차이점을 자세히 살펴봅니다.

인터페이스란 무엇인가요?

Java의 인터페이스는 구현 클래스가 따라야 하는 동작(메서드) 집합을 지정합니다. 메서드 서명과 상수만 포함됩니다. 추상 클래스와 달리 인터페이스는 클래스가 두 개 이상의 인터페이스를 구현할 수 있도록 하여 다중 상속을 허용합니다.

인터페이스의 주요 기능:

인터페이스의 변수는 암시적으로 공개, 정적, 최종 변수입니다.
모든 메소드는 암시적으로 공개적이고 추상적입니다(Java 8 이전).
클래스는 다중 인터페이스를 구현하여 클래스의 단일 상속 제한을 극복할 수 있습니다.
Java 8 이상에서는 인터페이스에 기본 메서드와 정적 메서드도 포함될 수 있어 이전 버전과의 호환성이 향상됩니다.

기본: 인터페이스 구문

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

로그인 후 복사

주요 개념 설명:

1. 인터페이스의 변수:

public: 인터페이스를 구현하는 모든 클래스에서 액세스할 수 있습니다.
static: 인터페이스 이름을 사용하여 직접 접근할 수 있습니다.
final: 일관성을 보장하기 위해 초기화된 값의 수정을 방지합니다.

참고: 정적 최종 변수는 선언 시 또는 정적 블록 내에서 초기화될 수 있습니다. 그러나 인터페이스는 정적 블록을 허용하지 않으므로 이러한 변수는 선언 중에 초기화되어야 합니다.

2. 추상 메소드:

본문이나 구현이 없는 메서드 서명입니다.
인터페이스에서는 기본적으로 공개되어 있습니다.
모든 추상 메소드는 구현 클래스에 의해 재정의되어야 합니다.

3. 기본 방법:

인터페이스의 메소드에 대한 기본 구현을 제공하기 위해 Java 8에 도입되었습니다.
이러한 방법은 기본적으로 공개됩니다.
클래스를 구현하면 클래스를 재정의할 수 있지만 필수는 아닙니다.
여기서 "기본값"은 접근 한정자가 아닙니다; 이는 단순히 메소드가 추상적이지 않고 구체적인 구현이 가능함을 나타냅니다.
이 기능은 개발자가 이전 버전과의 호환성을 중단하지 않고 기존 인터페이스를 확장하는 데 도움이 됩니다.

4. 정적 메소드:

정적 메소드는 인터페이스에 속합니다.
인터페이스 이름을 통해서만 액세스할 수 있습니다.
이러한 방법은 기본적으로 공개됩니다.
클래스를 구현해도 상속되지 않습니다.
정적 메소드는 재정의할 수 없습니다.

Java로 인터페이스 구현

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

로그인 후 복사

주요 개념 설명:

메서드 액세스:
기본 메서드(concreteMethod())와 재정의된 메서드(abstractMethod())는 클래스 인스턴스 obj를 사용하여 액세스되며, 두 가지 유형의 메서드를 모두 호출할 수 있는 방법을 보여줍니다.
인터페이스 변수 액세스:
인터페이스 변수 id는 인터페이스 이름(InterfaceBasics.id)과 구현 클래스 이름(InterfaceBasicsImpl.id)을 모두 사용하여 액세스할 수 있습니다. 이는 인터페이스의 정적 최종 변수가 상속되어 구현 클래스가 변수를 참조할 수 있음을 보여줍니다.
정적 메소드 액세스:
정적 메서드 staticMethod()는 인터페이스 이름(InterfaceBasics.staticMethod())을 통해서만 호출할 수 있습니다. 구현 클래스(InterfaceBasicsImpl.staticMethod())를 통해 이에 액세스하려고 하면 인터페이스의 정적 메서드가 상속되지 않
으므로 컴파일 시간 오류가 발생합니다.

왜 기본 메소드와 정적 메소드를 사용하나요?

1. 기본 방법

Java 8 이전에는 인터페이스에 새로운 메소드를 추가하는 것이 중요한 과제였습니다. 새로운 기능을 사용하려면 모든 구현 클래스를 업데이트해야 했으며, 이로 인해 대규모 코드베이스가 크게 변경되는 경우가 많았습니다.

기본 메소드가 도입되면서 인터페이스는 이제 새로운 메소드에 대한 구체적인 구현을 제공하여 이전 버전과의 호환성을 보장할 수 있습니다. 즉, 기존 수업은 변경되지 않은 채로 새로운 기능의 혜택을 계속 누릴 수 있습니다.

이 디자인 선택은 컬렉션 프레임워크에 스트림 및 람다 기능을 추가할 수 있는 길을 열었습니다.

2. 정적 방법

정적 메소드는 인터페이스와 관련된 유틸리티 기능을 제공하며 클래스를 구현하여 재정의할 필요가 없습니다.

Java는 정적 메소드를 인터페이스 자체에 연결하고 상속을 방지함으로써 다이아몬드 문제로 널리 알려진 여러 인터페이스 간의 메소드 이름 충돌로 인해 발생할 수 있는 잠재적인 모호성과 혼란을 방지합니다.

사용 사례 예시: 다음은 구성 로깅을 위한 정적 메서드가 있는 인터페이스의 실제 사용 사례입니다.

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

로그인 후 복사

이 예에서 정적 메소드 getDefaultLogFileName()은 인터페이스 내에서 구현을 깔끔하게 유지하고 캡슐화하면서 기본 로그 파일 이름을 검색하는 방법을 제공합니다.

인터페이스는 추상 클래스와 어떻게 다른가요?

기본 메소드를 사용하더라도 인터페이스는 추상 클래스와 구별됩니다.

Aspect	Interface	Abstract Class
Methods	Can have abstract, default, and static methods	Can have abstract and non-abstract methods
Variables	Only public, static, and final variables	Can have any access modifier and instance variables
Inheritance	Supports multiple inheritance	Supports single inheritance
Constructors	Cannot have constructors	Can have constructors

측면 인터페이스 추상 클래스 방법 추상, 기본, 정적 메소드를 가질 수 있습니다 추상 및 비추상 메소드를 가질 수 있습니다 변수 공개, 정적, 최종 변수만 모든 액세스 수정자와 인스턴스 변수를 가질 수 있습니다 상속 다중 상속 지원 단일 상속 지원 생성자 생성자를 가질 수 없습니다 생성자를 가질 수 있음

기본 메소드는 이전 버전과의 호환성이 필요한 기존 인터페이스를 확장하는 경우에만 사용해야 합니다. 이는 추상 클래스를 대체하지 않습니다.

인터페이스에 대한 일반적인 면접 질문

1. 인터페이스 변수를 수정할 수 있나요?

아니요, 인터페이스 변수는 암시적으로 최종적입니다. 즉, 할당된 후에는 해당 값을 변경할 수 없습니다.

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

로그인 후 복사

2. 기본 메서드와 정적 메서드를 모두 선언할 수 있나요?

아니요. 기본 메서드는 클래스 구현을 통해 재정의할 수 있는 구체적인 구현을 제공하므로 유연성이 허용됩니다. 이와 대조적으로 정적 메서드는 인터페이스 자체에 속하며 재정의할 수 없으며 유틸리티 기능을 제공합니다. 따라서 이 둘은 함께 사용할 수 없습니다.

package oops.interfaces;

// A class implementing the InterfaceBasics interface
public class InterfaceBasicsImpl implements InterfaceBasics {

    // Mandatory: Override all abstract methods from the interface
    @Override
    public void abstractMethod() {
        System.out.println("Overridden Method Called");
    }

    public static void main(String[] args) {
        InterfaceBasics obj = new InterfaceBasicsImpl();

        // Calling interface's default and overridden methods
        obj.concreteMethod();  // Output: Default Method Called
        obj.abstractMethod();  // Output: Overridden Method Called

        // Accessing interface variables (static and final by default)
        // Interface variables are inherited
        // Possible with both interface name and implementing class name
        System.out.println(InterfaceBasics.id);        // Output: 90
        System.out.println(InterfaceBasicsImpl.id);    // Output: 90

        // Cannot assign a value to final variable 'id'
        InterfaceBasicsImpl.id = 100;  // --> Compile Error

        // Calling static method using interface name
        // Cannot access using implementing class name
        // Interface static methods are NOT inherited
        InterfaceBasics.staticMethod();  // Output: Static Method Called
    }
}

로그인 후 복사

3. 인터페이스의 정적 메서드를 상속할 수 없는 이유는 무엇입니까?

정적 메서드는 클래스의 특정 인스턴스가 아닌 인터페이스 자체와 연결되어 있습니다. 즉, 정적 메서드는 인터페이스 전체에 속합니다. 클래스 구현을 통해 정적 메서드가 상속된 경우 어떤 메서드가 호출되는지에 대한 모호함과 혼란이 발생할 수 있습니다. 특히 여러 인터페이스가 동일한 이름의 메서드를 정의하는 경우 더욱 그렇습니다.

예:

package oops.interfaces.example;

public interface Logger {

    // Using a variable to store the default log file name
    String DEFAULT_LOG_FILE_NAME = "application.log";

    // Static method to get the default log file name with configuration
    static String getDefaultLogFileName() {
        // Simulating configuration retrieval
        // Could be from a properties file or environment variable
        String logFileName = System.getenv("LOG_FILE_NAME");

        // If a log file name is set in the environment, return it;
        // Otherwise, return the default
        if (logFileName != null && !logFileName.isEmpty()) {
            return logFileName;
        } else {
            return DEFAULT_LOG_FILE_NAME;
        }
    }
}

public class FileLogger implements Logger {

    public static void main(String[] args) {
        // Using the interface variable
        String defaultLogFile = Logger.DEFAULT_LOG_FILE_NAME;

        // Using the static method
        if ("FILE".equals(System.getenv("LOG_TYPE"))) {
            defaultLogFile = Logger.getDefaultLogFileName();
        }

        System.out.println("Log file used: " + defaultLogFile);
    }
}

로그인 후 복사

정적 메소드를 인터페이스에만 연결함으로써 Java는 명확성을 유지하고 악명 높은 다중 상속의 다이아몬드 문제로 이어지는 메소드 해결 시 잠재적인 충돌을 방지합니다.

결론

Java의 인터페이스는 구현 클래스가 준수해야 하는 동작을 정의하여 추상화를 달성하는 데 중요한 역할을 합니다. Java 8에 기본 및 정적 메서드가 도입되면서 인터페이스는 이전 버전과의 호환성을 허용하고 인터페이스 내에서 직접 유틸리티 메서드를 제공하는 등 더욱 강력해졌습니다.

그러나 인터페이스는 추상 클래스를 대체하지 않습니다. 동작에 대한 계약을 정의해야 할 때, 특히 다중 상속이 필요한 경우

에 사용해야 합니다.