Cosa sono le generiche (Generics) nella…

I Generics sono un meccanismo nei linguaggi di programmazione che permette di creare componenti (classi, interfacce, metodi/funzioni) che funzionano con diversi tipi di dati, senza perdere la sicurezza di tipo e senza ricorrere al cast dei tipi.

Gli obiettivi principali dell'uso dei Generics sono:

Aumentare la sicurezza di tipo: Il compilatore verifica i tipi in fase di compilazione, rilevando errori prima dell'esecuzione del programma.
Migliorare la leggibilità del codice: È chiaro con quali tipi di dati un componente lavora.
Riutilizzo del codice: È possibile creare un singolo componente che funziona con diversi tipi, invece di scrivere più versioni.
Ridurre i cast di tipo: Elimina la necessità di cast espliciti, rendendo il codice più pulito e meno soggetto a errori ClassCastException (nelle lingue in cui ciò è applicabile, ad esempio Java).

Esempi di utilizzo dei Generics:

Collezioni: Liste (List), set (Set), mappe (Map) possono contenere elementi di un tipo specifico, garantendo che non vengano inseriti elementi di altri tipi.
Metodi/funzioni: Un metodo può lavorare con parametri o restituire un valore di tipo universale.
Classi/interfacce: È possibile creare strutture dati universali o modelli di comportamento.

Esempio in Java:

// Classe generica Pair
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

// Uso
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Non è necessario il cast
int num = pair.getSecond(); // Non è necessario il cast

// Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Errore di compilazione: tipi incompatibili

Esempio in C#:

// Classe generica Pair
public class Pair<T, U>
{
    public T First { get; set; }
    public U Second { get; set; }

    public Pair(T first, U second)
    {
        First = first;
        Second = second;
    }
}

// Uso
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Non è necessario il conversione di tipo
int num = pair.Second; // Non è necessario il cast

// var wrongPair = new Pair<string, int>(123, "Hello"); // Errore di compilazione: tipi incompatibili

Esempio in TypeScript:

// Funzione generica per ottenere il primo elemento di un array
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Uso
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber ha tipo number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words); // firstWord ha tipo string

// let mixedArray: (number | string)[] = [1, "a", 2];
// let firstMixed = getFirstElement(mixedArray); // firstMixed ha tipo number | string

In conclusione, i Generics sono uno strumento potente per creare codice flessibile, sicuro in termini di tipi e riutilizzabile.

Cosa sono le generiche (Generics) nella programmazione?