Čo sú generiká (Generics) v programovaní?

Generiká sú mechanizmom v programovacích jazykoch, ktorý umožňuje vytvárať komponenty (triedy, rozhrania, metódy/funkcie), ktoré pracujú s rôznymi dátovými typmi, pričom neznižujú typovú bezpečnosť a nevyžadujú casting.

Hlavné ciele používania generík:

• Zvýšenie typovej bezpečnosti: Kompilátor kontroluje typy počas kompilácie, odhaľuje chyby pred spustením programu.
• Zlepšenie čitateľnosti kódu: Je jasné, s ktorými typmi dát komponent pracuje.
• Opakované použitie kódu: Môže sa vytvoriť jeden komponent, ktorý pracuje s rôznymi typmi, namiesto písania viacerých verzií.
• Zníženie castingov: Vyhýba sa potrebe explicitného castingovania, čo robí kód čistejším a menej náchylným na chyby ClassCastException (v jazykoch, kde je to relevantné, napr. Java).

Príklady použitia generík:

• Kolekcie: Zoznamy (List), množiny (Set), mapy (Map) môžu obsahovať prvky určitého typu, čo zaručuje, že do kolekcie nevstúpia prvky iného typu.
• Metódy/funkcie: Metóda môže pracovať s parametrami alebo vracať hodnotu univerzálneho typu.
• Triedy/rozhrania: Môžu sa vytvárať univerzálne dátové štruktúry alebo vzory správania.

Príklad v Jave:

// Generická trieda 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žitie
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Nie je potrebné casting
int num = pair.getSecond();   // Nie je potrebné casting

// Nesprávne párovanie
Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Chyba kompilátora: nesúlad typov

Príklad v C#:

// Generická trieda 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žitie
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Nie je potrebné casting
int num = pair.Second;   // Nie je potrebné casting

// Nesprávne párovanie
var wrongPair = new Pair<string, int>(123, "Hello"); // Chyba kompilátora

Príklad v TypeScript:

// Generická funkcia na získanie prvého prvku poľa
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Použitie
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

Takže, generiká predstavujú mocný nástroj na tvorbu flexibilného, typovo bezpečného a opakovane použiteľného kódu.