Nedarvning er et centralt koncept i objektorienteret programmering. Det giver dig mulighed for at oprette en ny klasse (subklasse), der arver egenskaber og metoder fra en eksisterende klasse (superklasse). Dette gør det nemt at genbruge kode og tilføje ny funktionalitet uden at omskrive alt fra bunden.

Nedarvning lader en klasse arve egenskaber og metoder fra en anden klasse. Dette gør det muligt at genbruge kode og skabe hierarkiske strukturer. En superklasse kan indeholde fælles funktioner, mens subklasser kan tilpasse og udvide funktionaliteten.

• Tilføje deres egne specifikke egenskaber og metoder.
• Overskrive metoder fra superklassen for at tilpasse dem.

Denne struktur gør det muligt at skabe komplekse, men velorganiserede programmer, og det anvendes ofte i praksis til at skabe fleksible og genanvendelige systemer.

For bedre at forstå nedarvning, lad os se på et konkret eksempel. Vi kan bruge en klasse til at repræsentere dyr som en superklasse, hvor specifikke typer dyr som hunde og katte arver fælles træk og tilføjer deres egne unikke egenskaber.

Først opretter vi en fælles klasse, der definerer generelle egenskaber og metoder for alle dyr.

class Dyr {
    String navn;
    int alder;
    
    Dyr(String navn, int alder) {
        this.navn = navn;
        this.alder= alder;
    }

    void spise() {
        println(navn + " spiser.");
    }

    void sove() {
        println(navn + " sover.");
    }
}

    void lavLyd() {
        println(navn + " laver en lyd!");
    }
}

Subklasser arver fra Dyr, hvilket betyder, at de automatisk får adgang til alle egenskaber og metoder fra superklassen, som fx spise og sove. De behøver ikke nødvendigvis at tilføje egne specifikke metoder eller egenskaber, men kan gøre det for at udvide eller tilpasse funktionaliteten.

For eksempel kan en subklasse være sådan:

class Fugl extends Dyr {
    Fugl(String navn, int alder) {
        super(navn, alder);
    }
    // Ingen yderligere metoder eller egenskaber
}

Her arver Fugl alt fra Dyr uden at tilpasse noget.

Til sammenligning kan en anden subklasse, fx Hund og Kat, tilføje eller overskrive en metode:

class Hund extends Dyr {
    Hund(String navn, int alder) {
        super(navn, alder);
    }

    @Override
    void lavLyd() {
        println(navn + " siger: Vov!");
    }
    
    @Override
    void spise() {
        super.spise(); // Kalder superklassens version af spise
        System.out.println(navn + " nyder sin mad ekstra meget!");
    }
}

class Kat extends Dyr {
    Kat(String navn, int alder) {
        super(navn, alder);
    }

    @Override
    void lavLyd() {
        println(navn + " siger: Miau!");
    }
}

Dette viser, hvordan subklasserne arver fra superklassen og tilpasser sig deres egne behov.

Eksemplerne ovenfor bruger nogle nye begreber, som er vigtige når vi laver nedarvning. Disse begreber bliver beskrevet nedenunder.

• extends: Dette bruges til at angive, at en klasse arver fra en anden klasse. For eksempel betyder class Hund extends Dyr, at klassen Hund arver alt fra Dyr.
• super: Dette bruges til at kalde superklassens metoder eller constructor. For eksempel kaldes super(navn, alder) for at initialisere attributterne i Dyr.
• @Override: Dette angiver, at en metode i subklassen overskriver en metode fra superklassen. Det er nyttigt, når du vil tilpasse adfærden i subklassen.