/*
匿名内部类：就是内部类的简写格式。
必须前提：内部类必须继承或者实现一个类或者接口。
匿名内部类其实就是一个匿名 子类对象。
格式：new 父类对象 or 接口(){
    子类内容；（覆盖父类的， 而且可以增加自己的方法）
}//相当于将 继承父类 和 new 的过程 写到了一起有某有！很方便有某有！
*/
class Outer{
        int num;
    public Outer(){
        num = 5;   
    }
     
    class Inner{
        int num;
        public Inner(){
            num = 10;
        }
        public void show(){//也就是调用该方法会有两个this指针入栈，why？很简单，因为内部类要访问外部类的数据啊！
           int num = 11;
           System.out.println("Inner part num " + num);//打印内部类中方法中的局部num变量
           System.out.println("Inner  num " + this.num);//打印内部类中num成员变量
           //System.out.println("Inner  num " + Inner.this.num);//打印内部类中num成员变量
           System.out.println("Outer  num " + Outer.this.num);//打印外部类中num成员变量
        }
    }
     
    public  void methods(){
        final int num = 55;//这个变量为什么一定要用final修饰呢？
        //因为如果不用final修饰，num就是一个局部变量，当这个函数结束之后就会消失！
        //而我们是在局部内部类的中访问这个num，这个类产生的对象是在堆上的，函数结束
        //对象也不会消失，那么这个对象在以后可能会多次访问这个num变量，这样就出错了!
        //如果是final， num 就是 55这一个值，不会变！
        class InnerTwo{
            void show(){
                System.out.println("part Inner final num = " + num);
            }
        }
         
        InnerTwo in = new  InnerTwo();
        in.show();
    }
     
    public void way(){
         System.out.println("******************************************");
         //普通内部类：
         new Inner().show();//匿名对象
         new Inner(){ // 匿名内部类
             public void show(){
                System.out.println("内部类的匿名类！");
             }
         }.show();
         //静态内部类：
         new InnerOne().way();
         new InnerOne(){
            public void way(){
                System.out.println("静态内部类的匿名类!");
            }
         }.way();
         //外部类：
         new Outer().show();
         new Outer(){
             public void show(){
                System.out.println("外部类的匿名类!");
            }
         }.show();
    }
     
    static class InnerOne{
         public static int num = 100;
          
         public void way(){
            System.out.println("静态内部类中的方法！");
         }
          
         public static void show(){
             System.out.println("static InnerOne num " + num);
         } 
    }
     
    public void show(){
           System.out.println("Outer num " + num);
    }
}
 
public class PC{
    public static void main(String[] args){
         Outer out = new  Outer();
         out.show();
         Outer.Inner in = out.new Inner();
         in.show();
 
        // out.InnerOne.show();//类的所属是类， 类是加载到方法区的，当然对象实例中不存在类；
         Outer.InnerOne.show();
 
         //匿名类和匿名对象的测试：
         out.way();     
    }
}