jad反编译工具，已经不再更新，且只支持JDK1.4，但并不影响其强大的功能。

基本用法：jad xxx.class，会生成直接可读的xxx.jad文件。

自动拆装箱

对于基本类型和包装类型之间的转换，通过xxxValue()和valueOf()两个方法完成自动拆装箱，使用jad进行反编译可以看到该过程：

  1. public class Demo {
  2.   public static void main(String[] args) {
  3.     int x = new Integer(10);  // 自动拆箱
  4.     Integer y = x;            // 自动装箱
  5.   }
  6. }

反编译后结果：

  1. public class Demo
  2. {
  3.     public Demo(){}
  5.     public static void main(String args[])
  6.     {
  7.         int i = (new Integer(10)).intValue();   // intValue()拆箱
  8.         Integer integer = Integer.valueOf(i);   // valueOf()装箱
  9.     }
  10. }

foreach语法糖

在遍历迭代时可以foreach语法糖，对于数组类型直接转换成for循环：

  1. // 原始代码
  2. int[] arr = {1, 2, 3, 4, 5};
  3.     for(int item: arr) {
  4.         System.out.println(item);
  5.     }
  6. }
  8. // 反编译后代码
  9. int ai[] = {
  10.     1, 2, 3, 4, 5
  11. };
  12. int ai1[] = ai;
  13. int i = ai1.length;
  14. // 转换成for循环
  15. for(int j = 0; j < i; j++)
  16. {
  17.     int k = ai1[j];
  18.     System.out.println(k);
  19. }

对于容器类的遍历会使用iterator进行迭代：

  1. import java.io.PrintStream;
  2. import java.util.*;
  4. public class Demo
  5. {
  6.     public Demo() {}
  7.     public static void main(String args[])
  8.     {
  9.         ArrayList arraylist = new ArrayList();
  10.         arraylist.add(Integer.valueOf(1));
  11.         arraylist.add(Integer.valueOf(2));
  12.         arraylist.add(Integer.valueOf(3));
  13.         Integer integer;
  14.         // 使用的for循环+Iterator，类似于链表迭代：
  15.         // for (ListNode cur = head; cur != null; System.out.println(cur.val)){
  16.         //     cur = cur.next;
  17.         // }
  18.         for(Iterator iterator = arraylist.iterator(); iterator.hasNext(); System.out.println(integer))
  19.             integer = (Integer)iterator.next();
  20.     }
  21. }

Arrays.asList(T…)

熟悉Arrays.asList(T…)用法的小伙伴都应该知道，asList()方法传入的参数不能是基本类型的数组，必须包装成包装类型再使用，否则对应生成的列表的大小永远是1：

  1. import java.util.*;
  2. public class Demo {
  3.   public static void main(String[] args) {
  4.     int[] arr1 = {1, 2, 3};
  5.     Integer[] arr2 = {1, 2, 3};
  6.     List lists1 = Arrays.asList(arr1);
  7.     List lists2 = Arrays.asList(arr2);
  8.     System.out.println(lists1.size()); // 1
  9.     System.out.println(lists2.size()); // 3
  10.   }
  11. }

从反编译结果来解释，为什么传入基本类型的数组后，返回的List大小是1：

  1. // 反编译后文件
  2. import java.io.PrintStream;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. public class Demo
  7. {
  8.     public Demo() {}
  10.     public static void main(String args[])
  11.     {
  12.         int ai[] = {
  13.             1, 2, 3
  14.         };
  15.         // 使用包装类型，全部元素由int包装为Integer
  16.         Integer ainteger[] = {
  17.             Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)
  18.         };
  20.         // 注意这里被反编译成二维数组，而且是一个1行三列的二维数组
  21.         // list.size()当然返回1
  22.         List list = Arrays.asList(new int[][] { ai });
  23.         List list1 = Arrays.asList(ainteger);
  24.         System.out.println(list.size());
  25.         System.out.println(list1.size());
  26.     }
  27. }

从上面结果可以看到，传入基本类型的数组后，会被转换成一个二维数组，而且是new int[1][arr.length]这样的数组，调用list.size()当然返回1。

