Paraan ng Overriding sa Java

Hi! Gumagamit ka na ng mga pamamaraan ng Java at marami kang alam tungkol sa mga ito. Marahil ay nahaharap ka sa sitwasyon kung saan ang isang klase ay may maraming mga pamamaraan na may parehong pangalan ngunit magkaibang mga parameter. Matatandaan mo na sa mga kasong iyon ay gumamit kami ng paraan ng overloading. Ngayon ay isinasaalang-alang namin ang isa pang sitwasyon. Isipin na mayroon tayong iisang ibinahaging pamamaraan, ngunit dapat itong gumawa ng iba't ibang mga bagay sa iba't ibang klase. Paano natin ipapatupad ang pag-uugaling ito? Upang maunawaan, isaalang-alang natin ang isang klase ng Animal parent, na kumakatawan sa mga hayop, at gagawa tayo ng paraan ng pagsasalita dito:

public class Animal {

   public void speak() {

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

Bagama't kasisimula pa lang namin sa pagsusulat ng programa, malamang na makakita ka ng potensyal na problema: maraming hayop sa mundo, at lahat sila ay 'nagsalita' nang iba: pusa ngiyaw, duck quack, at ahas sumisitsit. Ang aming layunin ay simple: iwasang lumikha ng maraming paraan ng pagsasalita. Sa halip na gumawa ng catSpeak() method para sa meowing, snakeSpeak() method para sa pagsitsit, atbp., gusto naming tawagan ang speak()paraan at pasingit ang ahas, ngiyaw ng pusa, at tumahol ang aso. Madali nating makakamit ito gamit ang overriding ng pamamaraan. Ibinigay ng Wikipedia ang sumusunod na paliwanag ng terminong 'overriding': Ang method overriding, sa object-oriented programming, ay isang feature ng wika na nagbibigay-daan sa isang subclass o child class na magbigay ng isang partikular na pagpapatupad ng isang method na naibigay na ng isa sa mga superclass nito o parent classes Iyan ay mahalagang tama. Ang pag-override ng pamamaraan ay nagbibigay-daan sa iyong kumuha ng ilang paraan ng parent class at isulat ang sarili mong pagpapatupad sa bawat child class. Ang bagong pagpapatupad ay 'pinapalitan' ang pagpapatupad ng magulang sa klase ng bata. Tingnan natin kung ano ang hitsura nito sa isang halimbawa. Lumikha ng 4 na klase na nagmamana ng aming klase ng Animal :

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

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

public class Dog extends Animal {

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


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

"Narito ang isang maliit na lifehack para sa hinaharap: upang i-override ang mga pamamaraan ng parent class, pumunta sa code ng child class sa IntelliJ IDE, I-click ang Ctrl+O, at piliin ang "Override method..." sa menu. Masanay sa paggamit ng mga hot key mula sa simula — makakatulong ito sa iyong magsulat ng mga programa nang mas mabilis! Upang tukuyin ang pag-uugali na kailangan namin, gumawa kami ng ilang bagay:

1. Sa bawat klase ng bata, gumawa kami ng paraan na may parehong pangalan sa pamamaraan ng parent class.


2. Sinabi namin sa compiler na ang pagbibigay ng pangalan sa pamamaraan na kapareho ng sa parent class ay hindi nangyari: gusto naming i-override ang pag-uugali nito. Para ipaalam ito sa compiler, itinakda namin ang @Override annotation sa itaas ng pamamaraan.
   Kapag inilagay sa itaas ng isang paraan, ang @Override annotation ay nagpapaalam sa compiler (pati na rin sa mga programmer na nagbabasa ng iyong code): 'Okay lang ang lahat. Ito ay hindi isang pagkakamali. Hindi ako nakakalimot. Alam kong mayroon nang ganitong paraan at gusto kong i-override ito'.


3. Isinulat namin ang pagpapatupad na kailangan namin para sa bawat klase ng bata. Kapag tinawag ang speak() method, dapat sumirit ang ahas, umungol ang oso, atbp.

Tingnan natin kung paano ito gumagana sa isang 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.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

Output ng console:

Woof!
Meow!
Growl!
Hiss!

Magaling! Lahat ay gumagana ayon sa nararapat! Gumawa kami ng 4 na reference na variable na nag-iimbak ng mga object ng klase ng Animal parent, at nagtalaga kami ng mga instance ng 4 na magkakaibang klase ng bata sa kanila. Bilang resulta, ang bawat bagay ay nagpapakita ng sarili nitong pag-uugali. Para sa bawat klase ng bata, pinalitan ng na-overridden na speak() na paraan ang 'native' speak() method sa Animal class (na nagpapakita lang ng 'Hello!'). May ilang limitasyon ang pag-override:

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

   Kung ang paraan ng pagsasalita ng parent class ay may String parameter, ang overridden na paraan sa child class ay dapat ding magkaroon ng String parameter. Kung hindi, bubuo ng error ang compiler:

   
   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Hello! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          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, makakakuha tayo ng error sa compiler:

   
   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }
   




3. Ang modifier ng access sa na-overridden na paraan ay dapat ding pareho sa 'orihinal' na paraan:

   
   public class Animal {
   	
         public void speak() {
   	
               System.out.println("Hello!");
         }
   }
   
   public class Cat extends Animal {
   
          @Override
          private void speak() {      // Error!
              System.out.println("Meow!");
          }
   }
   

Ang pamamaraang overriding sa Java ay isang paraan upang ipatupad ang polymorphism (ang prinsipyo ng OOP na inilarawan namin sa huling aralin). Nangangahulugan ito na ang pangunahing bentahe nito ay ang parehong kakayahang umangkop na tinalakay natin dati. Makakagawa tayo ng simple at lohikal na sistema ng mga klase, bawat isa ay may partikular na pag-uugali (tahol ng mga aso, pusang ngiyaw), na may karaniwang interface — isang paraan ng speak() para sa kanilang lahat sa halip na maraming pamamaraan, hal dogSpeak() , speakCat () , atbp.