java class反编译后的代码还原

最新推荐文章于 2024-04-28 15:58:57 发布
最新推荐文章于 2024-04-28 15:58:57 发布
阅读量2.9k 收藏 2
点赞数 1
分类专栏： Java decompiling 文章标签： java

前言

 java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，

例如：

label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7 、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter， JVM INSTR monitorexit、

这些一般是由特殊的for循环、try catch finally语句块、synchronized语句反编译后产生的。

下面，就简单介绍一下，一些反编译后的特殊代码的还原规则。本文在Jdk 1.4.2_08+jad 1.58f下测试。jad 1.5.8f可以到这里http://download.csdn.net/source/470540 下载。

 第一部分、for、while循环

1、普通的循环，原始

[java]  view plain copy
  1. public void f1() {  
  2.         boolean flag = false;  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             for (int i = 0; i < 10; i++) {  
  7.                 flag = Boolean.getBoolean("sys");  
  8.                 if (flag) {  
  9.                     System.exit(0);  
  10.                 }  
  11.             }  
  12.         }  
  13.     }  
  14.    
  15.    
反编译后的代码
[java]  view plain copy
  1. public void f1()  
  2.      {  
  3.          boolean flag = false;  
  4.          if(Boolean.getBoolean("sys"))  
  5.          {  
  6.              System.out.println("sys");  
  7.          } else  
  8.          {  
  9.              for(int i = 0; i < 10; i++)  
  10.              {  
  11.                  flag = Boolean.getBoolean("sys");  
  12.                  if(flag)  
  13.                      System.exit(0);  
  14.              }  
  15.    
  16.          }  
  17.      }  
  18.    
  19.       

2、反编译后代码变的很古怪，这是java原代码

[java]  view plain copy
  1. public void f2() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     if (list[i] == 2) {  
  9.                         continue check;  
  10.                     } else {  
  11.                         break;  
  12.                     }  
  13.                 }  
  14.             }  
  15.         }  
  16.     }  
  17.    
  18.        
Java反编译后的代码，部分逻辑丢失。
[java]  view plain copy
  1. public void f2()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(Boolean.getBoolean("sys"))  
  7.              System.out.println("sys");  
  8.          else  
  9.              do  
  10.              {  
  11.                  int i = 0;  
  12.                  if(i >= list.length || list[i] != 2);  
  13.              } while(true);  
  14.      }  
  15.    
  16.       

3、就是比f2（）多了一行System.out.println("list[i]");，反编译后也挺怪的。源码如下：

[java]  view plain copy
  1. public void f3() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     } else {  
  12.                         break;  
  13.                     }  
  14.                 }  
  15.             }  
  16.         }  
  17.     }  
  18.        
反编译后的代码：
[java]  view plain copy
  1. public void f3()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(Boolean.getBoolean("sys"))  
  7.              System.out.println("sys");  
  8.          else  
  9.              do  
  10.              {  
  11.                  int i;  
  12.                  do  
  13.                      i = 0;  
  14.                  while(i >= list.length);  
  15.                  System.out.println("list[i]");  
  16.                  if(list[i] != 2);  
  17.              } while(true);  
  18.      }  
  19.    
  20.       

4、f2（）中的break语言，移动了位置。源码如下：

[java]  view plain copy
  1. public void f4() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     if (list[i] == 2) {  
  9.                         continue check;  
  10.                     }  
  11.                 }  
  12.                 break;  
  13.             }  
  14.         }  
  15.     }  
  16.    
  17.        
反编译后代码：
[java]  view plain copy
  1. public void f4()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          int i;  
  7.          if(Boolean.getBoolean("sys"))  
  8.              System.out.println("sys");  
  9.          else  
  10.  label0:  
  11.              do  
  12.              {  
  13.                  for(i = 0; i < list.length; i++)  
  14.                      if(list[i] == 2)  
  15.                          continue label0;  
  16.    
  17.                  break;  
  18.              } while(true);  
  19.      }  
  20.    
  21.       

5、就是比f4（）多了一行System.out.println("list[i]");，反编译后相当怪的。源码如下：

