pengenalan
Tujuan utama program komputer ialah pemprosesan data. Untuk memproses data anda perlu menyimpannya entah bagaimana. Saya mencadangkan untuk memahami cara data disimpan.
Pembolehubah
Pembolehubah ialah bekas yang menyimpan sebarang data. Mari lihat Tutorial rasmi dari Oracle:
Mengisytiharkan Pembolehubah Ahli . Menurut Tutorial ini, terdapat beberapa jenis pembolehubah:
- Medan : pembolehubah yang diisytiharkan dalam kelas;
- Pembolehubah setempat : pembolehubah dalam kaedah atau blok kod;
- Parameter : pembolehubah dalam pengisytiharan kaedah (dalam tandatangan).
Semua pembolehubah mesti mempunyai jenis pembolehubah dan nama pembolehubah.
- Jenis pembolehubah menunjukkan data yang diwakili oleh pembolehubah (iaitu, data yang boleh disimpannya). Seperti yang kita ketahui, jenis pembolehubah boleh menjadi primitif (primitif ) atau object , bukan primitif (Bukan primitif). Dengan pembolehubah objek, jenisnya diterangkan oleh kelas tertentu.
- Nama pembolehubah mestilah huruf kecil, dalam huruf unta. Anda boleh membaca lebih lanjut mengenai penamaan dalam " Variables:Naming ".
Juga, jika pembolehubah peringkat kelas, i.e. ialah medan kelas, pengubah suai akses boleh ditentukan untuknya. Lihat
Mengawal Akses kepada Ahli Kelas untuk mendapatkan butiran lanjut .
Pengisytiharan Pembolehubah
Jadi, kita ingat apa itu pembolehubah. Untuk mula bekerja dengan pembolehubah, anda perlu mengisytiharkannya. Pertama, mari kita lihat pembolehubah tempatan. Daripada IDE, untuk kemudahan, kami akan menggunakan penyelesaian dalam talian dari tutorialspoint:
IDE Dalam Talian . Mari jalankan program mudah ini dalam IDE dalam talian mereka:
public class HelloWorld{
public static void main(String []args){
int number;
System.out.println(number);
}
}
Jadi, seperti yang anda lihat, kami telah mengisytiharkan pembolehubah tempatan dengan nama
numberdan jenis
int. Kami menekan butang "Lakukan" dan dapatkan ralat:
HelloWorld.java:5: error: variable number might not have been initialized
System.out.println(number);
Apa yang berlaku? Kami mengisytiharkan pembolehubah, tetapi tidak memulakan nilainya. Perlu diingat bahawa ralat ini tidak berlaku pada masa pelaksanaan (iaitu, bukan dalam Runtime), tetapi pada masa penyusunan. Pengkompil pintar menyemak sama ada pembolehubah tempatan akan dimulakan sebelum mengaksesnya atau tidak. Oleh itu, pernyataan berikut berikutan daripada ini:
- Pembolehubah tempatan hanya boleh diakses selepas ia dimulakan;
- Pembolehubah tempatan tidak mempunyai nilai lalai;
- Nilai pembolehubah tempatan disemak pada masa penyusunan.
Jadi, kami diberitahu bahawa pembolehubah mesti dimulakan. Memulakan pembolehubah ialah memberikan nilai kepada pembolehubah. Mari kita fikirkan apa itu dan mengapa.
Memulakan pembolehubah tempatan
Memulakan pembolehubah adalah salah satu topik paling rumit di Jawa, kerana... sangat berkait rapat dengan bekerja dengan ingatan, pelaksanaan JVM, spesifikasi JVM dan perkara lain yang sama menakutkan dan rumit. Tetapi anda boleh cuba memikirkannya sekurang-kurangnya pada tahap tertentu. Mari kita beralih daripada mudah kepada kompleks. Untuk memulakan pembolehubah, kami akan menggunakan pengendali tugasan dan menukar baris dalam kod kami sebelumnya:
int number = 2;
Dalam pilihan ini, tiada ralat dan nilai akan dipaparkan pada skrin. Apa yang berlaku dalam kes ini? Cuba kita beri alasan. Jika kita ingin memberikan nilai kepada pembolehubah, maka kita mahu pembolehubah itu menyimpan nilai. Ternyata nilai itu mesti disimpan di suatu tempat, tetapi di mana? Pada cakera? Tetapi ini sangat perlahan dan mungkin mengenakan sekatan ke atas kami. Ternyata satu-satunya tempat di mana kita boleh menyimpan data dengan cepat dan cekap "di sini dan sekarang" ialah memori. Ini bermakna kita perlu memperuntukkan sedikit ruang dalam ingatan. Ini adalah benar. Apabila pembolehubah dimulakan, ruang akan diperuntukkan untuknya dalam memori yang diperuntukkan kepada proses java di mana program kami akan dilaksanakan. Memori yang diperuntukkan kepada proses java dibahagikan kepada beberapa kawasan atau zon. Mana antara mereka yang akan memperuntukkan ruang bergantung pada jenis pembolehubah yang diisytiharkan.
Memori dibahagikan kepada bahagian berikut: Heap, Stack dan Non-Heap . Mari kita mulakan dengan ingatan tindanan.
Tindanan diterjemahkan sebagai timbunan (contohnya, timbunan buku). Ia ialah struktur data LIFO (Masuk Terakhir, Keluar Dahulu). Iaitu, seperti timbunan buku. Apabila kami menambahkan buku padanya, kami meletakkannya di atas, dan apabila kami mengambilnya, kami mengambil yang teratas (iaitu buku yang telah ditambahkan paling baru-baru ini). Jadi, kami melancarkan program kami. Seperti yang kita ketahui, program Java dilaksanakan oleh JVM, iaitu mesin maya Java. JVM mesti tahu di mana pelaksanaan program harus bermula. Untuk melakukan ini, kami mengisytiharkan kaedah utama, yang dipanggil "titik masuk". Untuk pelaksanaan dalam JVM, utas utama (Thread) dicipta. Apabila benang dicipta, ia diperuntukkan tindanannya sendiri dalam ingatan. Timbunan ini terdiri daripada bingkai. Apabila setiap kaedah baharu dilaksanakan dalam benang, bingkai baharu akan diperuntukkan untuknya dan ditambah pada bahagian atas tindanan (seperti buku baharu dalam timbunan buku). Bingkai ini akan mengandungi rujukan kepada objek dan jenis primitif. Ya, ya, int kami akan disimpan pada timbunan, kerana... int ialah jenis primitif. Sebelum memperuntukkan bingkai, JVM mesti memahami perkara yang perlu disimpan di sana. Atas sebab inilah kami akan menerima ralat "pembolehubah mungkin tidak dimulakan", kerana jika ia tidak dimulakan, maka JVM tidak akan dapat menyediakan timbunan untuk kami. Oleh itu, apabila menyusun atur cara, penyusun pintar akan membantu kita mengelak daripada melakukan kesilapan dan memecahkan segala-galanya.
(!) Untuk kejelasan, saya mengesyorkan artikel
super duper : “
Java Stack and Heap: Java Memory Allocation Tutorial ”. Ia memaut ke video yang sama hebat:
Selepas kaedah selesai, bingkai yang diperuntukkan untuk kaedah ini akan dipadamkan daripada susunan benang, dan bersama-sama dengannya, memori yang diperuntukkan untuk bingkai ini dengan semua data akan dikosongkan.
Memulakan Pembolehubah Objek Tempatan
Mari tukar kod kami sekali lagi kepada yang lebih rumit:
public class HelloWorld{
private int number = 2;
public static void main(String []args){
HelloWorld object = new HelloWorld();
System.out.println(object.number);
}
}
Apa yang akan berlaku di sini? Mari kita bercakap mengenainya lagi. JVM tahu dari mana ia harus melaksanakan program, i.e. dia nampak kaedah utama. Ia mencipta benang dan memperuntukkan memori untuknya (lagipun, benang perlu menyimpan data yang diperlukan untuk pelaksanaan di suatu tempat). Dalam urutan ini, bingkai diperuntukkan untuk kaedah utama. Seterusnya kita mencipta objek HelloWorld. Objek ini tidak lagi dicipta pada timbunan, tetapi pada timbunan. Kerana objek bukan jenis primitif, tetapi jenis objek. Dan timbunan hanya akan menyimpan rujukan kepada objek dalam timbunan (kita mesti mengakses objek ini). Seterusnya, dalam timbunan kaedah utama, bingkai akan diperuntukkan untuk melaksanakan kaedah println. Selepas melaksanakan kaedah utama, semua bingkai akan dimusnahkan. Jika bingkai dimusnahkan, semua data akan dimusnahkan. Objek objek tidak akan dimusnahkan serta-merta. Pertama, rujukan kepadanya akan dimusnahkan dan oleh itu tiada siapa yang akan merujuk kepada objek objek lagi dan akses kepada objek ini dalam ingatan tidak akan dapat dilakukan lagi. JVM pintar mempunyai mekanisme sendiri untuk ini - pemungut sampah (pengumpul sampah atau singkatannya GC). Ia kemudian mengalih keluar daripada objek ingatan yang tiada rujukan orang lain. Proses ini sekali lagi diterangkan dalam pautan yang diberikan di atas. Malah ada video dengan penjelasan.
Memulakan medan
Permulaan medan yang dinyatakan dalam kelas berlaku dengan cara yang istimewa bergantung pada sama ada medan itu statik atau tidak. Jika medan mempunyai kata kunci statik, maka medan ini merujuk kepada kelas itu sendiri, dan jika perkataan statik tidak ditentukan, maka medan ini merujuk kepada contoh kelas. Mari kita lihat ini dengan contoh:
public class HelloWorld{
private int number;
private static int count;
public static void main(String []args){
HelloWorld object = new HelloWorld();
System.out.println(object.number);
}
}
Dalam contoh ini, medan dimulakan pada masa yang berbeza. Medan nombor akan dimulakan selepas objek kelas HelloWorld dicipta. Tetapi medan kiraan akan dimulakan apabila kelas dimuatkan oleh mesin maya Java. Pemuatan kelas ialah topik yang berasingan, jadi kami tidak akan mencampurkannya di sini. Perlu diketahui bahawa pembolehubah statik dimulakan apabila kelas diketahui pada masa jalan. Sesuatu yang lebih penting di sini, dan anda telah menyedarinya. Kami tidak menyatakan nilai di mana-mana sahaja, tetapi ia berfungsi. Dan sesungguhnya. Pembolehubah yang merupakan medan, jika ia tidak mempunyai nilai yang ditentukan, ia dimulakan dengan nilai lalai. Untuk nilai berangka ini ialah 0 atau 0.0 untuk nombor titik terapung. Untuk boolean ini adalah palsu. Dan untuk semua pembolehubah jenis objek, nilainya akan menjadi batal (kita akan membincangkannya kemudian). Nampaknya, kenapa jadi begini? Tetapi kerana objek dicipta dalam Heap (dalam heap). Bekerja dengan kawasan ini dilakukan dalam Runtime. Dan kita boleh memulakan pembolehubah ini pada masa jalan, tidak seperti timbunan, memori yang mesti disediakan sebelum pelaksanaan. Beginilah cara memori berfungsi di Jawa. Tetapi terdapat satu lagi ciri di sini. Sekeping kecil ini menyentuh sudut memori yang berbeza. Seperti yang kita ingat, bingkai diperuntukkan dalam memori Stack untuk kaedah utama. Bingkai ini menyimpan rujukan kepada objek dalam ingatan Heap. Tetapi di manakah kiraan disimpan kemudian? Seperti yang kita ingat, pembolehubah ini dimulakan serta-merta, sebelum objek dicipta dalam timbunan. Ini adalah soalan yang sangat rumit. Sebelum Java 8, terdapat kawasan memori yang dipanggil PERMGEN. Bermula dengan Java 8, kawasan ini telah berubah dan dipanggil METASPACE. Pada asasnya, pembolehubah statik adalah sebahagian daripada definisi kelas, i.e. metadatanya. Oleh itu, adalah logik bahawa ia disimpan dalam repositori metadata, METASPACE. MetaSpace tergolong dalam kawasan memori Non-Heap yang sama dan merupakan sebahagian daripadanya. Ia juga penting untuk mengambil kira bahawa susunan pembolehubah diisytiharkan diambil kira. Sebagai contoh, terdapat ralat dalam kod ini:
public class HelloWorld{
private static int b = a;
private static int a = 1;
public static void main(String []args){
System.out.println(b);
}
}
Apa itu null
Seperti yang dinyatakan di atas, pembolehubah jenis objek, jika ia adalah medan kelas, dimulakan kepada nilai lalai dan nilai lalai itu adalah nol. Tetapi apakah null di Jawa? Perkara pertama yang perlu diingat ialah jenis primitif tidak boleh batal. Dan semuanya kerana null adalah rujukan khas yang tidak merujuk ke mana-mana, kepada mana-mana objek. Oleh itu, hanya pembolehubah objek boleh menjadi batal. Perkara kedua yang penting untuk difahami ialah null adalah rujukan. Saya merujuk juga mempunyai berat mereka. Mengenai topik ini, anda boleh membaca soalan mengenai stackoverflow: "
Adakah pembolehubah null memerlukan ruang dalam ingatan ".
Blok permulaan
Apabila mempertimbangkan permulaan pembolehubah, adalah berdosa jika tidak mempertimbangkan blok permulaan. Ia kelihatan seperti ini:
public class HelloWorld{
static {
System.out.println("static block");
}
{
System.out.println("block");
}
public HelloWorld () {
System.out.println("Constructor");
}
public static void main(String []args){
HelloWorld obj = new HelloWorld();
}
}
Susunan keluaran ialah: blok statik, blok, Pembina. Seperti yang dapat kita lihat, blok permulaan dilaksanakan sebelum pembina. Dan kadangkala ini boleh menjadi cara permulaan yang mudah.
Kesimpulan
Saya harap gambaran ringkas ini telah dapat memberikan sedikit gambaran tentang cara ia berfungsi dan sebabnya. #Viacheslav
GO TO FULL VERSION