10 perkara yang anda perlu tahu tentang pengubah suai statik di Java

Di Java, pengubah suai statik bermaksud sesuatu berkaitan secara langsung dengan kelas: jika medan statik, maka ia tergolong dalam kelas; jika kaedah adalah statik, maka ia tergolong dalam kelas. Akibatnya, anda boleh menggunakan nama kelas untuk memanggil kaedah statik atau merujuk medan statik. Sebagai contoh, jika countmedan adalah statik dalam Counterkelas, ini bermakna anda boleh merujuk pembolehubah dengan ungkapan berikut: Counter.count. 10 perkara yang anda perlu tahu tentang pengubah suai statik di Java - 1

Sudah tentu, pengubah suai akses mesti dipertimbangkan. Sebagai contoh, privatemedan hanya tersedia dalam kelas di mana ia diisytiharkan. Dan protectedmedan tersedia untuk semua kelas dalam pakej, dan juga kepada semua subkelas mereka di luar pakej. Katakan Counterkelas mempunyai kaedah statik increment()yang tugasnya adalah untuk menambahcountpadang. Untuk memanggil kaedah ini, anda boleh menggunakan Counter.increment(). Tidak perlu mencipta contoh kelas Counteruntuk mengakses medan atau kaedah statik. Ini ialah perbezaan asas antara pembolehubah dan kaedah statik (kelas) dan pembolehubah dan kaedah BUKAN statik (contoh). Nota penting. Jangan lupa bahawa ahli statik kelas secara langsung tergolong dalam kelas, bukan mana-mana contoh kelas. Iaitu, nilai pembolehubah statik countakan sama untuk semua Counterobjek. Dalam artikel ini, kita akan melihat aspek asas menggunakan pengubah suai statik dalam Java, serta beberapa ciri yang akan membantu anda memahami konsep pengaturcaraan utama.

Perkara yang perlu diketahui oleh setiap pengaturcara tentang pengubah suai statik di Java.

Dalam bahagian ini, kita melihat aspek utama menggunakan kaedah statik, medan dan kelas. Mari kita mulakan dengan pembolehubah.

Anda TIDAK BOLEH mengakses ahli bukan statik kelas dalam konteks statik, seperti kaedah statik atau blok. Menyusun kod di bawah akan mengakibatkan ralat:
```
public class Counter {
private int count;
public static void main(String args []) {
   System.out.println(count); //  Compile time error
}
}
```
Ini adalah salah satu kesilapan yang paling biasa dilakukan oleh pengaturcara Java, terutamanya pemula. Memandangkan mainkaedah adalah statik dan countpembolehubah tidak, menggunakan printlnkaedah di dalam mainkaedah akan menghasilkan "ralat masa penyusunan".
Tidak seperti pembolehubah tempatan, medan dan kaedah statik TIDAK thread safedalam Java. Dalam amalan, ini adalah salah satu punca masalah keselamatan yang paling kerap dalam pengaturcaraan berbilang benang. Memandangkan setiap contoh kelas merujuk salinan pembolehubah statik yang sama, pembolehubah sedemikian perlu dilindungi atau "dikunci" oleh kelas. Oleh itu, apabila menggunakan pembolehubah statik, pastikan ia betul synchronizeduntuk mengelakkan masalah seperti race conditions.
Kaedah statik mempunyai kelebihan praktikal kerana tidak perlu mencipta objek baharu setiap kali anda ingin memanggilnya. Kaedah statik boleh dipanggil menggunakan nama kelas yang mengisytiharkannya. Itulah sebabnya kaedah ini sesuai untuk factorykaedah dan utilitykaedah. Kelas java.lang.Mathadalah contoh yang menarik: hampir semua kaedahnya adalah statik. Kelas utiliti Java ditandakan finaluntuk sebab yang sama.
Satu lagi perkara penting ialah anda tidak boleh mengatasi ( @Override) kaedah statik. Jika anda mengisytiharkan kaedah sedemikian dalam subclass, iaitu kaedah dengan nama dan tandatangan yang sama, anda hanya "menyembunyikan" kaedah dan superclassbukannya mengatasinya. Fenomena ini dikenali sebagai method hiding. Ini bermakna jika kaedah statik diisytiharkan dalam kedua-dua kelas induk dan anak, kaedah yang dipanggil akan sentiasa berdasarkan jenis pembolehubah pada masa penyusunan. Tidak seperti kaedah overriding, kaedah sedemikian tidak akan dilaksanakan apabila program dijalankan. Mari kita pertimbangkan contoh:
```
class Vehicle {
     public static void kmToMiles(int km) {
          System.out.println("Inside the parent class / static method");
     } 
}

class Car extends Vehicle {
     public static void kmToMiles(int km) {
          System.out.println("Inside the child class / static method");
     } 
}

public class Demo {   
   public static void main(String args []) {
      Vehicle v = new Car();
       v.kmToMiles(10);
  }
}
```
Output konsol:

Di dalam kelas induk / kaedah statik

