『壹』 如何靜態測試 java 代碼
所有的這些新的工具使得確保代碼質量比以前簡單得多，不過您還需要知道如何使用它們。 代碼度量 「監視圈復雜度」展示如何使用簡單的代碼度量工具和基於 Java 的工具來監視代碼復雜度。 「軟體架構的代碼質量」解釋了如何持續地監視並糾正會影響軟體架構的長期生存能力的代碼質量方面。 「用代碼度量進行重構」介紹如何使用相同的代碼度量方法和提取方法模式進行有針對性的重構。 靜態分析工具 靜態分析工具承諾無需開發人員費勁就能找出代碼中已有的缺陷。當然，如果有多年的編寫經驗，就會知道這些承諾並不是一定能兌現。盡管如此，好的靜態分析工具仍然是工具箱中的無價之寶： FindBugs 是一個靜態分析工具，它檢查類或者 JAR 文件，將位元組碼與一組缺陷模式進行對比以發現可能的問題： 「FindBugs，第 1 部分」和「第 2 部分」分別介紹使用 FindBugs 的原因和方法以及如何編寫自定義檢測器以查找特定於應用程序的問題。 「消除 bug」展示了這個靜態分析工具如何幫助分析代碼。 「平衡測試，第 1 部分、第 2 部分 和第 3 部分」討論如何通過引進 FindBugs 靜態代碼分析工具來改進管理軟體質量的方式。 PMD 是一個開源的靜態分析工具，它分析 Java 源代碼，並找出潛在的 bug： 「用 PMD 鏟除 bug」解釋如何使用 PMD 內置的規則以及您自己定製的規則集來提高 Java 代碼質量。
『貳』 Java 中 靜態方法與非靜態方法的區別
靜態方法和實例方法的區別主要體現在兩個方面：
在外部調用靜態方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式。而實例方法只有後面這種方式。也就是說，調用靜態方法可以無需創建對象。
靜態方法在訪問本類的成員時，只允許訪問靜態成員（即靜態成員變數和靜態方法），而不允許訪問實例成員變數和實例方法；實例方法則無此限制。
下面幾個例子展示了這一區別。
1、調用靜態方法示例。
//-----------文件名hasStaticMethod.java，程序編號1-----------------public
class hasStaticMethod{//定義一個靜態方法public static void
callMe(){System.out.println("This is a static method.");}}
下面這個程序使用兩種形式來調用靜態方法。
//-----------文件名invokeStaticMethod.java，2-----------------
public class invokeStaticMethod{
public static void main(String args[]){
hasStaticMethod.callMe(); //不創建對象，直接調用靜態方法
hasStaticMethod oa = new hasStaticMethod(); //創建一個對象oa.callMe(); //利用對象來調用靜態方法}}
程序3.36兩次調用靜態方法，都是允許的，程序的輸出如下：
This is a static method.This is a static method.
允許不創建對象而調用靜態方法，是Java為了減少程序員調用某些常用方法時的麻煩，而允許程序員按照傳統的C語言中使用函數的方式來使用方法。典型的例子是前面某些程序中使用"Math.ramdon()"來獲取隨機數。
2、靜態方法訪問成員變數示例。
//-----------文件名accessMember.java，程序編號3.37-----------------class
accessMember{private static int sa; //定義一個靜態成員變數private int ia;
//定義一個實例成員變數//下面定義一個靜態方法static void statMethod(){int i = 0;
//正確，可以有自己的局部變數sa = 10; //正確，靜態方法可以使用靜態變數otherStat(); //正確，可以調用靜態方法ia =
20; //錯誤，不能使用實例變數insMethod(); //錯誤，不能調用實例方法}static void otherStat(){}
//下面定義一個實例方法 void insMethod(){int i = 0; //正確，可以有自己的局部變數sa = 15;
//正確，可以使用靜態變數ia = 30; //正確，可以使用實例變數statMethod(); //正確，可以調用靜態方法}}
本例其實可以概括成一句話：靜態方法只能訪問靜態成員，實例方法可以訪問靜態和實例成員。之所以不允許靜態方法訪問實例成員變數，是因為實例成員變數是屬於某個對象的，而靜態方法在執行時，並不一定存在對象。同樣，因為實例方法可以訪問實例成員變數，如果允許靜態方法調用實例方法，將間接地允許它使用實例成員變數，所以它也不能調用實例方法。基於同樣的道理，靜態方法中也不能使用關鍵字this。
main()方法是一個典型的靜態方法，它同樣遵循一般靜態方法的規則，所以它可以由系統在創建對象之前就調用。
『叄』 java static問題
static表示「全局」或者「靜態」的意思，用來修飾成員變數和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全局變數的概念。
被static修飾的成員變數和成員方法獨立於該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。
只要這個類被載入，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們。因此，static對象可以在它的任何對象創建之前訪問，無需引用任何對象。
用public修飾的static成員變數和成員方法本質是全局變數和全局方法，當聲明它類的對象市，不生成static變數的副本，而是類的所有實例共享同一個static變數。
static變數前可以有private修飾，表示這個變數可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問許可權限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問許可權關鍵字的效果也以此類推。
static修飾的成員變數和成員方法習慣上稱為靜態變數和靜態方法，可以直接通過類名來訪問，訪問語法為：
類名.靜態方法名(參數列表...)
類名.靜態變數名
用static修飾的代碼塊表示靜態代碼塊，當Java虛擬機（JVM）載入類時，就會執行該代碼塊（用處非常大，呵呵）。
1、static變數
按照是否靜態的對類成員變數進行分類可分兩種：一種是被static修飾的變數，叫靜態變數或類變數；另一種是沒有被static修飾的變數，叫實例變數。
兩者的區別是：
對於靜態變數在內存中只有一個拷貝（節省內存），JVM只為靜態分配一次內存，在載入類的過程中完成靜態變數的內存分配，可用類名直接訪問（方便），當然也可以通過對象來訪問（但是這是不推薦的）。
對於實例變數，沒創建一個實例，就會為實例變數分配一次內存，實例變數可以在內存中有多個拷貝，互不影響（靈活）。
所以一般在需要實現以下兩個功能時使用靜態變數：
在對象之間共享值時
方便訪問變數時
2、靜態方法
靜態方法可以直接通過類名調用，任何的實例也都可以調用，
因此靜態方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變數和實例方法(就是不帶static的成員變數和成員成員方法)，只能訪問所屬類的靜態成員變數和成員方法。
因為實例成員與特定的對象關聯！這個需要去理解，想明白其中的道理，不是記憶！！！
因為static方法獨立於任何實例，因此static方法必須被實現，而不能是抽象的abstract。
例如為了方便方法的調用，Java API中的Math類中所有的方法都是靜態的，而一般類內部的static方法也是方便其它類對該方法的調用。
靜態方法是類內部的一類特殊方法，只有在需要時才將對應的方法聲明成靜態的，一個類內部的方法一般都是非靜態的
3、static代碼塊
static代碼塊也叫靜態代碼塊，是在類中獨立於類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內，JVM載入類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先後順序依次執行它們，每個代碼塊只會被執行一次。例如：
public class Test5 {
private static int a;
private int b;
static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自動生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
}
運行結果：
3
hhahhahah
1000
4
5
利用靜態代碼塊可以對一些static變數進行賦值，最後再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調用而不用創建實例。
4、static和final一塊用表示什麼
static final用來修飾成員變數和成員方法，可簡單理解為「全局常量」！
對於變數，表示一旦給值就不可修改，並且通過類名可以訪問。
對於方法，表示不可覆蓋，並且可以通過類名直接訪問。
有時你希望定義一個類成員，使它的使用完全獨立於該類的任何對象。通常情況下，類成員必須通過它的類的對象訪問，但是可以創建這樣一個成員，它能夠被它自己使用，而不必引用特定的實例。在成員的聲明前面加上關鍵字static(靜態的)就能創建這樣的成員。如果一個成員被聲明為static，它就能夠在它的類的任何對象創建之前被訪問，而不必引用任何對象。你可以將方法和變數都聲明為static。static 成員的最常見的例子是main( ) 。因為在程序開始執行時必須調用main() ，所以它被聲明為static。
聲明為static的變數實質上就是全局變數。當聲明一個對象時，並不產生static變數的拷貝，而是該類所有的實例變數共用同一個static變數。聲明為static的方法有以下幾條限制：
•
它們僅能調用其他的static 方法。
•
它們只能訪問static數據。
•
它們不能以任何方式引用this 或super（關鍵字super 與繼承有關，在下一章中描述）。
如果你需要通過計算來初始化你的static變數，你可以聲明一個static塊，Static 塊僅在該類被載入時執行一次。下面的例子顯示的類有一個static方法，一些static變數，以及一個static 初始化塊：
// Demonstrate static variables，methods，and blocks.
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[]) {
meth(42);
}
}
一旦UseStatic 類被裝載，所有的static語句被運行。首先，a被設置為3，接著static 塊執行(列印一條消息)，最後，b被初始化為a*4 或12。然後調用main()，main() 調用meth() ，把值42傳遞給x。3個println ( ) 語句引用兩個static變數a和b，以及局部變數x 。
注意：在一個static 方法中引用任何實例變數都是非法的。
下面是該程序的輸出：
Static block initialized.
x = 42
a = 3
b = 12
在定義它們的類的外面，static 方法和變數能獨立於任何對象而被使用。這樣，你只要在類的名字後面加點號運算符即可。例如，如果你希望從類外面調用一個static方法，你可以使用下面通用的格式：
classname.method( )
這里，classname 是類的名字，在該類中定義static方法。可以看到，這種格式與通過對象引用變數調用非static方法的格式類似。一個static變數可以以同樣的格式來訪問——類名加點號運算符。這就是Java 如何實現全局功能和全局變數的一個控製版本。
下面是一個例子。在main() 中，static方法callme() 和static 變數b在它們的類之外被訪問。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是該程序的輸出：
a = 42
b = 99
static成員是不能被其所在class創建的實例訪問的。
如果不加static修飾的成員是對象成員，也就是歸每個對象所有的。
加static修飾的成員是類成員，就是可以由一個類直接調用，為所有對象共有的
『肆』 java的靜態變數 static
1.首先你 for (i = 0; i < 3; i++) 里的i就是那個靜態的i了 你把i=0了 於是靜態的i就變成0了 於是執行完循環i就變成3了
2.你的for循環並沒有定義局部的i 親
把那個for循環改成for ( int i = 0; i < 3; i++)
就可以了
『伍』 java靜態方法和動態方法的區別，本人初學者，要有例子的。詳細的話可以給精彩。
1.靜態的方法在整個應用程序其間存儲在內存中,速度快，但佔用內存.
class A
{
public static string b()
{
return "Hello";
}
}
用法: A.b(); //調用方便
靜態方法可以通過類名直接調用，
2.動態的方法在先聲明類實例才能調用類中的方法.
class A
{
public string b()
{
return "Hello";
}
}
用法: A a = new a(); a.b();
3.一般使用頻繁的方法用靜態方法，用的少的方法用動態的。靜態的速度快，占內存。動態的速度相對慢些，但調用完後，立即釋放類，可以節省內存，可以根據自己的需要選擇是用動態方法還是靜態方法。
4.靜態方法主要的問題就是數據同步的問題。如果你的靜態方法的類中不保存私有變數那麼什麼問題都不會有的。最好是包要操作的數據全部以參數的方式傳到方法中去
5. 靜態方法是類方法，調用時不需要創建類實例。
6. 靜態方法是靜態綁定到子類，不是被繼承。
『陸』 JAVA 里什麼是靜態方法,什麼是動態方法
請先看下面這段程序：
public class Hello{
public static void main(String[] args){ //(1)
System.out.println("Hello,world!"); //(2)
}
}
看過這段程序，對於大多數學過Java 的從來說，都不生疏。即使沒有學過Java，而學過其它的高
級語言，例如C，那你也應該能看懂這段代碼的意思。它只是簡單的輸出「Hello,world」，一點
別的用處都沒有，然而，它卻展示了static要害字的主要用法。
在1處，我們定義了一個靜態的方法名為main，這就意味著告訴Java編譯器，我這個方法不需要創建一個此類的對象即可使用。你還得你是怎麼運行這個程序嗎？一般，我們都是在命令行下，打入如下的命令(加下劃線為手動輸入)：
javac Hello.java
java Hello
Hello,world!
這就是你運行的過程，第一行用來編譯Hello.java這個文件，執行完後，假如你查看當前，會發現多了一個Hello.class文件，那就是第一行產生的Java二進制位元組碼。第二行就是執行一個Java程序的最普遍做法。執行結果如你所料。在2中，你可能會想，為什麼要這樣才能輸出。好，我們來分解一下這條語句。（假如沒有安裝Java文檔，請到Sun的官方網站瀏覽J2SE API）首先，System是位於java.lang包中的一個核心類，假如你查看它的定義，你會發現有這樣一行：public static final PrintStream out;接著在進一步，點擊PrintStream這個超鏈接，在METHOD頁面，你會看到大量定義的方法，查找println，會有這樣一行：
public void println(String x)。好了，現在你應該明白為什麼我們要那樣調用了，out是System的一個靜態變數，所以可以直接使用，而out所屬的類有一個println方法。
靜態方法
通常，在一個類中定義一個方法為static，那就是說，無需本類的對象即可調用此方法。如下所示：
class Simple{
static void go(){
System.out.println("Go...");
}
}
public class Cal{
public static void main(String[] args){
Simple.go();
}
}
調用一個靜態方法就是「類名.方法名」,靜態方法的使用很簡單如上所示。一般來說，靜態方法經常為應用程序中的其它類提供一些實用工具所用，在Java的類庫中大量的靜態方法正是出於此目的而定義的。
靜態變數
靜態變數與靜態方法類似。所有此類實例共享此靜態變數，也就是說在類裝載時，只分配一塊存儲空間，所有此類的對象都可以操控此塊存儲空間，當然對於final則另當別論了。看下面這段代碼：
class Value{
static int c=0;
static void inc(){
c++;
}}
class Count{
public static void prt(String s){
System.out.println(s);
}
public static void main(String[] args){
Value v1,v2;
v1=new Value();
v2=new Value();
prt("v1.c="+v1.c+"
v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
}}
結果如下：
v1.c=0 v2.c=0
v1.c=1 v2.c=1
由此可以證實它們共享一塊存儲區。static變數有點類似於C中的全局變數的概念。值得探討的是靜態變數的初始化問題。我們修改上面的程序：
class Value{
static int c=0;
Value(){
c=15;
}
Value(int i){
c=i;
}
static void inc(){
c++;
}}
class Count{
public static void prt(String s){
System.out.println(s);
}
Value v=new Value(10);
static Value v1,v2;
static{
prt("v1.c="+v1.c+"
v2.c="+v2.c);
v1=new Value(27);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v2=new Value(15);
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
public static void main(String[] args){
Count ct=new Count();
prt("ct.c="+ct.v.c);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
prt("ct.c="+ct.v.c);
}}
運行結果如下：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
這個程序展示了靜態初始化的各種特性。假如你初次接觸Java，結果可能令你吃驚。可能會對static後加大括弧感到困惑。首先要告訴你的是，static定義的變數會優先於任何其它非static變數，不論其出現的順序如何。正如在程序中所表現的，雖然v出現在v1和v2的前面，但是結果卻是v1和v2的初始化在v的前面。在static{後面跟著一段代碼，這是用來進行顯式的靜態變數初始化，這段代碼只會初始化一次，且在類被第一次裝載時。假如你能讀懂並理解這段代碼，會幫助你對static要害字的熟悉。在涉及到繼續的時候，會先初始化父類的static變數，然後是子類的，依次類推。非靜態變數不是本文的主題，在此不做具體討論，請參考Think in Java中的講解。
靜態類
通常一個普通類不答應聲明為靜態的，只有一個內部類才可以。這時這個聲明為靜態的內部類可以直接作為一個普通類來使用，而不需實例一個外部類。如下代碼所示：
public class StaticCls{
public static void main(String[] args){
OuterCls.InnerCls oi=new OuterCls.InnerCls();
}}
class OuterCls{
public static class InnerCls{
InnerCls(){
System.out.println("InnerCls");
}
}}
輸出結果會如你所料：
InnerCls
『柒』 JUnit test 如何做Java靜態方法測試
使用junit測試Java靜態私有方法，通過以下案例進行分析：
測試目標類如下：
packagecn.outofmemory.junit;
publicclassTestTarget{
/**
*移除正則表達式中需要轉義的字元
*@paramwword
*@return移除正則表達式中需要轉義的字元
*@authorAdministrator
*@date2015-7-11
*/
(Stringw){
if(w==null){
returnnull;
}
String[]convertedChars={"\",".","+","*","(",")","{","}","[","]","?","/","^","$","|"};
for(Stringc:convertedChars){
w=w.replace(c,"\"+c);
}
returnw;
}
}
測試方法：
@Test
publicvoidtestConvert4Regex()throwsException{
Stringinput="A+";
Stringexpected="A\+";
MethodtargetMethod=TestTarget.class.getDeclaredMethod("convert4Regex",String.class);
targetMethod.setAccessible(true);
Objectactual=targetMethod.invoke(TestTarget.class,newObject[]{input});
assertEquals(expected,actual);
}
『捌』 Java靜態代碼塊和靜態方法的區別
沒有靜態類，如果有什麼需要提前實例化的話，參考下面方式
static
int
i;
static{
i=1;
}
public
static
void
f(){
system.out.println(i);
}
『玖』 請分析在JAVA中,靜態類,抽象類,實例類,靜態方法,抽象方法,介面,以及繼承,實現的關系概念
如果真要看數的話，這些概念幾頁書都看不完！看完了你看不懂，還必須看十幾頁的範例，自己練習幾十遍才能搞懂！
先聲明一點：下面都是我個人的理解，但是否理解正確我不敢保證，所以如果因為我的誤導使你有錯誤的理解，我在此表示抱歉。
我這里就用最簡單的例子簡單的說明：
1.靜態方法：
1>類A裡面有非靜態方法b，則調用b方法是：new A().b();
實際原理：b並不存在內存中，需要實例化A來獲取b
實際應用：b方法中需要用到A類里的變數
2>類A裡面有靜態方法b，則調用b方法是：A.b();
實際原理：b已經存在內存中，可通過A的名稱直接調用，無需實例化A類
實際應用：b方法中不需要用到A類里的變數
2.靜態類，只存在於內部類，如果內部類裡面有靜態方法，則內部類必須是靜態類。實際應用中極少用到，至少我出來工作後從來沒用到過。
1>類A裡面啊有非靜態類B，B裡面有非靜態方法c，調用c方法是：new A().new B().c();
2>類A裡面啊有非靜態類B，B裡面有靜態方法c，這種情況不存在！因為c是靜態方法，B就必須是靜態類！
3>類A裡面啊有靜態類B，B裡面有靜態方法c，調用c方法是：A.B.c();
1>類A裡面啊有靜態類B，B裡面有非靜態方法c，調用c方法是：new A.B().c();
3.實例類，就是一般的類和非靜態內部類。沒啥好說的。
4.抽象方法
只有方法名和傳入參數，沒有實現內容。
例如有一個方法c如下：
public void c(String printText) {
System.out.println(printText);
}
對應的抽象方法就是：
public void c(String printText);
但抽象方法只能放在「抽象類」和「介面」中
5.介面類，介面類裡面只能放抽象方法，需要實現類來實現介面的抽象方法。
介面的目的有點類似書本的「目錄」所起的作用，用戶只需要關注方法實現了什麼功能，而不用去關注具體實現方法的內容。
常見的例子有:
Set<String> set = new TreeSet<String>();
Set<String> set = new HashSet<String>();
同一個介面，則必須介面規定的固有屬性，Set介面就是唯一性。
不同實現類，則具備不一樣特殊屬性：
TreeSet具備自動排序功能，但不能保存null
HashSet無序，但能存null
另外，一個實現類可實現（implements）多個介面類，但必須實現所有介面裡面的所有抽象方法。
6.抽象類，夾在一般類和介面中間，可放普通方法，也可放抽象方法，但抽象方法必須加abstract。
例如：
abstract public void test();
抽象類如果被一般類所繼承（extends），則一般類必須實現抽象類的抽象方法。
7.繼承，所有類之間都有可以有一個繼承關系，但要注意以下幾點：
1>介面類只能繼承介面類，可多繼承
2>除介面類以為的所有類，只能單繼承，即只能繼承一個類，並且不能繼承介面！
3>一般而言繼承之後，子類就擁有父類的方法，但如果父類有方法是私有的，則即使繼承也無法調用。
以上所說只是一個簡單的概括，肯定有很多遺漏的細節！還是必須多看書！多練習！！
『拾』 java中靜態方法與非靜態方法的區別
在外部調用靜態方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式。而實例方法只有後面這種方式。也就是說，調用靜態方法可以無需創建對象。
靜態方法在訪問本類的成員時，只允許訪問靜態成員（即靜態成員變數和靜態方法），而不允許訪問實例成員變數和實例方法；實例方法則無此限制。