1. /*
   
2. 匿名内部类
   
3. */
   
4. 
   
5. interface Inter
   
6. {
   
7.         public void show();
   
8. }
   
9. 
   
10. class Outer
    
11. {
    
12.         int x = 3;
    
13.         public void method()
    
14.         {
    
15.                 new Inter()//？？
    
16.                 {
    
17.                         public void show()
    
18.                         {
    
19.                                 System.out.println("show:"+x);
    
20.                         }
    
21.                 }.show();
    
22.         }
    
23. }
    
24. 
    
25. class InnerClassDemo3
    
26. {
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 new Outer().method();
    
30.         }
    
31. }

复制代码

这个一个匿名内部类代码，对15行new Inter()有两个疑问。
其一，学接口时说接口是不可以new对象的，这里为什么可以？
其二，这段代码开始做了一个接口用来给内部类来实现的，可是通篇都没有implements语句，15行是怎样实现的呢?

因为匿名内部类就是内部类的简写，匿名内部类也就是一个匿名的带内容的子类对象，匿名内部类必须继承一个类或者实现接口，定义匿名内部类时new出来的必须是父类或者接口，如：
                new Inter()//new出来的就是子类对象
               {
                      public void show()//实现了父接口的方法，即定义的就是子类的内容
                       {
                              System.out.println("show:"+x);
                        }
              }.show();//new出来的对象直接调用子类实现的方法

楼主应该好好看看匿名内部类的视频，
new Inter()//？？
                {
                        public void show()//该方法其实就是匿名内部类对inner接口的实现了
                        {
                                System.out.println("show:"+x);
                        }
                }.show();
这段代码是创建一个匿名内部类的对象，inner是这个匿名内部类继承的接口，既然是匿名内部类了当然是看不到内部类的名字。如果按你说的new创建的是inner类的对象，那inner不就成了类名了，这就和匿名内部类相悖了。
new Inter()//？？
                {
                        public void show()//这是实现接口的方法
                        {
                                System.out.println("show:"+x);
                        }
                        public void play（）//这是内部类自身的方法
                        {
                        System.out.println("play"+x);
                        }

                }.show();

这种方式实际上是一种简写形式，相当于：
class Inner implements Inter {
    public void show(){
         System.out.println("show:"+x);
    }
}
Inter in = new Inner();
in.show();
这样主要是为了简化代码书写，一般成员方法调用一次时候这样用，用到gui图形界面时候这样用的就比较多

你的代码中的15行new Inter(){}这实际是在隐式继承Inter接口，所以就相当于返回的是一个匿名子类对象，()指的是构造函数，如果父类里有特殊的构造函数，可以往（）里传参数。{}这个大括号里就是在定义内部类的内容，.show()就是在用这个对象调用子类方法
下面是匿名内部类的具体特点
匿名内部类：
1、        匿名内部类其实就是内部类的简写格式。
2、        定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
3、        匿名内部类的格式：new 父类或者接口(){定义子类的内容}; 这个地方的()指的是构造函数，如果父类里有特殊的构造函数，可以往（）里传参数。
4、        其实匿名内部类就是一个匿名子类对象。匿名子类对象只能调用一次。
5、        匿名内部类中定义的方法最好不要超过三个。

1. interface Inter
   
2. {
   
3.         void method();
   
4. }
   
5. class Test
   
6. {
   
7.                 static Inter funcation()
   
8.         {
   
9.                 return new Inter()
   
10.                 {       
    
11.                         public void method()
    
12.                         {
    
13.                                 System.out.println("method run!");
    
14.                         }
    
15.                        
    
16.                 };
    
17.         }
    
18. }
    
19. class InterTest
    
20. {
    
21.         public static void main(String[] args)
    
22.         {
    
23.                
    
24.                 Test.funcation().method();
    
25.         }
    
26. }
    

复制代码

interface Inter
  {
          public void show();
   }
  class Outer
  {
          int x = 3;
        public void method()
         {
                  new Inter()// class Inner implements Inter 这其实就是内部类的简写格式，就是一个匿名子类对象；
                  {
                          public void show()//实现父类接口方法

                        {
                                System.out.println("show:"+x);//定义子类内容，对父类方法的覆盖
                          }
                  }.show();//创建的对象直接调用匿名子类实现方法
         }// Inter in = new Inner(); in.show();
  }
   class InnerClassDemo3
{
          public static void main(String[] args)
         {

                 new Outer().method();
         }
  }

因为接口中有抽象方法，所以不能创建对象，所以子类对接口中的抽象方法要全部覆盖，子类才能实例化，否则子类为抽象类。

匿名内部类其实就是内部类继承外部类的一个简写形式,
java规定   为了方便阅读与书写,这种形式可以用匿名内部类代替
这是匿名内部类的固有格式,照着写就行了   能用自己的方法理解,记住就行了