成员内部类，局部内部类，匿名内部类和静态内部类；求详细说下这几个内的原理

内部类：

        1.在一个类的内部可以定义：
                1).成员变量
                2).成员方法；
                3).构造方法
                4).代码块；
                5).类
怎样实例化内部类：
                1).需要一个外部类的对象；
                2).实例化内部类对象；
成员内部类：class A
{
        int num = 10;
        class B
        {
                int num = 20;
                public void show(){
                        int num = 30;
                        System.out.println("num = " + num);//30
                        System.out.println("this.num = " + this.num);
                //        System.out.println(this.this.num);//编译错误
                //        System.out.println(A.num);//编译错误。访问静态的格式
                        System.out.println("A 的num = " + new A().num);//OK
                        System.out.println("A 的num = " + A.this.num);//OK
                }
        }
}
class Demo
{
        public static void main(String[] args)
        {
                new A().new B().show();
        }
}

局部内部类：

        1.定义在某个方法内，或其它局部代码中的类
        2.只有当局部代码获得执行时，才会加载这个局部内部类；
        3.可以在执行这个方法时，获取这个内部类对象的引用，需要这个内部类实现一个外部的接口或继承一个外部的类；
        注意：
        4.局部内部类，可以访问局部变量，但局部变量必须是常量：final


*/
interface IA
{
        void fun();
}

class A
{
       
//        public B show(){//不能返回B类型

        public IA show(){

                final int num = 10;

                class B implements IA
                {
                        public void fun(){
                                System.out.println("B--fun num = " + num);
                        }
                }
                return new B();
               
               
        }
}
class Demo
{
        public static void main(String[] args)
        {
                A a = new A();
               
                IA ia = a.show();//

                ia.fun();

        }
}
匿名内部类：
interface IA
{
        void fun();
}
class A
{
        public IA show(){
                //定义了一个有名字的内部类；
        /*        class B implements IA
                {
                        public void fun(){
                                System.out.println("B-->fun()");
                        }
                }
                IA a = new B();
                return a;
        */
                //************使用匿名的内部类***************//
                //既然内部类的名字，对外部来说没有什么用，可以使用匿名的
                IA a = new IA(){//IA a = new B();//定义一个IA的子类，并且实例化了
                        //内部，必须实现IA接口中的抽象方法
                        public void fun(){
                                System.out.println("B-->fun()");
                        }
                };
                return a;
       
                //写法的格式：new 接口/抽象类(){//重写方法};
        /*        return new IA(){
                        //内部，必须实现IA接口中的抽象方法
                        public void fun(){
                                System.out.println("B-->fun()");
                        }
                };
                */
        }
}
class Demo
{
        public static void main(String[] args)
        {
                A a = new A();
                IA obj = a.show();
                obj.fun();//调用匿名内部类的方法；
        }
}