匿名内部类：        为什么调用.num不对？

1.         abstract class AbsDemo
   
2.          {
   
3.                  abstract void show();
   
4.          }
   
5. 
   
6.         class Outer
   
7.          {
   
8.                  int x = 4;
   
9.                  public void function()
   
10.                  {
    
11.                          //new Inner().show();
    
12.                          new AbsDemo()//AbsDemo的子类对象
    
13.                          {     //这个大括号是类的，里面是成员变量/函数。                           
    
14.                                 int num = 9;
    
15.                                  void show()
    
16.                                  {
    
17.                                          System.out.println("num="+num);
    
18.                                  }
    
19.                                  void run()
    
20.                                  {
    
21.                                          System.out.println("run");
    
22.                                  }
    
23.                          }.num;       //.show();
    
24.                  }        //为什么调用.num不对？
    
25.          }
    
26. 
    
27.         class InnerClassNiMing
    
28.         {
    
29.                  public static void main(String[] args)
    
30.                 {
    
31.                          new Outer().function();
    
32.                  }
    
33.          }
    

复制代码

错误原因：.java:47: 不是语句
                            }.num;
                            ^

是与静态修饰有关吗？我现在有点儿乱。:'(:'(:'(

匿名内部类：没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。
匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

1. //1
   
2.                 new Object(){
   
3.                         void show(){
   
4.                                 System.out.println("show run");                               
   
5.                         }
   
6.                 }.show();
   
7.                 //2
   
8.                 Object obj = new Object(){
   
9.                         void show(){
   
10.                                 System.out.println("show run");
    
11.                         }
    
12.                 };
    
13.                 obj.show();

复制代码

1和2的写法正确吗？有区别吗？说出原因。
写法是正确，1和2都是在通过匿名内部类建立一个Object类的子类对象。
区别：
第一个可是编译通过，并运行。
第二个编译失败，因为匿名内部类是一个子类对象，当用Object的obj引用指向时，就被提升为了
Object类型，而编译时检查Object类中是否有show方法，所以编译失败。

1. new AbsDemo()//AbsDemo的子类对象
   
2. {
   
3.     int num = 9;
   
4.     void show()
   
5.     {
   
6.         System.out.println("num="+num);
   
7.     }
   
8.     void run()
   
9.     {
   
10.         System.out.println("run");
    
11.      }
    
12. }.num;
    

复制代码

匿名内部类相当于父类引用指向子类对象。
编译失败应该是父类中没有num变量

new AbsDemo()//AbsDemo的子类对象

                        {//这个大括号是类的，里面是成员变量/函数。                           
                                int num = 9;

                                void show()

                                {

                                        System.out.println("num="+num);

                                }

                                void run()

                                {

                                        System.out.println("run");

                                }

                        }.num;//你在这里，内部类调用成员变量是具体要做什么，是要设置其值：内部类对象.num = 12;还是要打印该值：system.out.println(内部类对象.num);需要具体指出来，否则编译失败，这是原因。
这句号就相当于  ：
class A{
    int num = 3;
}

class B{
    public static void main(String[] args){
            new A().num;//这句话是不对的。
            new A().num  = 10;//这句对，你需要指出你到底使用该变量要做什么。
   }
}

                new Object(){
                        void show(){
                                System.out.println("show run");                                
                        }
                }.show();/*匿名内部类是一个子类对象，当用Object的obj引用指向内部类时，就被提升为了
Object类型，而编译时检查Object类中是否有show方法，所以编译失败。Objiect类型访问子类方法需要强转*/