匿名类

原文地址：http://blog.csdn.net/jiaotuwoaini/article/details/51542059

匿名类，正如名字一样在Java中没有名字标识的类，当然了编译后还是会安排一个名字的。

下面是一个关于匿名类的简单例子：

[java] view plain copy

1. public class Client {  
2.   
3.     public static void main(String[] args) throws InterruptedException {  
4.         Thread t=new Thread(new Runnable() {  
5.               
6.             @Override  
7.             public void run() {  
8.                 System.out.println("hello,dusk!");  
9.                   
10.             }  
11.         });  
12.         t.start();  
13.     }  
14.   
15. }  

Java语言规范上是这么描述匿名类的：

匿名类的声明：

匿名类的声明是由java编译器自动派生自一个类实例创建表达式。

匿名类永远不能是抽象的。

匿名类总是隐式的final。

匿名类总是一个内部类；并且不能是static的。

匿名构造函数：

匿名类不能有显式声明的构造函数。相反的，Java编译器必须为这个匿名类自动提供一个匿名构造函数。匿名类Ｃ继承于父类Ｓ那么匿名构造函数是下面的形式：

• 如果Ｓ不是一个内部类或者Ｓ是一个静态上下文中的局部类，那么这个匿名构造函数有一个形参为每一个在Ｃ的类实例创建表达式中的实际参数。

类的实例创建表达式的实际参数用来确定S的一个构造函数cs，使用方法调用相同的规则。

每一个匿名构造函数的形参必须和cs中的相关形参一致。

这个构造函数中显式的包括super(...)构造函数调用，这个实际参数是构造函数的形参，按它们声明的顺序。

• 否则，Ｃ的构造函数第一个形参描述了这个值，直接包围实例ｉ相对于Ｓ。参数的类型是Ｓ的class类型。

构造函数有一个额外的形参为每一个类实例创建语句声明在匿名类中的实际参数。第n个形参和第n-1个实际参数相关。

类的实例创建表达式的实际参数用来确定S的一个构造函数cs，使用方法调用相同的规则。

每一个匿名构造函数的形参必须和cs中的相关形参一致。

这个构造函数中显式的包括super(...)构造函数调用，这个实际参数是构造函数的形参，按它们声明的顺序。

在所有的情况下，匿名构造函数的throws语句必须列出所有的检查异常，包括父类构造函数显式调用语句抛出的和匿名类的实例初始化或者变量初始化抛出的异常。

注意：匿名构造函数的签名涉及到了一个不可达类型是可能的(例如，出现在父类构造函数中的类型)，这不会导致任何编译时和运行时错误。

 

实际使用中我们只需注意这几点儿：

      1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
      2、匿名内部类中是不能定义构造函数的。
      3、匿名内部类中不能存在任何的静态成员变量和静态方法。
      4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
      5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

编译时的命名规则：

• 内部类的class文件命名是：主类＋$＋内部类名
• 匿名类的class文件命名是：主类＋$＋(1,2,3....)

定义一个场景：

[java] view plain copy

1. package com.dusk.anonymous;  
2.   
3. public class AnonymousClassTest {  
4.     private Runnable r1=new Runnable() {  
5.           
6.         @Override  
7.         public void run() {  
8.             System.out.println(1);  
9.         }  
10.     };  
11.     public void method1(){  
12.         Runnable r2=new Runnable() {  
13.               
14.             @Override  
15.             public void run() {  
16.                 System.out.println(2);  
17.             }  
18.         };  
19.     }  
20.     public static void main(String[] args) {  
21.             Runnable r3=new Runnable() {  
22.                   
23.                 @Override  
24.                 public void run() {  
25.                     System.out.println(3);  
26.                 }  
27.             };  
28.     }  
29. }  

从代码中我们可以看出定义了三个匿名类：

我们反编译出来：

[java] view plain copy

1. package com.dusk.anonymous;  
2.   
3. import java.io.PrintStream;  
4.   
5. class AnonymousClassTest$1  
6.   implements Runnable  
7. {  
8.   AnonymousClassTest$1(AnonymousClassTest paramAnonymousClassTest) {}  
9.     
10.   public void run()  
11.   {  
12.     System.out.println(1);  
13.   }  
14. }  

[java] view plain copy

1. package com.dusk.anonymous;  
2.   
3. import java.io.PrintStream;  
4.   
5. class AnonymousClassTest$2  
6.   implements Runnable  
7. {  
8.   AnonymousClassTest$2(AnonymousClassTest paramAnonymousClassTest) {}  
9.     
10.   public void run()  
11.   {  
12.     System.out.println(2);  
13.   }  
14. }  

[java] view plain copy

1. package com.dusk.anonymous;  
2.   
3. import java.io.PrintStream;  
4.   
5. class AnonymousClassTest$3  
6.   implements Runnable  
7. {  
8.   public void run()  
9.   {  
10.     System.out.println(3);  
11.   }  
12. }  

我们可以看出匿名类的名字中的数字和他们在代码中出现的位置一模一样。