OOP i Java - Part 2

Arv af klasser bruges til at udvide en klasse med dens variabler og metoder og sammensætte en ny klasse, der har arvet de fleste af variablerne og metoderne af den klasse den nye klasse arver fra. Hvorfor den nye klasse ikke arver alle variabler og metoder, vil vi se på lige om lidt. Men først vil vi se på konceptet af arv.



Her arver klassen Kirke fra klassen Hus med sætningen "class Kirke extends Hus". Her bliver Hus super-klassen for Kirke, mens Kirke er den arvede klasse. Det er kun muligt at arve fra én klasse i en ny klasse. 'antalBaenke' er en ny variabel, som man kun kan få adgang til via et Kirke-objekt. Derimod har man adgang til 'antalVinduer' og 'antalDore' både i Hus- og Kirke-objekter, idet et Kirke-objekt automatisk får tildelt et helt sæt af alle variabler og metoder, der er i klassen Hus.

Et objekt af klassen Kirke har i diagrammet arvet begge variabler fra klassen Hus, men hvad hvis man ikke vil have det sådan? Det er her adgangs-attributerne kommer ind. Der er 4 forskellige slags adgangs-attributer - alle skrives før variablerne eller metoderne:

1. <ingenting foran> (venlig adgang) - arver metoden eller variablen, hvis den er i den samme fil eller pakke.
2. private - arver ikke metoden eller variablen.
3. protected - arver variablen eller metoden.
4. public - arver også variablen eller metoden.

Hvad er så forskellen på protected og public? Jo, hvis man havde en metode som denne,

protected void info() {
  System.out.println("info...");
}

kan man kun få adgang til den i en arvet klasse eller i en klasse i den samme fil som denne metode. Her er et eksempel på de forskellige adgangs-attributer:

class Hus {
  void venlig() {
    System.out.println("venlig...");
  }
  public void reklame() {
    System.out.println("reklame...");
  }
  protected void info() {
    System.out.println("info...");
  }
  private void megetPrivatInfo() {
    System.out.println("hemmeligt...");
  }
}

public class Kirke extends Hus {      // filen hedder Kirke.java
  public static void main(String[] args) {
    Hus villa = new Hus();
    villa.venlig();
    villa.reklame();
    villa.info();
    // udkommenteret, da det ikke er muligt at kalde metoden:
    // villa.megetPrivatInfo(); 
  }
}

Du kan eventuelt prøve at fjerne udkommenteringen af "villa.megetPrivatInfo()"; det vil resultere i en fejlmeddelelse fra compileren. Vi vil nu tage et praktisk eksempel på arv:

class Hus {
  private String type;
  Hus(String type) {
    this.type = type;
    System.out.println("Hus-type: " + type);    
  }
}

public class Kirke extends Hus {   // filen hedder Kirke.java
  private String type;
  Kirke(String type) {
    super(type);   // kalder Hus-constructoren
    this.type = type;    
  }
  public String toString() {      // overskriver Object.toString()
    return "Kirke-type: " + type;
  }
     
  public static void main(String[] args) {
    Kirke kirke = new Kirke("Kirke");
    System.out.println(kirke);    // kalder kirkens toString()
  }
}

Først har vi klassen Hus, hvor der er en variabel 'type'. Den bliver sat i klassens constructor og bliver samtidig skrevet på skærmen. Klassen Kirke har også en variabel 'type', som også bliver sat i constructoren. Men før det bliver super-klassens constructor kaldet med sætningen "super(type)", hvor parameteren fra Kirke-klassens contructor bliver overført til Hus-klassens contructor. Hvis man kalder super-klassens constructor i en nedarvet klasses contructor, skal man gøre det som det første i sætninget. Ellers klager compileren. Metoden "public String toString()" er en metode, der stammer fra Objekt-klassen, super-klassen over alle super-klasser, idet alle klasser arver fra denne klasse. Når man kalder "System.out.println" bliver det pågældende objekts toString-metode kaldet. På samme måde som vi overskriver toString-metoden kan man også i en nedarvet klasse overskrive en hvilken som helst anden metode. Det gøres ved at definere nøjagtigt den samme metode, som er defineret i superklassen for den nedarvede klasse. Fx:

class SuperKlasse {
  public void skrig(String hvad); {
    System.out.println(hvad);
  }
}

class NedarvetKlasse extends SuperKlasse {
  public void skrig(String hvad) {
    System.out.println(hvad);
  }
}

Hvis vil lavede et NedarvetKlasse-objekt og kaldte skrig-metoden ville metoden i NedarvetKlasse blive kaldt. Til sidst skal det siges at der ikke er nogle grænser for hvor mange gange man kan nedarve fra sine klasser. Dog er det en god idé at beherske sig med arvningen. I næste artikel er det tid til en lidt mere avanceret teknik kaldet polymorphisme.