注解

Java中的类、接口、枚举、注解都可以看做是类类型。使用jad来看一下@interface被转换成什么：

  1. import java.lang.annotation.Retention;
  2. import java.lang.annotation.RetentionPolicy;
  4. @Retention(RetentionPolicy.RUNTIME)
  5. public @interface Foo{
  6.   String[] value();
  7.   boolean bar();
  8. }

查看反编译代码可以看出：

  • 自定义的注解类Foo被转换成接口Foo，并且继承Annotation接口
  • 原来自定义接口中的value()和bar()被转换成抽象方法
  1. import java.lang.annotation.Annotation;
  3. public interface Foo
  4.     extends Annotation
  5. {
  6.     public abstract String[] value();
  8.     public abstract boolean bar();
  9. }

注解通常和反射配合使用，而且既然自定义的注解最终被转换成接口，注解中的属性被转换成接口中的抽象方法，那么通过反射之后拿到接口实例，在通过接口实例自然能够调用对应的抽象方法：

  1. import java.util.Arrays;
  3. @Foo(value={"sherman", "decompiler"}, bar=true)
  4. public class Demo{
  5.     public static void main(String[] args) {
  6.         Foo foo = Demo.class.getAnnotation(Foo.class);
  7.         System.out.println(Arrays.toString(foo.value())); // [sherman, decompiler]
  8.         System.out.println(foo.bar());                    // true
  9.     }
  10. }

枚举

通过jad反编译可以很好地理解枚举类。

空枚举

先定义一个空的枚举类：

  1. public enum DummyEnum {
  2. }

使用jad反编译查看结果：

  • 自定义枚举类被转换成final类，并且继承Enum
  • 提供了两个参数（name，odinal）的私有构造器，并且调用了父类的构造器。注意即使没有提供任何参数，也会有该该构造器，其中name就是枚举实例的名称，odinal是枚举实例的索引号
  • 初始化了一个private static final自定义类型的空数组 $VALUES

  • 提供了两个public static方法：

    • values()方法通过clone()方法返回内部$VALUES的浅拷贝。这个方法结合私有构造器可以完美实现单例模式，想一想values()方法是不是和单例模式中getInstance()方法功能类似
    • valueOf(String s)：调用父类Enum的valueOf方法并强转返回
  1. public final class DummyEnum extends Enum
  2. {
  3.     // 功能和单例模式的getInstance()方法相同
  4.     public static DummyEnum[] values()
  5.     {
  6.         return (DummyEnum[])$VALUES.clone();
  7.     }
  8.     // 调用父类的valueOf方法，并墙砖返回
  9.     public static DummyEnum valueOf(String s)
  10.     {
  11.         return (DummyEnum)Enum.valueOf(DummyEnum, s);
  12.     }
  13.     // 默认提供一个私有的私有两个参数的构造器，并调用父类Enum的构造器
  14.     private DummyEnum(String s, int i)
  15.     {
  16.         super(s, i);
  17.     }
  18.     // 初始化一个private static final的本类空数组
  19.     private static final DummyEnum $VALUES[] = new DummyEnum[0];
  21. }

包含抽象方法的枚举

枚举类中也可以包含抽象方法，但是必须定义枚举实例并且立即重写抽象方法，就像下面这样：

  1. public enum DummyEnum {
  2.     DUMMY1 {
  3.         public void dummyMethod() {
  4.             System.out.println("[1]: implements abstract method in enum class");
  5.         }
  6.     },
  8.     DUMMY2 {
  9.         public void dummyMethod() {
  10.             System.out.println("[2]: implements abstract method in enum class");
  11.         }
  12.     };
  14.     abstract void dummyMethod();
  16. }

再来反编译看看有哪些变化：

  • 原来final class变成了abstract class：这很好理解，有抽象方法的类自然是抽象类
  • 多了两个public static final的成员DUMMY1、DUMMY2，这两个实例的初始化过程被放到了static代码块中，并且实例过程中直接重写了抽象方法，类似于匿名内部类的形式。
  • 数组$VALUES[]初始化时放入枚举实例

