final定義的變量可以看做一個常量，不能被改變； 
final定義的方法不能被覆蓋； 
final定義的類不能被繼承。 
final static 就是再加上static的特性就可以了

static 和final是沒有直接關系的

static 是在內存中分配一塊區域，供整個類通用，所有的類的對象都享有它的共同的值

static 和final的區別 
一、static ： 
什麽情況下我們要使用static呢？ 
1、只想用一個存儲區域來保存一個特定的數據——無論要創建多少個對象，甚至根本不創 建對象。 
2、我們需要一個特殊的方法，它沒有與這個類的任何對象關聯。也就是說，即使沒有創建對象，也需要一個能調用的方法。 
為滿足這兩方面的要求，可使用static（靜態）關鍵字。 
下面我先舉個例子：

一旦將什麽東西設為static，數據或方法就不會同那個類的任何對象實例聯系到一起。所以盡管從未創建那個類的一個對象，仍能調用一個static方法，或訪問一些static數據。 
為了將數據成員或方法設為static，只需在定義前置和這個關鍵字即可。 
例如，下述代碼能生成一個static數據成員，並對其初始化：

class StaticTest { 
Static int i = 47; 
}

現在，盡管我們制作了兩個StaticTest對象，但它們仍然只占據StaticTest.i的一個存儲空間。這兩個對象都共享同樣的i。請考察下述代碼： 
StaticTest st1 = new StaticTest(); 
StaticTest st2 = new StaticTest(); 
此時，無論st1.i還是st2.i都有同樣的值47，因為它們引用的是同樣的內存區域。 
有兩個辦法可引用一個static變量。正如上面展示的那樣，可通過一個對象命名它，如st2.i。亦可直接用它的類名引用，而這在非靜態成員裏是行不通的（最好用這個辦法引用static變量，因為它強調了那個變量的“靜態”本質）。 
StaticTest.i++; 
其中，++運算符會使變量增值。此時，無論st1.i還是st2.i的值都是48。

類似的邏輯也適用於靜態方法。既可象對其他任何方法那樣通過一個對象引用靜態方法，亦可用特殊的語法格式“類名.方法()”加以引用。靜態方法的定義是類似的： 
class StaticFun { 
static void incr() { StaticTest.i++; } 
} 
從中可看出，StaticFun的方法incr()使靜態數據i增值。可用典型的方法調用incr()：

StaticFun sf = new StaticFun(); 
sf.incr();

或者，由於incr()是一種靜態方法，所以可通過它的類直接調用： 
StaticFun.incr(); 
對方法來說，static一項重要的用途就是幫助我們在不必創建對象的前提下調用那個方法。 
舉簡單一例如下： 
public class TestStatic { 
public static void main(String args[]){ 
PhoneCard mycard_1 = new PhoneCard();//創建第一張卡對象 
PhoneCard mycard_2 = new PhoneCard();//創建第二張卡對象

mycard_1.addFee = 0.8;//給第一張卡的附加費addFee賦值為0.8 
//註意到我們沒有給第二張卡賦值

System.out.println("第一張卡的附加費：" + mycard_1.addFee); 
System.out.println("第二張卡的附加費：" + mycard_2.addFee); 
//發現沒有？輸出結果中第二張卡的附加費也是0.8 了。 
System.out.println("卡的附加費：" + PhoneCard.addFee); 
//該句的打印輸出表明卡類的附加費都是0.8 
} 
}

class PhoneCard{ 
static double addFee;//靜態域addFee 
}

該例創建了兩個類，PhoneCard類只定義了一個變量，TestStatic類裏創建了兩個PhoneCard類對象，並給其中的一個對象的附加費addFee賦值，而另一個對象沒賦值。

由上例可以看出，靜態域保存在類的公共存儲單元，而不是保存在對象的存儲單元內。

static 修飾方法時是同理。

二、final: 
final可修飾類、域（變量和常量）、方法 （而static不修飾類)

1、final修飾類，表示該類不可被繼承。 
如定義了一個final類： 
final class SnowBird{ 
int i; 
String s; 
static void fly(){ 
System.out.println("snowbird is flying"); 
} 
}

//現在定義一個類，試圖繼承SnowBird類:

public class Bird extends SnowBird{ 
public static void main(String[] args){ 
SnowBird.fly(); 
} 
}

把上面的兩個類拷貝到文件中，文件名保存為Bird.java ,現在編譯看看會出現什麽問題？ 
出錯信息是：cannot inherit from final SnowBird 
表明final 類不可被繼承。

那麽，final修飾變量是怎麽樣呢？ 
2、final修飾變量 
程序中經常需要定義各種類型的常量，如：3.24268,"201"等等。這時候我們就用final來修飾一個類似於標誌符名字。如：

final String connectNumber = "201"; 
final表明 connectNumber是一個常量，它的取值在整個過程都不會改變。

如果把final 去掉則connectNumber就成為變量了。

有時我們為了節省空間，常量通常聲明為 static .因為如上所說的 static 用的是類的內存空間。

3、修飾方法： 
final修飾的方法，稱為最終方法。最終方法不可被子類重新定義，即不可被覆蓋。 
如父類定義了public void fly(){ ....} 
則子類就不能定義 
public void fly(){。。。。。。} 
但註意覆蓋與重載的區別。不能被覆蓋並不是不能被重載，如你還可以定義 
public void fly(int i){.....}，

舉個例子如下：

class FinalValue { 
static final int i = 1; 
final void fly(){ 
System.out.println("SnowBird is flying over FinalValue "); 
} 
}

class TestFinal extends FinalValue { 
int i = 2; 
void fly(){ 
System.out.println("SnowBird is flying over TestFinal"); 
System.out.println("In class FinalValue static Final i = "+ FinalValue.i); 
System.out.println("In class TestFinal i = "+ i); 
} 
void fly(String s){ 
System.out.println("fly("+ s + ")"); 
} 
}

public class Test { 
public static void main(String args[]){ 
TestFinal tf = new TestFinal(); 
tf.fly(); 
tf.fly("ok"); 
System.out.println(tf.i); 
} 
} 
把上面的程序保存為Test.java編譯看看，出現什麽錯誤？ 
然後，把TestFinal類中的 void fly(){ ... } 註解掉 
即 如下 
/* void fly(){ 
System.out.println("SnowBird is flying over TestFinal"); 
System.out.println("In class FinalValue static Final i = "+ FinalValue.i); 
System.out.println("In class TestFinal i = "+ i); 
}*/
現在再編譯看看通過了嗎？ 可見重載與覆蓋的區別了吧。 還發現 FinalValue中的 i 與 TestFinal中的 i 沒關系 。因為對於變量而言，重定義只是父類的同名域被隱藏了而已。

final和static