What is the difference between java and JavaScript closures

The difference is: 1. The closure of javascript is actually a function defined inside a function (because it is a child function, it can read the internal variables of the parent function); 2. The closure of java can convert a The method is stored as a variable. This method has the ability to access free variables of the class.

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer.

1. Closure in Javascript:

1. The scope of the variable

Required To understand closures, you must first understand Javascript's special variable scope.

There are two types of scopes of variables: global variables and local variables.

The special thing about Javascript language is that global variables can be read directly inside the function

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

On the other hand, local variables within the function cannot be read outside the function.

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

There is one thing to note here. When declaring variables inside a function, you must use the var command. If you don't use it, you are actually declaring a global variable!

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

2. How to read local variables from the outside

For various reasons, we sometimes need to get local variables within a function. However, as mentioned before, this is not possible under normal circumstances and can only be achieved through workarounds.

That is to define another function inside the function.

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

Since f2 can read the local variables in f1, then as long as f2 is used as the return value, can't we read its internal variables outside f1!

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

3. The concept of closure

The f2 function above is a closure. A closure is actually a function defined inside a function (because it is a child function, it can read the internal variables of the parent function).

In essence, closure is a bridge connecting the inside of a function with the outside of the function.

4. Purpose of closure

1. You can read the variables inside the function.

2. Let these variables (referenced by the closure The value of a variable) is always kept in memory.

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

In this code, result is actually the closure f2 function. It was run twice, the first time the value was 999, the second time the value was 1000. This proves that the local variable n in function f1 is always stored in memory and is not automatically cleared after f1 is called.

Why is this so? The reason is that f1 is the parent function of f2, and f2 is assigned to a global variable, which causes f2 to always be in memory, and the existence of f2 depends on f1, so f1 is always in memory and will not be deleted after the call is completed. , recycled by the garbage collection mechanism (garbage collection).

Another thing worth noting in this code is the line "nAdd=function(){n =1}". First of all, the var keyword is not used before nAdd, so nAdd is a global variable. rather than local variables. Secondly, the value of nAdd is an anonymous function, and the anonymous function itself is also a closure, so nAdd is equivalent to a setter, which can operate on local variables inside the function outside the function.

5. Points of note when using closures

1. Since closure will cause the variables in the function to be stored in memory, the memory consumption is very large, so Don't abuse closures

2. Closures will change the values ​​of variables inside the parent function outside the parent function.

6. Application scenarios of closures

1. Protect variables within functions. Taking the initial example as an example, i in function a can only be accessed by function b and cannot be accessed through other means, thus protecting the security of i.

2. Maintain a variable in memory. Still as in the previous example, due to closure, i in function a always exists in memory, so every time c() is executed, i will be incremented by 1.

2. Closure in Java

1. The definition of closure in java

Definition: A closure can store a method as a variable. This method has the ability to access free variables of the class.

The Java language itself does not officially support closures, but it does allow simulation of closures (inner class interface). Closures can be implemented using anonymous inner classes.

How to enable this ordinary object to access the free variables of its class? Inner class. The inner class can access all properties and methods of the outer class.

Hiding the specific implementation is one of the functions of the inner class. How to ensure that the closure can be passed to external use while hiding the specific implementation? Let the inner class implement the common interface, and then upcast the inner class object to the interface type.

2. Simple code implementation:

  	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();  
		}   
	}

Summary:

1. Closures are not used much in actual projects , so I can’t comment on his quality.

2. It is recommended to use closures reasonably, not to use them completely, and not to abuse them.

3. Special attention: Closure will cause resources not to be recycled. As in the above example, set m to null in the main method, and use haveMeals to continue calling the drink method will still drink a bottle of milk, indicating that the Milk object has not been released.

[Recommended learning: javascript advanced tutorial]

The above is the detailed content of What is the difference between java and JavaScript closures. For more information, please follow other related articles on the PHP Chinese website!