Java Generics

In deze zelfstudie leren we over Java Generics, hoe we generieke klassen en methoden kunnen maken en de voordelen ervan met behulp van voorbeelden.

Met Java Generics kunnen we een enkele klasse, interface en methode maken die met verschillende soorten gegevens (objecten) kan worden gebruikt.

Dit helpt ons om onze code opnieuw te gebruiken.

Opmerking :Algemeen werkt niet met primitieve typen (int , float , char , enz.).

Java Generics-klasse

We kunnen een klasse maken die met elk type gegevens kan worden gebruikt. Zo'n klasse staat bekend als Generics Class.

Hier is hoe we een generieke klasse in Java kunnen maken:

Voorbeeld:maak een Generics Class

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

Uitvoer

Generic Class returns: 5
Generic Class returns: Java Programming

In het bovenstaande voorbeeld hebben we een generieke klasse gemaakt met de naam GenericsClass . Deze klasse kan worden gebruikt om met elk type gegevens te werken.

class GenericsClass<T> {...}

Hier, T gebruikt binnen de punthaak <> geeft de type parameter aan . Binnen de Main class hebben we twee objecten van GenericsClass . gemaakt

• intObj - Hier de typeparameter T wordt vervangen door Integer . Nu, de GenericsClass werkt met integer data.
• stringObj - Hier de typeparameter T wordt vervangen door String . Nu, de GenericsClass werkt met stringgegevens.

Java Generics-methode

Net als bij de klasse generieke geneesmiddelen, kunnen we ook een methode maken die met elk type gegevens kan worden gebruikt. Zo'n klasse staat bekend als Generics Method.

Hier is hoe we een generieke klasse in Java kunnen maken:

Voorbeeld:maak een algemene methode

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

Uitvoer

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

In het bovenstaande voorbeeld hebben we een generieke methode gemaakt met de naam genericsMethod .

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

Hier de typeparameter <T> wordt ingevoegd na de modifier public en voor het retourtype void .

We kunnen de generieke methode aanroepen door het werkelijke type <String> . te plaatsen en <Integer> tussen de haakjes voor de naam van de methode.

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

demo.<Integer>genericMethod(25);

Opmerking :We kunnen de generics-methode aanroepen zonder de parameter type op te nemen. Bijvoorbeeld,

demo.genericsMethod("Java Programming");

In dit geval kan de compiler de parameter type matchen op basis van de waarde die aan de methode is doorgegeven.

Begrensde typen

Over het algemeen is de type parameter kan alle gegevenstypen accepteren (behalve primitieve typen).

Als we echter generieke geneesmiddelen willen gebruiken voor bepaalde specifieke typen (zoals het accepteren van gegevens van nummertypen), dan kunnen we begrensde typen gebruiken.

In het geval van gebonden typen gebruiken we de extends trefwoord. Bijvoorbeeld,

<T extends A>

Dit betekent T kan alleen gegevens accepteren die subtypes zijn van A .

Voorbeeld:begrensde 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<>();
  }
}

In het bovenstaande voorbeeld hebben we een klasse gemaakt met de naam GenericsClass. Let op de uitdrukking, let op de uitdrukking

<T extends Number> 

Hier, GenericsClass wordt gemaakt met een begrensd type. Dit betekent GenericsClass kan alleen werken met gegevenstypen die kinderen zijn van Number (Integer , Double , enzovoort).

We hebben echter een object van de klasse generics gemaakt met String . In dit geval krijgen we de volgende foutmelding.

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

Voordelen van Java Generics

1. Herbruikbaarheid van codes

Met behulp van generieke middelen in Java kunnen we code schrijven die met verschillende soorten gegevens werkt. Bijvoorbeeld,

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

Hier hebben we een generieke methode ontwikkeld. Deze zelfde methode kan worden gebruikt om bewerkingen uit te voeren op integer data, string data, enzovoort.

2. Compileertypecontrole

De type parameter van generieke geneesmiddelen geeft informatie over het type gegevens dat in de generieke code wordt gebruikt. Bijvoorbeeld,

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

Hier weten we dat GenericsClass werkt met Integer alleen gegevens.

Als we nu andere gegevens dan Integer aan deze klasse proberen door te geven, genereert het programma een fout tijdens het compileren.

3. Gebruikt met verzamelingen

Het collectieraamwerk gebruikt het concept van generieke geneesmiddelen in Java. Bijvoorbeeld,

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

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

In het bovenstaande voorbeeld hebben we dezelfde ArrayList-klasse gebruikt om met verschillende soorten gegevens te werken.

gelijk aan ArrayList , andere collecties (LinkedList , Queue , Maps , enzovoort) zijn ook generiek in Java.