Vorwort
„Homepage des Autors“ : Sprite Youbai Bubbles
„Persönliche Website“ : Persönliche Website von Sprite
„Empfehlungsspalte“ :
★ Java-One-Stop-Service ★
★ Reagieren Sie vom Einstieg bis zur Beherrschung ★
★ Cooles Front-End-Code-Sharing ★
★ Von 0 bis zum Helden, der Weg, um Vue zu einem Gott zu machen ★
★ uniapp – von der Konstruktion bis zur Promotion ★
★ Von 0 bis zum Helden, Vue wird zu einem Gott Road ★
★ Eine Spalte reicht aus, um den Algorithmus zu lösen ★
★ Lassen Sie uns über die Architektur von 0 sprechen ★
★ Die exquisite Art der Datenzirkulation ★
★ Der Weg zum fortschrittlichen Backend ★
Fortsetzung des vorherigen Artikels Java - Grundlegende Grammatik (1)
Artikelverzeichnis
5. Vererbung und Polymorphismus:
Java unterstützt Vererbung und Polymorphismus. Vererbung ist eine wichtige Technik in der objektorientierten Programmierung, die es einer neuen Klasse ermöglicht, die Eigenschaften und Methoden einer vorhandenen Klasse zu erhalten. Polymorphismus bedeutet, dass sich dieselbe Methode in verschiedenen Situationen unterschiedlich verhält.
Im Folgenden werde ich Vererbung und Polymorphismus in Java ausführlich vorstellen.
Grundlegende Konzepte der Vererbung
In Java ist Vererbung ein objektorientierter Programmiermechanismus, der es einer Klasse ermöglicht, Eigenschaften und Verhalten von einer anderen Klasse zu erben. Die geerbte Klasse wird als übergeordnete Klasse oder Basisklasse bezeichnet, und die geerbte Klasse wird als Unterklasse oder abgeleitete Klasse bezeichnet. Vererbung erleichtert die Wiederverwendung von Code und verbessert gleichzeitig die Lesbarkeit und Wartbarkeit des Codes.
In Java wird das Schlüsselwort „extends“ verwendet, um die Vererbungsbeziehung zu implementieren. Der Beispielcode lautet wie folgt:
public class Animal {
public void eat() {
System.out.println("Animal is eating.");
}
}
public class Dog extends Animal {
public void bark() {
System.out.println("Dog is barking.");
}
}
Im obigen Code erbt die Dog-Klasse von der Animal-Klasse, sodass die Dog-Klasse die Mitgliedsmethode eat() in der übergeordneten Klasse Animal hat.
Geerbte Funktionen
- Unterklassen können die Mitgliedsvariablen und Mitgliedsmethoden der übergeordneten Klasse erben, einschließlich Mitgliedern der öffentlichen, geschützten und Standardzugriffsebenen.
- Unterklassen können die Mitgliedsmethoden der übergeordneten Klasse überschreiben, um bestimmte Anforderungen zu erfüllen.
- Unterklassen können neue Mitgliedsvariablen und Mitgliedsmethoden hinzufügen, um bestimmte Anforderungen zu erfüllen.
- Unterklassen können nicht direkt auf die privaten Mitgliedsvariablen und privaten Mitgliedsmethoden der übergeordneten Klasse zugreifen, sondern über die öffentlichen oder geschützten Mitgliedsmethoden der übergeordneten Klasse.
Das Grundkonzept des Polymorphismus
Polymorphismus ist eine Funktion der objektorientierten Programmierung, die es verschiedenen Objekten ermöglicht, unterschiedlich auf dieselbe Nachricht zu reagieren. In Java kann Polymorphismus durch Methodenüberladung und Methodenüberschreibung erreicht werden.
- Methodenüberladung: Unter Methodenüberladung versteht man die Definition mehrerer Methoden in einer Klasse mit demselben Methodennamen, aber unterschiedlichen Parameterlisten. Java entscheidet anhand der Parameterliste der Methode, welche Methode aufgerufen werden soll.
- Methodenumschreiben: Das Umschreiben von Methoden bezieht sich auf das Neudefinieren einer Methode der übergeordneten Klasse in der Unterklasse. Eine von einer Unterklasse überschriebene Methode muss denselben Namen, dieselbe Parameterliste und denselben Rückgabetyp wie die Methode der übergeordneten Klasse haben, und die Zugriffsmodifikatoren dürfen nicht restriktiver sein.
Beispielcode:
public class Animal {
public void eat() {
System.out.println("Animal is eating.");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("Dog is eating bones.");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("Cat is eating fish.");
}
}
Im obigen Code schreiben sowohl die Dog-Klasse als auch die Cat-Klasse die eat()-Methode in der übergeordneten Klasse Animal um. Wenn die Methode eat() aufgerufen wird, entscheidet die Java Virtual Machine basierend auf dem Typ des aufgerufenen Objekts, welche Methode aufgerufen werden soll.
polymorphe Implementierung
In Java gibt es zwei Möglichkeiten, Polymorphismus zu erreichen: Polymorphismus durch Vererbung und Schnittstellen.
-
Polymorphismus durch Vererbung:
Im Vererbungssystem kann der Zeiger der übergeordneten Klasse auf das Objekt der Unterklasse zeigen. Wenn die Referenzvariable der übergeordneten Klasse zum Aufrufen der überschriebenen Methode verwendet wird, entscheidet die Java Virtual Machine basierend auf dem Typ des aufgerufenen Objekts, welche Methode aufgerufen werden soll.
Beispielcode:
Animal ani1 = new Dog(); Animal ani2 = new Cat(); ani1.eat(); // 输出：Dog is eating bones. ani2.eat(); // 输出：Cat is eating fish. -
Polymorphismus durch Schnittstellen:
Eine Schnittstelle ist eine spezielle Art abstrakter Klasse, die nur Methodendeklarationen definiert, aber keine Methodenimplementierungen bereitstellt. Eine Klasse kann mehrere Schnittstellen implementieren und somit unterschiedliche Verhaltensmerkmale aufweisen. Polymorphismus wird in Java durch die Konvertierung von Objektreferenzen in Schnittstellentypen erreicht. Wenn die Referenzvariable der Schnittstelle zum Aufrufen der Methode in der Implementierungsklasse verwendet wird, bestimmt die Java Virtual Machine anhand des Typs des aufzurufenden Objekts, welche Methode aufgerufen werden soll.
Beispielcode:
interface Shape {
void draw();
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Draw a circle.");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Draw a rectangle.");
}
}
public class Main {
public static void main(String[] args) {
Shape s1 = new Circle();
Shape s2 = new Rectangle();
s1.draw(); // 输出：Draw a circle.
s2.draw(); // 输出：Draw a rectangle.
}
}
Im obigen Code implementieren die Klassen „Circle“ und „Rectangle“ beide die Schnittstelle „Shape“ und schreiben die Methode „draw()“ in der Schnittstelle neu. Wenn die Referenzvariable der Schnittstelle zum Aufrufen der Methode in der Implementierungsklasse verwendet wird, bestimmt die Java Virtual Machine basierend auf dem Typ des aufzurufenden Objekts, welche Methode aufgerufen werden soll.
gießen
In Java können Sie die obligatorische Typkonvertierung verwenden, um Referenzvariablen der übergeordneten Klasse in Referenzvariablen der Unterklasse zu konvertieren und so den Zugriff auf unterklassenspezifische Mitglieder zu erleichtern.
Beispielcode:
Animal ani = new Dog();
if (ani instanceof Dog) {
Dog d = (Dog)ani;
d.bark();
}
Im obigen Code ist ani eine Referenzvariable der Animal-Klasse, zeigt jedoch auf eine Instanz der Dog-Klasse. Mithilfe des Instanzoperators können Sie bestimmen, ob ani auf eine Instanz der Dog-Klasse zeigt. Wenn dies der Fall ist, können Sie eine Umwandlung verwenden, um ani in den Dog-Typ zu konvertieren, um auf die für die Dog-Klasse spezifische Methode bark() zuzugreifen.
Es ist zu beachten, dass eine ClassCastException ausgelöst wird, wenn das tatsächliche Objekt während der Umwandlung keine Unterklasse des erforderlichen Typs ist. Daher ist es besser, den Operator „instanceof“ zur Typprüfung vor dem Casting zu verwenden.
6. Rufen Sie den Konstruktor der übergeordneten Klasse auf
In Java erbt die Unterklasse alle Eigenschaften und Methoden der übergeordneten Klasse, erbt jedoch nicht den Konstruktor der übergeordneten Klasse. Daher ist es unbedingt erforderlich, den Konstruktor der übergeordneten Klasse im Konstruktor der Unterklasse aufzurufen, um sicherzustellen, dass die Mitgliedsvariablen der übergeordneten Klasse korrekt initialisiert werden.
Verwenden Sie das Schlüsselwort super im Konstruktor der Unterklasse, um den Konstruktor der übergeordneten Klasse aufzurufen. Wenn die übergeordnete Klasse über mehrere Konstruktoren verfügt, kann das Schlüsselwort super verwendet werden, um den Konstruktor anzugeben, der aufgerufen werden muss.
Beispielcode:
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
}
public class Dog extends Animal {
private int age;
public Dog(String name, int age) {
super(name); // 调用父类的构造方法
this.age = age;
}
}
Im obigen Code erbt die Dog-Klasse von der Animal-Klasse und ruft in ihrem Konstruktor den Konstruktor der Animal-Klasse auf.
Abstrakte Klassen und abstrakte Methoden
Eine abstrakte Klasse ist eine spezielle Klasse, die nicht instanziiert werden kann und nur als übergeordnete Klasse anderer Klassen verwendet werden kann. Eine abstrakte Klasse kann abstrakte Methoden enthalten, die keine konkrete Implementierung, sondern nur Methodendeklarationen haben.
Verwenden Sie in Java das Schlüsselwort abstract, um eine abstrakte Klasse oder abstrakte Methode zu definieren. Wenn eine Klasse abstrakte Methoden enthält, muss die Klasse abstrakt sein.
Beispielcode:
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("Draw a circle.");
}
}
class Rectangle extends Shape {
@Override
void draw() {
System.out.println("Draw a rectangle.");
}
}
Im obigen Code ist die Shape-Klasse eine abstrakte Klasse, die eine abstrakte Methode draw() enthält. Sowohl die Circle-Klasse als auch die Rechteck-Klasse erben von der Shape-Klasse und implementieren die Methode draw().
Es ist zu beachten, dass, wenn eine Klasse eine abstrakte Klasse erbt, alle abstrakten Methoden in der abstrakten Klasse implementiert werden müssen, andernfalls muss die Klasse auch als abstrakte Klasse deklariert werden.
Schnittstelle
Eine Schnittstelle ist eine spezielle Art abstrakter Klasse, die nur Methodendeklarationen definiert, aber keine Methodenimplementierungen bereitstellt. Eine Klasse kann mehrere Schnittstellen implementieren und somit unterschiedliche Verhaltensmerkmale aufweisen.
Verwenden Sie in Java das Schlüsselwort interface, um eine Schnittstelle zu definieren. Die Methoden in der Schnittstelle sind standardmäßig öffentliche abstrakte Methoden, und es können auch Konstanten, Standardmethoden und statische Methoden definiert werden.
Beispielcode:
interface Shape {
double PI = 3.14; // 定义常量
void draw(); // 定义抽象方法
default void show() {
// 定义默认方法
System.out.println("This is a shape.");
}
static void info() {
// 定义静态方法
System.out.println("This is a shape interface.");
}
}
class Circle implements Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public void draw() {
System.out.println("Draw a circle with radius " + radius);
}
}
Im obigen Code definiert die Shape-Schnittstelle eine Konstante PI, eine abstrakte Methode draw(), eine Standardmethode show() und eine statische Methode info(). Die Circle-Klasse implementiert die Shape-Schnittstelle und überschreibt die Methode draw().
Es ist zu beachten, dass, wenn eine Klasse eine Schnittstelle implementiert, alle Methoden in der Schnittstelle implementiert werden müssen, andernfalls muss die Klasse als abstrakte Klasse deklariert werden.
Zusammenfassen
Vererbung und Polymorphismus sind sehr wichtige Konzepte in der objektorientierten Programmierung. Vererbung erleichtert die Wiederverwendung von Code und verbessert gleichzeitig die Lesbarkeit und Wartbarkeit des Codes. Polymorphismus ist eine sehr leistungsstarke Funktion in der objektorientierten Programmierung, die es verschiedenen Objekten ermöglicht, unterschiedlich auf dieselbe Nachricht zu reagieren.
In Java wird das Schlüsselwort „extens“ zum Implementieren der Vererbungsbeziehung und das Schlüsselwort „super“ zum Aufrufen des Konstruktors der übergeordneten Klasse verwendet. Polymorphismus kann durch Methodenüberladung und Methodenüberschreibung sowie durch Schnittstellen erreicht werden. Wenn Sie eine obligatorische Typkonvertierung durchführen, müssen Sie auf die Typprüfung achten, um ClassCastException-Ausnahmen zu vermeiden. Darüber hinaus sind abstrakte Klassen und Schnittstellen auch sehr wichtige Konzepte in der objektorientierten Programmierung. Sie können uns helfen, Code besser zu organisieren, Daten zu kapseln und komplexe Funktionen zu realisieren.
6. Schnittstelle:
Eine Schnittstelle in Java ist eine Sammlung abstrakter Methoden. Schnittstellen können durch Klassen implementiert werden, und eine Klasse kann auch mehrere Schnittstellen implementieren. Schnittstellen werden mit dem Schlüsselwort interface definiert.
Im Folgenden werde ich das Konzept, die Eigenschaften, die Verwendungsmethoden und die Anwendungsszenarien von Schnittstellen in Java ausführlich vorstellen.
Das Konzept der Schnittstelle
In Java ist eine Schnittstelle eine spezielle abstrakte Klasse, die nur Methodendefinitionen und Konstantendeklarationen, aber keine konkreten Methodenimplementierungen enthält. Schnittstellen ermöglichen es mehreren verschiedenen Klassen, dieselbe Methode zu implementieren und so den Zweck der Code-Wiederverwendung zu erreichen. Gleichzeitig kann die Schnittstelle auch zur Implementierung des Rückrufmechanismus (Callback) verwendet werden, d. h. ein Objekt ruft unter bestimmten Umständen die Methode eines anderen Objekts auf.
Schnittstellenfunktionen
- Alle Methoden in der Schnittstelle sind öffentliche abstrakte Methoden und enthalten keine spezifischen Methodenimplementierungen.
- In einer Schnittstelle können Konstanten definiert werden, Variablen können jedoch nicht definiert werden.
- Schnittstellen können nicht instanziiert, sondern nur implementiert werden.
- Eine Klasse kann mehrere Schnittstellen implementieren.
- Eine Schnittstelle kann von mehreren Schnittstellen erben.
So verwenden Sie die Schnittstelle
In Java wird eine Schnittstelle mit dem Schlüsselwort interface definiert. Die Methoden in der Schnittstelle sind standardmäßig öffentliche abstrakte Methoden. Sie können das Schlüsselwort abstract vor dem Methodennamen hinzufügen, dies ist jedoch nicht erforderlich.
Beispielcode:
public interface Shape {
double getArea();
double getPerimeter();
}
Im obigen Code ist eine Shape-Schnittstelle definiert, die zwei Methoden getArea() und getPerimeter() enthält, die beide öffentliche abstrakte Methoden sind. Diese Schnittstelle kann von anderen Klassen implementiert werden, um Funktionen zur Berechnung der Fläche und des Umfangs verschiedener Formen bereitzustellen.
Implementierung der Schnittstelle
In Java wird eine Schnittstelle mit dem Schlüsselwort implementiert implementiert. Eine Klasse kann mehrere Schnittstellen implementieren, und die Klasse, die die Schnittstelle implementiert, muss alle in der Schnittstelle deklarierten Methoden implementieren.
Beispielcode:
public class Circle implements Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
return Math.PI * radius * radius;
}
@Override
public double getPerimeter() {
return 2 * Math.PI * radius;
}
}
Im obigen Code implementiert die Circle-Klasse die Shape-Schnittstelle und schreibt die Methoden getArea() und getPerimeter() neu.
Schnittstellenvererbung
In Java kann eine Schnittstelle auch eine andere Schnittstelle erben, sodass eine Unterschnittstelle die Methodendefinitionen der übergeordneten Schnittstelle erben kann.
Beispielcode:
public interface Drawable {
void draw();
}
public interface Shape extends Drawable {
double getArea();
double getPerimeter();
}
Im obigen Code erbt die Shape-Schnittstelle die Drawable-Schnittstelle und erweitert zwei neue Methoden getArea() und getPerimeter().
Anwendungsszenarien der Schnittstelle
- Polymorphismus implementieren: Schnittstellen ermöglichen es mehreren verschiedenen Klassen, dieselbe Methode zu implementieren und so den Zweck der Code-Wiederverwendung zu erreichen.
- Implementierung eines Rückrufmechanismus: Über Schnittstellen kann ein Rückrufmechanismus implementiert werden, d. h. ein Objekt ruft unter bestimmten Umständen eine Methode eines anderen Objekts auf.
- Einschränkung der Vererbung von Klassen: Schnittstellen können als Einschränkung verwendet werden, um die Vererbungsbeziehung einer bestimmten Klasse einzuschränken. Wenn eine Klasse eine Schnittstelle implementiert, muss sie alle in der Schnittstelle deklarierten Methoden implementieren.
- Konstanten definieren: Schnittstellen können Konstanten zur Verwendung durch andere Klassen definieren.
Kurz gesagt, die Schnittstelle ist eines der sehr wichtigen Konzepte in Java, das es uns ermöglicht, Code besser zu organisieren, Daten zu kapseln und komplexe Funktionen zu realisieren. Beim Entwerfen einer API ist die Schnittstelle auch ein sehr häufiges Entwurfsmuster, das die Skalierbarkeit und Wartbarkeit der API verbessern kann.
7. Generika:
Generics sind eine leistungsstarke Funktion in der Java-Sprache, die Code flexibler und sicherer machen kann. Durch die Verwendung von Generika können Typen parametrisiert werden, wodurch der Code besser an verschiedene Datentypen angepasst werden kann.
Okay, lassen Sie mich das Konzept, die Eigenschaften, die Verwendungsmethoden und die Anwendungsszenarien von Generika in Java im Detail vorstellen.
Generisches Konzept
In Java ist Generic ein parametrisierter Typmechanismus, der es uns ermöglicht, eine Klasse oder Methode zu definieren, die eine Vielzahl unterschiedlicher Datentypen unterstützt. Laienhaft ausgedrückt bestehen Generika darin, Datentypen als Parameter an Klassen oder Methoden zu übergeben, um die Wiederverwendung und Erweiterung von Code zu realisieren.
Allgemeine Funktionen
- Generics unterstützen die Typprüfung zur Kompilierungszeit, mit der Typfehler zur Kompilierungszeit erkannt werden können.
- Generika können die Codeduplizierung reduzieren und die Lesbarkeit und Wartbarkeit des Codes verbessern.
- Generics können die Flexibilität und Erweiterbarkeit von Programmen erhöhen.
So verwenden Sie Generika
Verwenden Sie in Java spitze Klammern <>, um generische Typen anzugeben, zum Beispiel:
List<String> list = new ArrayList<>();
Im obigen Code ist List eine generische Schnittstelle, die mehrere Methoden zum Betreiben von Listen enthält, String stellt den Elementtyp dar und ArrayList ist eine Array-Sequenz variabler Länge, die auf der durch ein Array implementierten List-Schnittstelle basiert.
generische Klasse
In Java können wir eine generische Klasse definieren, die viele verschiedene Objekttypen unterstützen kann. Fügen Sie beim Definieren einer generischen Klasse Typparameter nach dem Klassennamen hinzu, wie folgt:
public class Box<T> {
private T data;
public Box(T data) {
this.data = data;
}
public T getData() {
return data;
}
}
Im obigen Code ist die Box-Klasse eine generische Klasse, die einen Typparameter T definiert, der angibt, dass Box jeden Datentyp speichern kann. Beim Erstellen eines Box-Objekts müssen Sie den spezifischen T-Typ angeben.
generische Methode
In Java können wir auch eine generische Methode definieren, sodass sie viele verschiedene Parametertypen unterstützen kann. Generische Methoden müssen bei der Definition Typparameter vor dem Methodennamen hinzufügen, wie folgt:
public class ArrayUtil {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.printf("%s ", element);
}
System.out.println();
}
}
Im obigen Code ist printArray() eine generische Methode, die einen Typparameter T definiert, der angibt, dass die Methode Arrays jeden Typs verarbeiten kann. Wenn Sie die Methode printArray() aufrufen, müssen Sie den spezifischen Typ von T angeben.
Platzhalter
In Java können wir Platzhalter (Wildcards) verwenden, um eine bestimmte Art von Unterklasse oder übergeordneter Klasse darzustellen.
- ? erweitert T repräsentiert eine Unterklasse eines Typs.
- ? super T repräsentiert eine bestimmte Art von Superklasse.
Beispielcode:
public class Animal {
}
public class Dog extends Animal {
}
List<? extends Animal> list1 = new ArrayList<Dog>(); // 子类向父类转换
List<? super Dog> list2 = new ArrayList<Animal>(); // 父类向子类转换
Im obigen Code stellt Liste1 eine Liste dar, die alle Unterklassen von „Tier“ enthält und eine Liste vom Typ „Hund“ empfangen kann; Liste2 stellt eine Liste dar, die alle übergeordneten Klassen von „Hund“ enthält und eine Liste vom Typ „Tier“ empfangen kann. Auf diese Weise kann die Konvertierung von der Unterklasse in die übergeordnete Klasse und von der übergeordneten Klasse in die Unterklasse realisiert werden.
Allgemeine Anwendungsszenarien
- Sammlungsklassen: Sammlungsklassen in Java (wie List, Set, Map usw.) werden mithilfe von Generika implementiert.
- Schnittstellen und abstrakte Klassen: Generics können in Schnittstellen und abstrakten Klassen verwendet werden, um viele verschiedene Arten von Objekten zu unterstützen.
- Typsicherheit: Generics können das Schreiben von typsicherem Code gewährleisten und so Laufzeitfehler bei der Typkonvertierung vermeiden.
- Reflexionsmechanismus: Generika können mit Reflexionsmechanismen kombiniert werden, sodass wir zur Laufzeit generische Informationen erhalten können.
Kurz gesagt, Generics sind eines der sehr wichtigen Konzepte in Java. Generics ermöglichen es uns, Typfehler zur Kompilierungszeit zu finden und dadurch die Robustheit und Lesbarkeit des Codes zu verbessern. Außerdem wird die Codeduplizierung reduziert und die Wartbarkeit und Skalierbarkeit des Codes verbessert.
Zweitens gelten Generika nicht nur für Klassen, sondern auch für Methoden. Wenn Sie eine generische Methode definieren, müssen Sie vor dem Methodennamen Typparameter hinzufügen.
Drittens sind Platzhalter ein sehr wichtiges Konzept in Generika, das zur Darstellung einer bestimmten Art von Unterklasse oder übergeordneter Klasse verwendet werden kann. Beispielsweise stellt „List<? extensions Number>“ eine Liste dar, die alle „Number“-Unterklassen enthält, und „List<? super Integer>“ stellt eine Liste dar, die alle „Integer“-Elternklassen enthält.
Viertens sind die Anwendungsszenarien von Generika sehr umfangreich. Die häufigsten sind Sammlungsklassen, Schnittstellen und abstrakte Klassen, Typsicherheits- und Reflexionsmechanismen usw.
Hier ist ein Beispielcode mit Generika:
generische Klasse
public class Box<T> {
private T data;
public Box(T data) {
this.data = data;
}
public T getData() {
return data;
}
}
Im obigen Code ist Box eine generische Klasse, die einen Typparameter T definiert, der angibt, dass Box jeden Datentyp speichern kann.
generische Methode
public class ArrayUtil {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.printf("%s ", element);
}
System.out.println();
}
}
Im obigen Code ist printArray() eine generische Methode, die einen Typparameter T definiert, der angibt, dass die Methode Arrays jeden Typs verarbeiten kann.
Platzhalter
public class Animal {
}
public class Dog extends Animal {
}
List<? extends Animal> list1 = new ArrayList<Dog>(); // 子类向父类转换
List<? super Dog> list2 = new ArrayList<Animal>(); // 父类向子类转换
Im obigen Code stellt Liste1 eine Liste dar, die alle Unterklassen von „Tier“ enthält und eine Liste vom Typ „Hund“ empfangen kann; Liste2 stellt eine Liste dar, die alle übergeordneten Klassen von „Hund“ enthält und eine Liste vom Typ „Tier“ empfangen kann. Auf diese Weise kann die Konvertierung von der Unterklasse in die übergeordnete Klasse und von der übergeordneten Klasse in die Unterklasse realisiert werden.
generische Schnittstelle
public interface Comparable<T> {
int compareTo(T o);
}
Im obigen Code ist Comparable eine generische Schnittstelle, die einen Typparameter T definiert, der angibt, dass Comparable Objekte jeden Typs vergleichen kann.
generische Aufzählung
public enum Color {
RED, GREEN, BLUE}
public enum Size {
SMALL, MEDIUM, LARGE}
public class Shirt<T extends Enum<T>> {
private T color;
private T size;
public Shirt(T color, T size) {
this.color = color;
this.size = size;
}
public T getColor() {
return color;
}
public T getSize() {
return size;
}
}
Im obigen Code ist Shirt eine generische Klasse, die zwei Typparameter T und E definiert. T muss ein Aufzählungstyp sein (z. B. Farbe oder Größe) und E muss ein Typ sein, der die Comparable-Schnittstelle implementiert. Dadurch ist es möglich, eine generische Aufzählungsklasse zu erstellen, die die Farbe und Größe des Hemdes darstellt.
Zusammenfassend lässt sich sagen, dass Generics eines der sehr wichtigen Konzepte in Java sind, die es uns ermöglichen, robusteren, flexibleren und erweiterbareren Code zu schreiben. In der tatsächlichen Entwicklung sollten wir die Syntax und Verwendung von Generika beherrschen, um unsere Arbeit besser abschließen zu können.