Course Module 2: Java Core - Lecture: Overriding ng pamamaraan

Hi! Gumagamit ka na ng mga pamamaraan ng Java at marami kang alam tungkol sa mga ito.

Paano gumagana ang paraan ng pag-override - 1

Tiyak na nakatagpo ka ng isang klase na may maraming mga pamamaraan na may parehong pangalan ngunit magkaibang mga listahan ng argumento. Matatandaan mo na sa mga kasong iyon ay gumamit kami ng paraan ng overloading. Ngayon ay titingnan natin ang ibang sitwasyon. Isipin na mayroon tayong isang karaniwang pamamaraan, ngunit dapat itong gumawa ng iba't ibang bagay depende sa kung aling klase ito tinawag. Paano natin ipapatupad ang pag-uugaling ito? Upang maunawaan ito, kunin natin ang Animalklase ng magulang, na kumakatawan sa mga hayop, at lumikha ng isang speakparaan dito:

public class Animal {

   public void speak() {

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

Bagama't kasisimula pa lang naming isulat ang aming programa, malamang na makakita ka ng potensyal na problema: ang mundo ay puno ng maraming hayop, at lahat sila ay "nagsalita" nang iba: pusa ngiyaw, duck quack, ahas sumisitsit, atbp. Ang aming layunin ay simple:

Paano gumagana ang paraan ng pag-override - 2

kami nais na maiwasan ang paglikha ng isang bungkos ng mga pamamaraan para sa pagsasalita. Sa halip na gumawa ng meow()paraan para sa pag-meow, hiss()para sa pagsirit, atbp., gusto natin ang ahas na sumirit, ang pusa ay ngumyaw, at ang aso ay tumahol kapag ang speak()paraan ay tinatawag. Madali nating makakamit ito gamit ang overriding na pamamaraan . Ipinapaliwanag ng Wikipedia ang termino tulad ng sumusunod: Pamamaraan na 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 paraan na ibinigay na ng isa sa mga superclass o parent class nito. Iyan ay karaniwang tama. Hinahayaan ka ng overriding na kumuha ng ilang paraan ng isang parent na klase at isulat ang sarili mong pagpapatupad sa bawat nagmula na klase. Ang bagong pagpapatupad sa klase ng bata ay "pinapalitan" ang isa sa magulang. Tingnan natin kung ano ang hitsura nito sa isang halimbawa. Gumawa tayo ng 4 na inapo ng ating Animalklase:

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 isang parent class, pumunta sa code ng nagmula na klase sa IntelliJ IDE , pindutin ang Ctrl+O , at piliin ang Override method... mula sa menu. Masanay sa paggamit ng mga hotkey mula sa simula. Bilisan nila ang coding! Upang makuha ang ninanais na pag-uugali, gumawa kami ng ilang bagay:

Sa bawat descendant class, gumawa kami ng method na may parehong pangalan bilang method sa parent class.
Sinabi namin sa compiler na hindi lang namin binibigyan ang pamamaraan ng parehong pangalan tulad ng sa parent class ngunit sa halip ay gusto naming i-override ang pag-uugali nito. Ang "mensahe" na ito sa compiler ay ipinadala sa pamamagitan ng @Override annotation.
Ang @Override annotation sa itaas ng isang paraan ay nagsasabi sa compiler (pati na rin sa iba pang programmer na nagbabasa ng iyong code), "Huwag mag-alala. Ito ay hindi isang pagkakamali o oversight. Alam kong mayroon na ang paraang ito, at gusto kong i-override ito .
Isinulat namin ang pagpapatupad na kailangan namin para sa bawat descendant class. Kapag speak()tinawag ang pamamaraan, ang isang ahas ay dapat sumirit, isang oso ay dapat umungol, at iba pa.

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!

Mahusay, gumagana ang lahat ayon sa nararapat! Gumawa kami ng 4 na reference na variable na ang uri ay ang Animalparent class, at nagtalaga sa kanila ng 4 na magkakaibang object ng descendant classes. Bilang isang resulta, ang bawat bagay ay kumikilos nang iba. Para sa bawat isa sa mga nagmula na klase, speak()pinapalitan ng overridden na paraan ang umiiral speak()na paraan ng Animalklase (na ipinapakita lang ang "Speaking: " sa console).

Paano gumagana ang paraan ng pag-override - 3

Ang pag-override ng pamamaraan ay may ilang mga limitasyon:

Ang isang na-override na paraan ay dapat na may parehong mga argumento tulad ng pamamaraan sa parent class.

Kung ang speakparaan ng parent class ay kumukuha ng a Stringbilang input, ang overridden na paraan sa descendant class ay dapat ding kumuha ng a Stringbilang input. Kung hindi, bubuo ng error ang compiler:
```
public class Animal {

   public void speak(String s) {

       System.out.println("Speaking: " + s);
   }
}

public class Cat extends Animal {

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

Ang na-override na paraan ay dapat na may parehong uri ng pagbabalik tulad ng pamamaraan sa parent class.

Kung hindi, makakakuha tayo ng error sa compilation:

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!";
   }
}

Ang modifier ng access ng na-override na paraan ay hindi rin maaaring mag-iba mula sa orihinal:

public class Animal {

   public void speak() {

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

public class Cat extends Animal {

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

Sa Java, ang overriding ng pamamaraan ay isang paraan upang ipatupad ang polymorphism. Nangangahulugan iyon na ang pangunahing bentahe nito ay ang kakayahang umangkop na napag-usapan natin kanina. Maaari tayong bumuo ng simple at lohikal na hierarchy ng mga klase, bawat isa ay may partikular na pag-uugali (mga tumatahol na aso, meowing na pusa) ngunit isang interface — isang solong paraan speak()para sa lahat sa halip na isang grupo ng iba't ibang pamamaraan, hal bark(), meow(), atbp.