Schnittstellen und abstrakte Klassen in Java

Schnittstellen und abstrakte Klassen sind die wesentlichen Komponenten zum Erreichen von Abstraktion und Polymorphismus.

Was sind Schnittstellen?

Eine Schnittstelle in Java ist ein Referenztyp, ähnlich einer Klasse, der nur abstrakte Methoden, statische Methoden, Standardmethoden und statische Endvariablen (Konstanten) enthalten kann. Schnittstellen werden verwendet, um Abstraktion und Mehrfachvererbung in Java zu erreichen. Schnittstellen werden möglicherweise nicht direkt instanziiert.

?Vor Java 8 konnten Schnittstellen nur abstrakte Methoden haben.
Die Implementierung dieser Methoden muss in einer separaten Klasse bereitgestellt werden. Wenn also einer Schnittstelle eine neue Methode hinzugefügt werden soll, muss deren Implementierungscode in der Klasse bereitgestellt werden, die dieselbe Schnittstelle implementiert.

?Um dieses Problem zu lösen, hat Java 8 das Konzept der Standardmethoden eingeführt, die es den Schnittstellen ermöglichen, Methoden mit Implementierung zu haben, ohne Auswirkungen auf die Klassen zu haben, die die Schnittstelle implementieren .

Standardmethoden können überschrieben werden, indem bei Bedarf Klassen implementiert werden.

Hauptmerkmale von Schnittstellen

• Abstrakte Methoden: Methoden ohne Körper, deklariert mit dem Schlüsselwort abstract.
• Standardmethoden: Methoden mit einem Körper, eingeführt in Java 8, die es Schnittstellen ermöglichen, Standardimplementierungen bereitzustellen.
• Statische Methoden: Methoden, die zur Schnittstelle selbst gehören, nicht zu Instanzen der Schnittstelle.
• Konstanten: Als statisch und endgültig deklarierte Variablen, die implizit öffentlich sind.

Was sind abstrakte Klassen?

Eine abstrakte Klasse in Java ist eine Klasse, die nicht einzeln instanziiert werden kann und abstrakte Methoden (Methoden ohne Körper) und konkrete Methoden (Methoden mit Körper) enthalten kann. Abstrakte Klassen werden verwendet, um eine gemeinsame Basis für Unterklassen bereitzustellen und so die Wiederverwendung von Code und die Definition von gemeinsamem Verhalten zu ermöglichen.

Hauptmerkmale abstrakter Klassen

• Abstrakte Methoden: Methoden ohne Körper, deklariert mit dem Schlüsselwort abstract.
• Konkrete Methoden: Methoden mit einem Körper, die Standardimplementierungen bereitstellen.
• Konstruktoren: Abstrakte Klassen können Konstruktoren haben, aber sie können nicht direkt instanziiert werden.
• Instanzvariablen: Abstrakte Klassen können Instanzvariablen und statische Variablen haben.

Unterschiede zwischen Schnittstellen und abstrakten Klassen

Mehrfachvererbung

• Schnittstellen: Java unterstützt die Mehrfachvererbung über Schnittstellen, sodass eine Klasse mehrere Schnittstellen implementieren kann.
• Abstrakte Klassen: Java unterstützt keine Mehrfachvererbung von Klassen, was bedeutet, dass eine Klasse nur eine abstrakte Klasse erweitern kann.

Methodenkörper

• Schnittstellen: Vor Java 8 konnten Schnittstellen keine Methodenkörper enthalten. Mit Java 8 können Standard- und statische Methoden Körper haben.
• Abstrakte Klassen: Abstrakte Klassen können sowohl abstrakte Methoden (ohne Körper) als auch konkrete Methoden (mit Körpern) enthalten.

Variablen

• Schnittstellen: Variablen in Schnittstellen sind implizit öffentlich, statisch und endgültig.
• Abstrakte Klassen: Abstrakte Klassen können Instanzvariablen, statische Variablen und Konstanten haben.

Verwendung

• Schnittstellen: Ideal zum Definieren von Verträgen, die mehrere Klassen implementieren können.
• Abstrakte Klassen: Geeignet, um eine gemeinsame Basis für eine Familie verwandter Klassen bereitzustellen und Code und Verhalten auszutauschen.

Javas Ansatz zur Vererbung

Java unterstützt nur die Einzelvererbung, was bedeutet, dass jede Klasse Felder und Methoden nur einer Klasse erben kann. Wenn Sie Eigenschaften von mehr als einer Quelle erben müssen, bietet Java das Konzept der Schnittstellen, eine Form der Mehrfachvererbung.

?Schnittstellen ähneln Klassen. Sie definieren jedoch nur die Signatur der Methoden und nicht deren Implementierungen. Die in der Schnittstelle deklarierten Methoden werden in den Klassen implementiert. Mehrfachvererbung tritt auf, wenn eine Klasse mehrere Schnittstellen implementiert.

