Summary of inner classes in Java

Internal classes are not easy to understand, but to put it bluntly, one class actually contains another class

Just like a person is composed of brain, limbs, organs and other body parts, and internal classes are quite One of the organs, such as the heart: it also has its own attributes and behaviors (blood, beating)

Obviously, a heart cannot be represented unilaterally by attributes or methods here, but a class is required

And the heart is in the human body, just like the internal class is inside the outside

Example 1: The basic structure of the internal class

//外部类   
 class Out {   
     private int age = 12;   

     //内部类   
     class In {   
         public void print() {   
             System.out.println(age);   
         }   
     }   
 }   

 public class Demo {   
     public static void main(String[] args) {   
         Out.In in = new Out().new In();   
         in.print();   
         //或者采用下种方式访问   
         /*   
         Out out = new Out();   
         Out.In in = out.new In();   
         in.print();   
         */   
     }   
 }

Running result: 12

It is not difficult to see from the above example that inner classes actually seriously damage good code structure, but why should we still use inner classes?

Because the inner class can freely use the member variables of the outer class (including private) without generating objects of the outer class, this is the only advantage of the inner class

Just like the heart can directly access the blood of the body , instead of drawing blood through a doctor

After the program is compiled, two .class files will be generated, namely Out.class and Out$In.class

where $ represents Out in the above program The one in .In.

Out.In in = new Out().new In() can be used to generate objects of inner classes. There are two small knowledge points that need to be paid attention to in this method

1. The Out at the beginning is to indicate which external class the internal class object needs to be generated.

2. There must be an object of the external class before the object of the internal class can be generated, because the function of the internal class is to Access member variables in external classes

Example 2: Variable access form in internal classes

class Out {   
     private int age = 12;   

     class In {   
         private int age = 13;   
         public void print() {   
             int age = 14;   
             System.out.println("局部变量：" + age);   
             System.out.println("内部类变量：" + this.age);   
             System.out.println("外部类变量：" + Out.this.age);   
         }   
     }   
 }   

 public class Demo {   
     public static void main(String[] args) {   
         Out.In in = new Out().new In();   
         in.print();   
     }   
 }

Running results:

Local variables :14
Internal class variables: 13
External class variables: 12

It can be found from instance 1 that the inner class does not have member variables and local variables with the same name In this case, the inner class will directly access the member variables of the outer class without specifying the Out.this. attribute name

Otherwise, the local variables in the inner class will overwrite the member variables of the outer class

To access the member variables of the inner class itself, you can use this. attribute name, and to access the member variables of the external class, you need to use the Out.this. attribute name

Example 3: Static inner class

class Out {   
     private static int age = 12;   

     static class In {   
         public void print() {   
             System.out.println(age);   
         }   
     }   
 }   

 public class Demo {   
     public static void main(String[] args) {   
         Out.In in = new Out.In();   
         in.print();   
     }   
 }

Running results :12

You can see that if you use static to make the inner class static, then the inner class can only access the static member variables of the outer class, which has limitations

Secondly, because the inner class is Static, so Out.In can be viewed as a whole, and you can directly new the object of the inner class (access static through the class name, it does not matter whether the outer class object is generated or not)

Example 4: Private inner class

class Out {   
     private int age = 12;   

     private class In {   
         public void print() {   
             System.out.println(age);   
         }   
     }   
     public void outPrint() {   
         new In().print();   
     }   
 }   

 public class Demo {   
     public static void main(String[] args) {   
         //此方法无效   
         /*   
         Out.In in = new Out().new In();   
         in.print();   
         */   
         Out out = new Out();   
         out.outPrint();   
     }   
 }

Running result: 12

If an inner class only wants to be operated by methods in the outer class, then you can use private to declare the inner class

In the above code, we must In the Out class, an object of the In class is generated for operation, and Out.In in = new Out().new In() can no longer be used to generate an object of the inner class

In other words, the inner class at this time Only external classes can control

Like, my heart can only be controlled by my body, others cannot directly access it

Example 5: Method inner class

class Out {   
     private int age = 12;   

     public void Print(final int x) {   
         class In {   
             public void inPrint() {   
                 System.out.println(x);   
                 System.out.println(age);   
             }   
         }   
         new In().inPrint();   
     }   
 }   

 public class Demo {   
     public static void main(String[] args) {   
         Out out = new Out();   
         out.Print(3);   
     }   
 }

Running result:

3
12

In the above code, we moved the inner class to the method of the outer class, and then regenerated it in the method of the outer class An inner class object calls the inner class method

If we need to pass parameters into the method of the external class at this time, then the method parameters of the external class must be defined using final

As for final, There is no special meaning here, it is just a form of expression

The above is a summary of internal classes in Java. For more related content, please pay attention to the PHP Chinese website (www. php.cn)!