让JAD反编译工具我发现了很多有意思的程序

本文参考原文-http://bjbsair.com/2020-03-22/tech-info/5702/

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

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

自动拆装箱

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

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

反编译后结果：

public class Demo
{
    public Demo(){}  

    public static void main(String args[])
    {
        int i = (new Integer(10)).intValue();   // intValue()拆箱
        Integer integer = Integer.valueOf(i);   // valueOf()装箱
    }
}

foreach语法糖

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

// 原始代码
int[] arr = {1, 2, 3, 4, 5};
    for(int item: arr) {
        System.out.println(item);
    }
}  

// 反编译后代码
int ai[] = {
    1, 2, 3, 4, 5
};
int ai1[] = ai;
int i = ai1.length;
// 转换成for循环
for(int j = 0; j < i; j++)
{
    int k = ai1[j];
    System.out.println(k);
}

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

import java.io.PrintStream;
import java.util.*;  

public class Demo
{
    public Demo() {}
    public static void main(String args[])
    {
        ArrayList arraylist = new ArrayList();
        arraylist.add(Integer.valueOf(1));
        arraylist.add(Integer.valueOf(2));
        arraylist.add(Integer.valueOf(3));
        Integer integer;
        // 使用的for循环+Iterator，类似于链表迭代：
        // for (ListNode cur = head; cur != null; System.out.println(cur.val)){
        //     cur = cur.next;
        // }
        for(Iterator iterator = arraylist.iterator(); iterator.hasNext(); System.out.println(integer))
            integer = (Integer)iterator.next();
    }
}

Arrays.asList(T...)

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

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

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

// 反编译后文件
import java.io.PrintStream;
import java.util.Arrays;
import java.util.List;  

public class Demo
{
    public Demo() {}  

    public static void main(String args[])
    {
        int ai[] = {
            1, 2, 3
        };
        // 使用包装类型，全部元素由int包装为Integer
        Integer ainteger[] = {
            Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)
        };  

        // 注意这里被反编译成二维数组，而且是一个1行三列的二维数组
        // list.size()当然返回1
        List list = Arrays.asList(new int[][] { ai });
        List list1 = Arrays.asList(ainteger);
        System.out.println(list.size());
        System.out.println(list1.size());
    }
}

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

注解

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

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;  

@Retention(RetentionPolicy.RUNTIME)
public @interface Foo{
  String[] value();
  boolean bar();
}

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

  • 自定义的注解类Foo被转换成接口Foo，并且继承Annotation接口
  • 原来自定义接口中的value()和bar()被转换成抽象方法
import java.lang.annotation.Annotation;  

public interface Foo
    extends Annotation
{
    public abstract String[] value();  

    public abstract boolean bar();
}

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

import java.util.Arrays;  

@Foo(value={"sherman", "decompiler"}, bar=true)
public class Demo{
    public static void main(String[] args) {
        Foo foo = Demo.class.getAnnotation(Foo.class);
        System.out.println(Arrays.toString(foo.value())); // [sherman, decompiler]
        System.out.println(foo.bar());                    // true
    }
}

枚举

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

空枚举

先定义一个空的枚举类：

public enum DummyEnum {
}

使用jad反编译查看结果：

  • 自定义枚举类被转换成final类，并且继承Enum
  • 提供了两个参数（name，odinal）的私有构造器，并且调用了父类的构造器。注意即使没有提供任何参数，也会有该该构造器，其中name就是枚举实例的名称，odinal是枚举实例的索引号
  • 初始化了一个private static final自定义类型的空数组 $VALUES
  • 提供了两个public static方法：values()方法通过clone()方法返回内部$VALUES的浅拷贝。这个方法结合私有构造器可以完美实现单例模式，想一想values()方法是不是和单例模式中getInstance()方法功能类似valueOf(String s)：调用父类Enum的valueOf方法并强转返回