In Java wird Mehrfachvererbung durch Schnittstellen und nicht durch Klassen erreicht. Dadurch kann eine Klasse mehrere Schnittstellen implementieren und die Methodensignaturen von jeder von ihnen erben. Unten finden Sie ein Beispiel, das die Mehrfachvererbung mithilfe von Schnittstellen demonstriert.

Beispiel für Mehrfachvererbung mithilfe von Schnittstellen

Lassen Sie uns zwei Schnittstellen definieren, Flyable und Swimmable, und eine Klasse Duck, die beide Schnittstellen implementiert.

Schnittstelle: Flugfähig

public interface Flyable {
    void fly();
}

Schnittstelle: Schwimmbar

public interface Swimmable {
    void swim();
}

Klasse: Ente

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

Erläuterung

1. Schnittstellen:

   • Die Flyable-Schnittstelle definiert eine Methode fly().
   • Die schwimmbare Schnittstelle definiert eine Methode swim().

2. Klasse:

   • Die Duck-Klasse implementiert sowohl Flyable- als auch Swimmable-Schnittstellen.
   • Die Duck-Klasse stellt Implementierungen für die Methoden fly() und swim() bereit.

3. Hauptmethode:

   • Eine Instanz von Duck wird erstellt.
   • Die Methoden „fly()“ und „swim()“ werden auf der Duck-Instanz aufgerufen, was zeigt, dass die Duck-Klasse das Verhalten von beiden Schnittstellen geerbt hat.

Ausgabe

Duck is flying
Duck is swimming

Hier ist ein einfaches Diagramm, um die Beziehung zu veranschaulichen:

+----------------+
|    Flyable     |<--------------->Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |<--------------->Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |<--------------->Interface
|----------------|
| + swim()       |
+----------------+

In diesem Beispiel demonstriert die Duck-Klasse Mehrfachvererbung durch die Implementierung sowohl der Flyable- als auch der Swimmable-Schnittstelle. Dadurch kann die Duck-Klasse die in beiden Schnittstellen definierten Methoden erben und Implementierungen dafür bereitstellen, was zeigt, wie Java über Schnittstellen Mehrfachvererbung erreicht.

---

Abstrakte Klasse in Java

Abstrakte Klassen in Java werden verwendet, um eine gemeinsame Basis für eine Familie verwandter Klassen bereitzustellen. Sie können sowohl abstrakte Methoden (Methoden ohne Körper) als auch konkrete Methoden (Methoden mit Körper) enthalten. Unten finden Sie ein Beispiel, das die Verwendung einer abstrakten Klasse demonstriert.

Beispiel einer abstrakten Klasse

Lassen Sie uns eine abstrakte Klasse Animal und zwei Unterklassen Dog und Cat definieren, die die Animal-Klasse erweitern.

Abstrakte Klasse: Tier

public abstract class Animal {
    // Abstract method (does not have a body)
    public abstract void makeSound();

    // Concrete method (has a body)
    public void sleep() {
        System.out.println("The animal is sleeping");
    }
}

Unterklasse: Hund

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog says: Woof!");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

Unterklasse: Kat

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat says: Meow!");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();
        cat.sleep();
    }
}

Erläuterung

1. Abstrakte Klasse: Tier

   • Die Animal-Klasse ist als abstrakt deklariert, was bedeutet, dass sie nicht direkt instanziiert werden kann.
   • Es enthält eine abstrakte Methode makeSound(), die von jeder Unterklasse implementiert werden muss.
   • Es enthält auch eine konkrete Methode sleep(), die eine Standardimplementierung bereitstellt.

2. Unterklasse: Hund

   • Die Klasse „Hund“ erweitert die Klasse „Tier“.
   • Es stellt eine Implementierung für die abstrakte Methode makeSound() bereit.
   • Die Hauptmethode erstellt eine Instanz von Dog und ruft die Methoden makeSound() und sleep() auf.

3. Unterklasse: Katze

   • Die Cat-Klasse erweitert die Animal-Klasse.
   • Es stellt eine Implementierung für die abstrakte Methode makeSound() bereit.
   • Die Hauptmethode erstellt eine Instanz von Cat und ruft die Methoden makeSound() und sleep() auf.

Ausgabe

Für die Hundeklasse:

public interface Flyable {
    void fly();
}

Für den Katzenkurs:

public interface Swimmable {
    void swim();
}

Hier ist ein einfaches Diagramm, um die Beziehung zu veranschaulichen:

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

In diesem Beispiel stellt die abstrakte Klasse „Animal“ eine gemeinsame Basis für die Unterklassen „Hund“ und „Katze“ bereit. Die Animal-Klasse definiert eine abstrakte Methode makeSound(), die von jeder Unterklasse implementiert werden muss, und eine konkrete Methode sleep(), die eine Standardimplementierung bereitstellt. Die Klassen Dog und Cat erweitern die Klasse Animal und stellen ihre eigenen Implementierungen der makeSound()-Methode bereit.

Wichtige Punkte zu Schnittstellen

