Java-Generika

In diesem Tutorial lernen wir anhand von Beispielen etwas über Java Generics, das Erstellen von Generics-Klassen und -Methoden und deren Vorteile.

Die Java-Generika ermöglichen es uns, eine einzelne Klasse, Schnittstelle und Methode zu erstellen, die mit verschiedenen Datentypen (Objekten) verwendet werden kann.

Dies hilft uns, unseren Code wiederzuverwenden.

Hinweis :Generika funktioniert nicht mit primitiven Typen (int , float , char usw.).

Java-Generika-Klasse

Wir können eine Klasse erstellen, die mit jeder Art von Daten verwendet werden kann. Eine solche Klasse wird als Generics-Klasse bezeichnet.

So können wir eine generische Klasse in Java erstellen:

Beispiel:Generika-Klasse erstellen

class Main {
  public static void main(String[] args) {

    // initialize generic class
    // with Integer data
    GenericsClass<Integer> intObj = new GenericsClass<>(5);
    System.out.println("Generic Class returns: " + intObj.getData());

    // initialize generic class
    // with String data
    GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
    System.out.println("Generic Class returns: " + stringObj.getData());
  }
}

// create a generics class
class GenericsClass<T> {

  // variable of T type
  private T data;

  public GenericsClass(T data) {
    this.data = data;
  }

  // method that return T type variable
  public T getData() {
    return this.data;
  }
}

Ausgabe

Generic Class returns: 5
Generic Class returns: Java Programming

Im obigen Beispiel haben wir eine generische Klasse namens GenericsClass erstellt . Diese Klasse kann verwendet werden, um mit jeder Art von Daten zu arbeiten.

class GenericsClass<T> {...}

Hier, T innerhalb der spitzen Klammer <> verwendet gibt den Typparameter an . Innerhalb der Main Klasse haben wir zwei Objekte von GenericsClass erstellt

intObj - Hier der Typparameter T wird durch Integer ersetzt . Nun, die GenericsClass arbeitet mit Integer-Daten.
stringObj - Hier der Typparameter T wird durch String ersetzt . Nun, die GenericsClass funktioniert mit String-Daten.

Java Generics-Methode

Ähnlich wie bei der Generics-Klasse können wir auch eine Methode erstellen, die mit jedem Datentyp verwendet werden kann. Eine solche Klasse ist als Generics-Methode bekannt.

So können wir eine generische Klasse in Java erstellen:

Beispiel:Generika-Methode erstellen

class Main {
  public static void main(String[] args) {

    // initialize the class with Integer data
    DemoClass demo = new DemoClass();

    // generics method working with String
    demo.<String>genericsMethod("Java Programming");

    // generics method working with integer
    demo.<Integer>genericsMethod(25);
  }
}

class DemoClass {

  // creae a generics method
  public <T> void genericsMethod(T data) {
    System.out.println("Generics Method:");
    System.out.println("Data Passed: " + data);
  }
}

Ausgabe

Generics Method:
Data Passed: Java Programming
Generics Method:
Data Passed: 25

Im obigen Beispiel haben wir eine generische Methode namens genericsMethod erstellt .

public <T> void genericMethod(T data) {...}

Hier der Typparameter <T> wird nach dem Modifikator public eingefügt und vor dem Rückgabetyp void .

Wir können die Generics-Methode aufrufen, indem wir den tatsächlichen Typ <String> platzieren und <Integer> innerhalb der Klammer vor dem Methodennamen.

demo.<String>genericMethod("Java Programming");

demo.<Integer>genericMethod(25);

Hinweis :Wir können die Generics-Methode aufrufen, ohne den Typparameter einzuschließen. Zum Beispiel

demo.genericsMethod("Java Programming");

In diesem Fall kann der Compiler den Typparameter anhand des an die Methode übergebenen Werts abgleichen.

Begrenzte Typen

Im Allgemeinen der Typparameter kann alle Datentypen akzeptieren (außer primitive Typen).

Wenn wir jedoch Generics nur für bestimmte Typen verwenden möchten (z. B. Daten von Zahlentypen akzeptieren), können wir gebundene Typen verwenden.

Bei gebundenen Typen verwenden wir den extends Stichwort. Zum Beispiel

<T extends A>

Das bedeutet T kann nur Daten akzeptieren, die Untertypen von A sind .

Beispiel:Begrenzte Typen

class GenericsClass <T extends Number> {

  public void display() {
    System.out.println("This is a bounded type generics class.");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of GenericsClass
    GenericsClass<String> obj = new GenericsClass<>();
  }
}

Im obigen Beispiel haben wir eine Klasse namens GenericsClass erstellt. Beachten Sie den Ausdruck, beachten Sie den Ausdruck

<T extends Number>

Hier, GenericsClass wird mit begrenztem Typ erstellt. Das bedeutet GenericsClass kann nur mit Datentypen arbeiten, die untergeordnete Elemente von Number sind (Integer , Double , usw.).

Allerdings haben wir mit String ein Objekt der Generics-Klasse erstellt . In diesem Fall erhalten wir die folgende Fehlermeldung.

GenericsClass<String> obj = new GenericsClass<>();
                                                 ^
    reason: inference variable T has incompatible bounds
      equality constraints: String
      lower bounds: Number
  where T is a type-variable:
    T extends Number declared in class GenericsClass

Vorteile von Java-Generika

1. Wiederverwendbarkeit des Codes

Mit Hilfe von Generika in Java können wir Code schreiben, der mit verschiedenen Datentypen funktioniert. Zum Beispiel

public <T> void genericsMethod(T data) {...}

Hier haben wir eine Generika-Methode erstellt. Dieselbe Methode kann verwendet werden, um Operationen mit Integer-Daten, String-Daten usw. auszuführen.

2. Typüberprüfung zur Kompilierzeit

Der type-Parameter von Generika gibt Auskunft über die Art der Daten, die im Generika-Code verwendet werden. Zum Beispiel

// using Generics
GenericsClass<Integer> list = new GenericsClass<>();

Hier kennen wir diese GenericsClass arbeitet mit Integer nur Daten.

Wenn wir nun versuchen, andere Daten als Integer an diese Klasse zu übergeben, generiert das Programm zur Kompilierzeit einen Fehler.

3. Wird mit Sammlungen verwendet

Das Collections-Framework verwendet das Konzept der Generika in Java. Zum Beispiel

// creating a string type ArrayList
ArrayList<String> list1 = new ArrayList<>();

// creating a integer type ArrayList
ArrayList<Integer> list2 = new ArrayList<>();

Im obigen Beispiel haben wir dieselbe ArrayList-Klasse verwendet, um mit verschiedenen Datentypen zu arbeiten.

Ähnlich wie ArrayList , andere Sammlungen (LinkedList , Queue , Maps , usw.) sind in Java ebenfalls generisch.

Java-Lambda-Ausdrücke Java-Dateiklasse

Java