Apakah perbezaan antara penutupan java dan JavaScript

Perbezaannya ialah: 1. Penutupan JavaScript sebenarnya adalah fungsi yang ditakrifkan di dalam fungsi (kerana ia adalah fungsi anak, ia boleh membaca pembolehubah dalaman fungsi induk); kaedah disimpan sebagai pembolehubah Kaedah ini mempunyai keupayaan untuk mengakses pembolehubah bebas kelas.

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi JavaScript 1.8.5, komputer Dell G3.

1. Penutupan dalam Javascript:

1. Skop pembolehubah

Diperlukan Untuk memahami penutupan, anda mesti terlebih dahulu memahami skop pembolehubah khas Javascript.

Hanya terdapat dua skop pembolehubah: pembolehubah global dan pembolehubah tempatan.

Keistimewaan bahasa Javascript ialah pembolehubah global boleh dibaca terus di dalam fungsi

　var n=999;
　function f1(){
　　 alert(n);
　}
  f1(); // 999

Sebaliknya, pembolehubah tempatan dalam fungsi tidak boleh dibaca di luar fungsi.

　function f1(){
　 　var n=999;
　}
  alert(n); // error

Terdapat satu perkara yang perlu diperhatikan di sini Apabila mengisytiharkan pembolehubah di dalam fungsi, anda mesti menggunakan arahan var. Jika anda tidak menggunakannya, anda sebenarnya mengisytiharkan pembolehubah global!

　function f1(){
　　 n=999;
　}
  f1();
  alert(n); // 999

2. Cara membaca pembolehubah tempatan dari luar

Atas pelbagai sebab, kadangkala kita perlu mendapatkan pembolehubah tempatan dalam fungsi. Walau bagaimanapun, seperti yang dinyatakan sebelum ini, ini tidak boleh dilakukan dalam keadaan biasa dan hanya boleh dicapai melalui penyelesaian.

Iaitu untuk menentukan fungsi di dalam fungsi.

  function f1(){
　　  n=999;
　　  function f2(){
　　　　  alert(n); // 999
　　  }
　}

Memandangkan f2 boleh membaca pembolehubah tempatan dalam f1, maka selagi f2 digunakan sebagai nilai pulangan, tidakkah kita boleh membaca pembolehubah dalamannya di luar f1!

  function f1(){
　　  n=999;
　　  function f2(){
　　　　  alert(n);
　　　}
　　　return f2;
　}
　var result=f1();
　result(); // 999

3 Konsep penutupan

Fungsi f2 di atas ialah penutupan. Penutupan sebenarnya adalah fungsi yang ditakrifkan di dalam fungsi (kerana ia adalah fungsi anak, ia boleh membaca pembolehubah dalaman fungsi induk).

Pada dasarnya, penutupan ialah jambatan yang menghubungkan bahagian dalam fungsi dengan bahagian luar fungsi.

4. Tujuan penutupan

1. Anda boleh membaca pembolehubah di dalam fungsi

2. Biarkan pembolehubah ini (dirujuk oleh penutupan Nilai pembolehubah) sentiasa disimpan dalam ingatan.

  function f1(){
　　　　var n=999;
　　　　nAdd=function(){n+=1}
　　　　function f2(){
　　　　　　alert(n);
　　　　}
　　　　return f2;
　}
　var result=f1();
　result(); // 999
　nAdd();
　result(); // 1000

Dalam kod ini, hasil sebenarnya ialah fungsi penutupan f2. Ia dijalankan dua kali, kali pertama nilainya ialah 999, kali kedua nilainya ialah 1000. Ini membuktikan bahawa pembolehubah tempatan n dalam fungsi f1 sentiasa disimpan dalam ingatan dan tidak dikosongkan secara automatik selepas f1 dipanggil.

Mengapa ini berlaku? Sebabnya ialah f1 ialah fungsi induk bagi f2, dan f2 diberikan kepada pembolehubah global, yang menyebabkan f2 sentiasa berada dalam ingatan, dan kewujudan f2 bergantung kepada f1, jadi f1 sentiasa dalam ingatan dan tidak akan dipadamkan. selepas panggilan selesai , dikitar semula oleh mekanisme pengumpulan sampah (kutipan sampah).