1. Abstraktion: Die Schnittstelle in Java ist ein Mechanismus zur Abstraktion.
2. Standardmethoden: Standardmäßig sind Schnittstellenmethoden abstrakt und öffentlich.
3. Methodentypen: Schnittstellenmethoden können nur öffentlich, privat, abstrakt, standardmäßig, statisch und strictfp sein.
4. Feldtypen: Schnittstellenfelder (Variablen) können nur öffentlich, statisch oder endgültig sein.
5. IS-A-Beziehung: Java Interface repräsentiert auch die IS-A-Beziehung.
6. Instantiierung: Sie kann nicht direkt instanziiert werden, genau wie die abstrakte Klasse.
7. Lose Kopplung: Kann verwendet werden, um eine lose Kopplung zu erreichen.
8. Implizit abstrakt: Jede Schnittstelle ist implizit abstrakt.
9. Standardmethoden: Standardmethoden sind nur in Schnittstellen zulässig.

Duck is flying
Duck is swimming

Praktische Anwendungen

Schnittstellen nutzen

Schnittstellen werden häufig zum Definieren von APIs, Frameworks und Bibliotheken verwendet. Beispielsweise stellt die java.util.List-Schnittstelle einen Vertrag für Listenimplementierungen wie ArrayList und LinkedList bereit.

+----------------+
|    Flyable     |<--------------->Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |<--------------->Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |<--------------->Interface
|----------------|
| + swim()       |
+----------------+

Verwendung abstrakter Klassen

Abstrakte Klassen werden häufig verwendet, um eine Basisklasse für eine Familie verwandter Klassen bereitzustellen. Beispielsweise stellt die Klasse java.util.AbstractList eine Skelettimplementierung der List-Schnittstelle bereit, wodurch die Menge an Code reduziert wird, die Unterklassen implementieren müssen.

public interface Flyable {
    void fly();
}

---

Unterschied zwischen Interface- und Abstract-Klasse

SNo	Interface	Abstract Class
1	Interfaces cannot be instantiated	Abstract classes cannot be instantiated
2	It can have both abstract and non-abstract methods	It can have both abstract and non-abstract methods
3	In interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public	In abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods
4	Interface supports multiple inheritance. Multiple interfaces can be implemented	Abstract class or class can extend only one class
5	It is used if you expect that unrelated classes would implement your interface. Eg, the interfaces Comparable and Cloneable are implemented by many unrelated classes	It is used if you want to share code among several closely related classes
6	It is used if you want to specify the behavior of a particular data type, but not concerned about who implements its behavior.	It is used if you expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private)

Ref: https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Wenn eine abstrakte Klasse in eine Unterklasse unterteilt wird, stellt die Unterklasse normalerweise Implementierungen für alle abstrakten Methoden in ihrer übergeordneten Klasse bereit. Ist dies jedoch nicht der Fall, muss die Unterklasse ebenfalls als abstrakt deklariert werden.

---

Expertenmeinungen

Laut Joshua Bloch, Autor von „Effective Java“, werden Schnittstellen gegenüber abstrakten Klassen zum Definieren von Typen bevorzugt, da sie flexibler sind und Mehrfachvererbung unterstützen. Abstrakte Klassen sind jedoch nützlich, um gemeinsame Funktionalität bereitzustellen und Codeduplizierung zu reduzieren.

"Schnittstellen eignen sich ideal zum Definieren von Mixins. Klassen hingegen eignen sich ideal zum Definieren von Objekten mit intrinsischen Eigenschaften."

• Joshua Bloch

Höhepunkte

• Schnittstellen: Ideal zum Definieren von Verträgen und zur Unterstützung von Mehrfachvererbungen.
• Abstrakte Klassen: Geeignet, um eine gemeinsame Basis für verwandte Klassen bereitzustellen und Code und Verhalten auszutauschen.
• Unterschiede: Schnittstellen können nur abstrakte Methoden haben (vor Java 8), während abstrakte Klassen sowohl abstrakte als auch konkrete Methoden haben können.
• Verwendung: Schnittstellen werden zum Definieren von APIs und Frameworks verwendet, während abstrakte Klassen zur Bereitstellung von Skelettimplementierungen verwendet werden.

Entdecken Sie weiter

Entdecken Sie die Leistungsfähigkeit von Schnittstellen und abstrakten Klassen in Ihren eigenen Java-Projekten. Experimentieren Sie mit der Definition von Verträgen mithilfe von Schnittstellen und der Bereitstellung gemeinsamer Funktionen mithilfe abstrakter Klassen. Teilen Sie Ihre Erkenntnisse und Erfahrungen mit der Java-Community, um zum kollektiven Wissen und Wachstum beizutragen.

Korrekturen oder Ergänzungen zu diesem Beitrag sind willkommen.

public interface Flyable {
    void fly();
}

Das obige ist der detaillierte Inhalt vonSchnittstellen und abstrakte Klassen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!