?

1. 每個實例擁有一個實例變量；每種類別之下共享一個靜態變量。
2. 編譯器會處理除RuntimeException外的所有Exception。
3. try...catch...finally中，finally無論如何都會被最后執行。即使try & catch 內含有return，程序也會在return前先執行finally
4. try...catch中，如果有多個同父類(除Exception外）的Exception，catch Exception的順序從上到下應該是子類->父類。否則父類的Exception處理會掩蓋了子類的Exception處理。
5. 在一個方法中，如果出現Exception，并處理了該Exception后，沒有重新throw該Exception，則try...catch...finally外的代碼還會繼續被執行。這會對程序產生災難性影響的。

           public static void main(String[] arg) {
   	String key = "yes";
   	
   	try {
   		midlefun(key);
   	} catch (Exception e) {
   		e.printStackTrace();
   	}
   	
   	System.out.println("end of main");
   }
   
   static void midlefun(String key) throws Exception {
   	try {
   		System.out.println("start try");
   		doRisky(key);
   		System.out.println("end try");
   	} catch (Exception e) {
   		System.out.println("Exception from midlefun");
   //			throw new Exception();	//如果注釋這一條，"end of midlefun"就會被打印出來
   	} finally {
   		System.out.println("finally");
   	}
   	System.out.println("end of midlefun");
   }
   
   static void doRisky(String key) throws Exception{
   	System.out.println("start risky");
   	if("yes".equals(key)) {
   		throw new Exception();
   	}
   	System.out.println("end risky");
   	return ;
   }
         

   ?
6. 方法中的Exception應該要自己處理，如果還需要調用者對該異常也做出反應，則需要再throw出來。

7. Java 的輸入 / 輸出 API 帶有鏈接類型的串流，它代表來源與目的地之間的連接，連接串流將串流與其他串流連接起來。例如： PipedOutputStream 。

   一般來講，串流要兩兩連接才能做出有意義的事情 — 其中一個表示連接，另一個則是要被調用方法的。由于 Java 中有豐富的輸入 / 輸出流，只要配合起來就可以完成各種任務，達到最大的實用性！

   下面的圖是一個演示。保存 java 的對象到一個文件中。

?

8. 內部類對外部類有特權，可以自由地存取它的內容，就算是私有的內容也一樣。內部類可以把外部的方法或變量當作是自己的。例如：

           public class MyOuter {
   	private int x;
   	
   	public int getX() {
   		return x;
   	}
   	
   	class MyInner{
   		void go() {
   			x = 42;	//調用外部類的私有對象
   		}
   	}
   	
   	MyInner inner = new MyInner();	//初始化內部類
   	
   	public void doStuff() {
   		inner.go();
   	}
   	
   	public static void main(String[] arg) {
   		MyOuter outer = new MyOuter();
   		
   		System.out.println(outer.getX());
   		outer.doStuff();
   		
   		System.out.println(outer.getX());
   	}
   }
         

   ?如果需要在外部類中生成內部類變量，則需要首先生成外部類對象。這是由于內部類對外部類的那個特權決定的。

           public static void main(String[] arg) {
   	MyOuter outer = new MyOuter();
   	
   	System.out.println(outer.getX());
   	MyOuter.MyInner inner = outer.new MyInner();
   	inner.go();
   	
   	System.out.println(outer.getX());
   }
         

   ?內部類一般是在GUI程序中使用比較多。添加ActionListener的時候。
9. 線程（Thread）
   ? ~線程啟動需要有一個Runnable對象。
   ? ~線程有三個狀態：1.新建（Thread thread = new Thread(runnable);）；2.可執行（thread.start();）；3.執行中（何時被執行由java虛擬機來管理，你無法干預。并且多線程運行中，多個任務會被交替執行，而不是一個一個的被執行）；4.堵塞（因為Thread可能在等待其他程序的回復）。
   ? ～由于多個Thread由虛擬機來管理交替執行，PS：main函數也是一個Thread，其被執行的順序都是我們無法預測的。例如下面的代碼：

           public static void main( String[] args )
   {
   	System.out.println("start");
   	Thread myThread = new Thread(new Runnable() {
   		@Override
   		public void run() {
   			System.out.println("in thread");				
   		}
   	});
   	
   	myThread.start();
   	
   	System.out.println("back to main");
   }
         

   ?并不是每次都能夠得到下列輸出的：
   ? start
   ? back to main
   ? in thread
   ? 有可能得到下面的輸出：
   ? start
   ? in thread
   ? back to main
   ?
   ? 這要看虛擬機開心不開心了。^_^
   ? ～當某個runnable任務對某個狀態敏感，且多個Thread都會操作該狀態時，就會產生競爭。這時候可以在 操作該狀態的方法 上，增加修飾符synchronized，以達到加鎖的目的。
   ? ～無論synchronized關鍵字加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數當作鎖――而且同步方法很可能還會被其他線程的對象訪問。
   ? ～每個對象只有一個鎖（lock）與之相關聯。
   ? ～實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。
10. 待續

java 基礎學習之點滴