一、static代表着什么
在Java中並不存在全局變量的概念，但是我們可以通過static來實現一個“偽全局”的概念，在Java中static表示“全局”或者“靜態”的意思，用來修飾成員變量和成員方法，當然也可以修飾代碼塊。
Java把內存分為棧內存和堆內存，其中棧內存用來存放一些基本類型的變量、數組和對象的引用，堆內存主要存放一些對象。在JVM加載一個類的時候，若該類存在static修飾的成員變量和成員方法，則會為這些成員變量和成員方法在固定的位置開辟一個固定大小的內存區域（只要這個類被加載，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們），有了這些“固定”的特性，那么JVM就可以非常方便地訪問他們。同時如果靜態的成員變量和成員方法不出作用域的話，它們的句柄都會保持不變。同時static所蘊含“靜態”的概念表示着它是不可恢復的，即在那個地方，你修改了，他是不會變回原樣的，你清理了，他就不會回來了。
同時被static修飾的成員變量和成員方法是獨立於該類的，它不依賴於某個特定的實例變量，也就是說它被該類的所有實例共享。所有實例的引用都指向同一個地方，任何一個實例對其的修改都會導致其他實例的變化。
public class User { private static int userNumber = 0 ; public User(){ userNumber ++; } public static void main(String[] args) { User user1 = new User(); User user2 = new User(); System.out.println("user1 userNumber：" + User.userNumber); System.out.println("user2 userNumber：" + User.userNumber); } } ------------ Output: user1 userNumber：2 user2 userNumber：2
二、怎么使用static
static可以用於修飾成員變量和成員方法，我們將其稱之為靜態變量和靜態方法，直接通過類名來進行訪問。
ClassName.propertyName
ClassName.methodName(……)
static修飾的代碼塊表示靜態代碼塊，當JVM裝載類的時候，就會執行這塊代碼，其用處非常大。
1、static變量
static修飾的變量我們稱之為靜態變量，沒有用static修飾的變量稱之為實例變量，他們兩者的區別是：
靜態變量是隨着類加載時被完成初始化的，它在內存中僅有一個，且JVM也只會為它分配一次內存，同時類所有的實例都共享靜態變量，可以直接通過類名來訪問它。但是實例變量則不同，它是伴隨着實例的，每創建一個實例就會產生一個實例變量，它與該實例同生共死。
所以我們一般在這兩種情況下使用靜態變量：對象之間共享數據、訪問方便。
public class TestStatic { public static int count = 0; public static void main(String[] args){ TestStatic test1=new TestStatic(); System.out.println(test1.count); TestStatic test2=new TestStatic(); test2.count++; System.out.println(test1.count+" "+test2.count+" "+TestStatic.count); } }
輸出結果：
0 1 1 1
可見，static變量並不是所在類的某個具體對象所有，而是該類的所有對象所共有的，靜態變量既能被對象調用，也能直接拿類來調用。
2、static方法
static方法一般稱作靜態方法，由於靜態方法不依賴於任何對象就可以進行訪問，因此對於靜態方法來說，是沒有this的，因為它不依附於任何對象，既然都沒有對象，就談不上this了。並且由於這個特性，在靜態方法中不能訪問類的非靜態成員變量和非靜態成員方法，因為非靜態成員方法/變量都是必須依賴具體的對象才能夠被調用。
但是要注意的是，雖然在靜態方法中不能訪問非靜態成員方法和非靜態成員變量，但是在非靜態成員方法中是可以訪問靜態成員方法/變量的。
因為static方法獨立於任何實例，因此static方法必須被實現，而不能是抽象的abstract。
總結一下，對於靜態方法需要注意以下幾點：
（1）它們僅能調用其他的static 方法。
（2）它們只能訪問static數據。
（3）它們不能以任何方式引用this 或super。
舉個簡單的例子：
在上面的代碼中，由於print2方法是獨立於對象存在的，可以直接用過類名調用。假如說可以在靜態方法中訪問非靜態方法/變量的話，那么如果在main方法中有下面一條語句：
MyObject.print2();
此時對象都沒有，str2根本就不存在，所以就會產生矛盾了。同樣對於方法也是一樣，由於你無法預知在print1方法中是否訪問了非靜態成員變量，所以也禁止在靜態成員方法中訪問非靜態成員方法。
而對於非靜態成員方法，它訪問靜態成員方法/變量顯然是毫無限制的。
因此，如果說想在不創建對象的情況下調用某個方法，就可以將這個方法設置為static。我們最常見的static方法就是main方法，至於為什么main方法必須是static的，現在就很清楚了。因為程序在執行main方法的時候沒有創建任何對象，因此只有通過類名來訪問。
另外記住，即使沒有顯示地聲明為static，類的構造器實際上也是靜態方法。
3、static代碼塊
static關鍵字還有一個比較關鍵的作用就是 用來形成靜態代碼塊以優化程序性能。static塊可以置於類中的任何地方，類中可以有多個static塊。在類初次被加載的時候，會按照static塊的順序來執行每個static塊，並且只會執行一次。
為什么說static塊可以用來優化程序性能，是因為它的特性:只會在類加載的時候執行一次。下面看個例子:
class Person{ private Date birthDate; public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { Date startDate = Date.valueOf("1946"); Date endDate = Date.valueOf("1964"); return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; } }
isBornBoomer是用來判斷這個人是否是1946-1964年出生的，而每次isBornBoomer被調用的時候，都會生成startDate和birthDate兩個對象，造成了空間浪費，如果改成這樣效率會更好：
class Person{ private Date birthDate; private static Date startDate,endDate; static{ startDate = Date.valueOf("1946"); endDate = Date.valueOf("1964"); } public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; } }
因此，很多時候會將一些只需要進行一次的初始化操作都放在static代碼塊中進行。
三、static關鍵字的誤區
1、static關鍵字會改變類中成員的訪問權限嗎？
有些初學的朋友會將java中的static與C/C++中的static關鍵字的功能混淆了。在這里只需要記住一點：與C/C++中的static不同，Java中的static關鍵字不會影響到變量或者方法的作用域。在Java中能夠影響到訪問權限的只有private、public、protected（包括包訪問權限）這幾個關鍵字。看下面的例子就明白了：
提示錯誤"Person.age 不可視"，這說明static關鍵字並不會改變變量和方法的訪問權限。
2、能通過this訪問靜態成員變量嗎？
雖然對於靜態方法來說沒有this，那么在非靜態方法中能夠通過this訪問靜態成員變量嗎？先看下面的一個例子，這段代碼輸出的結果是什么？
public class Main { static int value = 33; public static void main(String[] args) throws Exception{ new Main().printValue(); } private void printValue(){ int value = 3; System.out.println(this.value); } }
輸出結果：33
這里面主要考查對this和static的理解。this代表什么？this代表當前對象，那么通過new Main()來調用printValue的話，當前對象就是通過new Main()生成的對象。而static變量是被對象所享有的，因此在printValue中的this.value的值毫無疑問是33。在printValue方法內部的value是局部變量，根本不可能與this關聯，所以輸出結果是33。在這里永遠要記住一點：靜態成員變量雖然獨立於對象，但是不代表不可以通過對象去訪問，所有的靜態方法和靜態變量都可以通過對象訪問（只要訪問權限足夠）。
3、static能作用於局部變量么？
在C/C++中static是可以作用域局部變量的，但是在Java中切記：static是不允許用來修飾局部變量。不要問為什么，這是Java語法的規定。
4、static和final一塊用表示什么？
static final用來修飾成員變量和成員方法，可簡單理解為“全局常量”！
對於變量，表示一旦給值就不可修改，並且通過類名可以訪問。
對於方法，表示不可覆蓋，並且可以通過類名直接訪問。
四、常見的筆試面試題
下面列舉一些面試筆試中經常遇到的關於static關鍵字的題目
1、下面這段代碼的輸出結果是什么？
public class Test extends Base{ static{ System.out.println("test static"); } public Test(){ System.out.println("test constructor"); } public static void main(String[] args) { new Test(); } } class Base{ static{ System.out.println("base static"); } public Base(){ System.out.println("base constructor"); } }
輸出結果：
base static test static base constructor test constructor
至於為什么是這個結果，我們先不討論，先來想一下這段代碼具體的執行過程，在執行開始，先要尋找到main方法，因為main方法是程序的入口，但是在執行main方法之前，必須先加載Test類，而在加載Test類的時候發現Test類繼承自Base類，因此會轉去先加載Base類，在加載Base類的時候，發現有static塊，便執行了static塊。在Base類加載完成之后，便繼續加載Test類，然后發現Test類中也有static塊，便執行static塊。在加載完所需的類之后，便開始執行main方法。在main方法中執行new Test()的時候會先調用父類的構造器，然后再調用自身的構造器。因此，便出現了上面的輸出結果。
2、這段代碼的輸出結果是什么？
public class Test { Person person = new Person("Test"); static{ System.out.println("test static"); } public Test() { System.out.println("test constructor"); } public static void main(String[] args) { new MyClass(); } } class Person{ static{ System.out.println("person static"); } public Person(String str) { System.out.println("person "+str); } } class MyClass extends Test { Person person = new Person("MyClass"); static{ System.out.println("myclass static"); } public MyClass() { System.out.println("myclass constructor"); } }
輸出結果：
test static myclass static person static person Test test constructor person MyClass myclass constructor
類似地，我們還是來想一下這段代碼的具體執行過程。首先加載Test類，因此會執行Test類中的static塊。接着執行new MyClass()，而MyClass類還沒有被加載，因此需要加載MyClass類。在加載MyClass類的時候，發現MyClass類繼承自Test類，但是由於Test類已經被加載了，所以只需要加載MyClass類，那么就會執行MyClass類的中的static塊。在加載完之后，就通過構造器來生成對象。而在生成對象的時候，必須先初始化父類的成員變量，因此會執行Test中的Person person = new Person()，而Person類還沒有被加載過，因此會先加載Person類並執行Person類中的static塊，接着執行父類的構造器，完成了父類的初始化，然后就來初始化自身了，因此會接着執行MyClass中的Person person = new Person()，最后執行MyClass的構造器。
3、這段代碼的輸出結果是什么？
public class Test { static{ System.out.println("test static 1"); } public static void main(String[] args) { } static{ System.out.println("test static 2"); } }
運行結果：
test static 1 test static 2
雖然在main方法中沒有任何語句，但是還是會輸出，原因上面已經講述過了。另外，static塊可以出現類中的任何地方（只要不是方法內部，記住，任何方法內部都不行），並且執行是按照static塊的順序執行的。
4、靜態代碼塊的初始化順序
class Parent { static String name = "hello"; { System.out.println("parent block"); } static { System.out.println("parent static block"); } public Parent() { System.out.println("parent constructor"); } } class Child extends Parent { static String childName = "hello"; { System.out.println("child block"); } static { System.out.println("child static block"); } public Child() { System.out.println("child constructor"); } } public class TestStatic { public static void main(String[] args) { new Child();// 語句(*) } }
問題：當執行完語句(*)時，打印結果是什么順序？為什么？
輸出結果：
parent static block child static block parent block parent constructor child block child constructor
分析:當執行new Child()時，它首先去看父類里面有沒有靜態代碼塊，如果有，它先去執行父類里面靜態代碼塊里面的內容，當父類的靜態代碼塊里面的內容執行完畢之后，接着去執行子類(自己這個類)里面的靜態代碼塊，當子類的靜態代碼塊執行完畢之后，它接着又去看父類有沒有非靜態代碼塊，如果有就執行父類的非靜態代碼塊，父類的非靜態代碼塊執行完畢，接着執行父類的構造方法；父類的構造方法執行完畢之后，它接着去看子類有沒有非靜態代碼塊，如果有就執行子類的非靜態代碼塊。子類的非靜態代碼塊執行完畢再去執行子類的構造方法，這個就是一個對象的初始化順序。
總結:
對象的初始化順序:首先執行父類靜態的內容，父類靜態的內容執行完畢后，接着去執行子類的靜態的內容，當子類的靜態內容執行完畢之后，再去看父類有沒有非靜態代碼塊，如果有就執行父類的非靜態代碼塊，父類的非靜態代碼塊執行完畢，接着執行父類的構造方法；父類的構造方法執行完畢之后，它接着去看子類有沒有非靜態代碼塊，如果有就執行子類的非靜態代碼塊。子類的非靜態代碼塊執行完畢再去執行子類的構造方法。總之一句話，靜態代碼塊內容先執行，接着執行父類非靜態代碼塊和構造方法，然后執行子類非靜態代碼塊和構造方法。
注意:子類的構造方法，不管這個構造方法帶不帶參數，默認的它都會先去尋找父類的不帶參數的構造方法。如果父類沒有不帶參數的構造方法，那么子類必須用supper關鍵子來調用父類帶參數的構造方法，否則編譯不能通過。