Generici Java

In questo tutorial, esploreremo attraverso esempi i generici Java, come creare classi e metodi generici e i loro vantaggi.

In Java:GenericiAiuta a creare classi, interfacce e metodi che possono essere utilizzati con oggetti (dati) di diversi tipi. Pertanto, ci permette di riutilizzare il nostro codice.

注意：GenericiI generici non si applicano ai tipi di base (int, float, char, ecc.).

Come utilizzare i generici Java

Per comprendere come utilizzareGenericiPossiamo utilizzare le classi della collezione Java ArrayList.

ArrayList è un esempio di classe generica. Possiamo usare ArrayList per memorizzare qualsiasi tipo di dati. Ad esempio

import java.util.ArrayList;
class Main {
　　　public static void main(String[] args) {
　　　　　　//Creare una lista array per memorizzare dati Integer
　　　　　　ArrayList<Integer> list1 = new ArrayList<>();
　　　　　　list1.add(4);
　　　　　　list1.add(5);
　　　　　　System.out.println("ArrayList di Integer: " + list1);
　　　　　　//Creare una lista array per memorizzare dati String
　　　　　　ArrayList<String> list2 = new ArrayList<>();
　　　　　　list2.add("Four");
　　　　　　list2.add("Five");
　　　　　　System.out.println("ArrayList di String: " + list2);
　　　　　　//Creare una lista array per memorizzare dati Double
　　　　　　ArrayList<Double> list3 = new ArrayList<>();
　　　　　　list3.add(4.5);
　　　　　　list3.add(6.5);
　　　　　　System.out.println("ArrayList di Double: " + list3);
　　　}
}

Risultato di output

ArrayList of Integer: [4, 5]
ArrayList of String: [Four, Five]
ArrayList of Double: [4.5, 6.5]

Nel esempio sopra, abbiamo utilizzato la stessa classe ArrayList per memorizzare elementi di tipo Integer, String e Double. PoichéGenerici Java, è possibile farlo.

Ecco questa riga, attenzione a questa

ArrayList<Integer> list1 = new ArrayList<>();

Abbiamo utilizzato Integer tra le parentesi angolari <> in questo contesto. Le parentesi angolari <> sono chiamateParametri di tipo.

Il parametro type viene utilizzato per specificare il tipo di oggetti (dati) a cui si applica la classe generica o il metodo.

Creazione di una classe generica

Ora che sappiamo come funzionano i generici in Java, vediamo come creare le nostre classi generiche.

Esempio: creazione di una classe generica

class Main {
　　public static void main(String[] args) {
　　　　//Inizializzazione della classe generica con dati di tipo intero
　　　　GenericsClass<Integer> intObj = new GenericsClass<>(5);
　　　　System.out.println("La classe generica restituisce: " + intObj.getData());
　　　　//Inizializzazione della classe generica con dati di tipo stringa
　　　　GenericsClass<String> stringObj = new GenericsClass<>("Java Programming");
　　　　System.out.println("La classe generica restituisce: " + stringObj.getData());
　　}
}
class GenericsClass<T> {
　　//Variabile di tipo T
　　private T data;
　　public GenericsClass(T data) {
　　　　this.data = data;
　　}
　　//Metodo per restituire una variabile di tipo T
　　public T getData() {
　　　　return this.data;
　　}
}

Risultato di output

La classe generica restituisce: 5
La classe generica restituisce: Java Programing

Nel esempio sopra, abbiamo creato una classe generica chiamata GenericsClass. Questa classe può essere utilizzata per gestire qualsiasi tipo di dati.

class GenericsClass<T> {...}

In questo contesto, T rappresentaParametri di tipoAll'interno della classe Main, abbiamo creato degli oggetti della classe GenericsClass chiamati intObj e stringObj.

• Quando si crea intObj, il parametro di tipo T viene sostituito con Integer. Questo significa che intObj utilizza GenericsClass per elaborare dati di tipo intero.

• Quando si crea stringObj, il parametro di tipo T viene sostituito con String. Questo significa che stringObj utilizza GenericsClass per elaborare dati di tipo stringa.

Creazione di un metodo generico

Similmente a una classe generica, possiamo anche creare i nostri metodi generici in Java.

Esempio: creazione di un metodo generico

