Arv (inheritance) i Java – Ärv kod från andra klasser

Arv är ett kraftfullt sätt att återanvända kod från redan existerande klasser.

Vad är Arv (inheritance) i Java?

Arv, ofta refererad som inheritance, använder man i Java för att återanvända kod från andra klasser. Många gånger vill man återanvända kod från klasser man redan har programmerat, men istället för att programmera liknande klasser flera gånger, kan man ärva kod från en annan klass. En klass som ärver kod kallas för subklass och dess förälder för superklass.

Istället för att programmera liknande klasser flera gånger, kan man ärva kod från en annan klass.

Det som är smidigt med arv är att subklassen får samma uppsättning av instansvariabler och metoder som superklassen, men det är även möjligt att lägga till nya metoder och klassvariabler om så önskas.

Arv i Java är:

  • Ett sätt att återanvända kod från en annan klass.
  • En klass som ärver kod kallas för subklass.
  • Klassen som blir ärvd från kallas superklass.
  • En subklass får samma uppsättning av instansvariabler som dess förälder (superklassen).
  • I subklassen kan man definera nya attribut och egenskaper.

Arv i Java – Syntax

Man kan skapa ett arv med det reserverade ordet extends. Syntaxen för att skapa en subklass är:

class subclassNamn extends superklassNamn{
    super(datatyp1 namn1, datatyp2 namn2 ) //osv
}

Man använder kommandot super för att kalla på konstruktorn i superklassen. Inparametrarna ska alltså vara densamma som för superklassen.

Olika typer av Arv i Java

Det finns ett par olika typer av arv i Java som är bra att känna till och förhoppningsvis öka förståelsen hur arv fungerar.

Notera hur vi använder ordet extends för att en klass ska ärva kod.

Enkelt Arv

class A { 
   // .... 
}

class B extends A {
   // .... 
}
Arv Java

Arv på flera nivåer

class A { 
   // .... 
}

class B extends A {
   // .... 
}

class C extends B { 
   // ....
}
Arv Java flera nivåer

Hierarkisk arv

class A { 
   // .... 
}

class B extends A {
   // .... 
}

class C extends A { 
   // ....
}
Hierarkisk arv Java

Viktigt att notera är att Java inte stödjer så kallad flertalet/multipla arv då en klass ärver kod från flera klasser. T.ex. att klass C ärver kod från A och B samtidigt, vilket innebär att en klass inte kan förlänga sig till mer än en klass. Dock, en klass kan implementera ett eller flera så kallade Interface, som vi kommer gå igenom på nästa sida.

Hur skapar man ett arv i Java – Exempel

Följande exempel är en fortsättning på föregående avsnitt. I exemplet har vi gått igenom hur vi kan skapa olika objekt från klassen dog.

Exempel fortsättning:

I föregående avsnitt skapade vi klassen Dog. Vi skapar nu subklassen “superdog” som ska ärva från klassen “Dog”:

//Skapar klassen "Dog". Praxis är att klassnamn har stor bokstav
class Dog {

    //Definierar klassvariablerna (egenskaperna) för klassen hund
    String name;
    int age;
    String breed;
    String color;

    //Definiera konstruktorn
    Dog(String name, int age, String breed, String color){
        this.name = name;
        this.age = age;
        this.breed = breed;
        this.color = color;
    }

    //Definierar metoderna för klassen hund
    void bark(){
        System.out.println(this.name + " skäller");
    }

    void eat(){
        System.out.println(this.name + " äter");
    }

    void sleep(){
        System.out.println(this.name + ": zZZzzZzzZ");
    }

    public static void main(String args[]){
        Dog dog = new Dog("Bosse", 3, "Terrier", "Brun");
        Dog dog2 = new Dog("Båtsman", 5, "Sankt Bernhard", "Svart");

        SuperDog superDog = new SuperDog("Bolt", 2, "Schäfer", "vit");

        dog.sleep();
        dog2.sleep();
        superDog.sleep();

    }

}

class SuperDog extends Dog {
    SuperDog(String name, int age, String breed, String color) {
        super(name, age, breed, color);
    }

    void sleep(){
        System.out.println(this.name + ": Jag tänker inte sova!");
    }
}

Vi kollar först på subklassen (rad 45-53):

class SuperDog extends Dog {
    SuperDog(String name, int age, String breed, String color) {
        super(name, age, breed, color);
    }

    void sleep(){
        System.out.println(this.name + ": Jag tänker inte sova!");
    }
}
  • Man skapar en subklass med namn “SuperDog”.
  • Vi ärver klassen hund med kommandot extends.
  • I subklassens konstruktor anger man kommandot super som anropar konstruktorn i superklassen “Dog”.
  • Inparametrarna måste alltså vara densamma som inparametrarna till superklassen.

En klass som ärver kod kallas för subklass och dess förälder för superklass.

  • I rad 50-52 justerar vi metoden “sleep()”  till ny önskad kod.
  • Man skapar objekt från subklasser på samma sätt som vanliga objekt (rad 35)
  • Om vi låter varje objekt anropa metoden “sleep()” (rad 37-39) så blir utskriften:
Bosse: zZZzzZzzZ 
Båtsman: zZZzzZzzZ 
Bolt: Jag tänker inte sova!

Självklart finns även superklassens andra metoder kvar från subklassen. Kommandot

superDog.eat();

ger alltså utskriften:

Bolt äter

Önskar man att lägga till klassvariabler och nya metoder görs det enkelt genom att lägga till dem i subklassen:

class SuperDog extends Dog {
    public int velocity;
    SuperDog(String name, int age, String breed, String color, int velocity) {
        super(name, age, breed, color);
        this.velocity = velocity;
    }

    void sleep(){
        System.out.println(this.name + ": Jag tänker inte sova!");
    }

    void run(){
        System.out.println(this.name + ": springer med hastigheten " + getVelocity() + "km/h");
    }
    int getVelocity(){
        return this.velocity;
    }
}

Nu kräver subklassen fem inparametrar. Vi kan nu skapa ett objekt från subklassen “SuperDog” enligt:

SuperDog superDog = new SuperDog("Bolt", 2, "Schäfer", "vit", 10);

Anropar man nu metoden “run()” enligt:

superDog.run();

Blir utskriften;

Bolt: springer med hastigheten 10km/h

Vad tyckte du om sidan?

Lämna gärna feedback och hjälp oss göra sidan bättre

Feedback gör oss bättre!

Lämna gärna feedback om vad du tyckte om avsnittet!