Base class constructors

Hi! Noong huling pagkakataon ay napag-usapan namin ang tungkol sa mga konstruktor at marami kaming natutunan tungkol sa kanila. Ngayon ay pag-uusapan natin ang tungkol sa mga base class constructor . Ano ang base class ? Ito ay may kinalaman sa katotohanan na sa Java maraming iba't ibang klase ay maaaring magkaroon ng isang karaniwang pinagmulan. Ito ay tinatawag na mana . Ang ilang mga klase ng bata ay maaaring magkaroon ng isang karaniwang ninuno. Halimbawa, isipin na mayroon tayong Animalklase:

public class Animal {
  
   String name;
   int age;
}

Maaari tayong magdeklara ng 2 klase ng bata: Catat Dog. Ginagawa ito gamit ang keyword extends .

public class Cat extends Animal {

}

public class Dog extends Animal {
  
}

Maaaring makatulong ito sa hinaharap. Halimbawa, kung may gawain na manghuli ng mga daga, gagawa kami ng Cat object sa aming programa. Kung ang gawain ay habulin ang isang stick, pagkatapos ay gagamit tayo ng isang Dog bagay. At kung lumikha kami ng isang programa na gayahin ang isang beterinaryo na klinika, gagana ito sa Animal klase (at sa gayon ay magagawang gamutin ang parehong mga pusa at aso). Napakahalagang tandaan na kapag ang isang bagay ay nilikha, ang constructor ng base class nito ay unang tinatawag na . Pagkatapos lamang na matapos ang konstruktor na iyon, ipapatupad ng programa ang tagabuo ng klase na naaayon sa bagay na aming nililikha. Sa madaling salita, kapag lumilikha ng isang Catbagay, ang Animalconstructor ay unang pinapatakbo , at pagkatapos lamang ay angCatconstructor executed . Upang makita ito, magdagdag ng ilang console output sa Catat Animalconstructors.

public class Animal {

   public Animal() {
       System.out.println("Animal constructor executed");
   }
}


public class Cat extends Animal {

   public Cat() {
       System.out.println("Cat constructor executed!");
   }

   public static void main(String[] args) {
       Cat cat = new Cat();
   }
}

Output ng console: Na-execute ng constructor ng hayop Cat constructor na executed! Sa katunayan, ito ay gumagana sa ganoong paraan! Bakit? Ang isang dahilan ay upang maiwasan ang pagdoble ng mga field na ibinahagi sa pagitan ng dalawang klase. Halimbawa, ang bawat hayop ay may puso at utak, ngunit hindi lahat ng hayop ay may buntot. Maaari naming ideklara ang mga field ng utak at puso , na karaniwan sa lahat ng mga hayop, sa Animalparent class, at isang tail field sa Catsubclass. . Ngayon ay magdedeklara kami ng isang Cattagabuo ng klase na kumukuha ng mga argumento para sa lahat ng 3 field.

public class Cat extends Animal {

   String tail;

