Mga tagabuo ng klase. Java JDK 1.5

Pangkalahatang impormasyon tungkol sa mga konstruktor

Конструкторay isang istraktura na katulad ng isang pamamaraan, ang layunin nito ay lumikha ng isang halimbawa ng isang klase. Mga katangian ng taga-disenyo:

• Ang pangalan ng constructor ay dapat tumugma sa pangalan ng klase (ayon sa convention, ang unang titik ay naka-capitalize, karaniwang isang pangngalan);
• Mayroong isang tagabuo sa anumang klase. Kahit na hindi ka magsulat ng isa, ang Java compiler ay gagawa ng default na constructor, na walang laman at walang ibang gagawin kundi ang tawagan ang superclass constructor.
• Ang isang konstruktor ay katulad ng isang pamamaraan, ngunit hindi ito isang pamamaraan, hindi rin ito itinuturing na isang miyembro ng klase. Samakatuwid, hindi ito maaaring mamana o ma-override sa isang subclass;
• Ang mga konstruktor ay hindi minana;
• Maaaring may ilang mga constructor sa isang klase. Sa kasong ito, ang mga konstruktor ay sinasabing na-overload;
• Kung ang isang klase ay hindi tumukoy ng isang constructor, ang compiler ay awtomatikong nagdaragdag ng isang parameterless constructor sa code;
• Ang isang konstruktor ay walang uri ng pagbabalik; ito ay hindi maaaring maging isang uri void; kung ang isang uri ay ibinalik void, kung gayon ito ay hindi na isang konstruktor ngunit isang pamamaraan, sa kabila ng pagkakaisa sa pangalan ng klase.
• Ang operator ay pinapayagan sa constructor return, ngunit walang laman lamang, nang walang anumang return value;
• Pinapayagan ng constructor ang paggamit ng mga modifier ng access; maaari mong itakda ang isa sa mga modifier: public, protected, privateo walang modifier.
• Ang isang constructor ay hindi maaaring magkaroon ng mga modifier abstract, final, native, statico synchronized;
• Ang keyword thisay tumutukoy sa isa pang constructor sa parehong klase. Kung ginamit, ang tawag dito ay dapat ang unang linya ng constructor;
• Tinatawag ng keyword superang constructor ng parent class. Kung ginamit, ang reference dito ay dapat ang unang linya ng constructor;
• Kung ang constructor ay hindi tumawag sa superancestor class's constructor (mayroon man o walang argumento), ang compiler ay awtomatikong nagdaragdag ng code para tawagan ang ancestor class's constructor nang walang argumento;

Default na tagabuo

Mayroong isang tagabuo sa anumang klase. Kahit na hindi ka magsulat ng isa, ang Java compiler ay gagawa ng default na constructor. Walang laman ang constructor na ito at walang ibang ginawa kundi tawagan ang superclass constructor. Yung. kung isusulat mo:

public class Example {}

kung gayon ito ay katumbas ng pagsulat:

public class Example
{
     Example()
     {
          super;
     }
}

Sa kasong ito, ang ancestor class ay hindi tahasang tinukoy, at bilang default, lahat ng Java classes ay nagmamana ng klase, Objectkaya ang class constructor ay tinatawag na Object. Kung tinukoy ng isang klase ang isang parameterized constructor, ngunit walang overloaded na parameterless constructor, kung gayon ang pagtawag sa parameterless constructor ay isang error. Gayunpaman, sa Java mula noong bersyon 1.5, posible na gumamit ng mga konstruktor na may mga argumento ng variable na haba. At kung mayroong isang constructor na may variable na haba ng argumento, kung gayon ang pagtawag sa default na constructor ay hindi magiging isang error. Ito ay hindi dahil ang variable na haba ng argumento ay maaaring walang laman. Halimbawa, ang sumusunod na halimbawa ay hindi mag-compile, ngunit kung aalisin mo ang komento sa constructor na may variable na haba ng argumento, ito ay mag-compile at tatakbo nang matagumpay at magreresulta sa isang linya ng code na tumatakbo DefaultDemo dd = new DefaultDemo(); tatawagin ang constructor DefaultDemo(int ... v). Naturally, sa kasong ito kinakailangan na gumamit ng JSDK 1.5. fileDefaultDemo.java

