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
Kod | Catatan |
---|---|
|
Pembolehubah age diberikan nilai awal Nilai awal ditimpa Pembolehubah umur menyimpan nilai awalnya. |
|
Ini dibenarkan: pembina pertama akan dipanggil |
|
Ini dibenarkan: pembina kedua akan dipanggil |
Inilah yang berlaku apabila Cat cat = new Cat("Whiskers", 2);
dilaksanakan:
- Objek
Cat
dicipta - 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:
Kod | Catatan |
---|---|
|
Kod ini tidak akan dikompilasi, kerana pada masa a
pembolehubah 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.
Kod | Catatan |
---|---|
|
0 0+2 0+2+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 int
jenis, ini adalah sifar.
Apabila JVM memulakan a
pembolehubah, 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 c
pembolehubah, pembolehubah a
dan b
akan 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 final
pengubah suai.
Jika pembolehubah mempunyai final
pengubah 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:
|
Buka strim baca fail Baca fail ke dalam tatasusunan bait Simpan tatasusunan bait sebagai rentetan Paparkan kandungan fail pada skrin |
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:
Kod | Catatan |
---|---|
|
Kod ini tidak akan disusun. |
Pembina FilePrinter
kelas boleh membuang pengecualian yang diperiksa , yang bermaksud anda tidak boleh mencipta FilePrinter
objek 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:
Kod | Catatan |
---|---|
|
Kelas ChildClass mewarisi ParentClass kelas. |
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
|
Cipta ChildClass objek Kaedah ini menulis teks yang dihantar ke konsol dan juga mengembalikannya. Isytiharkan teks Paparan ParentClass kelas dan juga mulakan pembolehubah dengannya. Tulis mesej bahawa pembina telah dipanggil. Abaikan nilai pulangan. Isytiharkan teks Paparan ChildClass kelas dan juga mulakan pembolehubah dengannya. Tulis mesej bahawa pembina telah dipanggil. Abaikan nilai pulangan. |
Jika anda melaksanakan kod ini, teks akan dipaparkan pada skrin seperti berikut:
Output konsol kaedahMain.print() |
---|
|
Oleh itu, anda sentiasa boleh memastikan secara peribadi bahawa pembolehubah kelas dimulakan sebelum pembina dipanggil. Kelas asas dimulakan sepenuhnya sebelum permulaan kelas yang diwarisi.
GO TO FULL VERSION