1.   abstract（抽象）

用法：類修飾符的一種，可以用來修飾類，方法，被修飾的類不能夠實例化（即不能用new關鍵字得到對象），被修飾的方法不能夠實現(xiàn)。一個抽象類中不一定要有抽象方法，但是一個類里面有抽象方法就一定是抽象類。如果由類要繼承抽象類的話，必須要實現(xiàn)里面的抽象方法。構造方法和靜態(tài)方法不可以修飾為抽象。

例子：

       public abstract class Animal {

              public abstract void cry();

              public void run(){

                     System.out.println(“跑的方法……”);

}

}

abstract關鍵字可以修改類或方法。

abstract類可以擴展（增加子類），但不能直接實例化。

abstract方法不在聲明它的類中實現(xiàn)，但必須在某個子類中重寫

-示例-

public abstract  class  MyClass{}

public abstract  StringmyMethod();

采用abstract方法的類本來就是抽象類，并且必須聲明為abstract。abstract類不能實例化。

僅當abstract類的子類實現(xiàn)其超類的所有abstract方法時，才能實例化abstract類的子類。這種類稱為具體類，以區(qū)別于abstract類 。

final 類的方法都不能是 abstract，因為 final 類不能有子類。

< 1> abstract抽象用在類的聲明中來指明一個類是不能被實例化的，但是可以被其他類繼承。一個抽象類可以使用抽象方法，抽象方法不需要實現(xiàn)，但是需要在子類中被實現(xiàn)。它的用途是向子類提供通用的信息。抽象類可以包含正常的類包含的任何東西，也就是說，類和實例變量，以及帶有任何修飾詞的方法。只有抽象類可能有抽象方法。如果一個不是抽象的類包含一個抽象方法，那么將會出現(xiàn)編譯錯誤。 
例子：如果下列的一個成立，那么一個有抽象方法：

 a.它顯式的聲明了一個abstract方法。

 b.它從它的直接父類繼承了一個抽象方法。 
c.一個直接的類的父借口聲明或繼承了它的一個方法（這因此必須是abstract） 

<2>如果用戶聲明private,static,和final方法為abstarct，編譯錯誤將出現(xiàn)。

不可能重設一個private方法，因為一個abstarct  private永遠不能被實現(xiàn)。

static方法總是可用的，因此必須有一個實現(xiàn)；static abstract將永遠沒有實現(xiàn)。

final方法不能被重設，因此不回有final abstract方法的實現(xiàn)。

2.extends 解釋：擴充，擴展 
用法：一個類繼承另一個類的關鍵字，當出現(xiàn)了這個關鍵字，兩個類就有了繼承關系，extends前面的類，我們稱之為父類。

extends后面的類，我們稱之為子類。有了繼承關系之后，我們就說子類擁有父類繼承下來的所有非私有的成員（包括了屬性，方法），但是不包括構造方法 。

extends 關鍵字用在 class 或 interface 聲明中，用于指示所聲明的類或接口是其名稱后跟有 extends 關鍵字的類或接口的子類。 
-示例- 
public class Rectangle extends Polygon{ }

 -注釋- 
在上例中，Rectangle 類繼承 Polygon 類的所有 public 和 protected 變量和方法。 
Rectangle 類可以重寫 Polygon 類的任何非 final 方法。 一個類只能擴展一個其他類。

3.final 
解釋：最終的，決定性的 
用法：修飾符的一種，它可以用來修飾類，方法，屬性。當一個屬性被修飾成final的之后，這個屬性變成了常量，它的值必須在定義的時候初始化，并且后面的代碼不能對其進行修改,它的命名應該全部都是大寫。當一個方法被修飾成final的之后，這個方法在繼承中是不能夠被進行覆蓋的。當一個類被修飾成final的之后，這個類不能再有子類。

final 關鍵字可以應用于類，以指示不能擴展該類（不能有子類）。 final 關鍵字可以應用于方法，以指示不能重寫任何子類中的方法。

 -示例- 
public final class MyFinalClass{ } 
public class MyClass{ 
public final String myFinalMethod() { 
<statements> } } 

例子：

