Java - Overschrijven

In het vorige hoofdstuk hebben we gesproken over superklassen en subklassen. Als een klasse een methode van zijn superklasse erft, is er een kans om de methode te overschrijven, op voorwaarde dat deze niet als definitief wordt gemarkeerd.

Het voordeel van overschrijven is:de mogelijkheid om een ​​gedrag te definiëren dat specifiek is voor het type subklasse, wat betekent dat een subklasse een bovenliggende klassenmethode kan implementeren op basis van de vereiste ervan.

In objectgeoriënteerde termen betekent overschrijven het overschrijven van de functionaliteit van een bestaande methode.

Voorbeeld

Laten we een voorbeeld bekijken.

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Animals can move
Dogs can walk and run

In het bovenstaande voorbeeld kun je zien dat, hoewel b is een type Animal, het voert de methode move uit in de klasse Dog. De reden hiervoor is:Tijdens het compileren wordt gecontroleerd op het referentietype. Tijdens de runtime berekent JVM echter het objecttype en voert het de methode uit die bij dat specifieke object hoort.

Daarom zal het programma in het bovenstaande voorbeeld correct compileren, aangezien de klasse Animal de methodeverplaatsing heeft. Vervolgens voert het tijdens runtime de methode uit die specifiek is voor dat object.

Beschouw het volgende voorbeeld −

Voorbeeld

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
   public void bark() {
      System.out.println("Dogs can bark");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
      b.bark();
   }
}

Dit levert het volgende resultaat op −

Uitvoer

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

Dit programma geeft een compileerfout omdat het referentietype van b Animal geen methode heeft met de naam bark.

Regels voor het overschrijven van methoden

• De lijst met argumenten moet exact hetzelfde zijn als die van de overschreven methode.

• Het retourtype moet hetzelfde zijn of een subtype zijn van het retourtype dat is gedeclareerd in de oorspronkelijke overschreven methode in de superklasse.

• Het toegangsniveau kan niet restrictiever zijn dan het toegangsniveau van de overschreven methode. Bijvoorbeeld:als de superklassemethode openbaar is verklaard, kan de overschrijvende methode in de subklasse niet privé of beschermd zijn.

• Instantiemethoden kunnen alleen worden overschreven als ze worden overgenomen door de subklasse.

• Een methode die definitief is verklaard, kan niet worden overschreven.

• Een methode die statisch is verklaard, kan niet worden overschreven, maar kan opnieuw worden gedeclareerd.

• Als een methode niet kan worden overgenomen, kan deze ook niet worden overschreven.

• Een subklasse binnen hetzelfde pakket als de superklasse van de instantie kan elke superklassemethode overschrijven die niet privé of definitief is verklaard.

• Een subklasse in een ander pakket kan alleen de niet-definitieve methoden overschrijven die openbaar of beschermd zijn verklaard.

• Een overschrijvende methode kan alle uitgeschakelde uitzonderingen genereren, ongeacht of de overschreven methode uitzonderingen genereert of niet. De overschrijvende methode mag echter geen gecontroleerde uitzonderingen genereren die nieuw of breder zijn dan degene die zijn gedeclareerd door de overschreven methode. De overschrijvende methode kan smallere of minder uitzonderingen veroorzaken dan de overschreven methode.

• Constructors kunnen niet worden overschreven.

Het super-zoekwoord gebruiken

Bij het aanroepen van een superklasseversie van een overschreven methode wordt de super zoekwoord wordt gebruikt.

Voorbeeld

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Animals can move
Dogs can walk and run