class DefaultDemo
{
 DefaultDemo(String s)
 {
  System.out.print("DefaultDemo(String)");
 }
 /*
 DefaultDemo(int ... v)
 {
  System.out.println("DefaultDemo(int ...)");
 }
 */

 public static void main(String args[])
 {
  DefaultDemo dd = new DefaultDemo();
 }
}

Ang resulta ng output ng programa kasama ang tagabuo ay walang komento:

DefaultDemo(int ...)

Gayunpaman, sa karaniwang kaso kung saan hindi tinukoy ng klase ang anumang constructor, ang pagtawag sa default na constructor (walang mga parameter) ay kinakailangan, dahil ang default na constructor substitution ay awtomatikong nangyayari.

Paglikha ng bagay at mga konstruktor

Kapag lumilikha ng isang bagay, ang mga sumusunod na aksyon ay isinasagawa nang sunud-sunod:

• Hinahanap ang object class sa mga klase na ginamit na sa programa. Kung wala ito, hahanapin ito sa lahat ng mga katalogo at aklatan na magagamit ng programa. Sa sandaling natuklasan ang isang klase sa isang direktoryo o library, ang mga static na field ng klase ay gagawin at sinisimulan. Yung. Para sa bawat klase, isang beses lang sinisimulan ang mga static na field.
• Ang memorya ay inilalaan para sa bagay.
• Sinisimulan na ang mga field ng klase.
• Nagpapatupad ang tagabuo ng klase.
• Ang isang link sa nilikha at nasimulan na bagay ay nabuo. Ang sanggunian na ito ay ang halaga ng expression na lumilikha ng bagay. Ang isang bagay ay maaari ding malikha sa pamamagitan ng pagtawag sa isang paraan newInstance()ng klase java.lang.Class. Sa kasong ito, ginagamit ang isang constructor na walang listahan ng parameter.

Overloading constructors

Ang mga konstruktor ng parehong klase ay maaaring magkaroon ng parehong pangalan at magkaibang lagda. Ang property na ito ay tinatawag na combination o overloading. Kung ang isang klase ay may maraming mga konstruktor, kung gayon ang constructor ay naroroon.

Mga Parameterized na Konstruktor

Ang lagda ng isang constructor ay ang bilang at mga uri ng mga parameter, pati na rin ang pagkakasunod-sunod ng kanilang mga uri sa listahan ng mga parameter ng constructor. Ang uri ng pagbabalik ay hindi isinasaalang-alang. Ang constructor ay hindi nagbabalik ng anumang mga parameter. Ipinapaliwanag ng pahayag na ito, sa isang kahulugan, kung paano nakikilala ng Java ang mga overloaded na konstruktor o pamamaraan. Ang Java ay nakikilala ang mga overloaded na pamamaraan hindi sa pamamagitan ng kanilang uri ng pagbabalik, ngunit sa pamamagitan ng bilang, mga uri, at pagkakasunud-sunod ng mga uri ng mga parameter ng input. Ang isang constructor ay hindi maaaring magbalik ng isang uri void, kung hindi, ito ay magiging isang regular na pamamaraan, kahit na ito ay katulad ng pangalan ng klase. Ang sumusunod na halimbawa ay nagpapakita nito. fileVoidDemo.java

class VoidDemo
{
 /**
  * Это конструктор
  */
 VoidDemo()
 {
  System.out.println("Constructor");
 }

 /**
  * А это уже обычный метод, даже не смотря на сходство с
  * именем класса, поскольку имеется возвращаемый тип void
  */
 void VoidDemo()
 {
  System.out.println("Method");
 }

