Arv med extends

Arv lar en subklasse gjenbruke og spesialisere en superklasse. Subklassen får alle (ikke-private) felt og metoder, og kan legge til nye eller overstyre eksisterende. Felles oppførsel samles oppe; det spesielle legges nede.

public abstract class Question {
    private String question;
    protected Question(String question) { this.question = question; }
    public void askQuestion(PrintStream out) { out.println(question); }
    public abstract boolean checkAnswer(String answer); // ulik per type
}

public class StringQuestion extends Question {
    private String answer;
    public StringQuestion(String question, String answer) {
        super(question);          // ma kalles forst
        this.answer = answer;
    }
    @Override
    public boolean checkAnswer(String answer) {
        return this.answer.equals(answer);
    }
}

super — kall til superklassen

Et kall til superklassens konstruktør, super(...), må stå som første linje i subklassens konstruktør. Du kan også kalle en overstyrt metode i superklassen med super.metode() for å gjenbruke dens oppførsel og legge til mer:

@Override
public void askQuestion(PrintStream out) {
    super.askQuestion(out);       // skriv selve sporsmalet
    int num = 1;
    for (String option : options) // legg til alternativene
        out.println(num++ + ". " + option);
}

@Override og dynamisk binding

@Override ber kompilatoren sjekke at du faktisk overstyrer en metode (fanger skrivefeil i signaturen). Polymorfi betyr at det er objektets faktiske type — ikke variabelens deklarerte type — som avgjør hvilken metodeimplementasjon som kjøres:

Question q = new StringOptionsQuestion(...); // deklarert Question
q.checkAnswer("2"); // kjorer StringOptionsQuestion sin versjon

Casting av referansetyper

Casting (SubType) obj tvinger kompilatoren til å behandle uttrykket som en annen type. På referansetyper sjekkes det ved kjøretid at objektet faktisk har den typen; ellers kastes ClassCastException. På talltyper konverterer casting verdien (f.eks. (int) Math.signum(x)).

Arv versus delegering

Et tilbakevendende drøftingspoeng: arv binder oppførselen ved kompilering, mens delegering (du holder et felt av en grensesnitt-type og videresender til det) kan byttes ved kjøretid og er derfor mer fleksibel. Velg arv for ekte «er-en»-forhold, delegering når oppførselen skal kunne variere dynamisk.

Eksempel i eksamensstil — felles superklasse for figurer

Du har klasser for sirkel og rektangel som begge har et areal. Trekk det felles opp i en abstrakt Figur med en abstrakt areal()-metode og en felles navn.

public abstract class Figur {
    private final String navn;
    protected Figur(String navn) { this.navn = navn; }
    public String getNavn() { return navn; }
    public abstract double areal();   // hver subklasse regner sitt
}

public class Sirkel extends Figur {
    private final double radius;
    public Sirkel(double radius) {
        super("sirkel");
        this.radius = radius;
    }
    @Override
    public double areal() { return Math.PI * radius * radius; }
}

En Figur[] kan inneholde både sirkler og rektangler, og f.areal() kjører riktig implementasjon takket være polymorfi.

Studieguide: Arv og polymorfisme

Studieguide: Arv og polymorfisme