Pagsisimula

1. Pagsisimula ng mga variable

Tulad ng alam mo na, maaari kang magdeklara ng ilang mga variable sa iyong klase, at hindi lamang ipahayag ang mga ito, ngunit agad ding simulan ang mga ito sa kanilang mga paunang halaga.

At ang parehong mga variable na ito ay maaaring masimulan din sa isang constructor. Nangangahulugan ito na, sa teorya, ang mga variable na ito ay maaaring magtalaga ng mga halaga nang dalawang beses. Halimbawa

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

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

   public Cat()
   {
     this.name = "Nameless";
   }
}

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

 Cat cat = new Cat();

Ito ang mangyayari kapag Cat cat = new Cat("Whiskers", 2);naisakatuparan:

• Ang isang Catbagay ay nilikha
• Ang lahat ng mga variable ng instance ay sinisimulan sa kanilang mga inisyal na halaga
• Ang constructor ay tinatawag at ang code nito ay pinaandar.

Sa madaling salita, ang mga variable ay unang nakakuha ng kanilang mga paunang halaga, at pagkatapos lamang ay naisakatuparan ang code ng constructor.

2. Pagkakasunud-sunod ng pagsisimula ng mga variable sa isang klase

Ang mga variable ay hindi lamang pinasimulan bago tumakbo ang constructor - sila ay sinisimulan sa isang mahusay na tinukoy na pagkakasunud-sunod: ang pagkakasunud-sunod kung saan sila ay ipinahayag sa klase.

Tingnan natin ang ilang kawili-wiling code:

public class Solution
{
   public int a = b + c + 1;
   public int b = a + c + 2;
   public int c = a + b + 3;
}

Ang code na ito ay hindi mag-compile, dahil sa oras na anilikha ang variable ay wala b pang c mga variable. Ngunit maaari mong isulat ang iyong code tulad ng mga sumusunod — ang code na ito ay mag-compile at tatakbo nang maayos.

public class Solution
{
   public int a;
   public int b = a + 2;
   public int c = a + b + 3;
}

Ngunit tandaan na ang iyong code ay dapat na transparent sa ibang mga developer. Mas mainam na huwag gumamit ng mga diskarteng tulad nito, dahil pinipigilan nito ang pagiging madaling mabasa ng code.

Dito dapat nating tandaan na bago ang mga variable ay italaga ng isang halaga mayroon silang isang default na halaga. Para sa inturi, ito ay zero.

Kapag sinimulan ng JVM ang avariable, itatalaga lang nito ang default na halaga para sa uri ng int: 0.

Kapag naabot nito ang b, malalaman na ang isang variable at magkakaroon ng value, kaya itatalaga ito ng JVM ng value 2.

At kapag naabot na nito ang cvariable, ang aat bvariable ay masisimulan na, kaya madaling kalkulahin ng JVM ang paunang halaga para sa c: 0+2+3.

Kung gagawa ka ng variable sa loob ng isang paraan, hindi mo ito magagamit maliban kung dati kang nagtalaga ng value dito. Ngunit hindi ito totoo para sa mga variable ng isang klase! Kung ang isang paunang halaga ay hindi itinalaga sa isang variable ng isang klase, ito ay itinalaga ng isang default na halaga.

3. Mga Constant

Habang sinusuri namin kung paano nilikha ang mga bagay, sulit na hawakan ang pagsisimula ng mga constant, ibig sabihin, mga variable na may finalmodifier.

Kung ang isang variable ay may finalmodifier, dapat magtalaga ng paunang halaga. Alam mo na ito, at walang nakakagulat tungkol dito.

Ngunit ang hindi mo alam ay hindi mo kailangang italaga kaagad ang paunang halaga kung itatalaga mo ito sa konstruktor. Ito ay gagana nang maayos para sa isang panghuling variable. Ang tanging kinakailangan ay kung marami kang mga konstruktor, kung gayon ang isang pangwakas na variable ay dapat magtalaga ng isang halaga sa bawat konstruktor.

Halimbawa:

public class Cat
{
   public final int maxAge = 25;
   public final int maxWeight;

   public Cat (int weight)
   {
     this.maxWeight = weight; // Assign an initial value to the constant
   }
}

4. Code sa isang constructor

At ilan pang mahahalagang tala tungkol sa mga konstruktor. Sa ibang pagkakataon, habang patuloy kang nag-aaral ng Java, makakatagpo ka ng mga bagay tulad ng pamana, serialization, exception, atbp. Lahat sila ay nakakaimpluwensya sa gawain ng mga constructor sa iba't ibang antas. Walang saysay na sumisid ng malalim sa mga paksang ito ngayon, ngunit obligado tayong hawakan man lang ang mga ito.

Halimbawa, narito ang isang mahalagang komento tungkol sa mga konstruktor. Sa teorya, maaari kang magsulat ng code ng anumang kumplikado sa isang constructor. Ngunit huwag gawin ito. Halimbawa:

class FilePrinter
{
   public String content;

   public FilePrinter(String filename) throws Exception
   {
      FileInputStream input = new FileInputStream(filename);
      byte[] buffer = input.readAllBytes();
      this.content = new String(buffer);
   }

   public void printFile()
   {
      System.out.println(content);
   }
}

