OVERSCHRIJVEN OP JAVA

Wanneer een subklasse een specifieke implementatie biedt voor een methode die al is gedefinieerd in de bovenliggende klasse, wordt dit methodeoverschrijving genoemd. De overschreven methode in de subklasse moet dezelfde naamparameters en hetzelfde retourtype hebben als de methode in de bovenliggende klasse.

Regels voor het overschrijven van methoden

Naamparameters en retourtype moeten overeenkomen met de bovenliggende methode.
Java kiest welke methode tijdens runtime moet worden uitgevoerd op basis van het daadwerkelijke objecttype en niet alleen van het type referentievariabele.
Statische methoden kunnen niet worden overschreven.
De @Annotatie overschrijven vangt fouten zoals typefouten op in methodenamen.

Java

    class   Animal     {          void     move  (){      System  .  out  .  println  (      'Animal is moving.'  );             }      void     eat  (){          System  .  out  .  println  (      'Animal is eating.'  );             }   }   class   Dog     extends     Animal  {          @Override     void     move  (){             // move method from Base class is overriden in this      // method      System  .  out  .  println  (  'Dog is running.'  );      }      void     bark  (){          System  .  out  .  println  (  'Dog is barking.'  );             }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      Dog     d     =     new     Dog  ();      d  .  move  ();         d  .  eat  ();         d  .  bark  ();      }   }

Uitvoer

Dog is running. Animal is eating. Dog is barking.

Uitleg: De klasse Animal definieert basisfunctionaliteiten zoals beweging() En eten() . De klasse Dog erft van Animal en overschrijft de move() methode om specifiek gedrag te bieden Hond rent. Beide klassen hebben toegang tot hun eigen methoden. Bij het maken van een Dog-object dat move() aanroept, wordt de overschreven methode uitgevoerd.

Speciale gevallen bij overschrijven

1. Oudermethode bellen met behulp van super

De supertrefwoord kan de bovenliggende klassemethode aanroepen vanuit de overschrijvende methode.

Java

    class   Parent  {          void     show  (){          System  .  out  .  println  (  'Parent's show()'  );      }   }   class   Child     extends     Parent  {          @Override      void     show  (){          super  .  show  ();      System  .  out  .  println  (  'Child's show()'  );      }   }   public     class   Main  {          public     static     void     main  (  String  []     args  ){          Parent     obj     =     new     Child  ();      obj  .  show  ();      }   }

Uitvoer

Parent's show() Child's show()

2. Definitieve methoden kunnen niet worden overschreven

Als we niet willen dat een methode wordt overschreven, declareren we deze als definitief . Zie alstublieft Finale gebruiken met erfenis .

Java

    class   Parent  {          // Can't be overridden      final     void     show  (){          }   }   class   Child     extends     Parent  {          // This would produce error      void     show  ()     {}   }

Uitvoer :

3. Statische methoden

Statische methoden kunnen niet worden overschreven; het definiëren van een statische methode in een subklasse met dezelfde signatuur als in de superklasse verbergt de superklassemethode.
Instantiemethoden kunnen worden overschreven, maar een subklasse kan een statische superklassemethode niet overschrijven.
Een statische methode in een subklasse met dezelfde signatuur als een statische methode van een superklasse verbergt de oorspronkelijke methode.

Java

    class   Parent  {      static     void     staticMethod  (){          System  .  out  .  println  (  'Parent static method'  );      }      void     instanceMethod  (){          System  .  out  .  println  (  'Parent instance method'  );      }   }   class   Child     extends     Parent  {          static     void     staticMethod  (){          // Hides Parent's static method      System  .  out  .  println  (  'Child static method'  );      }      @Override      void     instanceMethod  (){             // Overrides Parent's instance method      System  .  out  .  println  (  'Child instance method'  );      }   }   public     class   GFG  {          public     static     void     main  (  String  []     args  ){          Parent     p     =     new     Child  ();          // Calls Parent's static method (hiding)      p  .  staticMethod  ();          // Calls Child's overridden instance method      p  .  instanceMethod  ();         }   }

Uitvoer

Parent static method Child instance method

4. Privémethoden

Privémethoden kunnen niet worden overschreven omdat ze niet zichtbaar zijn voor subklassen.
Een subklassemethode met dezelfde naam wordt behandeld als een nieuwe onafhankelijke methode die geen verband houdt met de bovenliggende klasse.

Java

    class   Parent  {          private     void     display  (){          System  .  out  .  println  (  'Parent private method'  );      }   }   class   Child     extends     Parent  {          void     display  (){          // This is a new method not overriding      System  .  out  .  println  (  'Child method'  );      }   }   public     class   GFG  {          public     static     void     main  (  String  []     args  ){          Child     c     =     new     Child  ();          // Calls Child's method      c  .  display  ();         }   }

Uitvoer

Child method

5. Covariante retourtypen

Bij het overschrijven van een methode kan het retourtype van de overschrijvende methode een subklasse zijn van het retourtype van de overschreven methode.
Deze functie staat bekend als covariant retourtype en maakt meer specifieke retourtypen in de subklasse mogelijk.

Java

    class   Parent  {          Parent     getObject  (){          System  .  out  .  println  (  'Parent object'  );      return     new     Parent  ();      }   }   class   Child     extends     Parent  {          @Override          // Covariant return type      Child     getObject  ()     {         System  .  out  .  println  (  'Child object'  );      return     new     Child  ();      }   }   public     class   GFG  {          public     static     void     main  (  String  []     args  ){          Parent     obj     =     new     Child  ();          // Calls Child's method      obj  .  getObject  ();             }   }

Uitvoer

Child object

Afhandeling van uitzonderingen bij overschrijven

De overschrijvende methode kan geen nieuwe of breder gecontroleerde uitzonderingen genereren dan de methode in de superklasse.
Het kan minder of smaller gecontroleerde uitzonderingen opleveren.
Het kan alle niet-gecontroleerde uitzonderingen genereren (zoals RuntimeException), ongeacht de superklassemethode.

Java

    import     java.io.IOException  ;   class   Parent     {      void     display  ()     throws     IOException     {      System  .  out  .  println  (  'Parent method'  );      }   }   class   Child     extends     Parent     {      @Override      void     display  ()     throws     IOException     {      System  .  out  .  println  (  'Child method'  );      }   }   public     class   GFG  {          public     static     void     main  (  String  []     args  ){          // Parent reference Child object      Parent     obj     =     new     Child  ();         try  {          // Calls Child's overridden method      obj  .  display  ();         }     catch     (  IOException     e  ){          System  .  out  .  println  (  'Exception caught: '     +     e  .  getMessage  ());      }      }   }

Uitvoer

Child method

Waarom gebruiken we methodeoverschrijving?

Om het gedrag van een bestaande methode in een subklasse te veranderen of te verbeteren.
Om runtime-polymorfisme te bereiken, zijn methodeaanroepen afhankelijk van het daadwerkelijke objecttype.
Om methodenamen te hergebruiken, waardoor redundantie logischerwijs wordt verminderd.

Voorbeeld uit de praktijk: werknemersbeheersysteem

Laten we het overschrijven begrijpen met een analogie uit de echte wereld.

Stel je het werknemersbeheersysteem van een organisatie voor. Alle werknemers delen bepaalde gedragingen, zoals raiseSalary() en promote(), maar de logica verschilt voor verschillende rollen, zoals Manager of Engineer. We kunnen een enkele werknemersarray maken waarin individuele werknemers van verschillende typen zijn (verkooptechnologie, enz.) en hun functies aanroepen. Dit vereenvoudigt de algehele code aanzienlijk.

Java

    abstract     class   Employee     {      abstract     void     raiseSalary  ();      abstract     void     promote  ();   }   class   Manager     extends     Employee  {      @Override     void     raiseSalary  (){          System  .  out  .  println  (      'Manager salary raised with incentives.'  );      }      @Override     void     promote  (){          System  .  out  .  println  (      'Manager promoted to Senior Manager.'  );      }   }   class   Engineer     extends     Employee  {          @Override     void     raiseSalary  (){          System  .  out  .  println  (      'Engineer salary raised with bonus.'  );      }      @Override     void     promote  (){          System  .  out  .  println  (      'Engineer promoted to Senior Engineer.'  );      }   }   public     class   Company  {          public     static     void     main  (  String  []     args  ){          Employee  []     employees      =     {     new     Manager  ()     new     Engineer  ()     };      System  .  out  .  println  (  '--- Raising Salaries ---'  );      for     (  Employee     e     :     employees  ){          e  .  raiseSalary  ();         }      System  .  out  .  println  (  'n--- Promotions ---'  );      for     (  Employee     e     :     employees  )     {      e  .  promote  ();      }      }   }

Uitvoer

--- Raising Salaries --- Manager salary raised with incentives. Engineer salary raised with bonus. --- Promotions --- Manager promoted to Senior Manager. Engineer promoted to Senior Engineer.

Uitleg: Hoewel er naar zowel Manager- als Engineer-objecten wordt verwezen met het type Werknemer, roept Java de overschreven methoden van de werkelijke objecten tijdens runtime aan, wat de dynamische methodeverzending demonstreert (runtime polymorfisme).