你知道么，static的用法至少有五種？
初識static
static是“靜態”的意思，這個大家應該都清楚，靜態變量，靜態方法大家也都能隨口道來。但是，你真的理解靜態變量和靜態方法么？除了這些static還有什么用處？
事實上，static大體上有五種用法：
靜態導入。靜態變量。靜態方法。靜態代碼段。靜態內部類。接下來，我們將逐個看一下這些用法。
靜態導入
也許有的人是第一次聽說靜態導入，反正我在寫這篇文章之前是不清楚static還可以這樣用的。什么是靜態導入呢？我們先來看一段代碼：
public class OldImport { public static void main(String[] args) { double a = Math.cos(Math.PI / 2); double b = Math.pow(2.4,1.2); double r = Math.max(a,b); System.out.PRintln(r); }}1234567891012345678910看到這段代碼，你有什么想說的么？啥？沒有？你不覺得Math出現的次數太多了么？
恩，你覺得好像是有點多，怎么辦呢？看下面：
import static java.lang.Math.*;public class StaticImport { public static void main(String[] args) { double a = cos(PI / 2); double b = pow(2.4,1.2); double r = max(a,b); System.out.println(r); }}123456789101112123456789101112這就是靜態導入。我們平時使用一個靜態方法的時候，都是【類名.方法名】，使用靜態變量的時候都是【類名.變量名】，如果一段代碼中頻繁的用到了這個類的方法或者變量，我們就要寫好多次類名，比如上面的Math，這顯然不是喜歡偷懶的程序員所希望做的，所以出現了靜態導入的功能。
靜態導入，就是把一個靜態變量或者靜態方法一次性導入，導入后可以直接使用該方法或者變量，而不再需要寫對象名。
怎么樣，是不是覺得很方便？如果你以前不知道這個，你大概在竊喜，以后可以偷懶了。先別高興的太早，看下面的代碼：
import static java.lang.Double.*;import static java.lang.Integer.*;import static java.lang.Math.*;import static java.text.NumberFormat.*;public class ErrorStaticImport { // 輸入半徑和精度要求，計算面積 public static void main(String[] args) { double s = PI * parseDouble(args[0]); NumberFormat nf = getInstance(); nf.setMaximumFractionDigits(parseInt(args[1])); formatMessage(nf.format(s)); } // 格式化消息輸出 public static void formatMessage(String s){ System.out.println(" 圓面積是："+s); }}1234567891011121314151617181912345678910111213141516171819就這么一段程序，看著就讓人火大：常量PI，這知道，是圓周率；parseDouble 方法可能是Double 類的一個轉換方法，這看名稱也能猜測到。那緊接著的getInstance 方法是哪個類的？是ErrorStaticImport本地類的方法？不對呀，沒有這個方法，哦，原來是NumberFormate 類的方法，這和formateMessage 本地方法沒有任何區別了。這代碼也太難閱讀了，這才幾行？要是你以后接別人的代碼，看到成千上萬行這種代碼大概你想死的心都有了吧？
所以，不要濫用靜態導入！！！不要濫用靜態導入！！！不要濫用靜態導入！！！
正確使用靜態導入的姿勢是什么樣子的呢？
import java.text.NumberFormat;import static java.lang.Double.parseDouble;import static java.lang.Integer.parseInt;import static java.lang.Math.PI;import static java.text.NumberFormat.getInstance;public class ErrorStaticImport { // 輸入半徑和精度要求，計算面積 public static void main(String[] args) { double s = PI * parseDouble(args[0]); NumberFormat nf = getInstance(); nf.setMaximumFractionDigits(parseInt(args[1])); formatMessage(nf.format(s)); } // 格式化消息輸出 public static void formatMessage(String s){ System.out.println(" 圓面積是："+s); }}123456789101112131415161718192021123456789101112131415161718192021沒錯，這才是正確的姿勢，你使用哪個方法或者哪個變量，就把他導入進來，而不要使用通配符（*）！
并且，由于不用寫類名了，所以難免會和本地方法混淆。所以，本地方法在起名字的時候，一定要起得有意義，讓人一看這個方法名大概就能知道你這個方法是干什么的，而不是什么method1(),method2()，鬼知道你寫的是什么。。
總結：
不使用*通配符，除非是導入靜態常量類（只包含常量的類或接口）。方法名是具有明確、清晰表象意義的工具類。這里有一個小插曲，就是我在用idea寫示例代碼的時候，想用通配符做靜態導入，結果剛寫完，idea自動給我改成非通配符的了，嘿我這暴脾氣，我再改成通配符！特喵的。。又給我改回去了。。。事實證明，用一個好的IDE，是可以提高效率，比呢且優化好你的代碼的，有的時候后，想不優化都不行。哈哈哈，推薦大家使用idea。
靜態變量
這個想必大家都已經很熟悉了。我就再啰嗦幾句。
java類提供了兩種類型的變量：用static修飾的靜態變量和不用static修飾的成員變量。
靜態變量屬于類，在內存中只有一個實例。當jtbl所在的類被加載的時候，就會為該靜態變量分配內存空間，該變量就可以被使用。jtbl有兩種被使用方式：【類名.變量名】和【對象.變量名】。
實例變量屬于對象，只有對象被創建后，實例對象才會被分配空間，才能被使用。他在內存中存在多個實例，只能通過【對象.變量名】來使用。
第一篇文章《萬物皆對象》中講過，java的內存大體上有四塊：堆，棧，靜態區，常量區。
其中的靜態區，就是用來放置靜態變量的。當靜態變量的類被加載時，虛擬機就會在靜態區為該變量開辟一塊空間。所有使用該靜態變量的對象都訪問這一個空間。
一個例子學習靜態變量與實例變量。
public class StaticAttribute { public static int staticInt = 10; public static int staticIntNo ; public int nonStatic = 5; public static void main(String[] args) { StaticAttribute s = new StaticAttribute(); System.out.println("s.staticInt= " + s.staticInt); System.out.println("StaticAttribute.staticInt= " + StaticAttribute.staticInt); System.out.println("s.staticIntNo= " + s.staticIntNo); System.out.println("StaticAttribute.staticIntNo= " + StaticAttribute.staticIntNo); System.out.println("s.nonStatic= " + s.nonStatic); System.out.println("使用s,讓三個變量都+1"); s.staticInt ++; s.staticIntNo ++; s.nonStatic ++; StaticAttribute s2 = new StaticAttribute(); System.out.println("s2.staticInt= " + s2.staticInt); System.out.println("StaticAttribute.staticInt= " + StaticAttribute.staticInt); System.out.println("s2.staticIntNo= " + s2.staticIntNo); System.out.println("StaticAttribute.staticIntNo= " + StaticAttribute.staticIntNo); System.out.println("s2.nonStatic= " + s2.nonStatic); }}// 結果：// s.staticInt= 10// StaticAttribute.staticInt= 10// s.staticIntNo= 0// StaticAttribute.staticIntNo= 0// s.nonStatic= 5// 使用s,讓三個變量都+1// s2.staticInt= 11// StaticAttribute.staticInt= 11// s2.staticIntNo= 1// StaticAttribute.staticIntNo= 1// s2.nonStatic= 51234567891011121314151617181920212223242526272829303132333435363738394041424344454612345678910111213141516171819202122232425262728293031323334353637383940414243444546從上例可以看出，靜態變量只有一個，被類擁有，所有對象都共享這個靜態變量，而實例對象是與具體對象相關的。
與c++不同的是，在java中，不能在方法體中定義static變量，我們之前所說的變量，都是類變量，不包括方法內部的變量。
那么，靜態變量有什么用途呢？
靜態變量的用法
最開始的代碼中有一個靜態變量 — PI，也就是圓周率。為什么要把它設計為靜態的呢？因為我們可能在程序的任何地方使用到這個變量，如果不是靜態的，那么我們每次使用這個變量的時候都要創建一個Math對象，不僅代碼臃腫而且浪費了內存空間。
所以，當你的某一個變量會經常被外部代碼訪問的時候，可以考慮設計為靜態的。
靜態方法
同樣，靜態方法大家應該也比較熟悉了。就是在定義類的時候加一個static修飾符。
與靜態變量一樣，java類也同時提供了static方法和非static方法。
static方法是類的方法，不需要創建對象就可以使用，比如Math類里面的方法。使用方法【對象.方法名】或者【類名.方法名】非static方法是對象的方法，只有對象唄創建出來以后才可以被使用。使用方法【對象.方法名】static怎么用代碼寫我想大家都知道，這里我就不舉例了，你們看著煩，我寫著也煩。
注意事項
static方法中不能使用this和super關鍵字，不能調用非static方法，只能訪問所屬類的靜態變量和靜態方法。因為當static方法被調用的時候，這個類的對象可能還沒有創建，即使已經被創建了，也無法確認調用那個對象的方法。不能訪問非靜態方法同理。
用途—單例模式
static的一個很常見的用途是實現單例模式。單例模式的特點是一個類只能有一個實例，為了實現這一功能，必須隱藏該類的構造函數，即把構造函數聲明為private，并提供一個創建對象的方法。我們來看一下怎么實現：
public class Singleton { private static Singleton singleton; public static Singleton getInstance() { if (singleton == null) { singleton = new Singleton(); } return singleton; } private Singleton() { }}12345678910111213141234567891011121314這個類，只會有一個對象。
其他
用public修飾的static成員變量和成員方法本質是全局變量和全局方法，當聲明它類的對象時，不生成static變量的副本，而是類的所有實例共享同一個static變量。
static 變量前可以有private修飾，表示這個變量可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用–廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。
實際上你需要搞明白，private是訪問權限限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問權限關鍵字的效果也以此類推。
靜態方法的用場
靜態變量可以被非靜態方法調用，也可以被靜態方法調用。但是靜態方法只能被靜態方法調用。
一般工具方法會設計為靜態方法，比如Math類中的所有方法都是驚天的，因為我們不需要Math類的實例，我們只是想要用一下里面的方法。所以，你可以寫一個通用的 工具類，然后里面的方法都寫成靜態的。
靜態代碼塊
在講靜態代碼塊之前，我們先來看一下，什么是代碼塊。
什么是代碼塊
所謂代碼塊就是用大括號將多行代碼封裝在一起，形成一個獨立的數據體，用于實現特定的算法。一般來說代碼塊是不能單獨運行的，它必須要有運行主體。在Java中代碼塊主要分為四種：普通代碼塊，靜態代碼塊，同步代碼塊和構造代碼塊。
四種代碼塊
普通代碼塊
普通代碼塊是我們用得最多的也是最普遍的，它就是在方法名后面用{}括起來的代碼段。普通代碼塊是不能夠單獨存在的，它必須要緊跟在方法名后面。同時也必須要使用方法名調用它。
public void common(){ System.out.println("普通代碼塊執行"); } 123123靜態代碼塊
靜態代碼塊就是用static修飾的用{}括起來的代碼段，它的主要目的就是對靜態屬性進行初始化。
靜態代碼塊可以有多個，位置可以隨便放，它不在任何的方法體內，JVM加載類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先后順序依次執行它們，每個代碼塊只會被執行一次。
看一段代碼：
public class Person{ private Date birthDate; public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { Date startDate = Date.valueOf("1990"); Date endDate = Date.valueOf("1999"); return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; }} 1234567891011121312345678910111213isBornBoomer是用來這個人是否是1990-1999年出生的，而每次isBornBoomer被調用的時候，都會生成startDate和birthDate兩個對象，造成了空間浪費，如果改成這樣效率會更好：
public class Person{ private Date birthDate; private static Date startDate,endDate; static{ startDate = Date.valueOf("1990"); endDate = Date.valueOf("1999"); } public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; }}1234567891011121314151612345678910111213141516因此，很多時候會將一些只需要進行一次的初始化操作都放在static代碼塊中進行。
同步代碼塊
使用 synchronized 關鍵字修飾，并使用“{}”括起來的代碼片段，它表示同一時間只能有一個線程進入到該方法塊中，是一種多線程保護機制。
等講多線程的時候，在詳細講解這種代碼塊~
構造代碼塊
在類中直接定義沒有任何修飾符、前綴、后綴的代碼塊即為構造代碼塊。我們明白一個類必須至少有一個構造函數，構造函數在生成對象時被調用。構造代碼塊和構造函數一樣同樣是在生成一個對象時被調用，那么構造代碼在什么時候被調用？如何調用的呢？
看一段代碼：
public class CodeBlock { private int a = 1; private int b ; private int c ; //靜態代碼塊 static { int a = 4; System.out.println("我是靜態代碼塊1"); } //構造代碼塊 { int a = 0; b = 2; System.out.println("構造代碼塊1"); } public CodeBlock(){ this.c = 3; System.out.println("構造函數"); } public int add(){ System.out.println("count a + b + c"); return a + b + c; } //靜態代碼塊 static { System.out.println("我是靜態代碼塊2，我什么也不做"); } //構造代碼塊 { System.out.println("構造代碼塊2"); } public static void main(String[] args) { CodeBlock c = new CodeBlock(); System.out.println(c.add()); System.out.println(); System.out.println("*******再來一次*********"); System.out.println(); CodeBlock c1 = new CodeBlock(); System.out.println(c1.add()); }}//結果：//我是靜態代碼塊1//我是靜態代碼塊2，我什么也不做//構造代碼塊1//構造代碼塊2//構造函數//count a + b + c//6////*******再來一次*********////構造代碼塊1//構造代碼塊2//構造函數//count a + b + c//612345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061621234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162這段代碼綜合了構造代碼塊，普通代碼塊和靜態代碼塊。我們來總結一下：
靜態代碼塊只會執行一次。有多個靜態代碼塊時按順序依次執行。構造代碼塊每次創建新對象時都會執行。有多個時依次執行。執行順序：靜態代碼塊 > 構造代碼塊 > 構造函數。構造代碼塊和靜態代碼塊有自己的作用域，作用域內部的變量不影響作用域外部。構造代碼塊的應用場景：
1、 初始化實例變量 如果一個類中存在若干個構造函數，這些構造函數都需要對實例變量進行初始化，如果我們直接在構造函數中實例化，必定會產生很多重復代碼，繁瑣和可讀性差。這里我們可以充分利用構造代碼塊來實現。這是利用編譯器會將構造代碼塊添加到每個構造函數中的特性。
2、 初始化實例環境 一個對象必須在適當的場景下才能存在，如果沒有適當的場景，則就需要在創建對象時創建此場景。我們可以利用構造代碼塊來創建此場景，尤其是該場景的創建過程較為復雜。構造代碼會在構造函數之前執行。
靜態內部類
被static修飾的內部類，它可以不依賴于外部類實例對象而被實例化，而通常的內部類需要在外部類實例化后才能實例化。靜態內部類不能與外部類有相同的名字，不能訪問外部類的普通成員變量，只能訪問內部類中的靜態成員和靜態方法（包括私有類型）。
由于還沒有詳細講解過內部類，這里先一筆帶過，在講解內部類的時候會詳細分析靜態內部類。
只有內部類才能被static修飾，普通的類不可以。
總結
本文內容就先到這里，我們再來回顧一下學了什么：
static關鍵字的五種用法：
靜態導入靜態變量靜態方法靜態代碼塊代碼塊
普通代碼塊靜態代碼塊構造代碼塊同步代碼塊回憶一下這些知識點的內容，如果想不起來，記得翻上去再看一遍~
彩蛋 —— 繼承+代碼塊的執行順序
如果既有繼承，又有代碼塊，執行的順序是怎樣呢？
public class Parent { static { System.out.println("父類靜態代碼塊"); } { System.out.println("父類構造代碼塊"); } public Parent(){ System.out.println("父類構造函數"); }}class Children extends Parent { static { System.out.println("子類靜態代碼塊"); } { System.out.println("子類構造代碼塊"); } public Children(){ System.out.println("子類構造函數"); } public static void main(String[] args) { new Children(); }}//結果：//父類靜態代碼塊//子類靜態代碼塊//父類構造代碼塊//父類構造函數//子類構造代碼塊//子類構造函數1234567891011121314151617181920212223242526272829303132333435363712345678910111213141516171819202122232425262728293031323334353637結果你也知道了：
先執行靜態內容(先父類后子類)，然后執行父類非靜態，最后執行子類非靜態。（非靜態包括構造代碼塊和構造函數，構造代碼塊先執行）
如果文中有錯誤或者你有其他見解，請及時與我聯系。不保證文章內容的完全正確性。
原文地址：http://blog.csdn.net/QQ_31655965/article/details/54767522
轉載請注明出處。
看完文章，如果你學到了你以前不知道的知識，點個贊支持一下喲~
新聞熱點
疑難解答