 public static void main(String s[])
 {
  VoidDemo m = new VoidDemo();
 }
}

Bilang resulta, ang programa ay maglalabas ng:

Constructor

Muli nitong pinatutunayan na ang isang tagabuo ay isang pamamaraan na walang mga parameter ng pagbabalik. Gayunpaman, ang constructor ay maaaring bigyan ng isa sa tatlong modifier public, , privateo protected. At ang halimbawa ay magiging ganito na ngayon: FileVoidDemo2.java

class VoidDemo2
{
 /**
  * Это конструктор
  */
 public VoidDemo2()
 {
  System.out.println("Constructor");
 }

 /**
  * А это уже обычный метод, даже не смотря на сходство с
  * именем класса, поскольку имеется возвращаемый тип void
  */
 private void VoidDemo2()
 {
  System.out.println("Method");
 }

 public static void main(String s[])
 {
  VoidDemo2 m = new VoidDemo2();
 }
}

Pinapayagan na magsulat ng isang operator sa isang constructor return, ngunit isang walang laman lamang, nang walang anumang return value. fileReturnDemo.java

class ReturnDemo
{
 /**
  * В конструкторе допускается использование оператора
  * return без параметров.
  */
 public ReturnDemo()
 {
  System.out.println("Constructor");
  return;
 }

 public static void main(String s[])
 {
  ReturnDemo r = new ReturnDemo();
 }
}

Na-parameter ang mga constructor gamit ang mga variable-length na argumento

Ipinakilala ng Java SDK 1.5 ang isang pinakahihintay na tool - mga variable-length na argumento para sa mga konstruktor at pamamaraan. Noong nakaraan, ang isang variable na bilang ng mga dokumento ay naproseso sa dalawang hindi maginhawang paraan. Ang una sa mga ito ay idinisenyo upang matiyak na ang maximum na bilang ng mga argumento ay limitado sa isang maliit na bilang at alam ito nang maaga. Sa kasong ito, posibleng gumawa ng mga overloaded na bersyon ng pamamaraan, isa para sa bawat bersyon ng listahan ng mga argumentong ipinasa sa pamamaraan. Ang pangalawang paraan ay idinisenyo para sa isang bagay na hindi alam nang maaga at isang malaking bilang ng mga argumento. Sa kasong ito, ang mga argumento ay inilagay sa isang array, at ang array na ito ay ipinasa sa pamamaraan. Ang mga argumento ng variable na haba ay kadalasang kasama sa mga kasunod na manipulasyon na may mga variable na initialization. Ito ay maginhawa upang palitan ang kawalan ng ilan sa mga inaasahang constructor o method argument na may mga default na halaga. Ang argumento ng variable na haba ay isang array, at itinuturing bilang isang array. Halimbawa, ang constructor para sa isang klase Checkingna may variable na bilang ng mga argumento ay magiging ganito:

class Checking
{
 public Checking(int ... n)
 {
 }
}

Ang kumbinasyon ng character ... ay nagsasabi sa compiler na isang variable na bilang ng mga argumento ang gagamitin, at na ang mga argumentong ito ay maiimbak sa isang array na ang reference na halaga ay nasa variable n. Maaaring tawagan ang constructor na may ibang bilang ng mga argumento, kabilang ang walang mga argumento. Ang mga argumento ay awtomatikong inilalagay sa isang array at dumaan sa n. Kung walang mga argumento, ang haba ng array ay 0. Ang listahan ng mga parameter, kasama ng mga variable na haba ng argumento, ay maaari ding magsama ng mga mandatoryong parameter. Sa kasong ito, ang isang parameter na naglalaman ng variable na bilang ng mga argumento ay dapat ang huli sa listahan ng mga parameter. Halimbawa:

class Checking
{
 public Checking(String s, int ... n)
 {
 }
}