   public Cat(String brain, String heart, String tail) {
       this.brain = brain;
       this.heart = heart;
       this.tail = tail;
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

Tandaan: Ang constructor ay gumagana nang tama kahit na ang Catklase ay walang utak at puso field . Ang mga field na ito ay "minana" mula sa Animalbase class. Ang inheriting class ay may access sa mga field ng base class , kaya makikita ang mga ito sa aming Catklase. Bilang resulta, hindi namin kailangang i-duplicate ang mga field na ito sa Catklase. Maaari nating kunin sila mula sa Animalklase. Higit pa rito, maaari nating tahasang tawagan ang base class constructor sa child class constructor. Ang isang batayang klase ay tinatawag ding " superclass ". Iyon ang dahilan kung bakit ginagamit ng Java ang keyword na super para isaad ang base class. Sa nakaraang halimbawa

public Cat(String brain, String heart, String tail) {
       this.brain = brain;
       this.heart = heart;
       this.tail = tail;
   }

Hiwalay kaming itinalaga ang bawat field sa aming magulang na klase. Hindi talaga namin kailangang gawin ito. Sapat na tawagan ang parent class constructor at ipasa ang mga kinakailangang argumento:

public class Animal {

   String brain;
   String heart;

   public Animal(String brain, String heart) {
       this.brain = brain;
       this.heart = heart;
   }

public class Cat extends Animal {

   String tail;

   public Cat(String brain, String heart, String tail) {
       super(brain, heart);
       this.tail = tail;
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

Sa Catconstructor, tinawag namin ang Animalconstructor at pumasa sa dalawang field. Mayroon lang kaming isang field na tahasang magsisimula: tail , na wala sa Animal. Tandaan na binanggit namin na ang tagabuo ng klase ng magulang ay unang tinawag kapag nilikha ang isang bagay? Iyon ang dahilan kung bakit ang super() ay dapat palaging mauna sa isang constructor! Kung hindi, ang lohika ng constructor ay lalabag at ang programa ay bubuo ng isang error.

public class Cat extends Animal {

   String tail;

   public Cat(String brain, String heart, String tail) {
       this.tail = tail;
       super(brain, heart);// Error!
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

Alam ng compiler na kapag ang isang object ng isang child class ay ginawa, ang base class constructor ay unang tinatawag. At kung susubukan mong manu-manong baguhin ang gawi na ito, hindi ito papayagan ng compiler.

Paano nilikha ang isang bagay

Tumingin kami dati sa isang halimbawa na may base at parent class: Animalat Cat. Gamit ang dalawang klase bilang mga halimbawa, titingnan natin ngayon ang proseso ng paglikha ng isang bagay at pagsisimula ng mga variable. Alam namin na mayroong mga static at instance (non-static) na mga variable . Alam din namin na ang Animalbatayang klase ay may mga variable, at ang Catklase ng bata ay may sarili. Para sa kalinawan, magdaragdag kami ng isang static na variable bawat isa sa Animalat Catmga klase. Ang animalCount variable sa Animalklase ay kakatawan sa kabuuang bilang ng mga species ng hayop sa Earth, at ang catCountang variable ay magsasaad ng bilang ng mga species ng pusa. Bilang karagdagan, magtatalaga kami ng mga panimulang halaga sa lahat ng mga di-static na variable sa parehong mga klase (na pagkatapos ay babaguhin sa constructor).

public class Animal {

   String brain = "Initial value of brain in the Animal class";
   String heart = "Initial value of heart in the Animal class";

   public static int animalCount = 7700000;

   public Animal(String brain, String heart) {
       System.out.println("Animal base class constructor is running");
       System.out.println("Have the variables of the Animal class already been initialized?");
       System.out.println("Current value of static variable animalCount = " + animalCount);
       System.out.println("Current value of brain in the Animal class = " + this.brain);
       System.out.println("Current value of heart in the Animal class = " + this.heart);
       System.out.println("Have the variables of the Cat class already been initialized?");
       System.out.println("Current value of static variable catCount = " + Cat.catCount);

       this.brain = brain;
       this.heart = heart;
       System.out.println("Animal base class constructor is done!");
       System.out.println("Current value of brain = " + this.brain);
       System.out.println("Current value of heart = " + this.heart);
   }
}

public class Cat extends Animal {

   String tail = "Initial value of tail in the Cat class";

   static int catCount = 37;

   public Cat(String brain, String heart, String tail) {
       super(brain, heart);
       System.out.println("The cat class constructor has started (The Animal constructor already finished)");
       System.out.println("Current value of static variable catCount = " + catCount);
       System.out.println("Current value of tail = " + this.tail);
       this.tail = tail;
       System.out.println("Current value of tail = " + this.tail);
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

Kaya gumagawa kami ng bagong instance ng Catklase, na nagmamana ng Animal. Nagdagdag kami ng ilang detalyadong output ng console upang makita kung ano ang nangyayari at sa anong pagkakasunud-sunod. Ito ang ipapakita kapag ang isang Catbagay ay nilikha: Ang tagapagbuo ng klase ng base ng hayop ay tumatakbo Nasimulan na ba ang mga variable ng klase ng Hayop? Kasalukuyang halaga ng static na variable na animalCount = 7700000 Kasalukuyang halaga ng utak sa klase ng Hayop = Paunang halaga ng utak sa klase ng Hayop Kasalukuyang halaga ng puso sa klase ng Hayop = Paunang halaga ng puso sa klase ng Hayop Mayroon na ang mga variable ng klase ng Cat na-initialize? Kasalukuyang halaga ng static variable catCount = 37 Animal base class constructor tapos na! Kasalukuyang halaga ng utak = Utak Kasalukuyang halaga puso = Puso Ang cat class constructor ay nagsimula na (Ang Animal constructor ay tapos na) Kasalukuyang halaga ng static variable catCount = 37 Kasalukuyang halaga ng buntot = Inisyal na halaga ng buntot sa Cat class Kasalukuyang halaga ng buntot = buntot Kaya, ngayon ay malinaw na nating makikita ang pagkakasunud-sunod ng variable initialization at mga constructor na tawag kapag may nilikhang bagong object:

1. Ang mga static na variable ng base class ( Animal) ay sinisimulan. Sa aming kaso, ang variable na animalCountAnimal ng klase ay nakatakda sa 7700000.



2. Ang mga static na variable ng child class ( Cat) ay sinisimulan.

   Tandaan: nasa loob pa rin kami ng Animalconstructor at naipakita na namin ang:

   Ang animal base class constructor ay tumatakbo
   Nasimulan na ba ang mga variable ng Animal class?
   Kasalukuyang halaga ng static na variable na animalCount = 7700000
   Kasalukuyang halaga ng utak sa klase ng Hayop = Paunang halaga ng utak sa klase ng Hayop
   Kasalukuyang halaga ng puso sa klase ng Hayop = Paunang halaga ng puso sa klase ng Hayop
   Mayroon na ang mga variable ng klase ng Cat na-initialize?
   Kasalukuyang halaga ng static na variable na catCount = 37




3. Pagkatapos ay ang mga non-static na variable ng base class ay sinisimulan. Partikular naming itinalaga sa kanila ang mga paunang halaga, na pagkatapos ay papalitan sa constructor. Hindi pa tapos ang Animal constructor, ngunit ang mga unang halaga ng utak at puso ay naitalaga na:

   Ang animal base class constructor ay tumatakbo
   Nasimulan na ba ang mga variable ng Animal class?
   Kasalukuyang halaga ng static na variable na animalCount = 7700000
   Kasalukuyang halaga ng utak sa klase ng Hayop = Paunang halaga ng utak sa klase ng Hayop
   Kasalukuyang halaga ng puso sa klase ng Hayop = Paunang halaga ng puso sa klase ng Hayop




4. Magsisimula ang base class constructor .
   Nakumbinsi na namin ang aming sarili na ang hakbang na ito ay pang-apat: sa unang tatlong hakbang sa simula ng Animalconstructor, maraming mga variable ang naitalaga na ng mga halaga.




5. Ang mga non-static na field ng child class ( Cat) ay sinisimulan.
   Nangyayari ito bago Catmagsimulang tumakbo ang tagabuo.
   Kapag nagsimula itong tumakbo, ang tail variable ay mayroon nang value:

   Nagsimula na ang cat class constructor (Natapos na ang Animal constructor) Kasalukuyang value ng static variable catCount = 37 Current value ng tail = Initial value ng tail sa Cat class




6. Ang tagabuo ng Catklase ng bata ay tinatawag

   At iyon ang hitsura ng paglikha ng isang bagay sa Java!

   Dapat kong sabihin na hindi kami malaking tagahanga ng rote-learning, ngunit pinakamainam na kabisaduhin ang pagkakasunud-sunod ng variable initialization at constructor calls .

   Ito ay lubos na madaragdagan ang iyong pag-unawa sa daloy ng programa, at ang estado ng iyong mga bagay sa anumang partikular na sandali.

   Bukod dito, maraming klase ang hindi gumagamit ng mana. Sa kasong ito, hindi nalalapat ang mga hakbang na nauugnay sa base class.