Mis on üldistused (Generics) programmeerimises?

Generics on mehhanism programmeerimiskeeltes, mis võimaldab luua komponente (klassid, liidesed, meetodid/funktsioonid), mis töötavad erinevat tüüpi andmetega, säilitades samal ajal tüübiturvalisuse ning vältides tüübi konverteerimist (casting).

Generics kasutamise peamised eesmärgid:

• Tüübiturvalisuse tõstmine: Kompilaator kontrollib tüüpe kompileerimise ajal, avastades vead enne programmi käivitamist.
• Koodi loetavuse parandamine: On selge, milliste andmetüüpidega komponent töötab.
• Koodi taaskasutus: Võib luua ühe komponendi, mis töötab erinevate tüüpidega, mitte kirjutada mitu versiooni.
• Tüübi konverteerimise vähendamine: Vältib vajadust teha selgeid tüübi konverteerimisi, muutes koodi puhtamaks ja vähem vigadele vastuvõtlikuks ClassCastException (näiteks Java keeles).

Generics kasutamise näited:

• Kogumid: Nimekirjad (List), kogud (Set), kaardid (Map) võivad hoida kindla tüübi elemente, mis tagab, et kogumikku ei satu teise tüübi elemente.
• Meetodid/funktsioonid: Meetod võib töötada universaalse tüübi parameetritega või tagastada väärtuse.
• Klassid/liidesed: Võib luua universaalseid andmestruktuure või käitumise mustreid.

Java näide:

// Üldine paariklass
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;
    }
}

// Kasutus
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Tüüp ei nõua konverteerimist
int num = pair.getSecond();   // Tüüp ei nõua konverteerimist

// Vale paaride defineerimine - kompilaator annab vea
// Pair<String, Integer> valePair = new Pair<>(123, "Hello");

C# näide:

// Üldine paariklass
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;
    }
}

// Kasutus
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Tüüp ei nõua konverteerimist
int num = pair.Second;   // Tüüp ei nõua konverteerimist

// Vale paaride defineerimine - kompilaator annab vea
// var wrongPair = new Pair<string, int>(123, "Hello");

TypeScript näide:

// Üldine funktsioon esimese elemendi saamiseks massiivist
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Kasutus
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber on tüübiga number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord on tüübiga string

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

Seega on Generics võimas tööriist paindliku, tüübiturvalise ja taaskasutatava koodi loomiseks.