“问题已经解决”。



abstract class AbsDemo
{
abstract void show();

}
class Outer
{
int x = 3;
public void function()
{
  AbsDemo d =new AbsDemo()
  {
   int x = 9;
   void show()
   {
    System.out.println("x==="+this.x);
   }
   void abc()
   {
    System.out.println("hhee”);
   }
  };
  d.show();
  //d.abc();
}
}
class Test
{
public static void main(String[] args)
{
  new Outer().function();
}
}

问题1：为什么输出结果是是9，而不是3啊？
问题2：我向调用abc()的方法，在主函数中我应该怎么写啊，或者在Outer类中我该怎么写？

问题1：为什么输出结果是是9，而不是3啊？
   void show() {
              System.out.println("x===" + this.x);           因为你这里的this指的是当前对象，肯定是在本类中找x变量了，
   }
如果你想调用外部类Outer的x变量，那就这样：
   void show() {
                     System.out.println("x===" + Outer.this.x);           
   }
问题2：我向调用abc()的方法，在主函数中我应该怎么写啊，或者在Outer类中我该怎么写？

如果你想调用abc方法，那就首先要在抽象类AbsDemo中有abc的抽象方法，因为你的这个匿名内部类是覆写AbsDemo抽象类的，

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

复制代码

abstract class AbsDemo
{
abstract void show();
}
class Outer
{
        int x = 3;
        public void function()
        {
          //父类引用  创建匿名内部类对象        
        AbsDemo d =new AbsDemo()
          {
           int x = 9;
           void show()
           {
                   int x = 11;
                   System.out.println("x1== "+x);  //x1== 11
                   System.out.println("x2== "+this.x);//x2== 9
                   System.out.println("x3== "+Outer.this.x);//int x = 3;           }
           void abc()
           {
            System.out.println("hhee");
           }
          };
          d.show();
         
          //调用abc(),是子类中特有的方法，只能用子类对象去调用。         
          new AbsDemo()
          {
           int x = 9;
           void show()
           {
                   int x = 11;
                   System.out.println("x1== "+x);  //x1== 11
                   System.out.println("x2== "+this.x);//x2== 9
                   System.out.println("x3== "+Outer.this.x);//int x = 3;
           }
           void abc()
           {
            System.out.println("hhee");
           }
          }.abc();
        }
}
class Test
{
        public static void main(String[] args)
        {
          new Outer().function();
        }
}

//问题1：为什么输出结果是是9，而不是3啊？
//问题2：我向调用abc()的方法，在主函数中我应该怎么写啊，或者在Outer类中我该怎么写？
   new AbsDemo()
  {
        int x = 9;
  
         void show()
       {
            System.out.println("x==="+this.x);
       }
  
          void abc()
       {
            System.out.println("hhee");
       }
  };
上边的代码相当于一个是一个匿名子类对象，相当于内部类，this指的是本类对象，所以结果是9，要是改成Out.this.x  ，那么结果就是3了。
AbsDemo d =new AbsDemo()
  {
   int x = 9;
  
   void show()
   {
    System.out.println("x==="+this.x);
   }
  
   void abc()
    {
    System.out.println("hhee");
    }
  };
要是加上了名字，那就是多态了，父类的引用指向子类对象，而父类中并没有abc()这个方法，所以不能写成d.abc();要想调用abc()这个方法，必须在抽象类中
定义这个方法。不过这就没什么意义了，我想楼主只是想搞清楚匿名内部类调用自身特有方法，要是这样的话，调用abc()方法就是下边代码
new AbsDemo()
  {
        int x = 9;
        void show()
       {
           System.out.println("x==="+this.x);
       }
  
       void abc()
      {
           System.out.println("hhee");
      }
  }.abc();
这样比较麻烦，所以匿名内部类里的特有方法一般都很少，就一两个

abstract class AbsDemo
{
abstract void show();
}
class Outer
{
static int x = 3;
public void function()
{
    AbsDemo d =new AbsDemo()
    {
      int x = 9;

     void show()
     {
    System.out.println("x==="+x);
     }
           };
    d.show();
}
static void abc()
   {
  System.out.println("hhee");
   }
}
class Test
{
public static void main(String[] args)
    {
  
  Outer.abc();
   new Outer().function();
   
    }
}
楼主使用this.x则是调用当前x=9的值，如果想调用x=3，可以在this前加个Outer表示调用的是Outer类中的x，或者楼主可以再x=3将其变为静态static，这时输出语句中只需要直接输出x即可，即表示输出的是全局变量，即是Outer.this.x.
2.关于调用abc（）方法，因为父类中的方法只用一个show（），所以在子类中覆盖时，建立了父类的对象d，所调用的只有父类中show的方法。
  所以d.abc()调用不行的，要是就这调用的话，建议楼主将abc（）方法也写进父类中。
   简单的要调用abc（）方法，可以讲其放在function（）方法之外，要么在主函数中建议Outer对象进行调用，要么将abc（）静态化，在主函数中只用通过类的方法调用
即是Outer.abc();
希望对楼主用！