[java]  view plain copy
  1. public void f5() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     }  
  12.                 }  
  13.                 break;  
  14.             }  
  15.         }  
  16.     }  
  17.        
反编译后比较晕的代码：
[java]  view plain copy
  1. public void f5()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(!Boolean.getBoolean("sys")) goto _L2; else goto _L1  
  7.  _L1:  
  8.          System.out.println("sys");  
  9.            goto _L3  
  10.  _L2:  
  11.          int i = 0;  
  12.            goto _L4  
  13.  _L6:  
  14.          System.out.println("list[i]");  
  15.          if(list[i] != 2) goto _L5; else goto _L2  
  16.  _L5:  
  17.          i++;  
  18.  _L4:  
  19.          if(i < list.length) goto _L6; else goto _L3  
  20.  _L3:  
  21.      }  
  22.       

6、就是比f5()多了一行System.exit(0);代码，但是差异确很大。源码如下：

[java]  view plain copy
  1. public void f6() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     }  
  12.                 }  
  13.                 System.exit(0);  
  14.                 break;  
  15.             }  
  16.         }  
  17.     }  
  18.        
编译后代码，比f5()差异太大了。
[java]  view plain copy
  1. public void f6()  
  2.      {  
  3.          int list[];  
  4.          list = (new int[] {  
  5.              1, 2, 3, 4  
  6.          });  
  7.          if(Boolean.getBoolean("sys"))  
  8.          {  
  9.              System.out.println("sys");  
  10.              break MISSING_BLOCK_LABEL_75;  
  11.          }  
  12.  _L2:  
  13.          int i = 0;  
  14.            goto _L1  
  15.  _L5:  
  16.          System.out.println("list[i]");  
  17.          if(list[i] != 2) goto _L3; else goto _L2  
  18.  _L3:  
  19.          i++;  
  20.  _L1:  
  21.          if(i < list.length) goto _L5; else goto _L4  
  22.  _L4:  
  23.          System.exit(0);  
  24.      }  
  25.       

7、差异就是f6()中的System.exit(0);移动了位置，但是差异确很大。源码如下：

[java]  view plain copy
  1. public void f7() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             check: while (true) {  
  7.                 for (int i = 0; i < list.length; i++) {  
  8.                     System.out.println("list[i]");  
  9.                     if (list[i] == 2) {  
  10.                         continue check;  
  11.                     }  
  12.                 }  
  13.                 break;  
  14.             }  
  15.             System.exit(0);  
  16.         }  
  17.     }  
  18.        
编译后代码，比f6()差异太大了。
[java]  view plain copy
  1. public void f7()  
  2.      {  
  3.          int list[];  
  4.          list = (new int[] {  
  5.              1, 2, 3, 4  
  6.          });  
  7.          if(Boolean.getBoolean("sys"))  
  8.          {  
  9.              System.out.println("sys");  
  10.              break MISSING_BLOCK_LABEL_75;  
  11.          }  
  12.  _L2:  
  13.          int i = 0;  
  14.            goto _L1  
  15.  _L5:  
  16.          System.out.println("list[i]");  
  17.          if(list[i] != 2) goto _L3; else goto _L2  
  18.  _L3:  
  19.          i++;  
  20.  _L1:  
  21.          if(i < list.length) goto _L5; else goto _L4  
  22.  _L4:  
  23.          System.exit(0);  
  24.      }  
  25.       

8、逻辑和f7比没有变，只是多了一些System.out.println()代码。

[java]  view plain copy
  1. public void f8() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             System.out.println(":check while");  
  7.             check: while (true) {  
  8.                 System.out.println("for");  
  9.                 for (int i = 0; i < list.length; i++) {  
  10.                     System.out.println("list[i]");  
  11.                     if (list[i] == 2) {  
  12.                         continue check;  
  13.                     }  
  14.                 }  
  15.                 System.out.println("break");  
  16.                 break;  
  17.             }  
  18.             System.out.println("exit(0)");  
  19.             System.exit(0);  
  20.         }  
  21.     }  
  22.       
