Java: Arv & initiering

Det bästa sättet för att se vilka metoder som blir anropade i vilken ordning, är att helt enkelt lägga in en skrivning till standard out i varje metod. Då får du en fin utskrift för att se hur det fungerar. Så ändra dina klasser till följande, så borde du få en bättre överblick och förståelse.

package inherit.init;
public class Child extends Parent {
    private /*static*/ int num = 10;
    /* När du avkommenterar static ovanför, avkommentera även denna rad: */
    //static { System.out.println("Setting static variable num to 10"); }
    public int lookup() {
        System.out.println("Calling " + this.getClass().toString() + " method lookup() in Child");
        return num;
    }
}

package inherit.init;
public class Parent {
    private int val;
    public Parent() {
        System.out.println("Calling Parent constructor");
        val = lookup();
    }
    public int value() {
        System.out.println("Calling " + this.getClass().toString() + " method value()");
        return val;
    }
    public int lookup() {
        System.out.println("Calling " + this.getClass().toString() + " method lookup() in Parent");
        return 5;// Silly
    }
}

Är du ändå osäker, kan du t.ex. numrera dina utskrifter så att du ser vad som händer. Ett litet tips, istället för att ge dig svaret.

child.value() returns 10
parent.value() returns 10
parent2.value() returns 5

* Statiska medlemmar initialiseras alltid först. (De initialiseras i den ordning de står, sett uppifrån och ner i en fil.)
* Du överlagrar inte konstruktorn i Child. Varje instans av Child skapas således genom den implicita, tomma, Child(), som i sin tur gör ett implicit anrop till Parent() det första som sker. Alla konstruktorer i Java anropar en föräldraklass-konstruktor (som anropar en föräldra-konstruktor, som anropar...) innan den egna konstruktorn körs. Om du inte själv specificerar vilken som ska användas (m.h.a. super-nyckelordet) anropas den som inte tar några argument.
* Parent() sätter val till lookup(). Det är dock inte Parent.lookup() som anropas, utan den överlagrade Child.lookup()! Denna sätter ju val till num dvs 10. Eftersom både instanserna "child" och "parent" i är Child-instanser så får du 10.