Co jsou generika (Generics) v programování?

Obecné (Generics) jsou mechanismem v programovacích jazycích, který umožňuje vytvářet komponenty (třídy, rozhraní, metody/funkce), které pracují s různými datovými typy, aniž by ztratily typovou bezpečnost a aniž by bylo nutné provádět přetypování (casting).

Hlavní cíle používání generik:

• Zvýšení typové bezpečnosti: Kompilátor kontroluje typy v době kompilace, odhaluje chyby před spuštěním programu.
• Zlepšení čitelnosti kódu: Je jasné, s jakými datovými typy komponent pracuje.
• Opakované použití kódu: Lze vytvořit jeden komponent, který pracuje s různými typy, místo psaní několika verzí.
• Snížení přetypování: Odstraňuje potřebu explicitního přetypování, což činí kód čistším a méně náchylným k chybám ClassCastException (v jazycích, kde je to relevantní, například Java).

Příklady použití generik:

• Kolekce: Seznamy (List), množiny (Set), mapy (Map) mohou uchovávat prvky určitého typu, což zaručuje, že do kolekce nevstoupí prvky jiného typu.
• Metody/funkce: Metoda může pracovat s parametry nebo vracet hodnotu univerzálního typu.
• Třídy/rozhraní: Lze vytvářet univerzální datové struktury nebo vzory chování.

Příklad v jazyce Java:

// Obecná třída páru
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;
    }
}

// Použití
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Není potřeba přetypování
int num = pair.getSecond();   // Není potřeba přetypování

// Nesprávné přiřazení
Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Chyba kompilace: nesoulad typů

Příklad v jazyce C#:

// Obecná třída 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;
    }
}

// Použití
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Není potřeba přetypování
int num = pair.Second;   // Není potřeba přetypování

// Nesprávné přiřazení
var wrongPair = new Pair<string, int>(123, "Hello"); // Chyba kompilace

Příklad v TypeScriptu:

// Obecná funkce pro získání prvního prvku pole
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Použití
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber má typ number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord má typ string

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

Tímto jsou generika mocným nástrojem pro tvorbu flexibilního, typově bezpečného a znovu použitelných kódu.