Ang isang napakalinaw na limitasyon ay may kinalaman sa bilang ng mga parameter ng variable na haba. Dapat ay mayroon lamang isang variable-length na parameter sa listahan ng parameter. Dahil sa dalawang variable-length na parameter, imposibleng matukoy ng compiler kung saan magtatapos ang isang parameter at magsisimula ang isa. Halimbawa:

class Checking
{
 public Checking(String s, int ... n, double ... d) //ОШИБКА!
 {
 }
}

File Checking.java Halimbawa, mayroong kagamitan na may kakayahang makilala ang mga plaka ng lisensya ng sasakyan at alalahanin ang mga numero ng mga parisukat ng lugar kung saan binisita ng bawat isa sa mga sasakyan sa araw. Kinakailangang pumili mula sa kabuuang masa ng mga naitala na mga kotse na sa araw na binisita ang dalawang ibinigay na mga parisukat, sabihin 22 at 15, ayon sa mapa ng lugar. Ito ay medyo natural na ang isang kotse ay maaaring bisitahin ang maraming mga parisukat sa araw, o marahil isa lamang. Malinaw, ang bilang ng mga parisukat na binisita ay limitado ng pisikal na bilis ng kotse. Gumawa tayo ng isang maliit na programa kung saan gagawin ng tagabuo ng klase bilang mga argumento ang numero ng kotse bilang isang mandatoryong parameter at ang mga bilang ng binisita na mga parisukat ng lugar, ang bilang nito ay maaaring variable. Susuriin ng tagabuo kung ang isang kotse ay lumitaw sa dalawang parisukat; kung mayroon ito, pagkatapos ay ipakita ang numero nito sa screen.

Pagpasa ng mga parameter sa constructor

Mayroong pangunahing dalawang uri ng mga parameter sa mga programming language:

• mga pangunahing uri (primitives);
• mga sanggunian sa mga bagay.

Ang terminong tawag sa pamamagitan ng halaga ay nangangahulugang natatanggap ng tagabuo ang halaga na ipinasa dito ng module ng pagtawag. Sa kaibahan, ang tawag sa pamamagitan ng sanggunian ay nangangahulugan na natatanggap ng tagabuo ang address ng variable mula sa tumatawag. Gumagamit ang Java ng tawag ayon sa halaga lamang. Sa pamamagitan ng halaga ng parameter at sa pamamagitan ng halaga ng link ng parameter. Ang Java ay hindi gumagamit ng tawag sa pamamagitan ng sanggunian para sa mga bagay (bagaman maraming programmer at mga may-akda ng ilang mga libro ang nagsasabing ito). Kapag nagpapasa ng mga bagay sa Java, ang mga parameter ay ipinapasa hindi sa pamamagitan ng reference , ngunit sa pamamagitan ng halaga ng object reference ! Sa alinmang kaso, ang tagabuo ay tumatanggap ng mga kopya ng mga halaga ng lahat ng mga parameter. Hindi magagawa ng constructor ang mga parameter ng input nito:

• hindi maaaring baguhin ng tagabuo ang mga halaga ng mga parameter ng pag-input ng mga pangunahing (primitive) na uri;
• hindi maaaring baguhin ng tagabuo ang mga sanggunian ng parameter ng input;
• hindi maaaring italaga ng constructor ang mga reference ng parameter ng input sa mga bagong bagay.

Magagawa ng tagabuo sa mga parameter ng input nito:

• baguhin ang estado ng bagay na ipinasa bilang isang parameter ng input.

Ang sumusunod na halimbawa ay nagpapatunay na sa Java, ang mga parameter ng input sa isang constructor ay ipinapasa ng object reference value. Ipinapakita rin ng halimbawang ito na hindi maaaring baguhin ng constructor ang mga sanggunian ng mga parameter ng input, ngunit aktwal na nagbabago ng mga sanggunian ng mga kopya ng mga parameter ng input. fileEmpoyee.java

class Employee
{
 Employee(String x, String y)
 {
  String temp = x;
  x = y;
  y = temp;
 }
 public static void main(String args[])
 {
  String name1 = new String("Alice");
  String name2 = new String("Mary");
  Employee a = new Employee(name1, name2);
  System.out.println("name1="+name1);
  System.out.println("name2="+name2);
 }
}

