java随手记

Java的泛型只在源代码存在，只供编辑器检查使用，编译后的字节码文件已擦除了泛型类型，同时在必要的地方插入了强制转型的代码。
泛型代码：
Java代码

public static void main(String[] args) {     
    List<String> stringList = new ArrayList<String>();     
    stringList.add("oliver");     
    System.out.println(stringList.get(0));     
}   

public static void main(String[] args) {  
    List<String> stringList = new ArrayList<String>();  
    stringList.add("oliver");  
    System.out.println(stringList.get(0));  
} 

将上面的代码的字节码反编译后：
Java代码

public static void main(String args[])     
{     
    List stringList = new ArrayList();     
    stringList.add("oliver");     
    System.out.println((String)stringList.get(0));     
} 

循环历遍（foreach）
语法：
Java代码

List<Integer> list = new ArrayList<Integer>();     
for(Integer num : list){     
    System.out.println(num);     
}   

List<Integer> list = new ArrayList<Integer>();  
for(Integer num : list){  
    System.out.println(num);  
} 

Foreach要求被历遍的对象要实现Iterable接口，由此可想而知，foreach迭代也是调用底层的迭代器实现的。反编译上面源码的字节码：
Java代码

List list = new ArrayList();     
Integer num;     
Integer num;     
for (Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(num)){     
    num = (Integer) iterator.next();     
}   

枚举
枚举类型其实并不复杂，在JVM字节码文件结构中，并没有“枚举”这个类型。
其实源程序的枚举类型，会在编译期被编译成一个普通了类。利用继承和反射，这是完全可以做到的。
看下面一个枚举类：
Java代码

public enum EnumTest {     
    OLIVER,LEE;     
}    

public enum EnumTest {  
    OLIVER,LEE;  
}  

反编译字节码后：
Java代码

public final class EnumTest extends Enum {     

    private EnumTest(String s, int i) {     
        super(s, i);     
    }     

    public static EnumTest[] values() {     
        EnumTest aenumtest[];     
        int i;     
        EnumTest aenumtest1[];     
        System.arraycopy(aenumtest = ENUM$VALUES, 0,     
                aenumtest1 = new EnumTest[i = aenumtest.length], 0, i);     
        return aenumtest1;     
    }     

    public static EnumTest valueOf(String s) {     
        return (EnumTest) Enum.valueOf(EnumTest, s);     
    }     

    public static final EnumTest OLIVER;     
    public static final EnumTest LEE;     
    private static final EnumTest ENUM$VALUES[];     

    static {     
        OLIVER = new EnumTest("OLIVER", 0);     
        LEE = new EnumTest("LEE", 1);     
        ENUM$VALUES = (new EnumTest[] { OLIVER, LEE });     
    }     
} 

变长参数
变长参数允许我们传入到方法的参数是不固定个数。
对于这个方法：
Java代码

public void foo(String str,Object...args){     

}  

public void foo(String str,Object...args){  

}

我们可以这样调用：
Java代码

foo("oliver");     
foo("oliver",new Object());     
foo("oliver",new Integer(1),"sss");     
foo("oliver",new ArrayList(),new Object(),true,1);    

foo("oliver");  
foo("oliver",new Object());  
foo("oliver",new Integer(1),"sss");  
foo("oliver",new ArrayList(),new Object(),true,1);  

参数args可以是任意多个。
其实，在编译阶段，args是会被编译成Object [] args。
Java代码

public transient void foo(String s, Object aobj[])     
{     
}   

public transient void foo(String s, Object aobj[])  
{  
} 

这样，变长参数就可以实现了。
但是要注意的是，变长参数必须是方法参数的最后一项。