Detailed explanation of closures and callbacks between Java inner classes

Preface

A closure is a callable object that records some information from the scope in which it was created. Through this definition, it can be seen that the inner class is an object-oriented closure, because it not only contains information about the outer class object (the scope where the inner class is created), but also automatically has a reference to the outer class object, within this scope. , the inner class has the right to operate all members, including private members.

One of the most controversial issues in Java is the belief that Java should include some kind of pointer-like mechanism to allow callbacks. Through callbacks, an object can carry information that allows it to call the original object at a later time. If the callback is implemented through a pointer, then one can only hope that the programmer will not misuse the pointer.

1. Member inner class

You can think of an inner class as a member. A member inner class can unconditionally access all member properties and member methods of the outer class.

class OutterClass {//外部类
 private int in = 0;
 static int inn=4;
 public OutterClass(int in) {
   this.in = in;
 }
 class InnerClass {   //内部类
   public void output() {
     System.out.println(in);
     System.out.println(inn);
   }
 }
}

When a member inner class has a member variable or method with the same name as the outer class, by default the member of the member inner class is accessed. If you want to access a member of the external class with the same name, you need to access it in the following form:

OutterClass(外部类).this.成员

When an external class accesses an internal class, you must first create an object of the member internal class, and then point to this Object reference to access.

class OutterClass {
 private int in = 0;
 static int inn=4;
 public OutterClass(int in) {
   InnerClass inner=new InnerClass();
   this.in=inner.innerNum;
 }
 class InnerClass {  //内部类
   public int innerNum=1;
   public void output() {
     System.out.println(in);
     System.out.println(inn);
     int a=OutterClass.this.inn;
   }
 }
}

Member inner classes exist dependent on external classes. That is to say, if you want to create an object of member inner class, the premise is that there must be an object of external class. The general way to create member inner class objects is as follows:

public class classa {
 public static void main(){
   OutterClass oc=new OutterClass(3);
   OutterClass.InnerClass in=oc.new InnerClass();
 }
}

2. Local inner class

A local inner class is like a local variable in a method , cannot have public, protected, private and static modifiers.

class OutterClass {
 public OutterClass(int in) {
   class InnerClass {  //局部内部类
      int innerNum=1;
   }
 }
}

3. Nested inner classes

Nested inner classes are inner classes modified as static. An inner class declared as static does not require a connection between the inner class object and the outer class object, which means that we can directly reference outer.inner, that is, there is no need to create an outer class or an inner class.

class OutterClass {
 public OutterClass(int in) {   
 }
 static class InnerClass {  //局部内部类
   int innerNum=1;
 }
}
public class classa {
 public static void main(){
   OutterClass.InnerClass in=new OutterClass.InnerClass();
 }
}

4. Anonymous inner classes

Anonymous inner classes are what we use the most, because we don’t want to give them a name, so we have anonymous . Anonymous inner classes need to be defined in advance.

btnSan.setOnClickListener(newOnClickListener() {
  @Override
  publicvoidonClick(View v) {
  }
});

5. Closures and callbacks

A closure (Closure) is an object that can be called. It saves the scope in which it was created. Information. JAVA does not explicitly support closures, but in JAVA, closures can be implemented through "interface + internal class".

For example: an interface programmer and a base class writer both have the same method work and the same method name, but their meanings are completely different. In this case, closures are needed.

class Writer {//作家基类
 void work(){};
}
interface programmer{//程序员接口
 void work();
}

The closure implementation code is as follows:

public class WriterProgrammer extends Writer {
 @Override
 public void work(){
   //写作
 }
 public void code(){
   //写代码
 }
 class ProgrammerInner implements programmer{
   @Override
   public void work(){
     code();
   }
 }
}

An inner class that follows the programmer interface rules is defined in the subclass, and then uses the inner class The class implements the programmer's work() method callback code() method, and directly implements the parent class writer's work() method in the subclass.

6. The role of inner classes

Inner classes can be well hidden.

General non-internal classes are not allowed to have private and protected permissions, but internal classes can

Internal classes have access permissions to all elements of the peripheral class

But implementing multiple inheritance

can avoid modifying the interface and call two methods with the same name in the same class.

7. Summary

The above is the entire content of this article. I hope it will be helpful to everyone in learning or using Java. If you have any questions, you can leave a message to communicate.

For more detailed explanations of closures and callbacks between Java internal classes, please pay attention to the PHP Chinese website!