Anonymous Inner Class(匿名内部类)是否可以extends其他类？是否可以implements接口？

匿名内部类实现的本身就是一种继承或者实现的表现啊，不过想用extends和implements关键字的话，我还真没听说过可以写在哪里

内部类 也是类  完全可以继承类 或者实现接口  
优点：可以实现“多继承”
比如说  class A{
      class B extends   C{}
      class  D extends  E{}
}

那么就相当于  同时继承了  C  和 E

这里有个帖子，你可以看一下
标题：[已解决] 关于匿名内部类
链接地址：http://bbs.itheima.com/forum.php ... ;pre_pos=3&ext=

内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有
        之所以可以直接访问内部类中的成员，是因为内部类持有了一个外部类的引用 。格式：外部类名.this
2，外部类要访问内部类，必须建立内部对象

访问格式：
1，当内部类定义在外部类的成员位置上，也非私有，可以在外部其他类中直接建立内部类对象
格式：
        外部类名.内部类名 变量名 = 外部对象.内部对象
        Outer.Inner in = new Outer().new Inner();
2，当内部类在成员位置上，就可以被成员修饰符所修饰
        比如private：将内部类在外部类中进行封装
        static：内部类就具备了静态的特性
        当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问权限
       
        在外部其他类中，如何直接访问静态内部类的非静态成员呢
        new Outer.Inner().functin();
        在外部其他类中，如何直接访问静态内部类的静态成员呢
        Outer.Inner.function();
       
        注意当内部类定义了静态成员，该内部类必须是静态的
        当外部类中的静态方法访问内部类时，内部类也必须是static的

当描述事物时，事物的内部还有事物，该事物用内部类描述
因为内部事物在使用外部事物的内容。

1. class Outer
   
2. {
   
3.         private static int x;
   
4.         static class Inner
   
5.         {
   
6.                 static void fuction()
   
7.                 {       
   
8.                         int x = 4;
   
9.                         System.out.println("inner"+ x);
   
10.                 }
    
11.         }
    
12.         static class Inner2
    
13.         {
    
14.                  void show()
    
15.                 {
    
16.                         System.out.println("show run");
    
17.                 }
    
18.         }
    
19.         public static void method()
    
20.         {
    
21.                 //Inner in = new Inner();
    
22.                 //in.fuction();
    
23.                 new Inner2().show();
    
24.         }
    
25. }
    
26. 
    
27. class InnerClassDemo
    
28. {
    
29.         public static void main(String[] args)
    
30.         {
    
31.                 Outer out = new Outer();
    
32.                 out.method();
    
33.                 new Outer.Inner().fuction();
    
34.                 //直接访问内部类的成员
    
35.                 //Outer.Inner in =  new Outer().new Inner();
    
36.                 //in.fuction();
    
37.         }
    
38. }

复制代码

匿名内部类：
1，匿名内部类其实就是内部类的简写格式
2，定义匿名内部类的前提：
        内部类必须是继承一个类或实现接口
3，匿名内部类的格式：new 父类或者接口() {定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象
5，匿名内部类中定义的方法最好不超过三个
代码演示：

1. class Outer
   
2. {
   
3.         int x = 3;
   
4.         /*
   
5.         class Inner extends AbsDemo
   
6.         {
   
7.                 void show()
   
8.                 {
   
9.                         System.out.println("show :"+ x);
   
10.                 }
    
11.                 void abc()
    
12.                 {
    
13.                         System.out.println("abc :"+x);
    
14.                 }
    
15.         }
    
16.         */
    
17.         public void function()
    
18.         {
    
19.                 //new Inner().show();
    
20.                 new AbsDemo()
    
21.                 {
    
22.                         void show()
    
23.                         {
    
24.                                 System.out.println("show :"+x);
    
25.                         }
    
26.                         void abc()
    
27.                         {
    
28.                                 System.out.println("abc");
    
29.                         }
    
30.                 }.abc();
    
31.         }
    
32. }

复制代码