Oversikt

Generics (generiske typer) lar deg skrive klasser og metoder som kan operere pa ulike typer uten a miste typesikkerhet. I stedet for a bruke Object overalt og caste manuelt, bruker du en typeparameter (vanligvis T) som erstattes med en konkret type nar klassen brukes. Fordelen er todelt: du ungar feilaktige casts ved kjoring, og kompilatoren fanger typefeil allerede ved kompilering.

Generisk klasse

En generisk klasse deklareres med en typeparameter i vinkelparenteser: class MinKlasse<T> { ... }. Inne i klassen kan du bruke T som en vanlig type for felt, parametere og returverdier. Nar klassen instansieres, spesifiserer brukeren den konkrete typen: MinKlasse<String> obj = new MinKlasse<>();. Fra Java 7 kan du bruke diamantoperatoren (<>) pa hoyre side, sa kompilatoren infererer typen automatisk.

Begrensede typeparametere

Du kan begrense typeparameteren med extends: <T extends Comparable<T>> betyr at T ma implementere Comparable. Dette er nyttig nar du trenger a sammenligne elementer, for eksempel i en sortert liste eller prioritetsko. Uten denne begrensningen kan du ikke kalle compareTo() pa objekter av type T, fordi kompilatoren ikke vet at T har denne metoden.

Type erasure

Java implementerer generics via type erasure: typeparameteren fjernes ved kompilering og erstattes med Object (eller grensen hvis spesifisert). Dette har flere praktiske konsekvenser som du ma kjenne til:

Du kan ikke opprette arrays av generiske typer: new T[10] er ulovlig. Losningen er a bruke (T[]) new Object[10] med en unchecked cast, eller bruke ArrayList<T>.
Du kan ikke bruke instanceof med typeparametere: x instanceof T kompilerer ikke.
Primitiver (int, double) kan ikke brukes som typeparameter. Bruk wrapper-klasser: Integer, Double.

Generics pa eksamen

Generics testes ofte indirekte gjennom datastrukturoppgaver. V2018 ba eksplisitt om en generisk prioritetsko Prioritetskoe<T> som skulle fungere for vilkarlige typer. V2021 brukte ikke generics i prioritetskoen fordi den var spesifikt for Aktivitet-objekter, men Aktivitet implementerte Comparable<Aktivitet> som er et generisk grensesnitt. Forstaaelse av generics er ogsa nodvendig for a bruke Javas innebygde samlinger korrekt (ArrayList, HashMap) i de oppgavene der det er tillatt.

En viktig detalj: nar oppgaven sier "uten bruk av noe fra Javas bibliotek", ma du implementere alt selv. Men du kan fortsatt bruke generics-syntaksen -- det er en del av sprakket, ikke biblioteket.

Wildcard-typer

I tillegg til standard typeparametere stotter Java wildcards med ?: List<?> betyr "en liste av en eller annen type". List<? extends Number> betyr "en liste av Number eller en subklasse av Number". Wildcards brukes sjelden pa eksamen, men du bor kjenne til dem for a forstaa feilmeldinger fra kompilatoren. Det viktigste er at du ikke kan legge til elementer i en List<?> (fordi kompilatoren ikke vet hvilken type listen inneholder), men du kan lese fra den.

Generics er ogsa nokkelen til a forstaa forskjellen mellom Comparable<Aktivitet> og Comparable uten typeparameter (raatype). Raatyper gir advarsler fra kompilatoren og mister typesikkerheten -- bruk alltid den generiske versjonen.

Kodeeksempel 1: Generisk prioritetsko (V2018-stil)

class Prioritetskoe<T> {
    private Node forste;
    private int antall = 0;

    private class Node {
        T data;
        int prioritet;
        Node neste;

        Node(T data, int prioritet) {
            this.data = data;
            this.prioritet = prioritet;
        }
    }

    void settInn(T inn, int prio) {
        Node ny = new Node(inn, prio);
        // Sett inn sortert pa prioritet (lavt tall = hoy prioritet)
        if (forste == null || prio < forste.prioritet) {
            ny.neste = forste;
            forste = ny;
        } else {
            Node p = forste;
            while (p.neste != null && p.neste.prioritet <= prio) {
                p = p.neste;
            }
            ny.neste = p.neste;
            p.neste = ny;
        }
        antall++;
    }

    T taUt() {
        if (forste == null) return null;
        T data = forste.data;
        forste = forste.neste;
        antall--;
        return data;
    }

    int antall() { return antall; }
}

Kodeeksempel 2: Generisk metode med begrensning

// Generisk metode som finner storste element
static <T extends Comparable<T>> T finnStorst(T[] arr) {
    T storst = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i].compareTo(storst) > 0) {
            storst = arr[i];
        }
    }
    return storst;
}

// Bruk:
String[] navn = {"Ada", "Bo", "Carl"};
String storst = finnStorst(navn); // "Carl"

Integer[] tall = {3, 1, 4, 1, 5};
Integer storst2 = finnStorst(tall); // 5

Studieguide: Generics