反编译后的代码：和f7()比较一下，基本就可以确定反编译后的代码对应关系了。
[java]  view plain copy
  1. public void f8()  
  2.      {  
  3.          int list[];  
  4.          list = (new int[] {  
  5.              1, 2, 3, 4  
  6.          });  
  7.          if(Boolean.getBoolean("sys"))  
  8.          {  
  9.              System.out.println("sys");  
  10.              break MISSING_BLOCK_LABEL_107;  
  11.          }  
  12.          System.out.println(":check while");  
  13.  _L2:  
  14.          int i;  
  15.          System.out.println("for");  
  16.          i = 0;  
  17.            goto _L1  
  18.  _L5:  
  19.          System.out.println("list[i]");  
  20.          if(list[i] != 2) goto _L3; else goto _L2  
  21.  _L3:  
  22.          i++;  
  23.  _L1:  
  24.          if(i < list.length) goto _L5; else goto _L4  
  25.  _L4:  
  26.          System.out.println("break");  
  27.          System.out.println("exit(0)");  
  28.          System.exit(0);  
  29.      }  
  30.       

9、逻辑和f8比没有变，只是多了一行System.out.println()代码，导致了反编译后的/* Loop/switch isn't completed */。

[java]  view plain copy
  1. public void f9() {  
  2.         int[] list = new int[] { 1, 2, 3, 4 };  
  3.         if (Boolean.getBoolean("sys")) {  
  4.             System.out.println("sys");  
  5.         } else {  
  6.             System.out.println(":check while");  
  7.             check: while (true) {  
  8.                 System.out.println("for");  
  9.                 for (int i = 0; i < list.length; i++) {  
  10.                     System.out.println("list[i]");  
  11.                     if (list[i] == 2) {  
  12.                         System.out.println("continue check");  
  13.                         continue check;  
  14.                     }  
  15.                 }  
  16.                 System.out.println("break");  
  17.                 break;  
  18.             }  
  19.             System.out.println("exit(0)");  
  20.             System.exit(0);  
  21.         }  
  22.     }  
  23.  }  
  24.        
反编译后的代码：
[java]  view plain copy
  1. public void f9()  
  2.      {  
  3.          int list[] = {  
  4.              1, 2, 3, 4  
  5.          };  
  6.          if(!Boolean.getBoolean("sys")) goto _L2; else goto _L1  
  7.  _L1:  
  8.          System.out.println("sys");  
  9.            goto _L3  
  10.  _L2:  
  11.          System.out.println(":check while");  
  12.  _L5:  
  13.          System.out.println("for");  
  14.          for(int i = 0; i < list.length; i++)  
  15.          {  
  16.              System.out.println("list[i]");  
  17.              if(list[i] != 2)  
  18.                  continue;  
  19.              System.out.println("continue check");  
  20.              continue; /* Loop/switch isn't completed */  
  21.          }  
  22.    
  23.          System.out.println("break");  
  24.          System.out.println("exit(0)");  
  25.          System.exit(0);  
  26.  _L3:  
  27.          return;  
  28.          if(true) goto _L5; else goto _L4  
  29.  _L4:  
  30.      }  
  31.  }  

   第二部分、异常

   下面的代码前提是类中有如下属性，  Calendar cal = Calendar.getInstance();。

    1、Exceptioin的还原    反编译后的代码如下：

[java]  view plain copy
  1. public boolean f1()  
  2.   
  3. {  
  4.   
  5.     return cal.getTime().after(new Date());  
  6.   
  7.     Exception e;  
  8.   
  9.     e;  
  10.   
  11.     e.printStackTrace();  
  12.   
  13.     return false;  
  14.   
  15. }  
还原后的Java代码
[java]  view plain copy
  1. public boolean f1()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         return cal.getTime().after(new Date());  
  10.   
  11.     }  
  12.   
  13.     catch (Exception e)  
  14.   
  15.     {  
  16.   
  17.         e.printStackTrace();  
  18.   
  19.         return false;  
  20.   
  21.     }  
  22.   
  23. }  

2、finally代码的还原 反编译后的Java代码如下：