public final class Math{   private final float PI = 3.1415926;  
public final int abs(int i){  return i>=0?i:-I; 
} }   -注釋- 
一個類不能同時是 abstract 又是 final。abstract 意味著必須擴展類，final 意味著不能擴展類。 
一個方法不能同時是 abstract 又是 final。abstract 意味著必須重寫方法，final 意味著不能重寫方法。 
<1>對于基本類型前加以final修飾，表示被修飾的變量為常數(shù)，不可以修改。一個既是static又是final的字段表示只占據(jù)一段不能改變的存儲空間。

<2>final用于對象應用時，final使應用恒定不變。一旦引用被初始化指向一個對象，就無法再把它指向另一個對象。

<3>final方法:一是把方法鎖定，以防止繼承類修改它的含義，二是確保繼承中使方法行為保持不變，并且不會被覆蓋。類中所有的private方法都隱式地指定為是final。 
<4>final參數(shù)：對于基本類型的變量，這樣做并沒有什么實際意義，因為基本類型的變量在調用方法時是傳值，也就是說你可以在方法中更改這個參數(shù)變量而不會影響到調用語句，然而對于對象變量，卻顯得很實用，以為對象變量在傳遞時是傳遞其引用，這樣你在方法中對對象變量的修改也會影響到調用語句的對象變量，當你在方法中不需要改變作為參數(shù)的變量時，明確使用final進行聲明，會防止你無意的修改而影響到調用方法。 
<5>final類：當將某個類的整體定義為final時，就表明了該類不允許被繼承。

3.finally 
解釋：最后，終于，不可更改地 
用法：在異常處理機制當中，它的作用就像是人吃飯一樣，必須得做的，不論有異常還是沒有異常都要執(zhí)行的代碼就可以放到finally塊當中去。finally塊，必須要配合try塊一起使用，不能單獨使用，也不能直接和catch塊一起使用。 
finally 關鍵字用來定義始終在 try-catch-finally 語句中執(zhí)行的塊。finally 塊通常包含清理代碼，用在部分執(zhí)行 try 塊后恢復正常運行。

-示例- try{ 

                <可能引發(fā)異常的塊> } 
                 catch (<java.lang.Exception 或子類> e){ 
                <處理異常 e 的代碼>

} finally{ 
<有異?；驘o異常情況下都執(zhí)行的語句> } -注釋- 
開始和結束標記 { 和 } 是 finally 子句語法的一部分，即使該子句只包含一個語句，也不能省略這兩個標記。 
每個 try 塊都必須至少有一個 catch 或 finally 子句。 
如果執(zhí)行 try 塊的任何部分，不論是否出現(xiàn)異常，也不論 try 或 catch 塊是否包含 return、continue 或 break 語句，都一定會執(zhí)行 finally 塊中的代碼。 如果不出現(xiàn)異常，控件將跳過 try 塊，進入 finally 塊。 如果在執(zhí)行 try 塊期間出現(xiàn)異常，并且相應的 catch 塊包含 break、continue 或 return 語句，控件將首先穿過 finally 塊，之后再執(zhí)行 break、continue 或 return。

4、implements（接口）

用法：用來讓一個類實現(xiàn)一個接口的關鍵字，實現(xiàn)接口的這個類必須實現(xiàn)接口里面所有的方法。 

implements 關鍵字在 class 聲明中使用，以指示所聲明的類提供了在 implements 關鍵字后面的名稱所指定的接口中所聲明的所有方法的實現(xiàn)。 
-示例- 
public class Truck implements IVehicle{ } -注釋- 
在上例中，Truck 類必須提供在 IVehicle 接口中所聲明的所有方法的實現(xiàn)。 
否則，Truck 類將是獨立的；它可以聲明其他方法和變量，并擴展另一個類。 一個類可以實現(xiàn)多個接口。

5、instanceof 
用法：instanceof 關鍵字用來確定對象所屬的類。 
-示例- 

if (node instanceof TreeNode){ <statements> } -注釋- 
在上例中，如果 node 是 TreeNode 類的實例，或者是 TreeNode 的子類的實例，則 instanceof 表達式的值將為 true。 
instanceof 通常是用于判斷父類或者接口的引用是否是某個子類的實例，例如： 
class Animal{} 
class Bird extends Animal {} class Dog extends Animal {} Animal a= new Bird(); 
System.out.println( a instanceof Bird);  System.out.println( a instanceof Dog);

6、interface 

