Mi az a generikus (Generics) a programozásban?

Általánosítások (Generikusok) — ez egy mechanizmus a programozási nyelvekben, amely lehetővé teszi olyan összetevők (osztályok, interfészek, metódusok/függvények) létrehozását, amelyek különböző adattípusokkal működnek anélkül, hogy elveszítenék a típusbiztonságot, és anélkül, hogy típuskonverziókra (casting) lenne szükség.

A generikusok fő céljai:

• Típusbiztonság növelése: A fordító ellenőrzi a típusokat a fordítási időben, hibákat fedez fel a program futtatása előtt.
• Kód olvashatóságának javítása: Egyértelmű, hogy mely típusú adatokkal dolgozik az összetevő.
• Kód újrafelhasználhatóság: Egy összetevőt lehet létrehozni, amely különböző típusokkal működik, ahelyett, hogy több verziót írunk.
• Típuskonverziók csökkentése: Elkerüli a szükségességét a nyilvános típuskonverzióknak, így a kód tisztább és kevésbé hibára hajlamos ClassCastException (ahol ez alkalmazható, például Java esetén).

A generikusok használatának példái:

• Gyűjtemények: A listák (List), halmazok (Set), térképek (Map) tárolhatnak meghatározott típusú elemeket, biztosítva, hogy más típusú elemek nem kerülnek a gyűjteménybe.
• Metódusok/függvények: Egy metódus működhet paraméterekkel vagy visszatérhet általános típusú értékkel.
• Osztályok/interfészek: Létrehozhatunk általános adatstruktúrákat vagy viselkedési mintákat.

Példa Java nyelven:

// Általános osztály
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;
    }
}

// Használat
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Nincs szükség típuskonverzióra
int num = pair.getSecond();   // Nincs szükség típuskonverzióra

// Helytelen párosítás
Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Fordítási hiba: típusok nem egyeznek

C# példában:

// Általános osztály
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;
    }
}

// Használat
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Nincs szükség típuskonverzióra
int num = pair.Second;   // Nincs szükség típuskonverzióra

// Helytelen párosítás
var wrongPair = new Pair<string, int>(123, "Hello"); // Fordítási hiba

TypeScript példában:

// Általános függvény az első elem lekérésére egy tömbből
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Használat
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber típusa number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord típusa string

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

Így a generikusok erőteljes eszközt jelentenek a rugalmas, típusbiztos és újrahasznosítható kód létrehozásához.