public final class DummyEnum extends Enum
{
    // 功能和单例模式的getInstance()方法相同
    public static DummyEnum[] values()
    {
        return (DummyEnum[])$VALUES.clone();
    }
    // 调用父类的valueOf方法，并墙砖返回
    public static DummyEnum valueOf(String s)
    {
        return (DummyEnum)Enum.valueOf(DummyEnum, s);
    }
    // 默认提供一个私有的私有两个参数的构造器，并调用父类Enum的构造器
    private DummyEnum(String s, int i)
    {
        super(s, i);
    }
    // 初始化一个private static final的本类空数组
    private static final DummyEnum $VALUES[] = new DummyEnum[0];  

}

包含抽象方法的枚举

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

public enum DummyEnum {
    DUMMY1 {
        public void dummyMethod() {
            System.out.println("[1]: implements abstract method in enum class");
        }
    },  

    DUMMY2 {
        public void dummyMethod() {
            System.out.println("[2]: implements abstract method in enum class");
        }
    };  

    abstract void dummyMethod();  

}

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

  • 原来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，这两个文件出现也应证了上面的匿名内部类初始化的说法。

import java.io.PrintStream;  

public abstract class DummyEnum extends Enum
{
    public static DummyEnum[] values()
    {
        return (DummyEnum[])$VALUES.clone();
    }  

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

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

    // 抽象方法
    abstract void dummyMethod();  

    // 两个pubic static final实例
    public static final DummyEnum DUMMY1;
    public static final DummyEnum DUMMY2;
    private static final DummyEnum $VALUES[];  

    // static代码块进行初始化
    static
    {
        DUMMY1 = new DummyEnum("DUMMY1", 0) {
            public void dummyMethod()
            {
                System.out.println("[1]: implements abstract method in enum class");
            }
        }
;
        DUMMY2 = new DummyEnum("DUMMY2", 1) {
            public void dummyMethod()
            {
                System.out.println("[2]: implements abstract method in enum class");
            }
        }
;
        // 对本类数组进行初始化
        $VALUES = (new DummyEnum[] {
            DUMMY1, DUMMY2
        });
    }
}

正常的枚举类

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

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

public final class CustomEnum extends Enum
{
    public static CustomEnum[] values()
    {
        return (CustomEnum[])$VALUES.clone();
    }  

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

    private CustomEnum(String s, int i, int j, String s1, Object obj)
    {
        super(s, i);
        code = j;
        msg = s1;
        data = obj;
    }  

    public static final CustomEnum FIRST;
    public static final CustomEnum SECOND;
    public static final CustomEnum THIRD;
    private int code;
    private String msg;
    private Object data;
    private static final CustomEnum $VALUES[];  

    static
    {
        FIRST = new CustomEnum("FIRST", 0, 10010, "first", Long.valueOf(100L));
        SECOND = new CustomEnum("SECOND", 1, 10020, "second", "Foo");
        THIRD = new CustomEnum("THIRD", 2, 10030, "third", new Object());
        $VALUES = (new CustomEnum[] {
            FIRST, SECOND, THIRD
        });
    }
}

原文地址：https://blog.51cto.com/14744108/2481186

时间： 2024-10-02 22:02:25

让JAD反编译工具我发现了很多有意思的程序的相关文章

Ubuntu 16.04安装JAD反编译工具（Java）

JAD反编译工具有个好处,就是字节码和源代码一起输出. 官网:https://varaneckas.com/jad/ 安装步骤: 1.下载: 离线版本:(链接: https://pan.baidu.com/s/1skY7tCh 密码: kp19) 2.安装 sudo 7z e jad158e.linux.static.zip -o/opt/jad sudo chmod -R 777 /opt/jad sudo ln -s /opt/jad/jad /usr/bin/jad

如何在eclipse中配置反编译工具JadClipse