Ang output ng programa ay:

name1=Alice
name2=Mary

Kung gumamit ang Java ng tawag sa pamamagitan ng sanggunian upang ipasa ang mga bagay bilang mga parameter, ang constructor ay magpapalit name1at sa halimbawang ito name2. Ang constructor ay hindi aktuwal na ipagpalit ang mga object reference na nakaimbak sa name1at variable name2. Iminumungkahi nito na ang mga parameter ng constructor ay sinisimulan gamit ang mga kopya ng mga sangguniang ito. Pagkatapos ay pinapalitan ng tagabuo ang mga kopya. Kapag nakumpleto ng constructor ang trabaho nito, ang mga variable na x at y ay nawasak, at ang mga orihinal na variable name1ay patuloy name2na tumutukoy sa mga nakaraang bagay.

Ang pagpapalit ng mga parameter na ipinasa sa constructor.

Hindi maaaring baguhin ng constructor ang mga naipasa na parameter ng mga pangunahing uri. Gayunpaman, maaaring baguhin ng tagabuo ang estado ng bagay na ipinasa bilang isang parameter. Halimbawa, isaalang-alang ang sumusunod na programa: FileSalary1.java

class Salary1
{
 Salary1(int x)
 {
  x = x * 3;
  System.out.println("x="+x);
 }
 public static void main(String args[])
 {
  int value = 1000;
  Salary1 s1 = new Salary1(value);
  System.out.println("value="+value);
 }
}

Ang output ng programa ay:

x=3000
value=1000

Malinaw, hindi babaguhin ng pamamaraang ito ang pangunahing parameter ng uri. Samakatuwid, pagkatapos tawagan ang constructor, ang halaga ng variable valueay nananatiling katumbas ng 1000. Talagang tatlong bagay ang nangyayari:

1. xSinisimulan ang variable gamit ang isang kopya ng value ng parameter value(ibig sabihin, isang numero 1000).
2. Ang halaga ng variable xay triple - ito ay katumbas na ngayon ng 3000. Gayunpaman, ang halaga ng variable valueay nananatiling katumbas ng 1000.
3. Ang constructor ay nagtatapos at ang variable xay hindi na ginagamit.

Sa sumusunod na halimbawa, ang suweldo ng empleyado ay matagumpay na na-triple dahil ang halaga ng isang object reference ay ipinasa bilang isang parameter sa pamamaraan. fileSalary2.java

class Salary2
{
 int value = 1000;
 Salary2()
 {
 }
 Salary2(Salary2 x)
 {
  x.value = x.value * 3;
 }
 public static void main(String args[])
 {
  Salary2 s1 = new Salary2();
  Salary2 s2 = new Salary2(s1);
  System.out.println("s1.value=" +s1.value);
  System.out.println("s2.value="+s2.value);
 }
}

Ang output ng programa ay:

s1.value=3000
s2.value=1000

Ang halaga ng object reference ay ginagamit bilang isang parameter. Kapag isinasagawa ang linya Salary2 s2 = new Salary2(s1); ang constructor Salary2(Salary x)ay ipapasa ang halaga ng isang reference sa variable object s1, at ang constructor ay epektibong triple ang suweldo para sa s1.value, dahil kahit na ang kopya (Salary x)na nilikha sa loob ng constructor tumuturo sa variable object s1.

Mga konstruktor na na-parameter ng mga primitive.

Kung ang mga parameter ng isang overloaded constructor ay gumagamit ng isang primitive na maaaring paliitin (halimbawa int <- double), pagkatapos ay ang pagtawag sa isang pamamaraan na may isang makitid na halaga ay posible, sa kabila ng katotohanan na walang paraan na overloaded na may tulad na isang parameter. Halimbawa: FilePrimitive.java