[java]  view plain copy
  1. public boolean f2()  
  2.   
  3. {  
  4.   
  5.     boolean flag = cal.getTime().after(new Date());  
  6.   
  7.     System.out.println("finally");  
  8.   
  9.     return flag;  
  10.   
  11.     Exception e;  
  12.   
  13.     e;  
  14.   
  15.     e.printStackTrace();  
  16.   
  17.     System.out.println("finally");  
  18.   
  19.     return false;  
  20.   
  21.     Exception exception;  
  22.   
  23.     exception;  
  24.   
  25.     System.out.println("finally");  
  26.   
  27.     throw exception;  
  28.   
  29.   
  30.   
  31. }  
还原后的代码如下：
[java]  view plain copy
  1. public boolean f2()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         return cal.getTime().after(new Date());  
  10.   
  11.     }  
  12.   
  13.     catch (Exception e)  
  14.   
  15.     {  
  16.   
  17.         e.printStackTrace();  
  18.   
  19.         return false;  
  20.   
  21.     }  
  22.   
  23.     finally  
  24.   
  25.     {  
  26.   
  27.         System.out.println("finally");  
  28.   
  29.     }  
  30.   
  31. }  

3、MISSING_BLOCK_LABEL_的还原反编译后的代码

[java]  view plain copy
  1. public Object f22()  
  2.   
  3. {  
  4.   
  5.     Date date = cal.getTime();  
  6.   
  7.     System.out.println("finally");  
  8.   
  9.     return date;  
  10.   
  11.     Exception e;  
  12.   
  13.     e;  
  14.   
  15.     e.printStackTrace();  
  16.   
  17.     System.out.println("finally");  
  18.   
  19.     break MISSING_BLOCK_LABEL_45;  
  20.   
  21.     Exception exception;  
  22.   
  23.     exception;  
  24.   
  25.     System.out.println("finally");  
  26.   
  27.     throw exception;  
  28.   
  29.     return null;  
  30.   
  31. }  
还原后的Java代码
[java]  view plain copy
  1. public Object f22()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         return cal.getTime();  
  10.   
  11.     }  
  12.   
  13.     catch (Exception e)  
  14.   
  15.     {  
  16.   
  17.         e.printStackTrace();  
  18.   
  19.     }  
  20.   
  21.     finally  
  22.   
  23.     {  
  24.   
  25.         System.out.println("finally");  
  26.   
  27.     }  
  28.   
  29.     return null;  
  30.   
  31. }  

4、异常中:label的还原反编译后的代码

[java]  view plain copy
  1. public String f4()  
  2.   
  3.     throws Exception  
  4.   
  5. {  
  6.   
  7. l0:  
  8.   
  9.     {  
  10.   
  11.         try  
  12.   
  13.         {  
  14.   
  15.             Integer i = new Integer(1);  
  16.   
  17.             if(i.intValue() > 0)  
  18.   
  19.             {  
  20.   
  21.                 System.out.println(i);  
  22.   
  23.                 break label0;  
  24.   
  25.             }  
  26.   
  27.   
  28.   
  29.             System.err.println(i);  
  30.   
  31.         }  
  32.   
  33.         catch(Exception dae)  
  34.   
  35.   
  36.   
  37.   
  38.   
  39.   
  40.   
  41.         {  
  42.   
  43.             System.err.println(dae);  
  44.   
  45.             throw new RuntimeException(dae);  
  46.   
  47.         }  
  48.   
  49.         return null;  
  50.   
  51.     }  
  52.   
  53.     return "Hello";  
  54.   
  55. }  
注意，这个代码有点诡异，实际代码如下：
[java]  view plain copy
  1. public String f4() throws Exception  
  2.   
  3.   
  4.   
  5.   
  6.   
  7. {  
  8.   
  9.     try  
  10.   
  11.     {  
  12.   
  13.         Integer i = new Integer(1);  
  14.   
  15.         if (i.intValue() > 0)  
  16.   
  17.         {  
  18.   
  19.             System.out.println(i);  
  20.   
  21.         }  
  22.   
  23.         else  
  24.   
  25.         {  
  26.   
  27.             System.err.println(i);  
  28.   
  29.             return null;  
  30.   
  31.         }  
  32.   
  33.         return "Hello";  
  34.   
  35.     }  
  36.   
  37.     catch (Exception dae)  
  38.   
  39.     {  
  40.   
  41.         System.err.println(dae);  
  42.   
  43.         throw new RuntimeException(dae);  
  44.   
  45.     }  
  46.   
  47.   
  48.   
  49.   
  50.   
  51.   
  52.   
  53. }  