解釋：接口，界面 
用法：它本質上是一個類，一個完全抽象的類，里面沒有任何實現(xiàn)的方法。它不是用來繼承的，是用來實現(xiàn)的。某個類如果實現(xiàn)了接口就必須要實現(xiàn)接口里面的所有方法。并且接口是不能用來實例化的，它也是不能通過new關鍵字獲得對象。 
interface 關鍵字用來聲明新的 Java 接口，接口是方法的集合。 接口是 Java 語言的一項強大功能。任何類都可聲明它實現(xiàn)一個或多個接口，這意味著它實現(xiàn)了在這些接口中所定義的所有方法。 
-示例- 
public interface IPolygon{ 
public float getArea(); public int getNumberOfSides(); public int getCircumference(); } -注釋- 
實現(xiàn)了接口的任何類都必須提供在該接口中的所有方法的實現(xiàn)。 一個類可以實現(xiàn)多個接口。

7、static 解釋：靜態(tài)的 
用法：修飾符的一種，能夠用來修飾屬性和方法。需要注意的是被修飾的屬性和方法，不再屬于對象所有，而是屬于類，意味著，要訪問這些屬性和方法不再通過對象而是直接用類名來訪問。另外，靜態(tài)的方法不能夠訪問非靜態(tài)屬性，非靜態(tài)的方法能夠訪問靜態(tài)的屬性。 
static 關鍵字可以應用于內(nèi)部類（在另一個類中定義的類）、方法或字段（類的成員變量）。 
-示例- 
public class MyPublicClass{ public final static int MAX_OBJECTS = 100; static int _numObjects = 0; static class MyStaticClass{ } 
static int getNumObjects(){ } } -注釋- 
通常，static 關鍵字意味著應用它的實體在聲明該實體的類的任何特定實例外部可用。 
static（內(nèi)部）類可以被其他類實例化和引用（即使它是頂級類）。在上面的-示例-中，另一個類中的代碼可以實例化 MyStaticClass 類，方法是用包含它的類名來限定其名稱，如 MyClass.MyStaticClass。 
static 字段（類的成員變量）在類的所有實例中只存在一次?？梢詮念惖耐獠空{用 static 方法，而不用首先實例化該類。這樣的引用始終包括類名作為方法調用的限定符。在上面的示例中，MyClass 類外部的代碼以 MyClass.getNumObjects() 的形式調用 getNumObjects() static 方法。 
模式： 
public final static <type> varName = <value>; 
通常用于聲明可以在類的外部使用的類常量。在引用這樣的類常量時需要用類名加以限定。在上面的-示例-中，另一個類可以用 MyClass.MAX_OBJECTS 形式來引用 MAX_OBJECTS 常量。 
1>通常在一個類中定義一個方法為static，就是說無須本類的對象就可以直接調用。 
2>靜態(tài)變量和靜態(tài)方法類似。所有此類實例共享此靜態(tài)變量，也就是說類裝載時，只分配一塊存儲空間，所有此類的對象都可以操控此塊存儲空間，當然對于final就另當別論了。

3>static定義的變量會優(yōu)先于任何其他非static變量，不論其出現(xiàn)順序如何。

 4>static{}著是用來顯式的靜態(tài)變量初始化，這段代碼只會初始化一次，且在類被第一次裝載時。

5>在涉及到繼承的時候，會先初始化父類的static變量，然后是子類的。

 6>通常一個普通類不允許聲明為靜態(tài)的，只有一個內(nèi)部類才可以。這時這個聲明為靜態(tài)的內(nèi)部類可以直接作為一個普通類來使用，而不需要實例一個外部類。

8、synchronized 

用法：synchronized 關鍵字可以應用于方法或語句塊，并為一次只應由一個線程執(zhí)行的關鍵代碼段提供保護。當它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同
一時刻最多只有一個線程執(zhí)行該段代碼 
-示例- 
public class MyClass{ 
public synchronized static String mySyncStaticMethod(){ } 
public synchronized String mySyncMethod(){ } }

public class MyOtherClass{ 
Object someObj; 
public String myMethod(){ 
<statements> 
synchronized (someObj){ 
<statements affecting someObj> }}}

synchronized 關鍵字可防止代碼的關鍵代碼段一次被多個線程執(zhí)行。 如果應用于靜態(tài)方法（如上例中的 MySyncStaticMethod），那么，當該方法一次由一個線程執(zhí)行時，整個類將被鎖定。 
如果應用于實例方法（如上例中的 MySyncMethod），那么，當該方法一次由一個線程訪問時，該實例將被鎖定。 
如果應用于對象或數(shù)組，當關聯(lián)的代碼塊一次由一個線程執(zhí)行時，對象或數(shù)組將被鎖定。 
synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。  
  1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。 
如：  public synchronized void accessVal(int newVal); 

synchronized 方法控制對類成員變量的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進入可執(zhí)行狀態(tài)。這種機制確保了同一時刻對于每一個類實例，其所有聲明為 synchronized 的成員函數(shù)中至多只有一個處于可執(zhí)行狀態(tài)（因為至多只有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為 synchronized）。  
 在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態(tài)成員函數(shù)聲明為 synchronized ，以控制其對類的靜態(tài)成員變量的訪問。

synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為synchronized ，由于在線程的整個生命期內(nèi)它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變

量的代碼放到專門的方法中，

將其聲明為

 synchronized 

，

并在主方法中調用來

解決這一問題，

但是

 Java 

為我們提供了更好的解決辦法，

那就是

 synchronized 

塊。

2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：  
  synchronized(syncObject) {    //允許訪問控制的代碼    }  
   synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執(zhí)行，具體機制同前所述。由于可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。 
對synchronized(this)的一些理解 
1）、當兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內(nèi)只能有一個線程得到執(zhí)行。另一個線程必須等待當前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。package ths; 

public class Thread1 implements Runnable {       public void run() {            synchronized(this) {  
               for (int i = 0; i < 5; i++) {                      
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);  
               }            }       }  
     public static void main(String[] args) {          

  Thread1 t1 = new Thread1(); 

Thread ta = new Thread(t1, "A");        

   Thread tb = new Thread(t1, "B");ta.start();         

   tb.start();       } }

2）、當一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。

3）、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。 
 尤其關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。

4）、第三個例子同樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。

9、transient 
用法：transient 關鍵字可以應用于類的成員變量，以便指出該成員變量不應 在包含它的類實例已序列化時被序列化。 
-示例- 
public class MyClass{ 
private transient String password; } 
java語言的關鍵字，變量修飾符，如果用transient聲明一個實例變量，當對象存儲時，它的值不需要維持。 
Java的serialization提供了一種持久化對象實例的機制。當持久化對象時，可能有一個特殊的對象數(shù)據(jù)成員，我們不想    
用serialization機制來保存它。為了在一個特定對象的一個域上關閉serialization，可以在這個域前加上關鍵字transient。    
transient是Java語言的關鍵字，用來表示一個域不是該對象串行化的一部分。當一個對象被串行化的時候，transient型變量的值不包括在串行化的表示中，然而非transient型的變量是被包括進去的。

10、volatile 
用法：volatile 關鍵字用于表示可以被多個線程異步修改的成員變量。 
注意：volatile 關鍵字在許多 Java 虛擬機中都沒有實現(xiàn)。 -示例- 
public class MyClass{ 
volatile int sharedValue; } -注釋- 
volatile 的目標用途是為了確保所有線程所看到的指定變量的值都是相同的。 
Volatile修飾的成員變量在每次被線程訪問時，都強迫從主內(nèi)存中重讀該成員變量的值。而且，當成員變量發(fā)生變化時，強迫線程將變化值回寫到主內(nèi)存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。Java語言規(guī)范中指出：為了獲得最佳速度，允許線程保存共享成員變量的私有拷貝，而且只當線程進入或者離開同步代碼塊時才與共享成員變量的原始值對比。
 
這樣當多個線程同時與某個對象交互時，就必須要注意到要讓線程及時的得到共享成員變量的變化。      
而volatile關鍵字就是提示VM：對于這個成員變量不能保存它的私有拷貝，而應直接與共享成員變量交互。   
使用建議：在兩個或者更多的線程訪問的成員變量上使用volatile。當要訪問的變量已在synchronized代碼塊中，或者為常量時，不必使用。    
由于使用volatile屏蔽掉了VM中必要的代碼優(yōu)化，所以在效率上比較低，因此一定在必要時才使用此關鍵字。