Java static關鍵字以及Java靜態變量和靜態方法
static 修飾符能夠與變量、方法一起使用，表示是“靜態”的。

靜態變量和靜態方法能夠通過類名來訪問，不需要創建一個類的對象來訪問該類的靜態成員，所以static修飾的成員又稱作類變量和類方法。靜態變量與實例變量不同，實例變量總是通過對象來訪問，因為它們的值在對象和對象之間有所不同。

請看下面的例子：

public class Demo {  static int i = 10;  int j;  Demo() {    this.j = 20;  }  public static void main(String[] args) {    System.out.println("類變量 i=" + Demo.i);    Demo obj = new Demo();    System.out.println("實例變量 j=" + obj.j);  }}

運行結果：

類變量 i=10實例變量 j=20

static 的內存分配

靜態變量屬于類，不屬于任何獨立的對象，所以無需創建類的實例就可以訪問靜態變量。之所以會產生這樣的結果，是因為編譯器只為整個類創建了一個靜態變量的副本，也就是只分配一個內存空間，雖然有多個實例，但這些實例共享該內存。實例變量則不同，每創建一個對象，都會分配一次內存空間，不同變量的內存相互獨立，互不影響，改變 a 對象的實例變量不會影響 b 對象。

請看下面的代碼：

public class Demo {  static int i;  int j;  public static void main(String[] args) {    Demo obj1 = new Demo();    obj1.i = 10;    obj1.j = 20;        Demo obj2 = new Demo();        System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);    System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);  }}

運行結果：

obj1.i=10, obj1.j=20obj2.i=10, obj2.j=0

注意：靜態變量雖然也可以通過對象來訪問，但是不被提倡，編譯器也會產生警告。

上面的代碼中，i 是靜態變量，通過 obj1 改變 i 的值，會影響到 obj2；j 是實例變量，通過 obj1 改變 j 的值，不會影響到 obj2。這是因為 obj1.i 和 obj2.i 指向同一個內存空間，而 obj1.j 和 obj2.j 指向不同的內存空間，請看下圖：

注意：static 的變量是在類裝載的時候就會被初始化。也就是說，只要類被裝載，不管你是否使用了這個static 變量，它都會被初始化。

小結：類變量(class variables)用關鍵字 static 修飾，在類加載的時候，分配類變量的內存，以后再生成類的實例對象時，將共享這塊內存（類變量），任何一個對象對類變量的修改，都會影響其它對象。外部有兩種訪問方式：通過對象來訪問或通過類名來訪問。
靜態方法

靜態方法是一種不能向對象實施操作的方法。例如，Math 類的 pow() 方法就是一個靜態方法，語法為 Math.pow(x, a)，用來計算 x 的 a 次冪，在使用時無需創建任何 Math 對象。

因為靜態方法不能操作對象，所以不能在靜態方法中訪問實例變量，只能訪問自身類的靜態變量。

以下情形可以使用靜態方法：
一個方法不需要訪問對象狀態，其所需參數都是通過顯式參數提供（例如 Math.pow()）。
一個方法只需要訪問類的靜態變量。

讀者肯定注意到，main() 也是一個靜態方法，不對任何對象進行操作。實際上，在程序啟動時還沒有任何對象，main() 方法是程序的入口，將被執行并創建程序所需的對象。

關于靜態變量和靜態方法的總結：
一個類的靜態方法只能訪問靜態變量；
一個類的靜態方法不能夠直接調用非靜態方法；
如訪問控制權限允許，靜態變量和靜態方法也可以通過對象來訪問，但是不被推薦；
靜態方法中不存在當前對象，因而不能使用 this，當然也不能使用 super；
靜態方法不能被非靜態方法覆蓋；
構造方法不允許聲明為 static 的；
局部變量不能使用static修飾。

靜態方法舉例：

public class Demo {  static int sum(int x, int y){    return x + y;  }  public static void main(String[] args) {    int sum = Demo.sum(10, 10);    System.out.println("10+10=" + sum);  }}

運行結果：

10+10=20

static 方法不需它所屬的類的任何實例就會被調用，因此沒有 this 值，不能訪問實例變量，否則會引起編譯錯誤。

注意：實例變量只能通過對象來訪問，不能通過類訪問。
靜態初始器（靜態塊）

塊是由大括號包圍的一段代碼。靜態初始器(Static Initializer)是一個存在于類中、方法外面的靜態塊。靜態初始器僅僅在類裝載的時候（第一次使用類的時候）執行一次，往往用來初始化靜態變量。

示例代碼：

public class Demo {  public static int i;  static{    i = 10;    System.out.println("Now in static block.");  }  public void test() {    System.out.println("test method: i=" + i);  }  public static void main(String[] args) {    System.out.println("Demo.i=" + Demo.i);    new Demo().test();  }}

運行結果是：

Now in static block.Demo.i=10test method: i=10

靜態導入