5、典型数据库操作代码还原 反编译后代码

[java]  view plain copy
  1. public HashMap f5()  
  2.   
  3. {  
  4.   
  5.   
  6.   
  7.     Connection conn = null;  
  8.   
  9.     HashMap hashmap;  
  10.   
  11.   
  12.   
  13.     HashMap map = new HashMap();  
  14.   
  15.     Class.forName("");  
  16.   
  17.     conn = DriverManager.getConnection("jdbc:odbc:");  
  18.   
  19.     PreparedStatement pstmt = conn.prepareStatement("select * from table");  
  20.   
  21.     pstmt.setString(1, "param");  
  22.   
  23.     String columnVallue;  
  24.   
  25.     for(ResultSet rs = pstmt.executeQuery(); rs.next(); map.put(columnVallue, ""))  
  26.   
  27.         columnVallue = rs.getString("column");  
  28.   
  29.   
  30.   
  31.     hashmap = map;  
  32.   
  33.     if(conn != null)  
  34.   
  35.         try  
  36.   
  37.         {  
  38.   
  39.             conn.close();  
  40.   
  41.         }  
  42.   
  43.         catch(SQLException sqlce)  
  44.   
  45.         {  
  46.   
  47.             sqlce.printStackTrace();  
  48.   
  49.         }  
  50.   
  51.     return hashmap;  
  52.   
  53.     ClassNotFoundException cnfe;  
  54.   
  55.     cnfe;  
  56.   
  57.     cnfe.printStackTrace();  
  58.   
  59.     if(conn != null)  
  60.   
  61.         try  
  62.   
  63.         {  
  64.   
  65.             conn.close();  
  66.   
  67.         }  
  68.   
  69.         catch(SQLException sqlce)  
  70.   
  71.         {  
  72.   
  73.             sqlce.printStackTrace();  
  74.   
  75.         }  
  76.   
  77.     break MISSING_BLOCK_LABEL_188;  
  78.   
  79.     SQLException sqle;  
  80.   
  81.     sqle;  
  82.   
  83.     sqle.printStackTrace();  
  84.   
  85.     if(conn != null)  
  86.   
  87.         try  
  88.   
  89.         {  
  90.   
  91.             conn.close();  
  92.   
  93.         }  
  94.   
  95.         catch(SQLException sqlce)  
  96.   
  97.         {  
  98.   
  99.             sqlce.printStackTrace();  
  100.   
  101.         }  
  102.   
  103.     break MISSING_BLOCK_LABEL_188;  
  104.   
  105.     Exception exception;  
  106.   
  107.     exception;  
  108.   
  109.     if(conn != null)  
  110.   
  111.         try  
  112.   
  113.         {  
  114.   
  115.             conn.close();  
  116.   
  117.         }  
  118.   
  119.         catch(SQLException sqlce)  
  120.   
  121.         {  
  122.   
  123.             sqlce.printStackTrace();  
  124.   
  125.         }  
  126.   
  127.     throw exception;  
  128.   
  129.     return null;  
  130.   
  131. }  