class Primitive
{
 Primitive(double d)
 {
  d = d + 10;
  System.out.println("d="+d);
 }
 public static void main(String args[])
 {
  int i = 20;
  Primitive s1 = new Primitive(i);
 }
}

Ang output ng programa ay:

d=30.0

Sa kabila ng katotohanan na ang klase Primitiveay walang constructor na may uri ng parameter int, ang isang constructor na may input parameter ay gagana double. Bago tawagan ang constructor, ang variable iay lalawak mula sa uri inthanggang sa uri double. Ang kabaligtaran na opsyon, kapag ang variable iay type double, at ang constructor ay magkakaroon lamang ng parameter int, sa sitwasyong ito ay hahantong sa isang compilation error.

Tawag at operator ng tagabuonew

Ang constructor ay palaging tinatawag ng operator new. Kapag ang isang constructor ay tinawag kasama ang operator new, ang constructor ay palaging bumubuo ng isang reference sa isang bagong bagay. Imposibleng pilitin ang tagabuo na bumuo ng isang sanggunian sa isang umiiral nang bagay sa halip na isang sanggunian sa isang bagong bagay, maliban sa pamamagitan ng pagpapalit sa bagay na deserialized. At sa bagong operator, sa halip na isang sanggunian sa isang bagong bagay, imposibleng bumuo ng isang sanggunian sa isang umiiral na bagay. Halimbawa: FileSalary3.java

class Salary3
{
 int value = 1000;
 Salary3()
 {
 }
 Salary3(Salary3 x)
 {
  x.value = x.value * 3;
 }
 public static void main(String args[])
 {
  Salary3 s1 = new Salary3();
  System.out.println("First object creation: "+s1.value);

  Salary3 s2 = new Salary3(s1);
  System.out.println("Second object creation: "+s2.value);
  System.out.println("What's happend with first object?:"+s1.value);

  Salary3 s3 = new Salary3(s1);
  System.out.println("Third object creation: "+s3.value);
  System.out.println("What's happend with first object?:"+s1.value);
 }
}

Ang output ng programa ay:

First object creation: 1000
Second object creation: 1000
What's happend with first object?: 3000
Third object creation: 1000
What's happend with first object?: 9000

Una, gamit ang linya Salary3 s1 = new Salary3(); isang bagong bagay ang nilikha. Susunod, kung ginagamit ang linya Salary3 s2 = new Salary3(s1); o mga string Salary3 s3 = new Salary3(s1); magiging posible na lumikha ng isang link sa isang umiiral nang bagay, pagkatapos ay mag-iimbak s1.value s2.valuesila s3.valueng parehong halaga 1000. Talagang nasa linya Salary3 s2 = new Salary3(s1); gagawa ng bagong object para sa variable s2at magbabago ang estado ng object para sa variable s1sa pamamagitan ng pagpasa ng reference value nito sa object sa constructor parameter. Ito ay mapapatunayan ng mga resulta ng output. At kapag isinasagawa ang linya Salary3 s3 = new Salary3(s1); isang BAGONG object para sa variable ay malilikha s3at ang estado ng object para sa variable ay magbabago muli s1.

Mga konstruktor at mga bloke ng pagsisimula, pagkakasunud-sunod ng mga aksyon kapag tumatawag ng isang constructor

Ang seksyong Paglikha ng isang Bagay at Mga Konstruktor ay naglilista ng mga pangkalahatang aksyon na ginagawa kapag lumilikha ng isang bagay. Kabilang sa mga ito ay ang mga proseso ng pagsisimula ng mga patlang ng klase at paggawa ng tagabuo ng klase, na mayroon ding panloob na pagkakasunud-sunod:

1. Ang lahat ng mga field ng data ay sinisimulan sa kanilang mga default na halaga (0, false, o null).
2. Ang lahat ng field initializer at initialization block ay isinasagawa sa pagkakasunud-sunod na nakalista sa deklarasyon ng klase.
3. Kung ang isa pang constructor ay tinatawag sa unang linya ng isang constructor, pagkatapos ay ang tinatawag na constructor ay executed.
4. Ang katawan ng constructor ay naisakatuparan.

