Lebih lanjut mengenai skop pembolehubah

"Profesor itu tidak boleh keluar dari kebiasaannya. Guru-guru lama yang biasa bersyarah selalu seperti ini. Tiada apa yang dia boleh beritahu anda yang anda tidak dapati dalam buku. Anda tidak belajar berenang dengan mendengar kepada kuliah renang. Kuliah hanya berguna apabila anda sudah biasa dengan subjek itu dan tahu hampir sama seperti profesor anda."

"Namun, pelajarannya berguna."

"Ya. Maksud saya, kami harap mereka begitu. Semakin banyak perspektif tentang subjek yang anda dengar, semakin dekat anda dengan kebenaran. Apabila anda mendengar hanya satu, apa yang anda boleh lakukan ialah percaya atau tidak percaya. OK, mari kita kembali berniaga."

"Mari kita lihat gambar yang saya tunjukkan kepada awak sebelum ini."

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. Pembolehubah yang diisytiharkan dalam kaedah wujud (boleh dilihat) dari permulaan pengisytiharannya hingga akhir kaedah.

2. Pembolehubah yang diisytiharkan dalam blok kod wujud sehingga akhir blok kod.

3. Parameter kaedah wujud sehingga kaedah kembali.

4. Pembolehubah dalam objek wujud sepanjang hayat objek yang mengandunginya. Keterlihatan mereka juga dikawal oleh pengubah suai akses khas.

5. Pembolehubah statik (kelas) wujud sepanjang masa program dijalankan. Keterlihatan mereka juga ditakrifkan oleh pengubah suai akses."

"Betul. Saya ingat gambar ini."

"Bagus. Biar saya ingatkan anda tentang beberapa perkara penting."

"Semua pembolehubah yang diisytiharkan di dalam kaedah wujud (boleh dilihat) dari titik di mana ia diisytiharkan sehingga akhir kaedah (Contoh 1)."

"Jika pembolehubah diisytiharkan dalam blok kod, ia wujud sehingga akhir blok kod (Contoh 2)."

"Jika pembolehubah ialah parameter kaedah, ia wujud (boleh dilihat) dalam keseluruhan badan kaedah (Contoh 3)."

"Jika pembolehubah ialah pembolehubah contoh (Contoh 4), ia dipautkan kepada objek tertentu dan wujud selagi objek itu wujud. Jika tiada objek wujud, maka tiada kejadian pembolehubah itu. Anda boleh mengakses pembolehubah (iaitu pembolehubah boleh dilihat) daripada semua kaedah kelas, tidak kira sama ada ia diisytiharkan sebelum atau selepasnya. Pembolehubah baharu dicipta untuk setiap objek. Ia bebas daripada objek lain. Anda tidak boleh mengakses pembolehubah contoh daripada kaedah statik . "

"Jika pembolehubah diisytiharkan statik, iaitu ditandakan dengan kata kunci static , ia wujud selagi kelasnya wujud. JVM biasanya memuatkan kelas ke dalam memori pada penggunaan pertamanya. Itu juga apabila pembolehubah statik dimulakan."

"Contoh di atas mengisytiharkan kelas Cat, yang mempunyai empat pembolehubah: a, b, s (pembolehubah bukan statik) dan kiraan (pembolehubah statik). Jika kita mencipta beberapa objek kelas ini (katakan, tiga), setiap satu daripada mereka akan mengandungi contoh sendiri pembolehubah bukan statik kelas. Pembolehubah statik dikongsi oleh semua objek kelas. Dari segi teknikal, ia tidak berada di dalam objek ini, kerana ia wujud sebelum sebarang objek Cat dicipta."

"Inilah yang berlaku jika kami mengisytiharkan pembolehubah sstatik:"

"OK. Saya rasa saya faham."

"Bolehkah anda mengisytiharkan pembolehubah dengan nama yang sama?"

"Bukan di dalam kaedah. Semua pembolehubah yang diisytiharkan di dalam kaedah mesti mempunyai nama unik. Argumen kaedah juga dianggap pembolehubah setempat."

"Bagaimana dengan pembolehubah ahli?"

"Pembolehubah ahli juga mestilah unik untuk setiap kelas."

"Tetapi terdapat pengecualian: nama pembolehubah tempatan dan pembolehubah ahli boleh sama. "

"Jika kita menukar pembolehubah sedemikian, yang manakah antara dua pembolehubah yang dinamakan serupa akan ditukar?"

"Jika terdapat beberapa pembolehubah yang boleh dilihat (boleh diakses) dalam kod kami – katakan, pembolehubah contoh dan pembolehubah tempatan – pembolehubah tempatan akan diakses."

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

"Kod ini mengisytiharkan dua pembolehubah kiraan. Baris 3 mengisytiharkan pembolehubah kejadian , dan baris 8 – pembolehubah tempatan ."

"Inilah yang berlaku apabila kaedah larian dilaksanakan:"

"Dalam baris 7, kami mengakses pembolehubah contoh dan memberikan nilai 15 kepadanya"

"Dalam baris 8, kami mengisytiharkan (membuat) pembolehubah tempatan baharu : count. Ia menutup pembolehubah contoh. Pembolehubah tempatan ialah perkara yang akan dilihat oleh semua kod berikutnya dalam kaedah (akses)."

"Faham."

"Pembolehubah tempatan menutup pembolehubah instance. Dalam erti kata lain, pembolehubah tempatan ialah pembolehubah yang boleh diakses. Walau bagaimanapun, anda juga boleh mengakses pembolehubah instance. Ia hanya lebih rumit untuk berbuat demikian."

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

"Apa lagi yang boleh anda beritahu saya tentang kaedah statik dan pembolehubah statik?"

"Kaedah dan pembolehubah statik tidak dikaitkan dengan objek kelas; ia dikaitkan dengan kelas itu sendiri. Jika kita mencipta sepuluh objek Pembolehubah (lihat contoh pada permulaan tahap ini), kita akan mempunyai sepuluh pembolehubah instanceVariable (satu untuk setiap objek) dan hanya satu perkongsian (statik) pembolehubah TEKS ."

"Saya ada satu soalan."

"Apakah perbezaan antara kaedah statik dan bukan statik?"

"Mari kita lihat cara kaedah bukan statik berfungsi:"

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

"Apabila anda memanggil kaedah menggunakan <object> dot <method name> , anda sebenarnya memanggil kaedah kelas dan menghantar objek yang sama seperti hujah pertama. Di dalam kaedah, objek dipanggil 'ini' . Semua operasi dalam kaedah dilakukan pada objek ini dan datanya."

"Wah! Jadi begitulah semuanya berfungsi!"

"Dan inilah cara kaedah statik berfungsi."

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"Apabila anda memanggil kaedah statik, tiada objek dihantar kepadanya. Dalam erti kata lain, 'ini' sama dengan null . Itulah sebabnya kaedah statik tidak boleh mengakses pembolehubah dan kaedah bukan statik (kerana ia tidak mempunyai 'ini' untuk lulus kepada kaedah ini)."

"Hmmm. Saya rasa saya faham. Sekurang-kurangnya sedikit."

"Dan inilah Pakcik Diego... dan tugasnya."