实际代码如下：
[java]  view plain copy
  1. public HashMap f5()  
  2.   
  3. {  
  4.   
  5.   
  6.   
  7.     Connection conn = null;  
  8.   
  9.     try  
  10.   
  11.     {  
  12.   
  13.         HashMap map = new HashMap();  
  14.   
  15.         Class.forName("");  
  16.   
  17.         conn = DriverManager.getConnection("jdbc:odbc:");  
  18.   
  19.         PreparedStatement pstmt = conn.prepareStatement("select * from table");  
  20.   
  21.         pstmt.setString(1, "param");  
  22.   
  23.         ResultSet rs = pstmt.executeQuery();  
  24.   
  25.         while (rs.next())  
  26.   
  27.         {  
  28.   
  29.             String columnVallue = rs.getString("column");  
  30.   
  31.             map.put(columnVallue, "");  
  32.   
  33.         }  
  34.   
  35.         return map;  
  36.   
  37.     }  
  38.   
  39.     catch (ClassNotFoundException cnfe)  
  40.   
  41.     {  
  42.   
  43.         cnfe.printStackTrace();  
  44.   
  45.     }  
  46.   
  47.     catch (SQLException sqle)  
  48.   
  49.     {  
  50.   
  51.         sqle.printStackTrace();  
  52.   
  53.     }  
  54.   
  55.     finally  
  56.   
  57.     {  
  58.   
  59.         if (conn != null)  
  60.   
  61.         {  
  62.   
  63.             try  
  64.   
  65.             {  
  66.   
  67.                 conn.close();  
  68.   
  69.             }  
  70.   
  71.             catch (SQLException sqlce)  
  72.   
  73.             {  
  74.   
  75.                 sqlce.printStackTrace();  
  76.   
  77.             }  
  78.   
  79.         }  
  80.   
  81.     }  
  82.   
  83.     return null;  
  84.   
  85. }  

6、两层异常嵌套代码还原 反编译后的代码

[java]  view plain copy
  1. public int f6()  
  2.   
  3. {  
  4.   
  5.     int i = cal.getTime().compareTo(new Date());  
  6.   
  7.     System.out.println("finally");  
  8.   
  9.     return i;  
  10.   
  11.     Exception e1;  
  12.   
  13.     e1;  
  14.   
  15.     e1.printStackTrace();  
  16.   
  17.     System.out.println("finally");  
  18.   
  19.     return -1;  
  20.   
  21.     Exception e2;  
  22.   
  23.     e2;  
  24.   
  25.     e2.printStackTrace();  
  26.   
  27.     System.out.println("finally");  
  28.   
  29.     return -2;  
  30.   
  31.     Exception exception;  
  32.   
  33.     exception;  
  34.   
  35.     System.out.println("finally");  
  36.   
  37.     throw exception;  
  38.   
  39. }  
实际代码
[java]  view plain copy
  1. public int f6()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         try  
  10.   
  11.         {  
  12.   
  13.             return cal.getTime().compareTo(new Date());  
  14.   
  15.         }  
  16.   
  17.         catch (Exception e1)  
  18.   
  19.         {  
  20.   
  21.             e1.printStackTrace();  
  22.   
  23.             return -1;  
  24.   
  25.         }  
  26.   
  27.     }  
  28.   
  29.     catch (Exception e2)  
  30.   
  31.     {  
  32.   
  33.         e2.printStackTrace();  
  34.   
  35.         return -2;  
  36.   
  37.     }  
  38.   
  39.     finally  
  40.   
  41.     {  
  42.   
  43.         System.out.println("finally");  
  44.   
  45.     }  
  46.   
  47. }  

7、非常诡异的代码 反编译后的代码

[java]  view plain copy
  1.     public int f7()  
  2.   
  3.     {  
  4.   
  5.         int i = cal.getTime().compareTo(new Date());  
  6.   
  7.         System.out.println("finally");  
  8.   
  9.         return i;  
  10.   
  11.         Exception e1;  
  12.   
  13.         e1;  
  14.   
  15.         e1.printStackTrace();  
  16.   
  17. _L2:  
  18.   
  19.         System.out.println("finally");  
  20.   
  21.         return -1;  
  22.   
  23.         Exception e2;  
  24.   
  25.         e2;  
  26.   
  27.         e2.printStackTrace();  
  28.   
  29.         if(true) goto _L2; else goto _L1  
  30.   
  31. _L1:  
  32.   
  33.         Exception exception;  
  34.   
  35.         exception;  
  36.   
  37.         System.out.println("finally");  
  38.   
  39.         throw exception;  
  40.   
  41.     }  
