java高新技术总结(二)

枚举：

enum Week{
MON(2),TUE,;
private Week(){

}
private Week(int i){

}

}

反汇编的结果为：

final class Week extends java.lang.Enum{
public static final Week MON;

public static final Week TUE;

public static Week[] values();
Code:
0:   getstatic       #1; //Field $VALUES:[LWeek;
3:   invokevirtual   #2; //Method "[LWeek;".clone:()Ljava/lang/Object;
6:   checkcast       #3; //class "[LWeek;"
9:   areturn

public static Week valueOf(java.lang.String);
Code:
0:   ldc_w   #4; //class Week
3:   aload_0
4:   invokestatic    #5; //Method java/lang/Enum.valueOf:(Ljava/lang/Class;Lj
ava/lang/String;)Ljava/lang/Enum;
7:   checkcast       #4; //class Week
10:  areturn

static {};
Code:
0:   new     #4; //class Week
3:   dup
4:   ldc     #7; //String MON
6:   iconst_0
7:   iconst_2
8:   invokespecial   #8; //Method "<init>":(Ljava/lang/String;II)V
11:  putstatic       #9; //Field MON:LWeek;
14:  new     #4; //class Week
17:  dup
18:  ldc     #10; //String TUE
20:  iconst_1
21:  invokespecial   #11; //Method "<init>":(Ljava/lang/String;I)V
24:  putstatic       #12; //Field TUE:LWeek;
27:  iconst_2
28:  anewarray       #4; //class Week
31:  dup
32:  iconst_0
33:  getstatic       #9; //Field MON:LWeek;
36:  aastore
37:  dup
38:  iconst_1
39:  getstatic       #12; //Field TUE:LWeek;
42:  aastore
43:  putstatic       #1; //Field $VALUES:[LWeek;
46:  return

}

反汇编的结果着实让我吃了一惊。

其实枚举就是一个继承自java.lang.Enum的final类型的类,枚举类通过static{}静态语句块对枚举进行初始化。我们在枚举中定义了两个构造函数。
但是反汇编的结果却没有看见构造函数的代码。这是怎么回事呢？在static{}语句块中确实有invokespecial指令，难道是调用父类的构造方法？java.
lang.Enum类有个构造方法protect Enum(String name,int ordinal)，不过编译器不容许我们调用，也不容许我们继承java.lang.Enum类，似乎专门为
枚举服务。static{}中调用的Method "<init>":(Ljava/lang/String;I)V，这个构造函数很符合java.lang.Enum类的构造方法。但是
Method "<init>":(Ljava/lang/String;II)V这个方法调用很奇怪,这个方法这什么地方定义的呢？
4: ldc #7; //String MON
6: iconst_0
7: iconst_2
8： Method "<init>":(Ljava/lang/String;II)V
通过这个语句可以看出在这个方法接受的参数值为String MON，int 0,int 2。这显然是构造枚举中的MON。这个很像超类的构造方法接受的参数
后面再添加个int型的参数，也就是protect Enum(String name,int ordinal,int other)。但这构造函数是在哪定义的呢？Week的真正构造函数是什么呢？
由于反汇编无法得出结果，又没有源代码。想了很多办法，比如在构造方法中抛出运行时异常，发现不仅抛出了该异常，而且还抛出了
ExceptionInInitializerError,这个异常通常是在装载类并执行静态初始化的时候就发生了异常，这说明Week枚举中的static{}确实调用了该构造方法。
创建了一个Week对象。但是Week枚举的构造方法到底是什么样子呢？
经过了几番波折，终于想到了一个办法---暴力反射。代码如下：

Class clazz = Class.forName("enumtest.Week");
Constructor[] c = clazz.getDeclaredConstructors();
for(int i =0;i<c.length;i++){
System.out.println(c[i]);
}