Ang constructor ay nauugnay sa pagsisimula dahil sa Java mayroong tatlong paraan upang simulan ang isang field sa isang klase:

• magtalaga ng halaga sa deklarasyon;
• magtalaga ng mga halaga sa initialization block;
• itakda ang halaga nito sa constructor.

Naturally, kailangan mong ayusin ang initialization code upang ito ay madaling maunawaan. Ang sumusunod na klase ay ibinigay bilang isang halimbawa:

class Initialization
{
 int i;
 short z = 10;
 static int x;
 static float y;
 static
 {
  x = 2000;
  y = 3.141;
 }
 Initialization()
 {
  System.out.println("i="+i);
  System.out.println("z="+z);
  z = 20;
  System.out.println("z="+z);
 }
}

Sa halimbawa sa itaas, ang mga variable ay sinisimulan sa sumusunod na pagkakasunud-sunod: ang mga static na variable ay unang sinisimulan xgamit ang ymga default na halaga. Susunod, ang static na initialization block ay isinasagawa. Pagkatapos ang variable ay pinasimulan isa default na halaga at ang variable ay pinasimulan z. Susunod, magtrabaho ang taga-disenyo. Ang pagtawag sa mga konstruktor ng klase ay hindi dapat nakadepende sa pagkakasunud-sunod kung saan idineklara ang mga patlang. Ito ay maaaring humantong sa mga pagkakamali.

Mga konstruktor at mana

Ang mga konstruktor ay hindi minana. Halimbawa:

public class Example
{
 Example()
 {
 }
 public void sayHi()
 {
  system.out.println("Hi");
 }
}

public class SubClass extends Example
{
}

SubClassAwtomatikong minana ng klase ang pamamaraang sayHi()tinukoy sa parent class. Kasabay nito, ang constructor Example()ng parent class ay hindi minana ng descendant nito SubClass.

Keyword thissa mga constructor

Ang mga konstruktor ay ginagamit thisupang sumangguni sa isa pang konstruktor sa parehong klase, ngunit may ibang listahan ng mga parameter. Kung ginagamit ng tagabuo ang keyword this, dapat na nasa unang linya ito; ang pagwawalang-bahala sa panuntunang ito ay magreresulta sa isang error sa compiler. Halimbawa: FileThisDemo.java

public class ThisDemo
{
 String name;
 ThisDemo(String s)
 {
  name = s;
     System.out.println(name);
 }
 ThisDemo()
 {
  this("John");
 }
 public static void main(String args[])
 {
  ThisDemo td1 = new ThisDemo("Mary");
  ThisDemo td2 = new ThisDemo();
 }
}

Ang output ng programa ay:

Mary
John

Sa halimbawang ito mayroong dalawang constructor. Ang una ay tumatanggap ng string argument. Ang pangalawa ay hindi tumatanggap ng anumang mga argumento, tinawag lamang nito ang unang tagabuo gamit ang default na pangalan na "John". Kaya, maaari kang gumamit ng mga konstruktor upang masimulan ang mga halaga ng field nang tahasan at bilang default, na kadalasang kinakailangan sa mga programa.

Keyword supersa mga constructor

Ang mga konstruktor ay ginagamit superupang tumawag sa isang superclass na tagabuo. Kung ang constructor ay gumagamit ng super, kung gayon ang tawag na ito ay dapat na nasa unang linya, kung hindi, ang compiler ay magtapon ng isang error. Nasa ibaba ang isang halimbawa: FileSuperClassDemo.java

public class SuperClassDemo
{
 SuperClassDemo()
 {
 }
}

class Child extends SuperClassDemo
{
 Child()
 {
  super();
 }
}

