Java development inner class usage

In Java development, Java developers recommend using inner classes as little as possible, instead of pulling them out of the same class they are in and generating a separate class.
Direct to code:

package com.b510;

 
 public class InnerClassTest {

     public static void main(String[] args) {
         //This is an instance of InnerClassTest
         InnerClassTest innerClassTest = new InnerClassTest();
         innerClassTest.sayHelloworld();

         //This is an instance of class A
         InnerClassTest.A ia = innerClassTest.new A();
         ia.aSayHello();

         //This is an instance of InnerClassB
         InnerClassTest.A.InnerClassB iab = ia.new InnerClassB();
         iab.bSayHello();

         //This is an instance of InnerClassC
         InnerClassTest.A.InnerClassB.InnerClassC iabc = iab.new InnerClassC();
         iabc.cSayHello();

         //This is an instance of InnerClassD
         InnerClassTest.A.InnerClassD iad = ia.new InnerClassD();
         iad.dSayHello();

         //This is an instance of InnerClassE
         InnerClassTest.A.InnerClassB.InnerClassC.InnerClassE iabce = iabc.new InnerClassE();
         iabce.eSayHello();

         //And of course when we call InnerClassE, we can also write it like this
         InnerClassTest.A.InnerClassB.InnerClassC.InnerClassE e = new InnerClassTest().new A().new InnerClassB().new InnerClassC().new InnerClassE();
         System.out.println("====================== The separator ====");
         e.eSayHello();
     }

     //Method in the class InnerClassTest
     public void sayHelloworld() {
         System.out.println("i am Test,HelloWorld!");
     }

     
     class A {
         //Method in class A
         public void aSayHello() {
             System.out.println("i am A,helloworld!");
         }

         
         class InnerClassB extends A {
             //Method in class InnerClassB
             public void bSayHello() {
                 System.out.println("i am B,helloworld");
             }

             
             class InnerClassC {
                 //Method in the class InnerClassC
                 public void cSayHello() {
                     System.out.println("i am C,helloworld!");
                 }

                 
                 class InnerClassE {
                     //Method in the class InnerClassE
                     public void eSayHello() {
                         System.out.println("i am E,Helloworld!");
                     }
                 }
             }
         }

         
         class InnerClassD {
             //Method in the class InnerClassD
             public void dSayHello() {
                 System.out.println("i am D,Helloworld!");
             }
         }
     }
 }

Operation effect:

i am Test,HelloWorld!
 i am A,helloworld!
 i am B,helloworld
 i am C,helloworld!
 i am D,Helloworld!
 i am E,Helloworld!
 ====================== The separator ====
 i am E,Helloworld!