class Main {
　　public static void main(String[] args) {
　　　　// inizializzazione della classe con Integer
　　　　DemoClass demo = new DemoClass();
　　　　demo.<String>genericMethod("Programming Java");
　　}
}
class DemoClass {
　　// metodo generico
　　public <T> void genericMethod(T data) {
　　　　System.out.println("Questo è un metodo generico.");
　　　　System.out.println("I dati passati al metodo sono " + data);
　　}
}

Risultato di output

Questo è un metodo generico.
I dati passati al metodo sono: Programming Java

Nell'esempio sopra, abbiamo creato un metodo generico genericsMethod all'interno di una classe comune (DemoClass).

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

In questo caso, il parametro di tipo <T> viene inserito dopo il modificador (public) e prima del tipo di ritorno (void).

Possiamo chiamare il metodo generico inserendo il tipo effettivo <String> tra i parentesi del nome del metodo.

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

Attenzione: In molti casi, possiamo omettere il parametro di tipo durante la chiamata del metodo generico. Questo è perché il compilatore può utilizzare il valore passato al metodo per abbinare il parametro di tipo. Ad esempio,

demo.genericsMethod("Programming Java");

tipi limitati

Di solito,Parametro di tipopuò accettare qualsiasi tipo di dati (esclusi i tipi primitivi). Tuttavia, se vogliamo utilizzare i generici solo per determinati tipi specifici (ad esempio, accettare dati di tipo numerico), possiamo utilizzare i tipi vincolati.

Usiamo la parola chiave extends. Ad esempio,

<T extends A>

Questo significa che T può accettare solo i tipi figli di A.

Esempio: tipi vincolati

class GenericsClass <T extends Number> {
　　public void display() {}}
　　　　System.out.println("Questo è una classe generica limitata.");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　//Creazione di un oggetto GenericsClass
　　　　GenericsClass<String> obj = new GenericsClass<>();
　　}
}

Nel esempio sopra, abbiamo creato untipi limitatidi classe generica. Ecco, presta attenzione all'espressione

<T extends Number>

Questo significa che T può utilizzare solo i tipi di dati di sottoinsieme di Number (Integer, Double, ecc.).

Ma abbiamo già creato un oggetto di classe generica con String. Ecco perché, quando eseguiamo il programma, otteniamo l'errore seguente:

GenericsClass<String> obj = new GenericsClass<>();
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　^
　　　　ragione: la variabile inferenza T ha limiti incompatibili
　　　　　　limiti superiori: String
　　　　　　limiti inferiori: Number
　　dove T è una variabile tipo variabile:
　　　　T extends Number dichiarato nella classe GenericsClass

Vantaggi dei generici in Java

1. Riutilizzabilità del codice

GenericiCi permette di scrivere codice adatto a diversi tipi di dati. Ad esempio:

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

Ecco, abbiamo creato un metodo generico. Questo metodo può essere utilizzato per eseguire operazioni sui dati interi, dati di stringa, ecc.

2. Controllo dei tipi alla compilazione

GenericiParametro di tipoFornire informazioni sul tipo di dati utilizzato nel codice generico.

Di conseguenza, è possibile identificare gli errori durante la compilazione, che sono più facili da correggere rispetto agli errori in esecuzione. Ad esempio:

//Senza l'uso di generici
NormalClass list = new NormalClass();
//Chiamata al metodo di NormalClass
list.display("String");

Nel codice sopra, abbiamo una classe comune. Chiamiamo il metodo display() di questa classe passando dati di stringa.

Ecco, il compilatore non sa se il valore passato come parametro è corretto. Ma vediamo cosa accade se usiamo una classe generica.

//使用泛型
GenericsClass<Integer> list = new GenericsClass<>();
// Chiamare il metodo di GenericsClass
list2.display("String");
Nel codice sopra, abbiamo una classe generica. In questo caso, i parametri di tipo indicano che la classe sta elaborando dati di tipo Integer.
Di conseguenza, quando i dati di tipo stringa vengono passati come parametri, il compilatore genererà un errore.

3. Utilizzo dei generici con le collezioni

La struttura delle collezioni utilizza il concetto di generici in Java. Ad esempio:

// Creare un ArrayList di tipo stringa
ArrayList<String> list1 = new ArrayList<>();
// Creare un ArrayList di tipo intero
ArrayList<Integer> list2 = new ArrayList<>();

Nell'esempio sopra, abbiamo utilizzato la stessa classe ArrayList per gestire diversi tipi di dati.

Simile a ArrayList, altre collezioni (LinkedList, Queue, Maps, ecc.) sono generiche Java.