Member inner class

public class Inner {

    	public class Heart{ //Member inner class

		}

}

The Inner class is an external class

Internal classes can access the properties and methods of external classes unconditionally, but if external classes want to access the properties and methods of internal classes, they must first create the objects of internal classes, through which they can access the properties and methods of internal classes

public class Inner {//This is an external class
	public int OutNum1 =1;
	protected int OutNum2 =2;	
	int OutNum3 =3;
	private int OutNum4 =4;
	
	public Inner() {
		
		Heart heart=new Heart();//To access an internal class, first create an object
		System.out.println("Inner class InNum1 yes"+heart.InNum1);
		System.out.println("Inner class InNum2 yes"+heart.InNum2);
		System.out.println("Inner class InNum3 yes"+heart.InNum3);
		System.out.println("Inner class InNum4 yes"+heart.InNum4);
		heart.name();
		
	}
	
	public class Heart{ //Member inner class
		
		public int InNum1 =1;
		protected int InNum2 =2;	
		int InNum3 =3;
		private int InNum4 =4;	
				
		public void name() {
			System.out.println("It's an internal approach.");
			System.out.println("External class OutNum1 yes"+OutNum1);//Direct access to properties and methods of external classes
			System.out.println("External class OutNum1 yes"+OutNum2);
			System.out.println("External class OutNum1 yes"+OutNum3);
			System.out.println("External class OutNum1 yes"+OutNum4);
			
		}
	}

    public static void main(String[] args) {
    	
    	Inner inner=new Inner();
    }
}

The output results are as follows:

There are two ways to call internal classes:

    public static void main(String[] args) {
    	
    	Inner inner=new Inner();//Indirectly calling methods of inner classes
    	inner.name();
    	
    	Inner.Heart heart=new Inner().new Heart();//Calling methods of inner classes directly
    	heart.name();
    }

Static inner class

The static members of a class exist independently of any object of the class. Creating a static internal class object of a class does not need to depend on its external class object.

public class Inner {
	public int OutNum1 =1;
	protected int OutNum2 =2;	
	int OutNum3 =3;
	private int OutNum4 =4;
	
	public Inner() {
		
		Heart heart=new Heart();
		System.out.println("Inner class InNum1 yes"+heart.InNum1);
		System.out.println("Inner class InNum2 yes"+heart.InNum2);
		System.out.println("Inner class InNum3 yes"+heart.InNum3);
		System.out.println("Inner class InNum4 yes"+heart.InNum4);
		heart.name();
		
		StaticHeart staticHeart=new StaticHeart();
		System.out.println("Static inner class StaticNum1 yes"+staticHeart.StaticNum1);
		System.out.println("Static class StaticNum2 yes"+staticHeart.StaticNum2);
		System.out.println("Static class StaticNum3 yes"+staticHeart.StaticNum3);
		System.out.println("Static class StaticNum4 yes"+staticHeart.StaticNum4);
		heart.name();
		
	}

	static class StaticHeart{ //Static member inner class
		
		public int StaticNum1 =1;
		protected int StaticNum2 =2;	
		int StaticNum3 =3;
		private int StaticNum4 =4;	
		static int StaticNum5=5;//static property can be defined
				
		public void name() {
			System.out.println("This is a static inner class");
			//System.out.println("the external class OutNum1 is" + OutNum1);

			
		}
	}

}

Static internal classes cannot access the non static members of external classes. External non static members belong to each external class pair, but static internal classes exist independently of external class objects. Therefore, static internal classes cannot access the non static members of external classes, but external classes can access all members of access permissions of static internal classes.

Anonymous Inner Class

If the implementation class of the interface or the subclass of the parent class only needs to be used once, the definition of the class can be omitted and the anonymous inner class can be used instead.

Define an interface and its implementation class:

public interface MyIterface {
	
		public abstract void mewthod();
		
}

public class MyImpl implements MyIterface {

	@Override	
	public void mewthod() {
		// Method stubs generated automatically by TODO
		System.out.println("Implementation class override overrides methods");
		System.out.println("=================");
	}
	
}

Common writing:

	public static void main(String[] args) {
		MyImpl myImpl=new MyImpl();
		myImpl.mewthod();
		
		MyIterface myIterface=new MyImpl();//Use of upward transformation
		myIterface.mewthod();

		}

How to write anonymous inner class:

		//Anonymous Inner Class 
		MyIterface obj=new MyIterface() {
			
			@Override
			public void mewthod() {
				// Method stubs generated automatically by TODO
				System.out.println("Anonymous inner class implements methods A");
			}
		};
		obj.mewthod();
		
		//Anonymous inner class is used and the object name is also anonymous.
		new MyIterface() {
			
			@Override
			public void mewthod() {
				// Method stubs generated automatically by TODO
				System.out.println("Anonymous inner class implements methods B");
			}
		}.mewthod();