1. abstract class AbsDemo
   
2. {
   
3.         abstract void show();
   
4. }
   
5. 
   
6. class Outer
   
7. {
   
8.         int x=3;
   
9. 
   
10.         public void function()
    
11.         {
    
12.                 AbsDemo d=new AbsDemo()
    
13.                 {
    
14.                         int x=5;
    
15.                         void show()
    
16.                         {
    
17.                                 System.out.println("x="+x);
    
18.                         }
    
19.                         void abc()
    
20.                         {
    
21.                                 System.out.println("heihei");
    
22.                         }
    
23.                 };
    
24.                 d.show();
    
25.                 d.abc();
    
26.         }
    
27. }
    
28. 
    
29. 
    
30. 
    
31. class InnerClassDemo4
    
32. {
    
33.         public static void main(String[] args)
    
34.         {
    
35.                 new Outer().function();
    
36.         }
    
37. }
    

复制代码

问题1：
这里面的匿名内部类中定义了x=5，而外部类中定义了x=3，为什么不会编译失败，因为记得之前好像说过内部类中不能引用局部变量啊，要引用的话必须用 final 修饰了才可以。

问题2：
这里最后那个 d.show();没问题，但是d.abc();编译失败，应该是父类中没有这种方法，可是我想问的是子类不是继承了父类中的方法吗，这建立的是子类的匿名方法啊，

又不是建立父类的，子类相当于新增的功能，子类有，为什么不行啊。

父类里面加个
abstract void abc();
因为d对象属于AbsDemo类型,调用d.abc()它会去AbsDemo类里面找这个方法,显然是找不到.
public class Demo2 {
  public static void main(String[] args) {
    A a = new B();
    B b = new B();
    a.a();
//    a.b();//The method b() is undefined for the type A
  }
}
abstract class A{
  abstract void a();
}
class B extends A{
  void a(){
    System.out.println("B");
  }
  void b(){
    System.out.println("b");
  }
}

首先恭喜你，你很有主见，这是一个爷们应该有的素质，但是很遗憾的告诉你，你的理解是错的

首先，外部类x = 3的问题，可能你没深入练习并且理解他的真正概念，外部类的x是成员变量，是随着对象加载存储在对内存中，你所理解的final修饰，其实是内部类在访问局部变量的时候，也就是public void function()里定义的变量，需要用到final修饰，这个需要你自己再去理解一下

关于第二个问题，毕老师在视频里说的再清楚不过了，父类引用指向子类对象，编译时看左边，这个再三强调的，父类的引用指向父类没有的方法你认为他会给你编译通过吗？好好再理解一遍吧。

要认真哦！

AbsDemo d=new AbsDemo(){方法体}

new AbsDemo(){方法体}相当于在内存中直接创建了一个匿名的子类对象
AbsDemo d 然后父类引用指向了这个子类对象
于是栈内存的d指向了堆内存的匿名子类对象地址

于是此时你的 d.show()  d.abc()  操作的地址都是 你名字类对象地址

于是你的show输出的就是匿名子类对象里面的 x=5

至于  d.abc（）   毕老师的视频里不是说了  非static方法的时候是  编译看左  运行看右  么

你的父类里是没有abc（）方法   所以编译应该无法通过


我是这样看的 = =  哪里不对还望指出 我好长知识···

我在你的代码中回答你的问题把，这样会清楚一点：

1. abstract class AbsDemo
   
2. {
   
3.         abstract void show();
   
4. }
   
5. class AbsDemoImpl extends AbsDemo
   
6. {
   
7. 
   
8.         int x=5;
   
9.         @Override
   
10.         void show() {
    
11.                 // TODO Auto-generated method stub
    
12.                  System.out.println("x="+x);
    
13.         }
    
14.         void abc()
    
15.     {
    
16.             System.out.println("heihei");
    
17.     }
    
18.        
    
19. }
    
20. class Outer
    
21. {
    
22.         int x=3;
    
23. 
    
24.         public void function()
    
25.         {
    
26.                         /**
    
27.                          * Test1
    
28.                          */
    
29.                 AbsDemo d=new AbsDemo()
    
30.                 {
    
31.                         //这里面的匿名内部类中定义了x=5，而外部类中定义了x=3，为什么不会编译失败?
    
32.                         int x=5;//因为这个x和外面的x不是一个变量
    
33.                         @Override
    
34.                         void show()
    
35.                         {
    
36.                                 System.out.println("x="+x);//这里引用的x=5的那个x
    
37.                         }
    
38.                         public void abc()
    
39.                         {
    
40.                                 System.out.println("heihei");
    
41.                         }
    
42.                 };
    
43.                 d.show();
    
44.                 //d.abc();//因为这里的d类型是AbsDemo，但是在这个类中没有提供abc方法；
    
45.                     /**
    
46.                      * Test2
    
47.                      */
    
48.                    
    
49.                 //这样是可以的，因为在AbsDemoImpl中有abc方法
    
50.                 AbsDemoImpl d1=new AbsDemoImpl();
    
51.                 d1.show();
    
52.                 d1.abc();
    
53.                
    
54.                 /**
    
55.                      * Test3
    
56.                      */
    
57.                 //这样是不行了，因为d2声明的是AbsDemo类型，尽管它指向AbsDemoImpl但是，java虚拟机还是找不到abc方法
    
58.                 AbsDemo d2=new AbsDemoImpl();
    
59.                 d2.show();
    
60.                 //d2.abc();
    
61.         }
    
62. }
    
63. 
    
64. 
    
65. public class t1 {
    
66. 
    
67.         /**
    
68.          * @param args
    
69.          */
    
70.         public static void main(String[] args) {
    
71.                 // TODO Auto-generated method stub
    
72.                 new Outer().function();
    
73.         }
    
74. 
    
75. }
    

复制代码