java随手记

最新推荐文章于 2023-08-21 07:28:46 发布

原创最新推荐文章于 2023-08-21 07:28:46 发布 · 134 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java随手记

Java 专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了Java泛型在源代码、编译后字节码及反编译过程中的表现，解释了循环遍历、枚举类型及变长参数在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[])  
{  
}

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