Abstraktion: Dekodierung von Schnittstellen in Java-javaLernprogramm-php.cn

Abstraction: Decoding Interfaces in Java

In Java dienen Schnittstellen als Verträge, die Klassen einhalten müssen. Da eine Schnittstelle nur das Wissen darüber bereitstellt, was getan werden kann (über Methodensignaturen) und verbirgt, wie es gemacht wird (indem es die Implementierung den Klassen überlässt). Wenn Sie die Schnittstelle implementieren, wird eine Abstraktion erreicht. Diese Trennung von Was und Wie ist der Kerngedanke hinter der Abstraktion.

Mit Java 8 haben sich Schnittstellen über rein abstraktes Verhalten hinaus entwickelt und unterstützen Standard- und statische-Methoden, um die Flexibilität und Abwärtskompatibilität zu verbessern.

Dieser Beitrag befasst sich mit Schnittstellen, ihren Hauptfunktionen und den Unterschieden zwischen Schnittstellen und abstrakten Klassen, mit Codebeispielen, die Ihnen helfen, die Konzepte zu verstehen.

Was ist eine Schnittstelle?

Eine Schnittstelle in Java spezifiziert einen Satz von Verhaltensweisen (Methoden), denen die implementierende Klasse folgen muss. Es enthält nur die Methodensignaturen und Konstanten. Im Gegensatz zu abstrakten Klassen ermöglichen Schnittstellen Mehrfachvererbung, indem sie es einer Klasse ermöglichen, mehr als eine Schnittstelle zu implementieren.

Hauptmerkmale von Schnittstellen:

Variablen in Schnittstellen sind implizit öffentlich, statisch und endgültig.
Alle Methoden sind implizit öffentlich und abstrakt (vor Java 8).
Eine Klasse kann mehrere Schnittstellen implementieren und so die Einzelvererbungsbeschränkung von Klassen überwinden.
Ab Java 8 können Schnittstellen auch Standard- und statische Methoden enthalten, wodurch die Abwärtskompatibilität verbessert wird.

Die Grundlagen: Schnittstellensyntax

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");
    }
}

Nach dem Login kopieren

Erläuterung der Schlüsselkonzepte:

1. Variablen in Schnittstellen:

öffentlich: Zugänglich für jede Klasse, die die Schnittstelle implementiert.
statisch: Direkter Zugriff über den Schnittstellennamen.
final: Verhindert die Änderung des Werts nach der Initialisierung, um Konsistenz sicherzustellen.

Hinweis: Statische Endvariablen können entweder zum Zeitpunkt der Deklaration oder innerhalb statischer Blöcke initialisiert werden. Da Schnittstellen jedoch keine statischen Blöcke zulassen, diese Variablen müssen bei der Deklaration initialisiert werden.

2. Abstrakte Methoden:

Dies sind Methodensignaturen ohne Textkörper oder Implementierung.
Sie sind standardmäßig öffentlich in einer Schnittstelle.
Alle abstrakten Methoden müssen von der implementierenden Klasse überschrieben werden.

3. Standardmethoden:

Eingeführt in Java 8, um eine Standardimplementierung für Methoden in Schnittstellen bereitzustellen.
Diese Methoden sind standardmäßig öffentlich.
Implementierende Klassen können sie überschreiben, aber es ist nicht obligatorisch.
Hier ist „Standard“ kein Zugriffsmodifikator; es zeigt lediglich an, dass die Methode nicht abstrakt ist und eine konkrete Implementierung haben kann.
Diese Funktion hilft Entwicklern, bestehende Schnittstellen zu erweitern, ohne die Abwärtskompatibilität zu beeinträchtigen.

4. Statische Methoden:

Statische Methoden gehören zur Schnittstelle.
Sie können nur über den Schnittstellennamen aufgerufen werden.
Diese Methoden sind standardmäßig öffentlich.
Sie werden nicht vererbt durch die Implementierung von Klassen.
Statische Methoden können nicht überschrieben werden.

Implementieren einer Schnittstelle in 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");
    }
}

Nach dem Login kopieren

Erklärung der Schlüsselkonzepte:

Methodenzugriff:
Der Zugriff auf die Standardmethode (concreteMethod()) und die überschriebene Methode (abstractMethod()) erfolgt über die Klasseninstanz obj und zeigt, wie beide Arten von Methoden aufgerufen werden können.
Zugriff auf Schnittstellenvariablen:
Auf die Schnittstellenvariablen-ID kann sowohl über den Schnittstellennamen (InterfaceBasics.id) als auch über den Namen der implementierenden Klasse (InterfaceBasicsImpl.id) zugegriffen werden. Dies zeigt, dass statische Endvariablen in einer Schnittstelle vererbt werden, sodass die implementierende Klasse auf die Variable verweisen kann.
Statischer Methodenzugriff:
Die statische Methode staticMethod() kann nur über den Schnittstellennamen (InterfaceBasics.staticMethod()) aufgerufen werden. Der Versuch, über die implementierende Klasse (InterfaceBasicsImpl.staticMethod()) darauf zuzugreifen, führt zu einem Fehler bei der Kompilierung, da statische Methoden in Schnittstellen nicht vererbt werden.

Warum Standard- und statische Methoden?

1. Standardmethoden

Vor Java 8 stellte das Hinzufügen neuer Methoden zu Schnittstellen eine große Herausforderung dar. Jede neue Funktionalität erforderte die Aktualisierung aller implementierenden Klassen, was häufig zu bahnbrechenden Änderungen in großen Codebasen führte.

