Mga bagay at konstruktor

1. Paglikha ng isang bagay

Well, nakarating na kami sa paglikha ng mga bagay. Naranasan mo na ito noon, ngunit ngayon ay susuriin namin ang paksang ito nang mas detalyado. Ito ay talagang napakadaling lumikha ng mga bagay.

Upang lumikha ng isang bagay, kailangan mong gamitin ang bagong operator. Ang paglikha ng isang bagay ay mukhang halos ganito:

new Class(arguments)

Pagkatapos lumikha ng isang bagay, kadalasan ay agad kaming nagse-save ng isang reference dito sa isang variable, na kadalasang nagbabahagi ng parehong uri ng nilikha na bagay. Nangangahulugan iyon na kapag lumilikha ng isang bagay, karaniwan mong nakikita ang code na tulad nito:

Class name = new Class(arguments)

Nasaan ang paglikha ng isang bagong variable, at ang code sa kanan ng equals sign ay ang paglikha ng isang bagong bagay na ang uri ay .Class nameClass

Mga halimbawa:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

Kadalasang pinangalanan ng mga programmer ang mga variable pagkatapos ng kanilang mga klase, ngunit may maliit na titik. Para sa isang baguhang programmer, maaaring nakalilito ang naturang code:

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

Walang mali sa code na ito — ito ang pinaka-ordinaryong code, kung saan ang isang variable ay nilikha at pagkatapos ay agad na sinisimulan ng isang object ng parehong uri nito.

Sa kaliwa ng equals sign mayroon kaming paglikha ng isang variable. Sa kanan, ang paglikha ng isang bagay. Ayan yun.

2. Tagabuo

Marahil ay nakita mo na ang ilang mga argumento ay madalas na ipinapasa kapag lumilikha ng isang bagay. Higit pa rito, ipinapasa ang mga argumento para sa ilang bagay, ngunit hindi sa iba. Paano gumagana ang buong mekanismong ito na may mga argumento?

Ang lahat ay simple din dito: bawat klase ay may isang espesyal na pamamaraan (o mga pamamaraan) na responsable para sa paghawak ng mga argumentong ipinasa kapag lumilikha ng isang bagay. Ang mga pamamaraang ito ay tinatawag na mga constructor . O kapag isa lang ang pinag-uusapan natin: ang constructor .

Ang pagkilala sa isang paraan ng constructor mula sa isang regular na pamamaraan ay madali. Ang pamamaraang ito ay may dalawang natatanging tampok:

• ang pangalan ng isang constructor ay kapareho ng pangalan ng klase nito (at nagsisimula sa malaking titik)
• ang isang tagabuo ay walang uri ng pagbabalik.

Sa pangkalahatan, narito ang karaniwang hitsura nito:

modifiers Class(arguments)
{
   Code
}

Halimbawa:

public class Point
{
   public int x;
   public int y;

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}

Pansinin kung ano ang hitsura ng constructor: wala itong uri ng pagbabalik at ang pangalan nito ay kapareho ng pangalan ng klase.

At isa pang bagay: tingnan ang code sa loob ng constructor. Ang mga parameter ng constructor ay may parehong mga pangalan tulad ng mga field ng klase: x at y. Ito ay karaniwang kasanayan upang maiwasan ang paggawa ng mga pangalan ng nobelang parameter. Ang mga pangalan ay pareho sa mga patlang ng klase. Naresolba ang salungatan sa pangalan gamit ang keyword na ito.

3. Pagtawag ng constructor

Kapag ginamit ang bagong operator at isang utos tulad ng "new Class ( arguments )" upang lumikha ng bagong object, dalawang bagay ang mangyayari:

• Ang Java machine ay lumilikha ng isang bagay na ang uri ay Class
• Tinatawag ng Java machine ang constructor ng object at ipinapasa sa iyong mga argumento

Bilang isang programmer, makakapagpasya ka kung anong mga konstruktor ang dapat magkaroon ng iyong klase, at kung anong mga parameter ang dapat mayroon ang mga konstruktor na ito.

Ipagpalagay na nagpasya kang lumikha ng isang klase upang subaybayan ang mga pusa sa isang kanlungan ng hayop. Kung gayon ang iyong Catklase ay maaaring magmukhang ganito:

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

Ang Catklase ay may isang constructor lamang na may mga parameter ng pangalan at edad. Dahil walang iba pang mga constructor, dapat mong ipasa ang pangalan ng pusa ( name) at edad ( age) bilang mga argumento kapag gumagawa ng isang bagay. Ang pagpasa ng mga argumento sa constructor ay hindi opsyonal .

4. Maramihang mga constructor

Ngunit kung kailangan mo, maaari kang magdagdag ng maramihang mga konstruktor sa klase. Walang limitasyon sa bilang ng mga konstruktor o kanilang mga parameter. Kapag lumikha ka ng isang bagay, awtomatikong pipiliin ng compiler ang constructor na tumutugma sa mga parameter

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

Napagpasyahan naming isaalang-alang ang katotohanan na maaaring hindi alam ang edad ng pusa. Upang mahawakan ang kasong ito, idinagdag namin ang espesyal na pare-pareho UNKNOWNkasama ang isang constructor na may isang parameter lamang - ang pangalan ng pusa.

Tandaan na sinisimulan pa rin namin ang parehong mga variable sa loob ng parehong mga konstruktor. Pinapalitan namin ang hindi alam/nawawalang mga parameter ng constant UNKNOWN.

Kung walang itinalagang value sa variable ng edad, magkakaroon ito ng default na value na 0. Pagkatapos ng lahat, ang isang kuting na matatagpuan sa kalye ay maaaring 0 buong taon. Nangangahulugan iyon na ang isang zero sa variable ng edad ay hindi nangangahulugang "hindi kilalang edad."

5. Default na tagabuo

Kung nais mong ma-instantiate ang iyong mga bagay nang walang anumang mga parameter, ang iyong klase ay kailangang magdeklara ng isang no-argument constructor.

Ang isang constructor na walang mga parameter ay hindi nangangahulugang isang constructor na walang code. Ang nasabing constructor ay maaaring maglaman ng code na nagpapasimula ng mga variable na may mga panimulang halaga:

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

Default na tagabuo

May isang napakahalagang punto na dapat mong malaman at tandaan.

Kung hindi idineklara ng iyong klase ang isang constructor , ang compiler ay magdaragdag ng isang default na constructor, na isang walang-argumentong constructor na may pampublikong modifier.

Ngunit kung ang iyong klase ay nagdeklara ng kahit isang constructor , walang default na constructor ang idadagdag at kakailanganin mong idagdag ito mismo kung gusto mo ito.

class Cat
{
   public String name;
   public int age;
}

Cat cat = new Cat();