Schnittstellen und abstrakte Klassen sind die wesentlichen Komponenten zum Erreichen von Abstraktion und Polymorphismus.
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.
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.
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.
Lassen Sie uns zwei Schnittstellen definieren, Flyable und Swimmable, und eine Klasse Duck, die beide Schnittstellen implementiert.
public interface Flyable {
void fly();
}
public interface Swimmable {
void swim();
}
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();
}
}
Schnittstellen:
Klasse:
Hauptmethode:
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 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.
Lassen Sie uns eine abstrakte Klasse Animal und zwei Unterklassen Dog und Cat definieren, die die Animal-Klasse erweitern.
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");
}
}
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();
}
}
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();
}
}
Abstrakte Klasse: Tier
Unterklasse: Hund
Unterklasse: Katze
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.
Duck is flying Duck is swimming
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() |
+----------------+
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();
}
| 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.
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
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!
Methode zum Festlegen des HTML-Bereichs
IIS unerwarteter Fehler 0x8ffe2740 Lösung
Implementierungsmethode der js-Sperrfunktion
Eine vollständige Liste der Betriebs- und Wartungsbefehle für Linux-Server
Verwendung zufälliger Funktionen in der C-Sprache
Wie lautet das Passwort für den Mobilfunkdienst?
So sperren Sie den Bildschirm auf oppo11
So passen Sie die Helligkeit des Computerbildschirms an
