A detailed summary of inner classes in Java

Inner classes are not easy to understand, but they are simply a class that contains another class

Just as a person is made up of physical results such as brain, limbs, and organs, the inner class corresponds to one of these organs, such as the heart: it also has its own properties and behaviors (blood, beats).

Obviously, you can't represent a heart unilaterally with attributes or methods here, you need a class

And the heart is in the body, just as the inner class is in the outer

Example 1: the basic structure of an inner class

//Outside class
class Out { 
    private int age = 12; 

    //The inner class
    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(); 
        //Or access it the following way
        
    } 
}

Results: 12

As you can see from the above example, inner classes are a terrible way to break good code structure, but why use inner classes at all?

Because inner classes are free to use the member variables of outer classes (including private ones) without having to generate objects of outer classes, this is the only advantage of inner classes

Like the heart, it can access the body's blood directly, rather than having it drawn by a doctor

The program compiles to produce two.class files, out.class and Out$in.class

The $represents the one In out.in In the program above.

Out.In = new Out(). New In() can be used to generate objects for inner classes, and there are two small things to note about this method

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

2. You must have an object of an external class before you can generate an object of an internal class, because the purpose of an internal class is to access member variables in an external class

Example 2: variable access form in inner class

class Out { 
    private int age = 12; 

    class In { 
        private int age = 13; 
        public void print() { 
            int age = 14; 
            System.out.println(" Local variables: " + age); 
            System.out.println(" Inner class variables: " + this.age); 
            System.out.println(" External class variables: " + Out.this.age); 
        } 
    } 
} 

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

Operation results:

Local variable: 14
Inner class variable: 13
External class variable: 12

As you can see from example 1, when an inner class has no member variables and local variables of the same name, the inner class accesses the member variables of the outer class directly without specifying the out.this.attribute name

Otherwise, local variables in the inner class override member variables in the outer class

The name of this. Property can be used to access the member variables of the inner class itself, and the name of this. Property can be used to access the member variables of the outer class

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

Results: 12

As you can see, if the internal static is static with static, then the internal class can only access the static member variables of the external class, which has limitations

Secondly, since the inner class is static, out.in can be viewed as a whole, and the object of the inner class can be directly new (it doesn't matter whether the outer class object is generated or not if it is accessed through the class name).

Instance 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) { 
        //This method is invalid
        
        Out out = new Out(); 
        out.outPrint(); 
    } 
} 

Results: 12

If an inner class only wants to be manipulated by methods in an outer class, you can declare an inner class using private

In the above code, we have to generate the object of the In class In the Out class to operate on, and we can no longer use out.in In = new Out().new In() to generate the object of the inner class

That is, the inner class is controlled only by the outer class

Like, my heart is controlled only by my body, and no one else has direct access to 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); 
    } 
} 

Operation results:
3
12

In the above code, we moved the inner class to the methods of the outer class, and then regenerated an inner class object from the methods of the outer class to call the inner class methods

If at this point we need to pass arguments into the methods of the external class, then the method parameters of the external class must use the final definition

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