Mit der Einführung von Standardmethoden können Schnittstellen nun eine konkrete Implementierung für neue Methoden bereitstellen und so Abwärtskompatibilität gewährleisten. Das bedeutet, dass bestehende Klassen unverändert bleiben und dennoch von neuen Funktionen profitieren können.

Diese Designwahl ebnete auch den Weg für das Hinzufügen von Streams- und Lambdas-Funktionalität zum Collections Framework.

2. Statische Methoden

Statische Methoden stellen für die Schnittstelle relevante Hilfsfunktionen bereit und müssen nicht durch implementierende Klassen überschrieben werden.

Durch die Bindung statischer Methoden an die Schnittstelle selbst und die Verhinderung der Vererbung vermeidet Java potenzielle Mehrdeutigkeiten und Verwirrung, die durch Kollisionen von Methodennamen über mehrere Schnittstellen hinweg entstehen könnten, die im Volksmund als Diamantproblem bekannt sind.

Beispielhafter Anwendungsfall: Hier ist ein realer Anwendungsfall einer Schnittstelle mit einer statischen Methode zur Protokollierungskonfiguration:

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");
    }
}

Nach dem Login kopieren

In diesem Beispiel bietet die statische Methode getDefaultLogFileName() eine Möglichkeit, den Standardprotokolldateinamen abzurufen und gleichzeitig die Implementierung sauber und innerhalb der Schnittstelle gekapselt zu halten.

Wie unterscheiden sich Schnittstellen noch von abstrakten Klassen?

Selbst mit Standardmethoden unterscheiden sich Schnittstellen weiterhin von abstrakten Klassen:

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

Aspekt Schnittstelle Abstrakte Klasse Methoden Kann abstrakte, standardmäßige und statische Methoden haben Kann abstrakte und nicht abstrakte Methoden haben Variablen Nur öffentliche, statische und endgültige Variablen Kann beliebige Zugriffsmodifikatoren und Instanzvariablen haben Vererbung Unterstützt Mehrfachvererbung Unterstützt Einzelvererbung Konstruktoren Kann keine Konstruktoren haben Kann Konstruktoren haben

Standardmethoden sollten nur zur Erweiterung vorhandener Schnittstellen verwendet werden, wenn Abwärtskompatibilität erforderlich ist. Sie sind kein Ersatz für abstrakte Klassen.

Häufige Fragen im Vorstellungsgespräch zu Schnittstellen

1. Kann eine Schnittstellenvariable geändert werden?

Nein, Schnittstellenvariablen sind implizit endgültig, was bedeutet, dass ihr Wert nach der Zuweisung nicht mehr geändert werden kann.

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");
    }
}

Nach dem Login kopieren

2. Können wir eine Methode sowohl als Standardmethode als auch als statische Methode deklarieren?

Nein. Eine Standardmethode stellt eine konkrete Implementierung bereit, die durch die Implementierung von Klassen überschrieben werden kann, was Flexibilität ermöglicht. Im Gegensatz dazu gehört eine statische Methode zur Schnittstelle selbst, kann nicht überschrieben werden und bietet Hilfsfunktionen. Daher könnendie beiden nicht zusammen verwendet werden.

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
    }
}

Nach dem Login kopieren

3. Warum können statische Methoden in Schnittstellen nicht vererbt werden?

Statische Methoden sind mit der Schnittstelle selbst verknüpft und nicht mit einer bestimmten Instanz einer Klasse, was bedeutet, dass sie zur Schnittstelle als Ganzes gehören. Wenn statische Methoden von implementierenden Klassen geerbt würden, könnte dies zu Mehrdeutigkeit und Verwirrung darüber führen, welche Methode aufgerufen wird, insbesondere wenn mehrere Schnittstellen Methoden mit demselben Namen definieren.

Zum Beispiel:

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);
    }
}

Nach dem Login kopieren

Dadurch, dass statische Methoden nur an die Schnittstelle gebunden bleiben, sorgt Java für Klarheit und vermeidet potenzielle Konflikte bei der Methodenauflösung, die zum berüchtigten Diamond-Problem der Mehrfachvererbung führen.

Fazit

Schnittstellen in Java spielen eine entscheidende Rolle beim Erreichen der Abstraktion, indem sie das Verhalten definieren, das implementierende Klassen einhalten müssen. Mit der Einführung von Standardmethoden und statischen Methoden in Java 8 sind Schnittstellen noch leistungsfähiger geworden, was Abwärtskompatibilität ermöglicht und Hilfsmethoden direkt innerhalb von Schnittstellen bereitstellt.

Schnittstellen sind jedoch kein Ersatz für abstrakte Klassen. Sie sollten verwendet werden, wenn Sie einen Vertrag für das Verhalten definieren müssen, insbesondere wenn Mehrfachvererbung erforderlich ist.

Wichtige Erkenntnisse:

Schnittstellen bieten Abstraktion, indem sie definieren, was eine Klasse tun soll, ohne anzugeben, wie.
Variablen in Schnittstellen sind immer öffentlich, statisch und endgültig.
Standard- und statische Methoden, eingeführt in Java 8, ermöglichen Abwärtskompatibilität und Dienstprogrammimplementierungen innerhalb von Schnittstellen.
Statische Methoden in Schnittstellen werden nicht vererbt, was Klarheit in ihrer Verwendung gewährleistet.

Wenn Sie verstehen, wie und wann Sie Schnittstellen verwenden, verbessern Sie nicht nur Ihre Programmierkenntnisse, sondern bereiten Sie auch auf Interviewfragen rund um OOPs-Konzepte und Java-Designmuster vor.