Inisialisasi

1. Memulakan pembolehubah

Seperti yang anda sedia maklum, anda boleh mengisytiharkan beberapa pembolehubah dalam kelas anda, dan bukan sahaja mengisytiharkannya, tetapi juga segera memulakannya dengan nilai awalnya.

Dan pembolehubah yang sama ini boleh dimulakan dalam pembina juga. Ini bermakna, secara teori, pembolehubah ini boleh diberikan nilai dua kali. Contoh

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();

Inilah yang berlaku apabila Cat cat = new Cat("Whiskers", 2);dilaksanakan:

• Objek Catdicipta
• Semua pembolehubah contoh dimulakan dengan nilai awalnya
• Pembina dipanggil dan kodnya dilaksanakan.

Dalam erti kata lain, pembolehubah mula-mula mendapat nilai awalnya, dan barulah kod pembina dilaksanakan.

2. Susunan permulaan pembolehubah dalam kelas

Pembolehubah bukan sahaja dimulakan sebelum pembina dijalankan — ia dimulakan dalam susunan yang jelas: susunan di mana ia diisytiharkan dalam kelas.

Mari lihat beberapa kod yang menarik:

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

Kod ini tidak akan dikompilasi, kerana pada masa apembolehubah dibuat masih belum ada b dan c pembolehubah. Tetapi anda boleh menulis kod anda seperti berikut — kod ini akan disusun dan akan berjalan dengan baik.

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

Tetapi ingat bahawa kod anda mestilah telus kepada pembangun lain. Adalah lebih baik untuk tidak menggunakan teknik seperti ini, kerana ia menjejaskan kebolehbacaan kod.

Di sini kita mesti ingat bahawa sebelum pembolehubah diberikan nilai mereka mempunyai nilai lalai . Untuk intjenis, ini adalah sifar.

Apabila JVM memulakan apembolehubah, ia hanya akan menetapkan nilai lalai untuk jenis int: 0.

Apabila ia mencapai b, pembolehubah akan sudah diketahui dan mempunyai nilai, jadi JVM akan memberikannya nilai 2.

Dan apabila ia mencapai cpembolehubah, pembolehubah adan bakan sudah dimulakan, jadi JVM akan dengan mudah mengira nilai awal untuk c: 0+2+3.

Jika anda mencipta pembolehubah di dalam kaedah, anda tidak boleh menggunakannya melainkan anda telah memberikan nilai kepadanya sebelum ini. Tetapi ini tidak benar untuk pembolehubah kelas! Jika nilai awal tidak diberikan kepada pembolehubah kelas, maka ia diberikan nilai lalai.

3. Pemalar

Semasa kita menganalisis cara objek dicipta, ia patut disentuh pada permulaan pemalar, iaitu pembolehubah dengan finalpengubah suai.

Jika pembolehubah mempunyai finalpengubah suai, maka mesti diberikan nilai awal. Anda sudah mengetahui perkara ini, dan tiada apa yang mengejutkan mengenainya.

Tetapi apa yang anda tidak tahu ialah anda tidak perlu memberikan nilai awal dengan segera jika anda menetapkannya dalam pembina. Ini akan berfungsi dengan baik untuk pembolehubah akhir. Satu-satunya keperluan ialah jika anda mempunyai berbilang pembina, maka pembolehubah akhir mesti diberikan nilai dalam setiap pembina.

Contoh:

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. Kod dalam pembina

Dan beberapa lagi nota penting tentang pembina. Kemudian, semasa anda terus mempelajari Java, anda akan menemui perkara seperti pewarisan, siri, pengecualian, dll. Kesemuanya mempengaruhi kerja pembina ke tahap yang berbeza-beza. Tidak masuk akal untuk menyelami topik ini secara mendalam sekarang, tetapi kami bertanggungjawab untuk sekurang-kurangnya menyentuhnya.

Sebagai contoh, berikut adalah kenyataan penting tentang pembina. Secara teori, anda boleh menulis kod apa-apa kerumitan dalam pembina. Tetapi jangan lakukan ini. Contoh:

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);
   }
}