原始代码
[java]  view plain copy
  1. public int f7()  
  2.   
  3. {  
  4.   
  5.     try  
  6.   
  7.     {  
  8.   
  9.         try  
  10.   
  11.         {  
  12.   
  13.             return cal.getTime().compareTo(new Date());  
  14.   
  15.         }  
  16.   
  17.         catch (Exception e1)  
  18.   
  19.         {  
  20.   
  21.             e1.printStackTrace();  
  22.   
  23.             return -1;  
  24.   
  25.         }  
  26.   
  27.     }  
  28.   
  29.     catch (Exception e2)  
  30.   
  31.     {  
  32.   
  33.         e2.printStackTrace();  
  34.   
  35.         return -1;  
  36.   
  37.     }  
  38.   
  39.     finally  
  40.   
  41.     {  
  42.   
  43.         System.out.println("finally");  
  44.   
  45.     }  
  46.   
  47. }  
JavaMarker
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java代码的编译、执行
Scott的专栏
05-02 3625
Java程序运行在JVM之上，所以JVM的状态对Java语言会产生很大影响。要了解Java语言的编译、运行机制，首先应对JVM有所了解。 JVM的标准结构如下所示： JVM负责装载class文件并执行。 1.编译机制 JVM规范中定义了class文件的格式，但并未定义Java源码如何编译为class文件，各厂商在实现JDK时通常会将符合Java语言规范的源码编译为class
java反编译使用报错_Java反编译class
weixin_35621342的博客
02-28 1664
工具工具使用jad(还有joda,jd等工具)1、使用jad反编译class文件，jad可以配置到eclipse中当做插件，直接下载jad的eclipse插件jar包，放在eclipse的plugin目录下即可。把下载的jad.exe放在JAVA_HOME的bin下。然后eclipse中点击class文件即可查看到源码。2、使用其他工具，FrontEnd Plus集成了jad的java反编译工具，...
class文件反编译_通过Java反编译揭开一些问题的真相
weixin_39659748的博客
11-28 514
相信很多朋友刚开始见到反编译后的内容的时候，肯定会吐槽：WTF!其实只要静下心来认真了解下，反编译也不过如此，Java字节码的长度为一个字节，顶多256条指令，目前，Java虚拟机规范已经定义了其中约200条编码值对应的指令含义。这里先用一个小例子来开始我们的征程(这里只是举例，要是在真实生活中看到这种代码，估计要骂娘了)：问题来了：最后y和z分别是多少？看到y估计还能看看，看到z就晕乎乎的了，大...
java通过反编译工具生成源码
03-26 645
1.下载一个jd-gui.zip文件 2.下载之后解压，点击jd-gui.exe可执行文件 3.点击file，打开要反编译的class文件 4.选择当前的class文件，点击保存源文件，之后就可以导入项目，查看源代码 5.反编译工具生成源代码导入项目详细视频地址点击打开链接 ...
通过java代码，将jar或class反编译为java文件的四种方式
最新发布
weixin_44005802的博客
04-28 1262
在java项目中对class或jar进行反编译，得到对应java文件
java class反编译后的代码还原（一）
feelinghappy的专栏
08-21 2007
java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，例如：label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7 、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter，这些一般是由特殊的for循环、try ...
android 反编译代码中goto语句还原
HuanWen_Cheng的博客
12-15 805
android 反编译后有很多goto语句该如何正确还原？ 例如下面一段反编译后的代码： public byte[] array() { ByteIO byteio; Iterator iterator; byteio = new ByteIO(size()); int i; if(idList == null) i = 0; else i = id...
java 反编译 goto_java – 反编译代码中的Goto语句导致问题
weixin_30095343的博客
02-13 340
我已经在客户的jar文件中给了一些古老的不受支持的第三方供应商代码,我正在尝试对其进行逆向工程,因此我重新实现了用于连接服务器的相同协议.我已经反编译了它,其中一个类似乎有标签和goto语句.我的编译器在这方面投入了大量的东西,因为我理解它在Java中不支持goto.由于IP问题,我无法发布所有代码,但这里是它的要点(我已将编译器错误放在注释中)：private void methodName(I...
javaClass反编译: jd-gui
08-29
JavaClass反编译是开发者在探索和理解Java代码运行机制时常用的一种技术。jd-gui是一款功能强大的开源工具，专门用于将编译后的.class文件转换回可读的Java源代码，帮助开发者查看和理解二进制字节码背后的逻辑。在...
java Class 反编译软件
01-05
Java Class反编译是将已经编译好的Java字节码（.class文件）转换回可读的Java源代码（.java文件）的过程。这在进行逆向工程、学习开源库的内部实现或调试已丢失源代码的类时非常有用。在Java领域，有一些工具专门...
代码反编译工具
10-29
将.class文件反编译成java文件
么把.class文件反编译成.java 经修改后再编译成.class
07-17
把.class文件反编译成.java 经修改后再编译成.class
class类反编译工具
12-15
在排查错误的时候，有时候会需要查看编译后的class文件，此工具就是反编译的工具
Java类class反编译工具
11-02
Java类class反编译工具是开发者在理解和学习Java字节码或者进行逆向工程时必不可少的辅助工具。这些工具能够将已经编译过的.class文件转换回可读性强的.java源代码，帮助我们查看和理解已有的Java类结构，尤其是在...
Java Class文件反编译工具 jd-gui
11-22
3. 反编译细节：它可以解析出大部分的Java语法，如循环、条件语句、异常处理等，尽管可能无法完美还原原始源代码的注释和精确格式。 4. 内存友好：jd-gui运行时占用的内存资源相对较少，适合开发者日常使用。 5. ...
java反编译+回编教程
qq_28130847的博客
07-28 1332
放到如下文件夹有需要和原.jar包启动需要的依赖的lib依赖的文件夹下。然后执行javac命令如下命令指向需要的依赖classpath和编码然后即可回编。使用jd-gui-windows打开你需要反编译的jar文件或者.class文件。注意此命令在windows下执行才有效linux格式自行百度。-classpath指定依赖所需要的环境。Class文件放回压缩包。找到要修改的class。存为.java文件。.........
java反编译还原_Java .class文件反编译后的特殊代码还原
weixin_35974411的博客
02-12 1170
javaclass反编译后的代码还原(一)Javaclass利用jad反编译之后，偶尔回碰到一些不正常的代码，例如：label0:_L1MISSING_BLOCK_LABEL_30、JVMINSTRret7、JVMINSTRtableswitch13:default269、JVMINSTRmonitorexit、JVMINSTRmonitorenter，这...
关于java的反编译的一些坑，反编译后代码中的$+数字是什么
热门推荐
qq_31448629的博客
03-26 1万+
    本人菜鸡一名，说的不够周到还请见谅。现在拿到一份虚机环境然后想把环境中的war还原成代码，反编译嘛，我觉得大部分人都接触过，看看源码啊啥的。先简单说说本次我用到的反编译工具。首先说推荐的好用的工具JD，基本语法都正常，而且保留了编译后的那些内部类，方法，这匿名类方法具体我下面会说。但是有些语法糖，尤其是for循环反编译后结果有些乱，他总是把for循环的变量做成全局变量，这种时候该怎么办呢。...
class文件反编译成java文件
07-31
class文件反编译成java文件是将已经编译过的class文件还原为java源代码的过程。由于编译过程中，java源代码经过词法分析、语法分析、语义分析等多个步骤生成了字节码文件，因此反编译过程需要对字节码文件进行逆向操作。 使用一些特定的工具，我们可以将class文件中的字节码指令转换为等效的java源代码。这些工具能够将class文件中的常量池、类、字段、方法等信息还原出来，并将字节码指令转化成相应的java代码。然而，由于class文件不仅包含字节码指令，还包含了很多与字节码无关的元数据信息，因此反编译后的java文件通常并不能完全还原原始的java源代码，只是近似地反映出class文件的结构和功能。 反编译java文件有一定的合法性问题，因为这涉及到对他人的代码进行还原和分析，可能侵犯到知识产权。但在某些特定的场景下，比如排查问题、学习研究等，反编译java文件是合法且有益的。 总之，class文件反编译为java文件，是一种将已编译的java源代码还原为人类可读的形式的过程。这个过程帮助我们理解和研究他人的代码，并能在一定程度上了解代码的结构和功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值