Q:为什么有必要在开发环境中配置反编译工具呢? A:  当运行引用了第三方jar包项目时,突然报出了jar包中的某个类的某一行出现异常.我们想看一下这个class文件的代码时,经常出现了如下图所示的场景: god ,我的内心是崩溃的. 去找源码吗?可以,but很浪费时间(除非是maven项目,在pom.xml中引入依赖jar包会连同源文件下载下来). so ,在eclipse中配置反编译工具,就可以随时查看class文件的内容了. 下面就以JadClipse为例,讲述一下配置过程,如有高见,不吝

Eclipse反编译工具Jad及插件JadClipse配置(转)

Eclipse反编译工具Jad及插件JadClipse配置 Jad是一个Java的一个反编译工具,是用命令行执行,和通常JDK自带的java,javac命令是一样的.不过因为是控制台运行,所以用起来不太方便.不过幸好有一个eclipse的插件JadClipse,二者结合可以方便的在eclipse中查看class文件的源代码.下面介绍一下配置:    A.下载JadClipse,http://jadclipse.sourceforge.net/wiki/index.php/Main_Page#Do

Eclipse反编译工具Jad及插件JadClipse配置

Jad是一个Java的一个反编译工 具,是用命令行执行,和通常JDK自带的java,javac命令是一样的.不过因为是控制台运行,所以用起来不太方便.不过幸好有一个eclipse的 插件JadClipse,二者结合可以方便的在eclipse中查看class文件的源代码. 1  下载Eclipse反编译工具Jad. 下载路径:  http://pan.baidu.com/s/1tOSO2 2 把下载包中的 net.sf.jadclipse_3.3.0.jar放入到 eclipse的安装目录下,..

java反编译工具jad及jadclipse

java源码学习中常用到的工具 jad 反编译.class 文件 下载地址及使用(详见压缩包中的readme) http://varaneckas.com/jad/ 如果用eclipse 可以配合 jadclipse插件 http://sourceforge.net/projects/jadclipse/?source=typ_redirect eclipse中 jadclipse插件配置需用到jad 配置使用见如下链接 http://download.csdn.net/detail/xlxio

Java 反编译工具 —— JAD 的下载地址（Windows版/Linux版/Mac OS 版）

Java 反编译工具 —— JAD 的下载地址. 各种版本哦! Windows版,Linux版,Mac OS 版,等等 下载地址: http://varaneckas.com/jad/ Java 反编译工具 -- JAD 的下载地址(Windows版/Linux版/Mac OS 版),布布扣,bubuko.com

使用java反编译工具jad

jad支持所有内部和匿名的类 4. 命令行选择的列表 -a - 用JVM字节格式来注解输出 -af - 同 -a,但是注解的时候用全名称 -clear - 清除所有的前缀 -b - 输出多于的括号 (e.g., if(a) { b(); }, default: no) -d <dir> - 指定输出文件的文件目录 -dead -试图反编译代码的dead 部分(default: no) -disass - 不用用字节码的方式反编译 (no JAVA source generated) -f -

java反编译工具jad

下好以后解压就可以用了,软件就只有一个exe文件和一个帮助文件.在众多的JAVA反编译工具中,有几种非常著名的工具使用了相同的核心引擎--JAD,其中主要包括:FrontEnd Plus.mDeJava.Decafe Pro.Cavaj Java Decompiler.DJ Java     Decompiler.NMI's Java Class Viewer和国产的JAVA源代码反编译专家.JAD本身是一个命令行工具,没有图形界面,上述的这些工具大多是在JAD内核的基础之上加了一个图形界面而已

eclipse安装反编译工具

身为一名程序员来说,日常最常做的就是编写代码和查看别人写好的源代码了,有时候打开别人写的class文件发现根本不是自己想要的,所以给大家介绍一种eclipse中反编译class文件的工具. 第一步:下载工具 url地址:http://download.csdn.net/detail/u010608551/9489420 第二步:解压下载的zip文件,将其中的net.sf.jadclipse_3.3.0.jar拷贝到eclipse安装目录下的plugins文件夹里面 第三步:依次点击eclipse