还有其它变化么？

在反编译后的DummyEnum类中，是存在抽象方法的，而枚举实例在静态代码块中初始化过程中重写了抽象方法。在Java中，抽象方法和抽象方法重写同时放在一个类中，只能通过内部类形式完成。因此上面第二点应该说成就是以内部类形式初始化。

可以看一下DummyEnum.class存放的位置，应该多了两个文件：

  • DummyEnum$1.class
  • DummyEnum$2.class

Java中.class文件出现$符号表示有内部类存在，就像OutClass$InnerClass，这两个文件出现也应证了上面的匿名内部类初始化的说法。

  1. import java.io.PrintStream;
  3. public abstract class DummyEnum extends Enum
  4. {
  5.     public static DummyEnum[] values()
  6.     {
  7.         return (DummyEnum[])$VALUES.clone();
  8.     }
  10.     public static DummyEnum valueOf(String s)
  11.     {
  12.         return (DummyEnum)Enum.valueOf(DummyEnum, s);
  13.     }
  15.     private DummyEnum(String s, int i)
  16.     {
  17.         super(s, i);
  18.     }
  20.     // 抽象方法
  21.     abstract void dummyMethod();
  23.     // 两个pubic static final实例
  24.     public static final DummyEnum DUMMY1;
  25.     public static final DummyEnum DUMMY2;
  26.     private static final DummyEnum $VALUES[];
  28.      // static代码块进行初始化
  29.     static 
  30.     {
  31.         DUMMY1 = new DummyEnum("DUMMY1", 0) {
  32.             public void dummyMethod()
  33.             {
  34.                 System.out.println("[1]: implements abstract method in enum class");
  35.             }
  36.         }
  37. ;
  38.         DUMMY2 = new DummyEnum("DUMMY2", 1) {
  39.             public void dummyMethod()
  40.             {
  41.                 System.out.println("[2]: implements abstract method in enum class");
  42.             }
  43.         }
  44. ;
  45.         // 对本类数组进行初始化
  46.         $VALUES = (new DummyEnum[] {
  47.             DUMMY1, DUMMY2
  48.         });
  49.     }
  50. }

正常的枚举类

实际开发中，枚举类通常的形式是有两个参数（int code，Sring msg）的构造器，可以作为状态码进行返回。Enum类实际上也是提供了包含两个参数且是protected的构造器，这里为了避免歧义，将枚举类的构造器设置为三个，使用jad反编译：

最大的变化是：现在的private构造器从2个参数变成5个，而且在内部仍然将前两个参数通过super传递给父类，剩余的三个参数才是真正自己提供的参数。可以想象，如果自定义的枚举类只提供了一个参数，最终生成底层代码中private构造器应该有三个参数，前两个依然通过super传递给父类。

  1. public final class CustomEnum extends Enum
  2. {
  3.     public static CustomEnum[] values()
  4.     {
  5.         return (CustomEnum[])$VALUES.clone();
  6.     }
  8.     public static CustomEnum valueOf(String s)
  9.     {
  10.         return (CustomEnum)Enum.valueOf(CustomEnum, s);
  11.     }
  13.     private CustomEnum(String s, int i, int j, String s1, Object obj)
  14.     {
  15.         super(s, i);
  16.         code = j;
  17.         msg = s1;
  18.         data = obj;
  19.     }
  21.     public static final CustomEnum FIRST;
  22.     public static final CustomEnum SECOND;
  23.     public static final CustomEnum THIRD;
  24.     private int code;
  25.     private String msg;
  26.     private Object data;
  27.     private static final CustomEnum $VALUES[];
  29.     static 
  30.     {
  31.         FIRST = new CustomEnum("FIRST", 0, 10010, "first", Long.valueOf(100L));
  32.         SECOND = new CustomEnum("SECOND", 1, 10020, "second", "Foo");
  33.         THIRD = new CustomEnum("THIRD", 2, 10030, "third", new Object());
  34.         $VALUES = (new CustomEnum[] {
  35.             FIRST, SECOND, THIRD
  36.         });
  37.     }
  38. }