Ce sunt generalizările (Generics) în programare?

Genericele (Generics) sunt un mecanism în limbajele de programare care permite crearea de componente (clase, interfețe, metode/funcții) care lucrează cu diferite tipuri de date, fără a pierde siguranța tipurilor și fără a recurge la conversii de tipuri (casting).

Obiectivele principale ale utilizării Generics:

• Creșterea siguranței tipurilor: Compilatorul verifică tipurile în timpul compilării, detectând erorile înainte de execuția programului.
• Îmbunătățirea lizibilității codului: Este clar cu ce tipuri de date lucrează componenta.
• Reutilizarea codului: Se poate crea o singură componentă care funcționează cu diferite tipuri, în loc să se scrie mai multe versiuni.
• Reducerea conversiilor de tip: Elimină necesitatea conversiilor explicite, făcând codul mai curat și mai puțin predispus la erori ClassCastException (în limbajele în care se aplică, de exemplu Java).

Exemple de utilizare a Generics:

• Colecții: Listări (List), mulțimi (Set), hărți (Map) pot stoca elemente de un anumit tip, garantând că nu vor fi introduse elemente de alt tip.
• Metode/funcții: O metodă poate lucra cu parametri sau poate returna o valoare de tip universal.
• Clase/interfețe: Se pot crea structuri de date universale sau modele de comportament.

Exemplu în Java:

// Clasă generică 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;
    }
}

// Utilizare
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Nu este nevoie de conversie
int num = pair.getSecond(); // Nu este nevoie de conversie

// Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Eroare de compilare: incompatibilitate de tipuri

Exemplu în C#:

// Clasă generică 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;
    }
}

// Utilizare
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Nu este nevoie de conversie
int num = pair.Second; // Nu este nevoie de conversie

// Pair<string, int> wrongPair = new Pair<>(123, "Hello"); // Eroare de compilare: incompatibilitate de tipuri

Exemplu în TypeScript:

// Funcție generică pentru obținerea primului element dintr-un array
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Utilizare
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber are tipul number

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

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

În concluzie, generics reprezintă un instrument puternic pentru crearea de cod flexibil, sigur în ceea ce privește tipurile și reutilizabil.