靜態導入是 Java 5 的新增特性，用來導入類的靜態變量和靜態方法。

一般我們導入類都這樣寫：

import packageName.className; // 導入某個特定的類

或

import packageName.*; // 導入包中的所有類

而靜態導入可以這樣寫：

import static packageName.className.methonName; // 導入某個特定的靜態方法

或

import static packageName.className.*; // 導入類中的所有靜態成員

導入后，可以在當前類中直接用方法名調用靜態方法，不必再用 className.methodName 來訪問。

對于使用頻繁的靜態變量和靜態方法，可以將其靜態導入。靜態導入的好處是可以簡化一些操作，例如輸出語句 System.out.println(); 中的 out 就是 System 類的靜態變量，可以通過 import static java.lang.System.*; 將其導入，下次直接調用 out.println() 就可以了。

請看下面的代碼：

import static java.lang.System.*;import static java.lang.Math.random;public class Demo {  public static void main(String[] args) {    out.println("產生的一個隨機數：" + random());  }}

運行結果：

產生的一個隨機數：0.05800891549018705

Java final關鍵字：阻止繼承和多態
在 Java 中，聲明類、變量和方法時，可使用關鍵字 final 來修飾。final 所修飾的數據具有“終態”的特征，表示“最終的”意思。具體規定如下：
final 修飾的類不能被繼承。
final 修飾的方法不能被子類重寫。
final 修飾的變量（成員變量或局部變量）即成為常量，只能賦值一次。
final 修飾的成員變量必須在聲明的同時賦值，如果在聲明的時候沒有賦值，那么只有 一次賦值的機會，而且只能在構造方法中顯式賦值，然后才能使用。
final 修飾的局部變量可以只聲明不賦值，然后再進行一次性的賦值。

final 一般用于修飾那些通用性的功能、實現方式或取值不能隨意被改變的數據，以避免被誤用，例如實現數學三角方法、冪運算等功能的方法，以及數學常量π=3.141593、e=2.71828 等。

事實上，為確保終態性，提供了上述方法和常量的 java.lang.Math 類也已被定義為final 的。

需要注意的是，如果將引用類型（任何類的類型）的變量標記為 final，那么該變量不能指向任何其它對象。但可以改變對象的內容，因為只有引用本身是 final 的。

如果變量被標記為 final，其結果是使它成為常數。想改變 final 變量的值會導致一個編譯錯誤。下面是一個正確定義 final 變量的例子：

public final int MAX_ARRAY_SIZE = 25; // 常量名一般大寫

常量因為有 final 修飾，所以不能被繼承。

請看下面的代碼：

public final class Demo{  public static final int TOTAL_NUMBER = 5;  public int id;  public Demo() {    // 非法，對final變量TOTAL_NUMBER進行二次賦值了    // 因為++TOTAL_NUMBER相當于 TOTAL_NUMBER=TOTAL_NUMBER+1    id = ++TOTAL_NUMBER;  }  public static void main(String[] args) {    final Demo t = new Demo();    final int i = 10;    final int j;    j = 20;    j = 30; // 非法，對final變量進行二次賦值  }}

final 也可以用來修飾類（放在 class 關鍵字前面），阻止該類再派生出子類，例如 Java.lang.String 就是一個 final 類。這樣做是出于安全原因，因為要保證一旦有字符串的引用，就必須是類 String 的字符串，而不是某個其它類的字符串（String 類可能被惡意繼承并篡改）。

方法也可以被 final 修飾，被 final 修飾的方法不能被覆蓋；變量也可以被 final 修飾，被 final 修飾的變量在創建對象以后就不允許改變它們的值了。一旦將一個類聲明為 final，那么該類包含的方法也將被隱式地聲明為 final，但是變量不是。

被 final 修飾的方法為靜態綁定，不會產生多態（動態綁定），程序在運行時不需要再檢索方法表，能夠提高代碼的執行效率。在Java中，被 static 或 private 修飾的方法會被隱式的聲明為 final，因為動態綁定沒有意義。

由于動態綁定會消耗資源并且很多時候沒有必要，所以有一些程序員認為：除非有足夠的理由使用多態性，否則應該將所有的方法都用 final 修飾。

這樣的認識未免有些偏激，因為 JVM 中的即時編譯器能夠實時監控程序的運行信息，可以準確的知道類之間的繼承關系。如果一個方法沒有被覆蓋并且很短，編譯器就能夠對它進行優化處理，這個過程為稱為內聯(inlining)。例如，內聯調用 e.getName() 將被替換為訪問 e.name 變量。這是一項很有意義的改進，這是由于CPU在處理調用方法的指令時，使用的分支轉移會擾亂預取指令的策略，所以，這被視為不受歡迎的。然而，如果 getName() 在另外一個類中被覆蓋，那么編譯器就無法知道覆蓋的代碼將會做什么操作，因此也就不能對它進行內聯處理了。