Dalam pembina kelas FilePrinter, kami segera membuka aliran bait pada fail dan membaca kandungannya. Ini adalah tingkah laku yang kompleks dan boleh mengakibatkan ralat.

Bagaimana jika tiada fail sedemikian? Bagaimana jika terdapat masalah dengan membaca fail? Bagaimana jika ia terlalu besar?

Logik kompleks membayangkan kebarangkalian ralat yang tinggi dan ini bermakna kod mesti mengendalikan pengecualian dengan betul.

Contoh 1 — Pensirilan

Dalam program Java standard, terdapat banyak situasi di mana anda bukan orang yang mencipta objek kelas anda. Sebagai contoh, katakan anda memutuskan untuk menghantar objek melalui rangkaian: dalam kes ini, mesin Java itu sendiri akan menukar objek anda kepada satu set bait, menghantarnya dan mencipta semula objek daripada set bait.

Tetapi anggap fail anda tidak wujud pada komputer lain. Akan ada ralat dalam pembina, dan tiada siapa yang akan mengendalikannya. Dan itu cukup mampu menyebabkan program ditamatkan.

Contoh 2 — Memulakan medan kelas

Jika pembina kelas anda boleh membuang pengecualian yang diperiksa, iaitu ditandakan dengan kata kunci lontaran, maka anda mesti menangkap pengecualian yang ditunjukkan dalam kaedah yang mencipta objek anda.

Tetapi bagaimana jika tiada kaedah sedemikian? Contoh:

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

Pembina FilePrinterkelas boleh membuang pengecualian yang diperiksa , yang bermaksud anda tidak boleh mencipta FilePrinterobjek tanpa membungkusnya dalam blok cuba-tangkap. Dan blok cuba-tangkap hanya boleh ditulis dalam kaedah

5. Pembina kelas asas

Dalam pelajaran sebelum ini, kami membincangkan sedikit tentang warisan. Malangnya, perbincangan penuh kami tentang warisan dan OOP dikhaskan untuk tahap yang dikhaskan untuk OOP, dan warisan pembina sudah relevan untuk kami.

Jika kelas anda mewarisi kelas lain, objek kelas induk akan dibenamkan di dalam objek kelas anda. Lebih-lebih lagi, kelas induk mempunyai pembolehubah sendiri dan pembinanya sendiri.

Ini bermakna bahawa adalah sangat penting untuk anda mengetahui dan memahami cara pembolehubah dimulakan dan pembina dipanggil apabila kelas anda mempunyai kelas induk dan anda mewarisi pembolehubah dan kaedahnya.

Kelas

Bagaimanakah kita mengetahui susunan pembolehubah dimulakan dan pembina dipanggil? Mari kita mulakan dengan menulis kod untuk dua kelas. Satu akan mewarisi yang lain:

class ParentClass
{
   public String a;
   public String b;

   public ParentClass()
   {
   }
}

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

   public ChildClass()
   {
   }
}

Kita perlu menentukan susunan pembolehubah dimulakan dan pembina dipanggil. Pembalakan akan membantu kami melakukan ini.

Pembalakan

Pengelogan ialah proses merekod tindakan yang dilakukan oleh program semasa ia berjalan, dengan menulisnya ke konsol atau fail.

Adalah agak mudah untuk menentukan bahawa pembina telah dipanggil: dalam badan pembina, tulis mesej ke konsol. Tetapi bagaimana anda boleh mengetahui sama ada pembolehubah telah dimulakan?

Sebenarnya, ini juga tidak begitu sukar: tulis kaedah khas yang akan mengembalikan nilai yang digunakan untuk memulakan pembolehubah, dan log permulaan. Inilah rupa kod tersebut:

Kod akhir

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");
   }
}

Jika anda melaksanakan kod ini, teks akan dipaparkan pada skrin seperti berikut:

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

Oleh itu, anda sentiasa boleh memastikan secara peribadi bahawa pembolehubah kelas dimulakan sebelum pembina dipanggil. Kelas asas dimulakan sepenuhnya sebelum permulaan kelas yang diwarisi.