Sa simpleng halimbawang ito, ang constructor Child()ay naglalaman ng isang tawag super()na lumilikha ng isang instance ng class SuperClassDemo, bilang karagdagan sa class Child. Dahil superito ay dapat ang unang pahayag na naisakatuparan sa isang subclass constructor, ang order na ito ay palaging pareho at hindi nakadepende sa kung super(). Kung hindi ito ginagamit, ang default (walang mga parameter) constructor ng bawat superclass, simula sa base class, ay unang isasagawa. Ang sumusunod na programa ay nagpapakita kapag ang mga konstruktor ay naisakatuparan. fileCall.java

//Создать суперкласс A
class A
{
 A()
 {
  System.out.println("Inside A constructor.");
 }
}

//Создать подкласс B, расширяющий класс A
class B extends A
{
 B()
 {
  System.out.println("Inside B constructor.");
 }
}

//Создать класс (C), расширяющий класс В
class C extends B
{
 C()
 {
  System.out.println("Inside C constructor.");
 }
}

class Call
{
 public static void main(String args[])
 {
  C c = new C();
 }
}

Output mula sa programang ito:

Inside A constructor.
Inside B constructor.
Inside C constructor.

Ang mga constructor ay tinatawag sa pagkakasunud-sunod ng class subordination. Ito ay may katuturan. Dahil ang superclass ay walang kaalaman sa anumang subclass, ang anumang initialization na kailangan nitong gawin ay hiwalay. Kung maaari, dapat itong mauna sa anumang initialization na ginawa ng subclass. Kaya naman dapat gawin muna.

Nako-customize na mga konstruktor

Ang mekanismo ng pagkilala sa uri ng run-time ay isa sa mga makapangyarihang pangunahing prinsipyo ng wikang Java na nagpapatupad ng polymorphism. Gayunpaman, hindi pinoprotektahan ng naturang mekanismo ang developer mula sa hindi tugmang uri ng pag-cast sa ilang mga kaso. Ang pinakakaraniwang kaso ay ang pagmamanipula ng isang pangkat ng mga bagay, ang iba't ibang uri nito ay hindi alam nang maaga at tinutukoy sa oras ng pagtakbo. Dahil ang mga error na nauugnay sa hindi pagkakatugma ng uri ay maaari lamang lumitaw sa yugto ng runtime, ito ay nagpapahirap sa kanila na hanapin at alisin. Ang pagpapakilala ng mga custom na uri sa Java 2 5.0 ay naglilipat ng ilan sa mga error na ito mula sa runtime patungo sa oras ng pag-compile at nagbibigay ng ilan sa nawawalang uri ng kaligtasan. Hindi na kailangan para sa tahasang uri ng paghahagis kapag lumilipat mula sa isang uri Objectpatungo sa isang kongkretong uri. Dapat tandaan na ang mga tool sa pag-customize ng uri ay gumagana lamang sa mga bagay at hindi nalalapat sa mga primitive na uri ng data na nasa labas ng class inheritance tree. Sa mga custom na uri, ang lahat ng mga cast ay awtomatikong gumanap at sa likod ng mga eksena. Nagbibigay-daan ito sa iyong protektahan laban sa mga hindi pagkakatugma ng uri at muling paggamit ng code nang mas madalas. Maaaring gamitin ang mga custom na uri sa mga constructor. Maaaring maging custom ang mga constructor kahit na hindi custom na uri ang kanilang klase. Halimbawa:

class GenConstructor
{
 private double val;
 <T extends Number> GenConstructor(T arg)
 {
   val = arg.doubleValue();
 }

 void printValue()
 {
  System.out.println("val: "+val);
 }
}

class GenConstructorDemo
{
 public static void main(String args[])
 {
  GenConstructor gc1 = new GenConstructor(100);
  GenConstructor gc2 = new GenConstructor(123.5F);

  gc1.printValue();
  gc2.printValue();
 }
}

Dahil ang constructor GenConstructoray tumutukoy ng custom na uri ng parameter na dapat ay isang nagmula na klase mula sa klase Number, maaari itong tawagan mula sa alinmang