Sa FilePrinter class constructor, agad naming binuksan ang isang byte stream sa isang file at binasa ang mga nilalaman nito. Ito ay kumplikadong pag-uugali at maaaring magresulta sa mga pagkakamali.

Paano kung walang ganoong file? Paano kung may mga problema sa pagbabasa ng file? Paano kung ito ay masyadong malaki?

Ang kumplikadong lohika ay nagpapahiwatig ng isang mataas na posibilidad ng mga error at nangangahulugan ito na ang code ay dapat pangasiwaan nang tama ang mga pagbubukod.

Halimbawa 1 — Serialization

Sa isang karaniwang Java program, maraming mga sitwasyon kung saan hindi ikaw ang gumagawa ng mga bagay ng iyong klase. Halimbawa, ipagpalagay na nagpasya kang magpadala ng isang bagay sa network: sa kasong ito, ang Java machine mismo ang magko-convert sa iyong bagay sa isang hanay ng mga byte, ipapadala ito, at muling likhain ang bagay mula sa hanay ng mga byte.

Ngunit ipagpalagay na ang iyong file ay hindi umiiral sa kabilang computer. Magkakaroon ng error sa constructor, at walang hahawak nito. At iyon ay lubos na may kakayahang magdulot ng pagwawakas ng programa.

Halimbawa 2 — Pagsisimula ng mga field ng isang klase

Kung ang iyong tagabuo ng klase ay maaaring magtapon ng mga naka-check na eksepsiyon, ibig sabihin ay minarkahan ng mga throws na keyword, pagkatapos ay dapat mong mahuli ang ipinahiwatig na mga eksepsiyon sa paraang lumilikha ng iyong bagay.

Ngunit paano kung walang ganoong pamamaraan? Halimbawa:

class Solution
{
   public FilePrinter reader = new FilePrinter("c:\\readme.txt");
}

Ang FilePrintertagabuo ng klase ay maaaring maghagis ng naka-check na exception , na nangangahulugang hindi ka makakagawa ng isang FilePrinterbagay nang hindi binabalot ito sa isang try-catch block. At ang isang try-catch block ay maaari lamang isulat sa isang paraan

5. Base class constructor

Sa mga nakaraang aralin, medyo napag-usapan natin ang pamana. Sa kasamaang palad, ang aming buong talakayan ng inheritance at OOP ay nakalaan para sa antas na nakatuon sa OOP, at ang inheritance ng mga constructor ay may kaugnayan na para sa amin.

Kung ang iyong klase ay nagmamana ng isa pang klase, ang isang object ng parent class ay i-embed sa loob ng isang object ng iyong klase. Higit pa rito, ang parent class ay may sariling mga variable at sarili nitong mga constructor.

Nangangahulugan iyon na napakahalaga para sa iyo na malaman at maunawaan kung paano sinisimulan ang mga variable at tinatawag ang mga constructor kapag may parent class ang iyong klase at minana mo ang mga variable at pamamaraan nito.

Mga klase

Paano natin malalaman ang pagkakasunud-sunod kung saan sinisimulan ang mga variable at tinawag ang mga konstruktor? Magsimula tayo sa pagsulat ng code para sa dalawang klase. Ang isa ay magmamana ng isa:

class ParentClass
{
   public String a;
   public String b;

   public ParentClass()
   {
   }
}

class ChildClass extends ParentClass
{
   public String c;
   public String d;

   public ChildClass()
   {
   }
}

Kailangan nating matukoy ang pagkakasunud-sunod kung saan sinisimulan ang mga variable at tinawag ang mga konstruktor. Ang pag-log ay makakatulong sa amin na gawin ito.

Pagtotroso

Ang pag-log ay ang proseso ng pagtatala ng mga aksyon na isinagawa ng isang programa habang tumatakbo ito, sa pamamagitan ng pagsusulat ng mga ito sa console o isang file.

Ito ay medyo simple upang matukoy na ang constructor ay tinawag: sa katawan ng constructor, magsulat ng isang mensahe sa console. Ngunit paano mo malalaman kung ang isang variable ay nasimulan?

Sa totoo lang, hindi rin ito napakahirap: magsulat ng isang espesyal na paraan na magbabalik ng halaga na ginamit upang simulan ang variable, at i-log ang pagsisimula. Ito ang maaaring hitsura ng code:

Panghuling code

public class Main
{
   public static void main(String[] args)
   {
      ChildClass obj = new ChildClass();
   }

   public static String print(String text)
   {
      System.out.println(text);
      return text;
   }
}

class ParentClass
{
   public String a = Main.print("ParentClass.a");
   public String b = Main.print("ParentClass.b");

   public ParentClass()
   {
      Main.print("ParentClass.constructor");
   }
}

class ChildClass extends ParentClass
{
   public String c = Main.print("ChildClass.c");
   public String d = Main.print("ChildClass.d");

   public ChildClass()
   {
      Main.print("ChildClass.constructor");
   }
}

Kung ipapatupad mo ang code na ito, ang teksto ay ipapakita sa screen tulad ng sumusunod:

ParentClass.a
ParentClass.b
ParentClass.constructor
ChildClass.c
ChildClass.d
ChildClass.constructor

Kaya maaari mong palaging personal na matiyak na ang mga variable ng isang klase ay sinisimulan bago tawagin ang tagabuo. Ang isang batayang klase ay ganap na nasisimulan bago ang pagsisimula ng minanang klase.