Inner class （ The relationship between the heart and the body ）

Definition ： stay Java in , You can define a class in another class or a method , Such a class is called an inner class . With the corresponding , Classes that contain inner classes are called outer classes .
characteristic ：
1 Internal classes can directly access members of external classes
2 The outer class accesses the inner class , Objects of inner classes must be created
classification ： Member inner class 、 Method inner class 、 Anonymous inner class

Access rules ：

• Internal classes can directly access members of external classes
• If an external class wants to access an internal class , Only objects of internal classes can be created to access
• external $ Inner class ;

Member inner class （ Common internal class ）

class Outer
{
    

	class Inner // Inner class .
	{
    
		void show()
		{
    
			System.out.println("inner is show");
		}
	}
	static class Inner2 // Equivalent to an external class 
	{
    
		void show2()
		{
    
			System.out.println("inner2 is show2");
		}
		static void show3()
		{
    
			System.out.println("inner2 is show3");
		}
	}
	// error ： If a static member is defined in an inner class , Then the inner class is also static 
	class Inner3 
	{
    
		static void show4()
		{
    
			System.out.println("inner2 is show4");
		}
	}
	public void method()
	{
    
		Inner in = new Inner();
		in.show();
	}
}

class InnerClassDemo
{
    
	public static void main(String[] args)
	{
    
		Outer o = new Outer();
		o.method();
//============== The static , Non private internal class access =============
		// External programs access internal classes 
		Outer.Inner in = new Outer().new Inner();
		in.show();
//============== static state , Non private internal class access ===============
	   Outer.Inner2 in2 = new Outer.Inner2();
		in2.show2();// Access non static methods 
		
		Outer.Inner2.show3();// Access static methods 
	}
}

Interview questions （ polymorphic ）

problem ： Why can internal classes directly access members of external classes ？
Because the inner class holds the reference of the outer class
External class name .this

class Outer
{
    
	int num = 2;
	class Inner
	{
    
		int num = 3;
		void show()
		{
    
			int num = 4;
			System.out.println("num="+num);
			System.out.println("num="+Inner.this.num);
			System.out.println("num="+Outer.this.num);
		}
	}
	public void method()
	{
    
		// Anonymous object 
		new Inner().show();
	}
}

Local inner classes

Be careful ： Local inner classes , Can only be accessed by final Modified local variables

class Outer
{
    
	int num = 3;
	void method()
	{
    
	    // If we do not set up final:  If method After leaving the stack , But the object created by the local inner class points to the new object , Then this local variable cannot be accessed .
		final int x = 5;
		
		class Inner {
    
			void show()
			{
    
				System.out.println("x="+x);
				System.out.println ("num="+num);
			}
		}
		// Create inner class objects 
		Inner in = new Inner();
	    in.show ();
	}
	
}
class OuterDemo
{
    
	public static void main(String[] args)
	{
    
		Outer outer = new Outer ( );
		outer.method ( );
	}
}

Anonymous inner class ： Is the short form of the inner class

Anonymous inner class inherits abstract methods

/** *  Anonymous inner class ： Is the abbreviation of anonymous class  *  Premise ： *  The inner class must inherit or implement the interface of an outer class  *  Anonymous inner class ： In fact, it is an anonymous subclass object  * new  Parent class or Interface (){ Subclass content } */
abstract class Demo{
    
    abstract void show();
}
class Outer{
    
    /* The premise of having a name  int num = 4; class Inner extends Demo { void show(){ System.out.println ("show..."+num); } } public void method(){ new Inner ().show (); } */
    int num  =4;
    public void method()
    {
    
        // Anonymous inner class 
        new Demo ()
        {
    
            void show() {
    
                System.out.println ("show......."+num);
            }
        }.show ();
    }
}
public class InnerClassDemo {
    
    public static void main(String[] args) {
    
        System.out.println ("hello world");
    }
}

Anonymous inner classes implement interfaces

interface Inter
{
    
    void show1();
    void show2();
}
class Outer
{
    
    /*1 Normal writing  class Innner implements Inter { void show1() { } void show2() { } } public void method() { Innner in = new Innner () in.show1 (); in.show2 (); } */

   /* How to write anonymous inner class  public void method() { new Inter (){ void show1() { } void show2() { } }.show1 (); new Inter (){ void show1() { } void show2() { } }.show2(); } */
   /* One of the commonly used scenarios ： *  When the function parameter is an interface type , And the methods in the interface do not exceed 3 individual  *  You can pass anonymous inner classes as actual parameters  * */
   public void method() {
    
       Inter in = new Inter ( ) {
    
           void show1() {
    

           }

           void show2() {
    

           }
       };
       in.show1 ();
       in.show2 ();
   }

}
// The actual use 
public class InnerClassDemo1 {
    
    public static void main(String[] args) {
    
        show (new Inter ( ) {
    
            public void show1() {
    

            }
            public void show2() {
    

            }
        });
    }
    public static void show(Inter inter){
    
        inter.show2 ();
        inter.show1 ();
    }
}

Interview questions

public class InnerClassDemo1 {
    
    static class Inner
    {
    

    }
    public static void main(String[] args) {
    
        new Inner (); // The main function is static , Cannot access non static members .
    }
    
}

public class InnerClassDemo1 {
    
    public static void main(String[] args) {
    
        new Outer ().method ();
    }

}
// Compare the following 2 Anonymous inner class 
class Outer
{
    
    void method()
    {
    
        new Object (){
    
            public void show()
            {
    
                System.out.println ("show run");
            }
        }.show ();
    }
}
class Outer
{
    
    void method()
    {
    
        Object obj = new Object (){
    
            public void show()
            {
    
                System.out.println ("show run");
            }
        };
        obj.show ();// Because the subclass object of anonymous inner class is transformed upward into a parent class Object 了 
        // In this way, subclass specific methods cannot be used 
    }
}

summary

Member inner class ：

• For method access in non static inner classes ：Outer.Inner in = new Outer().new Inner()
• Access to non static methods in static inner classes ：Outer.Inner in = new Outer.Inner()
• Access to static methods in static inner classes ：Outer.Inner.method()
• Access to static methods in non static inner classes , non-existent , Because static methods are stored in the method area , Take precedence over class loading
• At the same time, understand why internal classes can point to external classes , Because there is an external class pointing .num,this.num,Outer.this,num

Local inner classes

• Understand that you need to use final Embellished , Because the inner class you create may point to other references . After method stack , The member variable does not exist , But the object still exists , Because the object exists in the heap , At this time, you need to access the member variable just now . Only set it to final Can only be , because final The decorated content will be stored in the runtime constant pool of the method area , It will not disappear with the exit of the stack .

Anonymous inner class

• Anonymous inner classes actually simplify the writing process of an inner class .
• Format ：new Interface or parent class (){ The content of the subclass }