Mekanismo ng overriding na pamamaraan o Override sa Java

Kamusta! Gumagamit ka na ng mga pamamaraan sa Java at marami kang alam tungkol sa mga ito. Marahil ay nakatagpo ka ng isang sitwasyon kung saan mayroong maraming mga pamamaraan sa isang klase na may parehong pangalan ngunit magkaibang mga argumento. Kung natatandaan mo, sa mga kasong iyon ay ginamit namin ang paraan ng overloading na mekanismo. Ngayon tingnan natin ang ibang sitwasyon. Isipin na mayroon kaming isang karaniwang pamamaraan, ngunit dapat itong gumawa ng iba't ibang mga bagay depende sa kung aling klase ito tinawag. Paano ipatupad ang pag-uugaling ito? Upang malaman ito, kumuha tayo ng isang klase ng magulang Animalna tumutukoy sa mga hayop at lumikha ng isang paraan dito voice- " boses ":

public class Animal {

   public void voice() {

       System.out.println("Voice!");
   }
}

Bagama't kasisimula pa lang naming magsulat ng programa, malamang na makikita mo ang potensyal na problema: maraming hayop sa mundo, at lahat sila ay "nagsalita" nang iba: pusa ngiyaw, duck quack, ahas sumisitsit. Ang aming layunin ay simple: iwasan ang paglikha ng isang grupo ng mga pamamaraan para sa pagboto. Sa halip na lumikha ng mga pamamaraan voiceCat()para sa pag-meow, voiceSnake()para sa pagsirit, atbp., gusto nating voice()ang ahas ay sumirit, ang pusa ay ngumyaw, at ang aso ay tumahol kapag ang pamamaraan ay tinatawag. Madali nating makakamit ito gamit ang paraan ng overriding na mekanismo (I-override sa Java) . Ibinigay ng Wikipedia ang sumusunod na paliwanag ng terminong "overriding": Ang pamamaraang overriding sa object - oriented programming ay isa sa mga tampok ng isang programming language na nagpapahintulot sa isang subclass o child class na magbigay ng isang partikular na pagpapatupad ng isang paraan na ipinatupad na sa isa sa mga superclass. o mga klase ng magulang. Ito ay, sa pangkalahatan, tama. Binibigyang-daan ka ng overriding na kumuha ng paraan ng parent class at isulat ang sarili mong pagpapatupad ng paraang ito sa bawat descendant class. "Papalitan" ng bagong pagpapatupad ang magulang sa klase ng bata. Tingnan natin kung ano ang hitsura nito sa isang halimbawa. Gumawa tayo ng 4 na kahalili na klase para sa ating klase Animal:

public class Bear extends Animal {
   @Override
   public void voice() {
       System.out.println("Р-р-р!");
   }
}
public class Cat extends Animal {

   @Override
   public void voice() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void voice() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void voice() {
       System.out.println("Ш-ш-ш!");
   }
}

Isang maliit na life hack para sa hinaharap: upang i-override ang mga pamamaraan ng parent class, pumunta sa code ng descendant class sa Intellij IDE a, pindutin ang Ctrl+O at piliin ang “ Override method... ” mula sa menu. Masanay sa paggamit ng mga hotkey mula sa simula, ito ay magpapabilis sa pagsusulat ng mga programa! Upang itakda ang gawi na gusto namin, gumawa kami ng ilang bagay:

1. Gumawa kami ng paraan sa bawat descendant class na may parehong pangalan bilang method sa parent class.

2. Sinabi namin sa compiler na pinangalanan namin ang pamamaraan na kapareho ng sa parent class para sa isang dahilan: gusto naming i-override ang pag-uugali nito. Para sa "mensahe" na ito sa compiler, naglagay kami ng @Override annotation sa paraan .
   Ang @Override annotation na inilagay sa itaas ng isang paraan ay nagsasabi sa compiler (at ang mga programmer ay nagbabasa rin ng iyong code): "Ang lahat ay ok, ito ay hindi isang pagkakamali o ang aking pagkalimot. Naaalala ko na mayroon nang ganitong paraan, at gusto kong i-override ito."

3. Isinulat namin ang pagpapatupad na kailangan namin para sa bawat descendant class. Kapag tinawag, dapat sumirit ang ahas voice(), umungol ang oso, atbp.

Tingnan natin kung paano ito gagana sa programa:

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.voice();
       animal2.voice();
       animal3.voice();
       animal4.voice();
   }
}

Output ng console: Woof! Meow! Rrrr! Shhh! Mahusay, gumagana ang lahat ayon sa nararapat! Gumawa kami ng 4 na reference na variable ng parent class Animal, at itinalaga ang mga ito sa 4 na magkakaibang object ng descendant classes. Bilang isang resulta, ang bawat bagay ay kumikilos nang iba. Para sa bawat isa sa mga descendant na klase, voice()pinalitan ng overridden na paraan ang "native" na paraan voice()mula sa klase Animal(na naglalabas lang ng "Voice!" sa console). Ang pag-override ay may ilang limitasyon:

1. Ang na-override na paraan ay dapat na may parehong mga argumento gaya ng paraan ng magulang.

   Kung ang isang pamamaraan voicesa isang parent class ay tinatanggap bilang input String, ang na-override na paraan sa child class ay dapat ding tanggapin bilang input String, kung hindi, ang compiler ay magtapon ng isang error:

   public class Animal {
   
      public void voice(String s) {
   
          System.out.println("Voice! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override//error!
      public void voice() {
          System.out.println("Meow!");
      }
   }




2. Ang na-override na paraan ay dapat na may parehong uri ng pagbabalik gaya ng paraan ng magulang.

   Kung hindi, makakatanggap kami ng error sa compilation:

   public class Animal {
   
      public void voice() {
   
          System.out.println("Voice!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String voice() {         //error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }




3. Ang access modifier ng isang overridden na paraan ay hindi rin maaaring mag-iba sa "orihinal":

   public class Animal {
   
      public void voice() {
   
          System.out.println("Voice!");
      }
   }
   
   public class Cat extends Animal {
   
      @Override
      private void voice() {      //error!
          System.out.println("Meow!");
      }
   }

Ang pamamaraan ng overriding sa Java ay isa sa mga tool para sa pagpapatupad ng ideya ng polymorphism (ang prinsipyo ng OOP, na pinag-usapan natin sa huling lecture). Samakatuwid, ang pangunahing bentahe ng paggamit nito ay ang parehong kakayahang umangkop na napag-usapan namin kanina. Maaari kaming bumuo ng isang simple at lohikal na sistema ng mga klase, na ang bawat isa ay magkakaroon ng tiyak na pag-uugali (mga aso bark, pusa meow), ngunit may isang solong interface - isang paraan voice()para sa lahat sa halip na isang grupo ng mga pamamaraan voiceDog(), voiceCat()atbp.