Kod itu jelas menunjukkan bahawa walaupun objek itu ialah a Car, kaedah statik dalam Vehiclekelas dipanggil, kerana kaedah itu dipanggil pada masa penyusunan. Dan ambil perhatian bahawa tiada ralat kompilasi!
Apatah lagi, selain daripada kelas peringkat atas, anda boleh mengisytiharkan kelas statik. Kelas sedemikian dikenali sebagai nested static classes. Mereka berguna untuk menyediakan perpaduan yang lebih baik. Contoh yang menarik bagi kelas statik bersarang ialah HashMap.Entry, yang merupakan struktur data di dalamnya HashMap. Perlu diingat bahawa, seperti kelas dalam, kelas bersarang statik diisytiharkan dalam fail .class yang berasingan. Oleh itu, jika anda mengisytiharkan lima kelas bersarang dalam kelas utama anda, anda akan mempunyai 6 fail dengan sambungan .class. Contoh lain ialah pengisytiharan kami sendiri Comparator, seperti pembanding umur ( AgeComparator) dalam Employeekelas.
Pengubah suai statik juga boleh ditentukan dalam blok statik, lebih dikenali sebagai "blok permulaan statik", yang dilaksanakan apabila kelas dimuatkan. Jika anda tidak mengisytiharkan blok sedemikian, Java mengumpul semua medan statik ke dalam satu senarai dan memulakannya apabila kelas dimuatkan. Blok statik TIDAK BOLEH membuang pengecualian yang telah ditanda, tetapi ia boleh membuang yang tidak ditanda. Dalam kes ini, ExceptionInInitializerErrorakan berlaku. Dalam amalan, sebarang pengecualian yang berlaku semasa permulaan medan statik akan dibalut dalam ralat ini oleh Java. Ini juga merupakan punca paling biasa NoClassDefFoundError, kerana kelas tidak akan berada dalam ingatan apabila ia dirujuk.
Adalah berguna untuk mengetahui bahawa kaedah statik dipautkan pada masa penyusunan, tidak seperti pautan kaedah maya atau bukan statik, yang dipautkan pada masa larian apabila dipanggil pada objek sebenar. Sehubungan itu, kaedah statik tidak boleh ditindih dalam Java, kerana polimorfisme tidak terpakai padanya pada masa jalankan. Ini adalah had penting untuk dipertimbangkan semasa mengisytiharkan kaedah statik. Melakukannya masuk akal hanya apabila tiada keupayaan atau keperluan untuk mengatasi kaedah dalam subkelas. Kaedah kilang dan kaedah utiliti adalah contoh baik penggunaan pengubah statik yang betul. Joshua Bloch menunjukkan beberapa kelebihan yang terdapat pada kaedah kilang statik berbanding konstruktor dalam bukunya Java Efektif, yang merupakan bacaan wajib bagi setiap pengaturcara Java.
Permulaan ialah aspek penting bagi blok statik. Medan atau pembolehubah statik dimulakan selepas kelas dimuatkan ke dalam memori. Urutan permulaan adalah dari atas ke bawah, dalam susunan yang sama di mana ia diisytiharkan dalam fail sumber kelas Java. Memandangkan medan statik dimulakan dengan cara selamat benang, proses ini juga digunakan untuk melaksanakan Singletoncorak. Jika anda tidak menggunakan Enumsebagai atas Singletonsebab tertentu, maka anda mempunyai alternatif yang baik. Tetapi dalam kes ini, anda mesti mengambil kira bahawa ini bukan permulaan "malas". Ini bermakna bahawa medan statik akan dimulakan walaupun SEBELUM seseorang "meminta" untuknya. Jika objek adalah sumber yang berat atau jarang digunakan, maka memulakannya dalam blok statik tidak akan memihak kepada anda.
Semasa bersiri, medan statik, seperti transientpembolehubah, tidak bersiri. Sesungguhnya, jika anda menyimpan sebarang data dalam medan statik, ia akan mengandungi nilai asalnya (lalai) selepas penyahserikatan. Sebagai contoh, jika medan statik ialah int, nilainya akan menjadi sifar selepas penyahserikatan. Jika jenisnya ialah float, nilainya ialah 0.0. Jika medan ialah Object, nilainya ialah null. Sejujurnya, ini adalah salah satu soalan yang paling kerap ditanya tentang bersiri dalam temu bual untuk jawatan Java. Jangan simpan data objek penting dalam medan statik!
Akhir sekali, mari kita bercakap tentang import statik. Pengubah suai ini mempunyai banyak persamaan dengan importpernyataan standard, tetapi ia berbeza kerana ia membolehkan anda memindahkan satu atau semua ahli kelas statik. Sebaik sahaja kaedah statik diimport, ia boleh diakses seolah-olah ia diisytiharkan dalam kelas yang sama. Begitu juga, dengan mengimport medan statik, kita boleh mengaksesnya tanpa menyatakan nama kelas. Ciri ini muncul dalam Java 1.5 dan meningkatkan kebolehbacaan kod apabila digunakan dengan betul. Konstruk ini paling kerap ditemui dalam ujian JUnit, kerana hampir semua pembangun ujian menggunakan import statik untuk kaedah menegaskan, cth assertEquals()dan varian terlampau beban mereka.
Itu sahaja buat masa ini. Setiap pengaturcara Java perlu mengetahui semua aspek pengubah statik yang disebutkan di atas. Artikel ini menyemak maklumat asas tentang pembolehubah statik, medan, kaedah, blok permulaan dan import. Ia juga menyentuh beberapa sifat penting yang penting untuk diketahui untuk menulis dan memahami program Java. Saya berharap setiap pembangun akan menyempurnakan penggunaan ahli statik mereka dengan mahir, kerana ia sangat penting untuk pembangunan perisian yang serius."