打印的结果为：
private enumtest.Week(java.lang.String,int)
private enumtest.Week(java.lang.String,int,int)
发现Week枚举中确实和java.lang.Enum类有这同样参数的默认构造方法，我们在程序中定义的构造方法，都是在默认构造方法参数后面添加我们定义
参数的。但是java编译器是怎么做到这一点的？javap为什么没有反编译出构造方法？这很让人费解。
枚举的这些特性，使得他具备单例的特征。用枚举实现单例确实是个不错的办法。

反射:

类名.class
这个用法看上去很像是对类中静态变量的调用，但实际上不是这样，这种用法有点像数组的length属性，java编译会按照特殊方式编译它。这个代表
类的字节码，也就是.class文件。编译器会在常量池中定义一个代表该类的表项，Class clazz = Object.class该语句先把常量池中代表Object的表项
从常量池中压入栈顶，并存储在clazz变量中。并没有创建对象的指令。这是否说明了java虚拟机在执行这条语句是并未创建Class对象？
通过查看Class类的源代码，Class类中只有一个私有的无参数的构造函数，无法通过new关键字创建Class对象。如果想获得Class对只能通过forName
静态方法。但这不能说明Class类是一个单例，因为forName方法会根据传入的类的完全限定名返回不同的Class对象。那为什么会这么做呢？我认为Class
类是特殊的单例，
Object.class==new Object().getClass==Class.forName("java.lang.Object");
这三个语句返回的是同一个Class对象，这说明每个Class对象对应的是该Class对象的类的字节码。也就是说程序中无论通过什么样的方式得到同
样类的Class对象都是同一个对象。那java虚拟机是如何做到这一点的呢？由于forName,和getClass方法都是native的，而java编译器在编译 类名.class
语句时只是将常量池中所对应的表项压入栈顶而已。 我们无法得知其实现细节,究竟java虚拟机是在加载类的过程中就创建了该类的Class对象。还是
执行到上面的语句时才会创建Class对象。这些问题还有待研究。

反射就是将java类的元素映射成java类。Class类就是对所有java类的统一描述。类中的方法，字段，构造方法分别由Method,Filed,Constructor描述
。为什么会把构造方法和其他方法分开呢，其实在java虚拟机中，对象的构造和初始化是分开的。但在java语言中把这个系列动作统一成一个动作。就是说
创建对象时必须由某个构造函数对其进行初始化。
虽然同一个类的Class对象都是==的，但是通过对象获得的Method，Field，Constructor都是!=的。

内省：

内省是java反射的一个应用。它假定java类满足某种规则，并且根据这种规则来推断java类中的字段，构造方法，以及方法。并用java反射对其进行操作
可以通过配置文件的信息的信息，这样可以程序变得很灵活。最典型的例子就是对javabean进行内省，一个满足javabean规范的java类就是一个javabean。
例如javabean必须为每个字段定义getter和setter方法，并且提供无参的构造函数。在很多框架中都有这样的应用，比如在hibernate中，hibernate-hbm.xml
映射文件中配置的java类就必须满足这些条件。

注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnno{
}
class AnnoTest{
@MyAnno
public void xx(){
}
}

反编译结果为：

interface MyAnno extends java.lang.annotation.Annotation{
}

class AnnoTest extends java.lang.Object{
AnnoTest();
Code:
0:   aload_0
1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
4:   return

public void xx();
Code:
0:   return

}

可以看出其实注解就是继承自java.lang.annotation.Annotation的接口,从反编译的结果看并没有看见任何注解的痕迹，似乎注解只是留给java编译器
看的。但是注解却可以保持到运行期间，这是如何做到的呢？注解的方法被称为属性，可以在声明注解时为其赋值。这让我联想到了javabean，保留在
运行时的注解，是不是会为其动态地创建实现类？注解似乎是专门为反射用的。因为在java.lang.reflect包中专门有一个AccessibleObject类来操作注解。
如在spring2.5中通过给类加个注解就可以决定这个类是否交给spring管理，这样免去了在配置文件中进行复杂的配置。
这是否说明了java编译器在.class文件中动了手脚？当然这些只是猜测而已。