Satu lagi perkara yang perlu diberi perhatian dalam kod ini ialah baris "nAdd=function(){n =1}". Pertama sekali, kata kunci var tidak digunakan sebelum nAdd, jadi nAdd ialah pembolehubah global daripada pembolehubah tempatan. Kedua, nilai nAdd ialah fungsi tanpa nama, dan fungsi tanpa nama ini sendiri juga merupakan penutup, jadi nAdd adalah bersamaan dengan penetap, yang boleh beroperasi pada pembolehubah tempatan di dalam fungsi di luar fungsi.

5 Perkara yang perlu diberi perhatian apabila menggunakan penutupan

1. Memandangkan penutupan akan menyebabkan pembolehubah dalam fungsi disimpan dalam ingatan, penggunaan memori adalah sangat besar, jadi Jangan menyalahgunakan penutupan

2. Penutupan akan mengubah nilai pembolehubah di dalam fungsi induk di luar fungsi induk.

6. Senario aplikasi penutupan

1. Lindungi pembolehubah dalam fungsi. Mengambil contoh awal sebagai contoh, i dalam fungsi a hanya boleh diakses oleh fungsi b dan tidak boleh diakses melalui cara lain, sekali gus melindungi keselamatan i.

2. Kekalkan pembolehubah dalam ingatan. Masih seperti dalam contoh sebelumnya, disebabkan penutupan, i dalam fungsi a sentiasa wujud dalam ingatan, jadi setiap kali c() dilaksanakan, i akan dinaikkan sebanyak 1.

2 Penutupan dalam Java

1. Definisi penutupan dalam java

Definisi: Penutupan boleh menyimpan kaedah sebagai pembolehubah Kaedah ini mempunyai keupayaan untuk mengakses pembolehubah bebas kelas.

Bahasa Java sendiri tidak menyokong penutupan secara rasmi, tetapi ia membenarkan simulasi penutupan (antara muka kelas dalam). Penutupan boleh dilaksanakan menggunakan kelas dalaman tanpa nama.

Bagaimana untuk membenarkan objek biasa ini mengakses pembolehubah bebas kelasnya? Kelas dalaman. Kelas dalam boleh mengakses semua sifat dan kaedah kelas luar.

Menyembunyikan pelaksanaan khusus ialah salah satu fungsi kelas dalaman Bagaimana untuk memastikan pelaksanaan khusus disembunyikan sambil juga meneruskan penutupan kepada penggunaan luaran? Biarkan kelas dalam melaksanakan antara muka biasa, dan kemudian naikkan objek kelas dalam kepada jenis antara muka.

2. Pelaksanaan kod mudah:

  	public final static String name = "纯牛奶";// 名称


		private static int num = 16;// 数量


		public Milk() {
			System.out.println(name + "：16/每箱");
		}


		/**
		 * 闭包
		 * 
		 * @return 返回一个喝牛奶的动作
		 */
		public Active HaveMeals() {
			return new Active() {
				public void drink() {
					if (num == 0) {
						System.out.println("木有了，都被你丫喝完了.");
						return;
					}
					num--;
					System.out.println("喝掉一瓶牛奶");
				}
			};
		}


		/**
		 * 获取剩余数量
		 */
		public void currentNum() {
			System.out.println(name + "剩余：" + num);
		}
	}


	/**
	 * 通用接口
	 */
	interface Active {
		void drink();
	}  
	
	//闭包的使用
	public class Person {   
		public static void main(String[] args) {  
			//买一箱牛奶  
			Milk m = new Milk(); 
			Active haveMeals = m.HaveMeals();
			//没事喝一瓶  
			haveMeals.drink();  
			//有事喝一瓶  
			haveMeals.drink(); 
			//看看还剩多少？  
			m.currentNum();  
		}   
	}

Ringkasan:

1. Tidak banyak digunakan dalam projek sebenar , jadi saya tidak boleh mengulas tentang kualitinya.

2. Adalah disyorkan untuk menggunakan penutupan secara munasabah, tidak menggunakannya sepenuhnya, dan tidak menyalahgunakannya.

3. Perhatian khusus: penutupan akan menyebabkan sumber tidak dikitar semula Seperti dalam contoh di atas, menetapkan m kepada null dalam kaedah utama, menggunakan haveMeals untuk terus memanggil kaedah minuman masih akan minum sebotol susu. , menunjukkan bahawa objek Susu belum dilepaskan.

[Pembelajaran yang disyorkan: Tutorial JavaScript Lanjutan]

Atas ialah kandungan terperinci Apakah perbezaan antara penutupan java dan JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!