jdk反編譯後都是null判斷
❶ java里，判斷一個對象是否是null，怎麼判斷
boolean b = null instanceof Object;
java中的類都是Object的子類，如果不是null的話上面的句子肯定是true
不過誰要這么寫肯定會被boss罵
❷ 求教JDK中的反編譯命令
用習慣了著名的反編譯工具jad的話,如果有的時候單給出class文件,要快速看這個class文件
的JDK版本號等,其實不用工具,也可以用JDK自帶的javap命令進行反編譯輸出,下面小結
其用法:
1,javap -verbose 類名
得到的信息如下：
Compiled from "Test.java"
public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 50
Constant pool:
......
可以看出jdk的版本,這個用在判斷某些CLASS的版本是否兼容的時候很有用.
2 最常見的不帶參數的情況：javap 類名
比如某個類:
Java代碼
packagetest;
publicclassTest{
intnumber=5;
publicvoidsayHello(){
System.out.println("Hello");
}
}
則:
C: empjavaptest>javap Test
Compiled from "Test.java"
public class test.Test extends java.lang.Object{
int number;
public test.Test();
public void sayHello();
}
帶參數-c:
則可以看到位元組碼了:
Java代碼
C: empjavaptest>javap-cTest
Compiledfrom"Test.java"
publicclasstest.Testextendsjava.lang.Object{
intnumber;
publictest.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."<init>":()V
4:aload_0
5:iconst_5
6:putfield#2;//Fieldnumber:I
9:return
publicvoidsayHello();
Code:
0:getstatic#3;//Fieldjava/lang/System.out:Ljava/io/PrintStream;
3:ldc#4;//StringHello
5:invokevirtual#5;//Methodjava/io/PrintStream.println:(Ljava/lang/String;)V
8:return
}
帶參數-l: 將顯示行號和局部變數表
-public 只顯示 public 類及成員。
-protected 只顯示 protected 和 public 類及成員。
-package 只顯示包、protected 和 public 類及成員。這是預設設置。
-private 顯示所有類和成員。
❸ java反編譯後是scala嗎
javap是JDK提供的一個反編譯工具。常用的選項有-c -l -s。如果僅僅是想查看編譯的得到的位元組碼文件中函數與變數，不需要帶選項。使用javap很容易發現源文件與編譯後得到的位元組碼文件有什麼不同，可以加深對編譯器的理解。
javap -help
Usage: javap <options> <classes>...
where options include:
-c Disassemble the code
-classpath <pathlist> Specify where to find user class files
-extdirs <dirs> Override location of installed extensions
-help Print this usage message
-J<flag> Pass <flag> directly to the runtime system
-l Print line number and local variable tables
-public Show only public classes and members
-protected Show protected/public classes and members
-package Show package/protected/public classes and members (default)
-private Show all classes and members
-s Print internal type signatures
-bootclasspath <pathlist> Override location of class files loaded by the bootstrap class loader
-verbose Print stack size, number of locals and args for methods If verifying, print reasons for failure
Scala是基於JVM的，所有其位元組碼和Java編譯得到的位元組碼應該是一致的。首先從Hello World開始
object Main {
def main(args: Array[String]) = {
println("Hello, " + args(0))
}
}
使用scalac編譯都得到兩個位元組碼文件：Main.class和Main$.class。
在class文件所在的目錄分別運行javap Main和javap Main$得到如下結果：
Compiled from "Main.scala"
public final class Main extends java.lang.Object{
public static final void main(java.lang.String[]);
}
Compiled from "Main.scala"
public final class Main$ extends java.lang.Object implements scala.ScalaObject{
public static final Main$ MODULE$;
public static {};
public void main(java.lang.String[]);
}
Scala的object是單例模式。上面的反編譯結果給了我們Scala實現原理的提示。MODULE$指向類的實例，相當於this。而方法也是被聲明為靜態的。做了一個測試，更加直觀。http://stackoverflow.com/questions/2347107/what-is-scala-equivalent-of-javas-static-block說如果不是去發射火箭，Object的代碼跟Java的靜態代碼可以認為是等價的。
把上面的代碼稍作修改：
case class Main {
def main(args: Array[String]) = {
println("Hello, " + args(0))
}
}
在class文件所在的目錄分別運行javap Main和javap Main$得到如下結果：
Compiled from "Main.scala"
public class Main extends java.lang.Object implements scala.ScalaObject,scala.Proct,scala.Serializable{
public scala.collection.Iterator proctIterator();
public scala.collection.Iterator proctElements();
public void main(java.lang.String[]);
public int hashCode();
public java.lang.String toString();
public boolean equals(java.lang.Object);
public java.lang.String proctPrefix();
public int proctArity();
public java.lang.Object proctElement(int);
public boolean canEqual(java.lang.Object);
public Main();
}
Compiled from "Main.scala"
public final class Main$ extends scala.runtime.AbstractFunction0 implements scala.ScalaObject,scala.Serializable{
public static final Main$ MODULE$;
public static {};
public final java.lang.String toString();
public boolean unapply(Main);
public Main apply();
public java.lang.Object readResolve();
public java.lang.Object apply();
}
與輸入的文件相比，Scala添加了許多東西：
1. Scala自動幫助Case類生成toString， equals，hashCode等方法。
2. Scala自動幫助Case類生成apply方法，不需要new就可以直接創建類的實例或引用。
3. 對於類的成員，Scala自動生成成員的Getter和Setter。
4. Case類提供對模式匹配的支持。
下面來看Scala對類和隱式轉換的處理，有一個Rational類：
class Rational(n: Int, d: Int) {
require(d != 0)
private val g = gcd(n.abs, d.abs)
val numer = n / g
val denom = d / g
def this(n: Int) = this(n, 1)
def +(that: Rational): Rational =
new Rational(numer * that.denom + that.numer * denom, denom * that.denom)
def +(i: Int): Rational = new Rational(numer + i * denom, denom)
def -(that: Rational): Rational =
new Rational(numer * that.denom - that.numer * denom, denom * that.denom)
def -(i: Int): Rational = new Rational(numer - i * denom, denom)
def *(that: Rational): Rational = new Rational(numer * that.numer, denom * that.denom)
def *(i: Int): Rational = new Rational(numer * i, denom)
def /(that: Rational): Rational = new Rational(numer * that.denom, denom * that.numer)
def /(i: Int): Rational = new Rational(numer, denom * i)
override def toString = numer + "/" + denom
private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
}
object Rational{
implicit def intToRational(x: Int) = new Rational(x)
}
javap得到：
Compiled from "Rational.scala"
public class Rational extends java.lang.Object implements scala.ScalaObject{
public static final Rational intToRational(int);
public int numer();
public int denom();
public Rational(int);
public Rational $plus(Rational);
public Rational $plus(int);
public Rational $minus(Rational);
public Rational $minus(int);
public Rational $times(Rational);
public Rational $times(int);
public Rational $div(Rational);
public Rational $div(int);
public java.lang.String toString();
public Rational(int, int);
}
Compiled from "Rational.scala"
public final class Rational$ extends java.lang.Object implements scala.ScalaObje
ct{
public static final Rational$ MODULE$;
public static {};
public Rational intToRational(int);
}
對於普通類，Scala自動添加的東西稍微少一些。一直出現的還有一個特別的函數：public static {};通過帶參數-c的javap可以看到其匯編代碼：
public static {};
Code:
0: new #9; //class Rational$
3: invokespecial #12; //Method "<init>":()V
6: return
new創建一個對象並將其引用值壓入棧頂，invokespecial調用父類的構造方法，return從當前方法返回void。該方法實際上就是一個創建自身的靜態方法。Java虛擬機指令參考http://blog.csdn.net/noonlyandroid/article/details/6117470
Rational$中的intToRational是我們提供的隱式類型轉換，將一個Int轉換為Rational。其匯編代碼如下：
public Rational intToRational(int);
Code:
0: new #16; //class Rational
3: p
4: iload_1
5: invokespecial #20; //Method Rational."<init>":(I)V
8: areturn
new首先創建一個Rational對象並將其引用值壓入棧頂，p復制棧頂數值並將復制值壓入棧頂，iload_1將第二個int型本地變數推送至棧頂，invokespecial調用Rational的構造方法，最後areturn從當前方法返回對象引用。
我們用如下代碼來測試隱式類型轉換：
import Rational._
object RationalTest {
def main(args: Array[String]) {
val r = new Rational(2,3)
println(2 * r)
}
}
2 * r本身不合法的，因為Int不存在*(Rational)的方法，由於隱式轉換的存在，Scala將做一些轉換工作。上面程序的匯編代碼如下：
Compiled from "RationalTest.scala"
public final class RationalTest$ extends java.lang.Object implements scala.Scala
Object{
public static final RationalTest$ MODULE$;
public static {};
Code:
0: new #9; //class RationalTest$
3: invokespecial #12; //Method "<init>":()V
6: return
public void main(java.lang.String[]);
Code:
0: new #16; //class Rational
3: p
4: iconst_2
5: iconst_3
6: invokespecial #20; //Method Rational."<init>":(II)V
9: astore_2
10: getstatic #25; //Field Rational$.MODULE$:LRational$;
13: iconst_2
14: invokevirtual #29; //Method Rational$.intToRational:(I)LRational;
17: aload_2
18: invokevirtual #33; //Method Rational.$times:(LRational;)LRational;
21: astore_3
22: getstatic #38; //Field scala/Console$.MODULE$:Lscala/Console$;
25: aload_3
26: invokevirtual #42; //Method scala/Console$.println:(Ljava/lang/Object;
)V
29: return
}
在做乘法（$times）之前調用了 intToRational，返回一個Rational對象， 調用Rational對象的*方法已經合法化了。
❹ jdk1.8有字元串判空的方法嗎
默認沒有的，不過可以自己寫一個工具類，判斷是否為null，是否與空字元串相等
❺ java反編譯後得到的源碼 很混亂 怎麼辦
不是每個反編譯都能完美的，用eclipse規范下代碼，然後不符合的語法的方法，自己換成適合當前jdk版本支持的就可以了，反編譯還是得花力氣在代碼的上，偷懶有限啊。