Ano ang Isang Tagatayo sa Java at Paano Mo Ito Ginagamit?

Sa programa na nakatuon sa object, ang isang tagapagbuo ay isang espesyal na pagpapaandar na tinawag mo upang lumikha ng isang bagay. Ang mga tagabuo ay may maraming mga natatanging tampok na nagbibigay-daan sa kanila upang gumana.

Sa Java, pinangalanan mo ang isang tagapagbuo pagkatapos ng klase nito. Ang tagapagbuo ay isang pamamaraan, na tinukoy sa klase na nalalapat nito. Ang mga tagapagbuo ng Java ay maaaring gumamit ng labis na karga upang magbigay ng alternatibong pag-uugali. Ang mga konstruktor sa Java ay maaari ring gumamit ng mana upang magamit muli ang code.

Bakit Kailangan Mo Pa Ang Mga Tagatayo?

Ang mga tagabuo ay isang pangunahing bahagi ng programa na nakatuon sa object, at ang Java ay walang kataliwasan. Ipinapakita ng halimbawang ito kung paano mo matutukoy ang isang pangunahing klase ng Circle na may isang data na pag-aari at isang pamamaraan:

public class Circle {  
 public double radius;  
 public double area() { return 3.14159 * radius * radius; }  
}

Maaari ka ring lumikha ng isang halimbawa ng klase na ito at makipag-ugnay dito:

Circle c = new Circle();  
c.radius = 2;  
System.out.println(c.area()); // 12.56636

Ngunit ito ay hindi gaanong maginhawa at matatag kaysa sa maaari. Mahusay na kasanayan na nakatuon sa object upang i-encapsulate ang data, pinoprotektahan ito mula sa hindi awtorisadong pag-access:

public class Circle {  
  private  double radius;  
 public double area() { return 3.14159 * radius * radius; }  
  public void setRadius(double r) { radius = r; }   
}

Ngayon ang calling code ay maaaring gamitin ang setRadius pamamaraan at hindi mag-alala tungkol sa mga detalye ng pagpapatupad nito:

kung paano makahanap ng pang-internasyonal na may-ari ng numero ng telepono

Circle c = new Circle();  
  c.setRadius(2);

Nag-aalok ang mga konstruktor ng isang mas mahusay na paraan ng pagbibigay ng data sa isang bagay kapag nilikha mo ito. Kadalasan ginagamit ang mga ito para sa pagsisimula ng mga katangian, tulad ng radius dito

Mga halimbawa ng Mga Simpleng Tagatayo

Ang pinaka-pangunahing tagapagbuo ay isa na walang mga argumento, na walang ginagawa:

public class Circle {  
  public Circle() {}   
}

Tingnan din: Alamin Kung Paano Lumikha ng Mga Klase sa Java

Kung hindi mo tinukoy ang isang tagapagbuo, magbibigay ang Java ng isang default na kumikilos sa parehong paraan.

Tandaan ang ilang mga bagay:

Ang pangalan ng tagagawa ay tumutugma sa pangalan ng klase.
Gumagamit ang tagapagbuo na ito ng pampubliko i-access ang modifier, kaya't ang anumang iba pang code ay maaaring tumawag dito.
Ang isang tagapagbuo ay hindi nagsasama ng isang uri ng pagbabalik. Hindi tulad ng iba pang mga pamamaraan, ang mga tagapagbuo ay hindi maaaring ibalik ang isang halaga.

Karaniwang isinasagawa ng mga tagabuo ang ilang uri ng pagsisimula. Tandaan na ang code sa itaas ay hindi pinasimulan ang halaga ng radius. Sa kasong ito, awtomatikong itatakda ito ng wika sa zero. Inaasahan ng klase na ito ang isang gumagamit na gagamitin setRadius () . Upang magamit ang isang mas kapaki-pakinabang na default kaysa sa 0, maaari mo itong italaga sa loob ng tagapagbuo:

public class Circle {  
  public Circle() { radius = 1; }   
}

Ang mga lupon na nilikha kasama ang klase na ito ay magkakaroon ng isang aktwal na lugar ngayon! Maaari pa ring gumamit ng tumatawag setRadius () upang magbigay ng isang radius maliban sa 1. Ngunit ang tagapagbuo ay maaaring maging mas kaibigang:

public class Circle {  
  public Circle(double r) { radius = r; }   
}

Ngayon ay maaari kang lumikha ng mga lupon na may isang tukoy na radius mula pa nang kapanganakan:

ilang mga abiso sa paglabag sa copyright ang maaari kong makuha

Circle c = new Circle(2);  
System.out.println(c.area());  // 12.56636

Ito ay isang napaka-karaniwang paggamit para sa mga konstruktor. Madalas mong gagamitin ang mga ito upang simulan ang mga variable sa mga halagang parameter.

Overloading ng Consumer

Maaari mong tukuyin ang higit sa isang tagapagbuo sa isang kahulugan ng klase:

public Circle() { radius = 1; }  
public Circle(double r) { radius = r; }

Nagbibigay ito ng calling code ng isang pagpipilian kung paano bumuo ng mga bagay:

Circle c1 = new Circle(2);  
Circle c2 = new Circle();  
System.out.println(c1.area() + ', ' + c2.area()); // 12.56636, 3.14159

Sa isang bahagyang mas kumplikadong Circle, maaari mong tuklasin ang mas kawili-wiling mga konstruktor. Iniimbak ng bersyon na ito ang posisyon nito:

public class Circle {  
 public double  x, y,  radius;  
 public Circle() { radius = r; }  
 public Circle(double r) { radius = r; }  
  public Circle(double x, double y, double r) {  
 this.x = x; this.y = y; radius = r;  
 }   
 public double area() { return 3.14159 * radius * radius; }  
}

Maaari ka na ngayong lumikha ng isang Circle na walang mga argumento, isang solong radius, o x at y na mga coordinate sa tabi ng radius. Ito ang parehong uri ng overloading na sinusuportahan ng Java para sa anumang pamamaraan.

Consaintor Chain

Paano ang tungkol sa paglikha ng isang Circle, batay sa iba pa? Bibigyan kami nito ng kakayahang makopya nang madali ang Mga Lupon. Pagmasdan ang sumusunod na bloke:

public Circle(Circle c) {  
 this.x = c.x;  
 this.y = c.y;  
 this.radius = c.radius;  
}

Gagana ito, ngunit inuulit nito ang ilang code nang hindi kinakailangan. Dahil ang klase ng Circle ay mayroon nang tagapagbuo na humahawak sa mga indibidwal na katangian, maaari mo itong tawagan sa halip na gamitin ang ito keyword:

public Circle(Circle c) {  
 this(c.x, c.y, c.radius);  
}

Ito ay isang uri ng chain ng konstruktor, tumatawag sa isang tagapagbuo mula sa iba pa. Gumagamit ito ng mas kaunting code at tumutulong sa sentralisahin ang isang operasyon sa halip na doblehin ito.

Pagtawag sa Magulang na Tagatayo

Ang iba pang anyo ng chain ng konstruktor ay nangyayari kapag ang isang tagatayo ay tumawag sa isang tagapagbuo ng magulang na klase. Maaari itong maging maliwanag o implicit. Upang tumawag nang malinaw sa isang tagapagbuo ng magulang, gamitin ang sobrang super keyword:

super(x, y);

Isipin ang isang klase sa Hugis na kumikilos bilang magulang ng Circle:

public class Shape {  
 double x, y;  
 public Shape(double _x, double _y) { x = _x; y = _y; }  
}

Humahawak ito ng karaniwang pagpoposisyon para sa lahat ng mga hugis dahil ito ang pagpapaandar na ibinabahagi nilang lahat. Ngayon ang klase ng Circle ay maaaring magtalaga ng paghawak sa posisyon sa magulang nito:

public class Circle  extends Shape  {  
 double radius;  
 public Circle(double r) { super(0, 0); radius = r; }  
 public Circle(double x, double y, double r) {  
  super(x, y);   
 radius = r;  
 }  
}

Ang konstruksyon ng Superclass ay isang napakahalagang aspeto ng mana sa Java . Pinapatupad ito ng wika bilang default kung hindi mo malinaw na tumawag sobrang super sa iyong mga tagapagbuo.

Mga Modifier ng Pag-access sa Mga Consumer

Maaaring isama ng mga konstruktor ang isang modifier ng pag-access sa kanilang lagda. Tulad ng ibang mga pamamaraan, tinutukoy nito kung aling mga uri ng tumatawag ang maaaring ma-access ang tagapagbuo:

public class Test {  
 private static Test uniqueInstance = new Test();  
  private Test() { }   
 public static Test getInstance() {  
 return uniqueInstance;  
 }  
}

Ito ay isang mas kumplikadong halimbawa, kaya't ingat na maunawaan ito:

Ang klase ay hindi abstract, kaya posible na mag-instantiate mula rito.
Pribado ang tagapagbuo kaya ang klase lamang na ito ang makakalikha ng isang bagong halimbawa.
Sa pamamagitan ng isang static na pag-aari at pamamaraan, inilalantad ng klase ang isang solong, natatanging halimbawa ng sarili nito sa mga tumatawag.

Gumamit ng Mga Consumer sa Java upang Lumikha ng Mga Bagay

Mahalaga ang mga konstruktor sa object-oriented na programa. Pinapayagan ka nilang lumikha ng mga bagay, na mahalaga!

Sa Java, ang mga nagtayo ay katulad ng ibang mga pamamaraan at gumagana sa pareho sa parehong paraan. Dapat mong tandaan ang mga espesyal na patakaran sa paligid ng mga default na konstruktor, overloading, at chain ng konstruktor. Kung ang mga tagabuo ay bago sa iyo, baka gusto mong basahin ang iba pang mga pangunahing konsepto ng Java na dapat mong malaman kapag nagsisimula.

Magbahagi Magbahagi Mag-tweet Email 10 Mga Core na Konsepto ng Java na Dapat Mong Malaman Kapag Nagsisimula

Nagsusulat ka man ng isang GUI, pagbuo ng software ng panig ng server, o isang mobile application na gumagamit ng Android, ang pag-aaral ng Java ay maglilingkod sa iyo nang maayos. Narito ang ilang pangunahing konsepto ng Java upang matulungan kang makapagsimula.

Basahin Susunod Mga Kaugnay na Paksa

Programming
Java
Mga Tip sa Coding

Tungkol sa May-akda Bobby Jack(58 Mga Artikulo Na-publish)

Si Bobby ay isang mahilig sa teknolohiya na nagtrabaho bilang isang developer ng software sa loob ng halos dalawang dekada. Masigasig siya sa paglalaro, nagtatrabaho bilang Review Editor sa Switch Player Magazine, at nahuhulog sa lahat ng aspeto ng online na pag-publish at pag-unlad sa web.

ikonekta ang mga headphone ng bluetooth sa xbox isa

Higit pa Mula kay Bobby Jack

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe