jdk檔案目錄結構：
jdk 
-bin:存放Java編譯器javac.exe，Java執行工具java.exe，Java打包工具jar.exe,還有Java文件生成工具等
-db:小型的資料庫，jdk6開始Java引入的新成員javaDB，支援JDBC4.0所有規範
-jre:Java程式執行環境，其中有JVM，一些執行時的類包，Java應用啟動器，以及一個bin目錄
-include:JDK是通過c/c++實現的，啟動時需要引入一些標頭檔案，於是都放在這裡
-lib:Java類庫
-src.zip:為src資料夾的壓縮檔案，src放置的是jdk核心類原始碼，通過該檔案可以檢視Java基礎類的原始碼，如Java一些lang包，util包等。
JDK內部的jre是專用jre，有的人可能外部又安裝了個jre，那是共用jre，一般安裝了jdk會自帶jre不用再安裝共用jre。
jre檔案
-bin
-lib

Java小細節：
一個Java中只有一個public class，並且public class檔名要跟.Java檔名一致。Java中連續的字串是不能分開在兩行書寫的。Java中byte整型1個位元組，char是2個位元組。Java封裝繼承多型抽象過載。System.gc()主動呼叫jvm進行垃圾回收。Java中常用靜態程式碼塊對類的成員變數進行初始化。javadoc命令可以將Java中文件註釋內容提取出來自動生成HTML格式的幫助文件。Java不允許多重繼承，而C++支援多重繼承，可是要慎用容易出問題。JDK7.0之後switch語句開始支援字串型別了。JDK5.0之後增加了一個類StringBuilder類和foreach迴圈，for(Object obj:list)會將每次list元素賦給obj。泛型JDK5之後採用。

Java執行機制：
首先用javac.exe編譯器將java源程式編譯成與平臺無關的位元組碼檔案，之後由java虛擬機器對位元組碼檔案解釋執行，在執行位元組碼時，JVM負責將每一條要執行的位元組碼送給直譯器，直譯器再將其翻譯成特定平臺環境的機器指令並執行。JVM在解釋執行位元組碼檔案時還可以優化位元組碼，使其轉換成效率更高的機器指令，Java的跨平臺特性是由不同平臺不同的JVM決定的。JVM中類的裝載是由類載入器(ClassLoader)和它的子類來實現的，ClassLoader是java執行時一個重要的系統元件，負責在執行時查詢和裝入類檔案的類。

static{}靜態程式碼塊和非靜態程式碼塊的區別：
靜態程式碼塊，在虛擬機器載入類的時候就會執行，且執行一次。非靜態程式碼塊在建立物件即new一個物件的時候執行，且每次建立物件都會執行一次。所以說有時候有一些專案，在專案啟動時就要執行的就可以用static{}。

單例模式：
單例模式需要做到兩點：私有化構造方法（防止外部建立例項），靜態公有例項化物件，可以被外部訪問但無法再修改。

class Single{
	private Single(){} // 私有化構造方法
	public static final Single INSTANCE=new Single(); // 公有靜態例項化物件且不能修改	
 }

或者：

class Single{
	private Single(){} // 私有化構造方法
	private static Single INSTANCE=new Single(); // 私有靜態例項化物件
	public static Single getInstance(){ // 公有靜態方法返回一個單例模式物件，可外部直接訪問
		return INSTANCE;
	}
}

內部類：

①內部類：Outer.Inner inner=new Outer().new Inner();
②靜態內部類：Outer.Inner inner=new Outer().Inner();
③方法內部類：new Outer().test();

④匿名內部類：匿名內部類並不是例項化物件，而是建立一個繼承自Animal的匿名類物件，通過new表示式返回的引用自動向上轉型為Animal的引用。

animalShout(new Animal(){
	public void shout(){
		System.out.println("eeee");
	} 
});

Java關於引用的理解：
Person person;

這裡的person並不是真正的物件，而是一個指向Person類物件的引用。

Java堆和棧的理解：
①Java堆：Java中的記憶體區粗略可分為堆記憶體和棧記憶體，Java的堆是Java虛擬機器所管理的記憶體中最大的一塊，這個記憶體的唯一目的就是存放物件例項，幾乎所有的物件例項都在這裡分配記憶體，堆是被所有執行緒所共享的一塊記憶體，Java堆可以處於物理上不連續的記憶體空間，只要邏輯上是連續的就好。引用型別的變數，其記憶體分配在堆上或者常量池，主要存放執行時建立(new)的物件。
②Java棧：Java棧可不是執行緒共享的，它是執行緒私有的，它的生命週期也是和私有執行緒的生命週期捆綁在一起。基本資料型別 變數以及物件的引用 變數，其記憶體分配在棧上，變量出了作用域就會自動釋放。棧記憶體的主要作用是存放基本資料型別和引用變數。棧的記憶體管理是通過棧的"後進先出"模式來實現的。
③那為何要區分棧和堆呢？
當一個方法執行時，每個方法都會建立自己的記憶體棧，在這個方法定義的變數將會放到這塊棧記憶體裡，隨著方法的結束，這個方法的記憶體棧也將自動銷燬。（不需要GC回收）

當我們在程式中建立一個物件時，這個物件會被儲存到堆記憶體，以便反覆使用，因為建立物件的成本會比較大，堆記憶體有個特點，他不會隨著方法的結束而自動銷燬，既是方法結束後，這個存在於堆記憶體的物件還可以被另一個/物件的引用變數/所引用。之所以說建立物件的開銷會很大，是因為建立物件的根本途徑是構造器，用new關鍵字來呼叫某個構造器完成這個類的例項。

異常概述：

大量的異常類繼承自java.lang.Throwable類，該類有兩個直接子類一個Error表示執行時的錯誤，另一個是Exception表示異常，Exception又有其他的子類，RuntimeException類及其子類都是執行時異常，而Exception的其他子類都是編譯時就異常。其中Throwable類中常用的方法有：String getMessage()返回此throwable的詳細訊息字串；void printStackTrace()將此throwable及其追蹤輸出至標準錯誤流；void printStackTrace(PrintStream s)將此throwable及其追蹤輸出至指定的輸出流；

try{
    /*可能出現異常的程式碼*/
}catch(Exception e){
    /*異常輸出*/
}finally{
    /*無論是否發生異常都執行的語句*/
}

對可能發生異常的程式碼用try...catch進行處理，若在catch程式碼塊中增加了一個return語句，則用於結束當前try...catch所在的方法，但是finally中必須要執行完，所以finally中經常被用作釋放系統資源等事情，但有種情況finally不能執行，是try..catch中執行了System.exit(0),表示退出當前的Java虛擬機器。在呼叫別人的方式時為防止不知道的錯誤可以丟擲異常，

public void function() throws Exception{
    /*可能出現異常的語句*/
}

也可以用自定義異常，除了在需要呼叫的方法後丟擲異常，也可在某處丟擲自定義的異常,自定義異常可以繼承自Exception，而它內部是有帶引數和不帶引數的構造方法。throwable new DivideByMinusException();一旦丟擲異常就必須得捕獲，如在方法內某處丟擲異常可以在方法後面在丟擲異常，然後再呼叫方法處try...catch一下。

編譯異常和執行異常：
編譯異常（checked異常）：在程式編譯時產生的異常，而這些異常必須要進行處理。
執行異常（unchecked異常）：在程式執行時產生的異常，這種異常既是不編寫異常處理部分也依然可以通過編譯。如陣列下標越界，除以0等產生的執行的異常。

Java中常用包：
在Java不同功能的類放在不同的包中，Java核心類主要放在Java包及其子包下，Java擴充套件的大部分類放在javax包及其子包下。
①java.lang:Java語言核心類，如String,Math,System,Thread等，此包中的類無需import匯入，系統自動匯入。
②java.util:Java的工具類、集合類等，如Arrays、List、Set等。
③java.net:Java網路程式設計相關類以及介面。
④java.io:Java輸入輸出類以及介面。
⑤java.awt:包含構建圖形介面GUI相關類以及介面。
⑥java.sql:資料庫程式設計常用的類以及介面。
⑦javax.swing:JGUI相關類以及介面。
⑧...

訪問控制級別：
①private:此成員只能被該類的其他成員訪問
②default:此成員只能被本包中其他類訪問
③protected:此成員既能被同一包下其他類訪問，也能被不同包下該類的子類訪問
④public:此類成員能被所有類訪問

Java中的多執行緒語法：
①通過繼承Thread類來實現多執行緒

public class Test{
	new MyThread.start(); // 開啟多執行緒
}
class MyThread extends Thread{
	public void run(){
		while(true){
			/*不斷迴圈的執行緒*/
		}
	}
}

②通過實現Runnable介面來建立多執行緒

public class Test{
	new Thread(new MyRunnable).start(); // 開啟多執行緒
}
class MyRunable implements Runnable{
	public void run(){
		while(true){
			/*不斷迴圈的執行緒*/
		}	
	}
}

Runnable比Thread類來講，可以避免由於Java單繼承帶來的侷限性，可以相同程式碼的執行緒去處理統一資源的情況。

Java的執行緒概述：
t.setDaemon(true); // 將執行緒t設定為後臺執行緒，此方法必須在start（）方法之前呼叫。當程序中只有後臺執行緒執行時，程序也就會結束了。執行緒生命週期從Thread物件建立完成開始，當run方法執行完畢或者執行緒中丟擲一個未捕獲的異常或者錯誤時執行緒生命週期便會結束。執行緒生命週期分為五態：
①New新建態：通過start()方法進入就緒態。新建一個執行緒所處的狀態。
②Runnable就緒態：獲得CPU使用許可權變成執行態。呼叫start()方法所處的狀態，位於可執行池中，只是具備了執行條件，執行還等待cpu排程。
③Running執行態：通過run()方法執行完或異常錯誤進入死亡狀態。就緒態執行緒獲得CPU使用權，開始執行run()方法實體
④Blocked阻塞態：失去CPU使用許可權變成就緒態。後面具體講解。
⑤Terminated死亡態：一旦進入死亡態，執行緒將不再擁有執行資格，也無法轉到其他態。

執行緒阻塞狀態：
常見於執行輸入輸出操作，進入阻塞，
①當執行緒獲取某個物件的同步鎖時，如果該鎖被其他執行緒佔有，當前執行緒阻塞。獲得同步鎖解除阻塞。
②當執行緒呼叫了一個阻塞的IO方法時，執行緒進入阻塞。等待IO方法返回解除阻塞。
③當執行緒呼叫某物件的wait()方法時，進入阻塞。用notify()方法喚醒執行緒進入就緒態。
④當執行緒呼叫了Thread的sleep()方法時，進入阻塞。等待執行緒睡眠時間到了，即可自動進入有序佇列。
⑤當執行緒中呼叫了另一個執行緒的join()方法時，會使當前執行緒進入阻塞。等新加入的執行緒執行結束後才會進入就緒狀態。

執行緒排程：
計算機中執行緒排程有兩種模式，分為分時排程和搶佔式排程，Java虛擬機器預設是搶佔式，當然也可以由程式自己來控制CPU的排程。
①設定執行緒優先順序：通過thread.setPriority(10);設定thread這個執行緒優先順序為10，數字越大優先順序越高
②執行緒休眠：通過Thread.sleep(時間)靜態方法使得人為控制當前執行緒阻塞一段時間，此方法要處理異常，通常直接捕獲異常InterruptedException或者繼續丟擲異常給呼叫者處理。
③執行緒讓步：通過Thread.yield()方法使得當前執行緒直接由執行態進入就緒態而不是阻塞態。
④執行緒插隊：通過thread.join();使當前執行緒進入阻塞，直到被插入的執行緒執行完後才會進入就緒狀態。

多執行緒同步：
同步程式碼塊：可以保證處理共享資源的程式碼在任何時刻只能有一個執行緒訪問

synchronized(lock){  // lock為Object型別
	/*操作共享資源的程式碼*/
}

lock為一個鎖物件，預設情況鎖物件的標誌位為1，為1時可執行此此同步程式碼塊，且將此鎖物件的標誌位置0；為0則執行緒發生阻塞。

同步方法：synchronized 返回值型別 方法名(引數...)，同步方法同樣也是有鎖的，他的鎖就是this物件。同步程式碼塊和同步方法都是用來解決執行緒安全問題。

死鎖問題：兩個執行緒執行到一半，A執行緒要使用B的資源，此事B執行緒要使用A的資源，於是二者發生死鎖。多執行緒通訊的wait(),notify()來解決死鎖問題。

多執行緒通訊：
如在操作取操作和存操作兩個執行緒同時處理一個空間，當存取滿空間時，回到0下標，這是可能出現問題的，於是需要執行緒間通訊。需要用到wait(),notify(),notifyAll()方法用來解決問題。

Java API：
①String,StringBuilder,StringBuffer:Sting字串常量，StringBuilder非執行緒安全，StringBuffer執行緒安全；String是不可改變的物件，對此對String物件進行改變其實都是等同於生成一個新的String物件，然後將指標指向新的String物件，而StringBuffer會對物件本身操作，所以當字串經常需要改變的情況下推薦使用StringBuffer類；StringBuilder是JDK5.0以後新增的，是StringBuffer的一個簡易替換，但是不保證執行緒同步的安全性，常被用在字串緩衝區被單個執行緒使用，這時候優先採用此類，此時他會比StringBuffer還要快，二者的方法基本相同。StringBuffer和StringBuilder預設容量為16，當容量儲存超過16時他們會自動擴容，擴容機為2*n+2。
②System和Runtime:System常用的方法有終止當前虛擬機器，有執行垃圾回收器，返回當前時間等他們都是靜態方法；Runtime類用來專門表示虛擬機器的執行狀態，每次啟動java.exe都對應一個Runtime例項，所以此類是採用單例模式進行設計的。
③Math與Random:Math類很常用提供了許多方便的數學方法，其中有兩個靜態常量，PI和E表示π和e；Random在java.util包中，可以在指定的取值範圍內產生隨機數，其有兩個構造方法Random()和Random(long seed)，第一個構造方法的種子是當前的時間戳，而第二個構造方法的種子是傳進去的seed，有引數的構造方法的物件兩次實驗結果會相同，而無參的會不同，因為時間在改變。

public static void main(Sting args[]){ // 無參的舉例
	Random r=new Random();
	for(int x=0;x<10;x++){
		System.out.println(r,nextInt(100)); // 0到100的整型隨機數
	}
}

當然Random中還有其他的方法。

④Date,Calendar,DateFormat:三個類都是對日期進行操作，前二者在java.util包下，後面一個在java.text包下，在Date類中大部分構造方法都被宣告為已過時，只有Date()和Date(long date)還建議使用，date引數表示自1970.01.01.00:00以來的毫秒數，即時間戳，從JDK1.1開始Calendar類取代了Date的大部分功能；與Date類不同，Calendar是一個abstract class，不能例項化物件，可以通過靜態方法getInstance()來得到一個物件，他不是單例模式，Calendar有兩種模式，一個是日曆欄位模式lenient(default)，其欄位可以超過允許值的範圍，如指定13月也是不報錯的，另一種是non-lenient模式，當超過限度時會報出異常；DateFormat可以將日期格式轉換為字串或者特定格式顯示的日期字串轉化為一個Date物件，DateFormat還有個子類是SimpleDateFormat，他可以更加靈活。

包裝類：
由於在Java設計中很多方法是要接受引用型別的資料物件，無法將基本資料型別傳入，於是有了包裝類的概念，包裝類可以將基本資料型別的值包裝成引用資料型別物件。
①boolean--Boolean
②byte--Byte
③char--Character
④short--Short
⑤int--Integer
⑥long--Long
⑦float--Float
⑧double--Double
裝箱

int a;
Integer in=Integer(a);

拆箱

int b=in.intValue();

包裝類都重寫了Object類的toString()方法，還有許多常用的方法等。在JDK5.0以後提供了自動拆裝箱。

集合類概述：
集合按照儲存結構分兩大類：
Collection單列結合(介面)
List有序可重複(介面)
ArrayList(類)(執行緒不安全)
LinkedList(類)
Vector(類)(執行緒安全)
Set無序不可重複(介面)
HashSet(類)
TreeSet(類)
Map雙列集合(介面)
HashMap(類)(執行緒不安全)
TreeMap(類)
HashTable(類)(執行緒安全)
Properties(類)

集合類細講：
①Collection介面：所有單列集合的父介面，裡頭有size()方法，iterator()方法等。
②List介面：單列介面，元素有序且可重複，線性方式儲存。
③ArrayList集合：單列有序可重複基於線性表結構，執行緒不安全，是程式中最常見的集合，內部封裝了一個長度可變的陣列，add(Object o)用來儲存元素，get(int index)用來取出下標為index的元素。
④LinkedList集合：單列有序可重複基於雙向迴圈連結串列結構，同時有方便的插入刪除操作方法。
⑤Iterator介面：他是一個迭代器，通常用法：

Iterator it=list.iterator();
while(it.hasNext()){
	Object obj=it.next();
}

⑥ListIterator介面：為Iterator的子類，與Iterator不同，ListIterator可以提供反向的迭代。

ListIterator it=list.listIterator(list.size()); // 括號內為從哪裡開始
while(it.hasPrevious()){
	Object obj=it.previous();
}

⑦Enumeration介面：一個老式的迭代器，用法和Iterator類似

Vector v=new Vector();
Enumeration en=v.elements();
while(en.hasMoreElements()){
	Object obj=en.nextElement();
}

⑧Vector集合：用法與ArrayList完全相同，但他是執行緒安全的。之所以ArrayList類是執行緒不安全，因為他們作為線性表結構，儲存資料有兩步，第一：儲存，第二：下標或指標往後移位，對於Vector類而言，程式開發者希望他是執行緒安全的，於是在處理儲存操作方法用同步方法來代替。
⑨Set介面：單列介面，元素無序不可重複，非線性儲存結構。
⑩HashSet集合：單列無序不可重複基於散列表的儲存結構，不是同步的。向HashSet結合中儲存元素時，首先會自動用該物件的hashCode()方法確定元素儲存位置，之後呼叫物件equals()方法確保該位置沒有重複。
①①TreeSet集合：單列有序不可重複基於自平衡的排序二叉樹儲存結構。
①②Map介面：所有雙列結的父介面。Map集合的兩種遍歷方式：首先用Map物件的keySet()方法，獲得Map中所有鍵的Set集合，然後用Iterator迭代Set集合的每一個元素，最後呼叫get(String key)方法根據鍵獲取對應的值。或者先獲取集合中的所有對映關係，然後從對映關係中取出鍵和值。如下：

Map map=new HashMap();
/*已向集合中加入了元素*/
Set keySet=map.keySet();
Iterator it=keySet.iterator();
while(it.hasNext()){
	Object key=it.next();
	Object value=map.get(key);
}

或者：

Map map=new HashMap();
/*已向集合中加入了元素*/
Set entrySet=map.entrySet();
Iterator it=entrySet.iterator();
while(it.hasNext()){
	Map.Entry entry=(Map.Entry)(it.next());
	Object key=entry.getKey();
	Object value=entry.getValue();
}

①③HashMap集合：雙列無序鍵不可重複基於雜湊值演算法的儲存結構，執行緒不安全。若想使迭代的元素順序
和存入的是一致的，可以用HashMap的子類LinkedHashMap，內部是雙向連結串列。
①④TreeMap集合：雙列有序鍵不可重複基於紅黑樹的儲存結構。在使用TreeMap時也可以自定義比較器對所有鍵進行排序：

public class Example{
	public static void main(String argsp[]){
		TreeMap tm=new TreeMap(new MyComparator());
		Set keySet=tm.keySet();
		Iterator it=keySet.iterator();
		while(it.hasNext()){
			Object key=it.next();
			Object value=tm.get(key);
		}
	}
}
class MyComparator implements Comparator{ // 自定義的比較器
	public int compare(Object obj1,Object obj2){
		String id1=(String) obj1;
		String id2=(String) obj2;
		return id2.compareTo(id1);
	}
}

①⑤HashTable集合：雙列無序鍵不可重複基於雜湊值演算法的儲存結構，執行緒安全。用法和HashMap一樣。
①⑥Properties集合：是HashTable的子類，實際應用中很重要，用來儲存字串型別的鍵和值，存取應用的配置項。setProperty()和getProperty()是對字串存取的兩個重要方法。

泛型：
泛型是JDK5之後採用的，用泛型因為集合儲存元素可以存任何型別物件，但存入後，將物件取出後，物件就變成類Object型別，如：ArrayList<String>list=new ArrayList<String>();這樣可以在編譯時就提前發現問題不會等到執行時在發現問題。自定義泛型如下：

class cachePool<T>{
	T temp;
	public void save(T temp){
		this.temp=temp;
	}
	public T get(){
		return temp;
	}
}
public class Example{
	public static void main(String args[]){
		cachePool<Integer>pool=new cachePool<Integer>();
		pool.save(new Integer(1));
		Integer temp=pool.get();
	}
}

集合類中的工具類：
①Collections工具類：Collections工具類中有許多靜態方法方便對集合中元素進行排序查詢修改等操作。
②Arrays工具類：Arrays工具類中有許多靜態方法方便對陣列重元素進行操作。有諸如sort方法binarySearch方法copyOfRange方法fill方法等常用方法。

IO輸入輸出概述：
IO流：
位元組流：
InputStream位元組輸入流(抽象類)
FileInputStream(類)讀取檔案資料
BufferedInputStream(包裝類)帶緩衝流的位元組流
OutputStream位元組輸出流(抽象類)
FileOutputStream(類)檔案
BufferedOutputStream(包裝類)帶緩衝流的位元組流
字元流：
Reader字元輸入流(抽象類)
BufferedReader(包裝類)
LineNumberReader(包裝類)
InputStreamReader(包裝類)
FileReader檔案字元輸入流
Writer字元輸出流(抽象類)
BufferedWriter(包裝類)
OutputStreamWriter(包裝類)
FileWriter檔案字元輸出流

IO輸入輸出細講：
①InputStream：為抽象類，是位元組輸入流的定級父類，有read方法close方法等常用方法，其下有許多子類。
②OutputStream：為抽象類，是位元組輸出流的定級父類，有write方法flush方法close方法等常用方法，其下有許多子類。
③FileInputStream：是InputStream的子類，檔案位元組輸入流，

FileInputStream in=new FileInputStream("test.txt"); // 從檔案讀入為檔案輸入流
int b=0;
while(true){
	b=in.read(); // 讀入的資料儲存到b(int)
	if(b!=-1)
		break; // 判斷是否讀完
}
in.close(); // 關閉流

④FileOutputStream：是OutputStream的子類，檔案位元組輸出流，

FileOutputStream out=new FileOutputStream("example.txt");
String str="nihao";
byte[] b=str.getBytes(); // 將String轉化為byte[]陣列
for(int i=0;i<b.length;i++){
	out.write(b[i]);
}
out.close(); // 關閉流

⑤BufferedInputStream：是FileInputStream的子類，是一個包裝類，採用裝飾設計模式。
⑥BufferedOutputStream：是FileOutputStream的子類，是一個包裝類，採用裝飾設計模式。如：

BufferedInputSream bis=new BufferedInputStream(new FileInputStream("src.txt"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("des.txt"));
int len;
while((len=bis.read())!=-1){
	bos.write(len);
}
bis.close();
bos.close();

⑦Reader：為抽象類，是字元輸入流的頂級父類，有read方法close方法等常用方法，其下有許多子類。
⑧Writer：為抽象類，是字元輸出流的頂級父類，有write方法close方法等常用方法，其下有許多子類。
⑨FileReader：Reader→InputStreamReader→FileReader，檔案字元輸入流。
⑩FileWriter：Writer→OutputStreamWriter→FileWriter，檔案字元輸出流。FileWriter和FileOutputStream類一樣，如果指定檔案不存在，就會先建立檔案，再寫入資料，如果檔案存在，就會先清空檔案內容再寫入資料。
①①BufferedReader：Reader→BufferedReader，是一個包裝類，可以包裝FileReader型別。
①②BufferedWriter：Writer→BufferedWriter，是一個包裝類，可以包裝FileWriter型別。
①③LineNumberReader：Reader→BufferedReader→LineNumberReader，是一個包裝類，可以包裝FileReader型別。是一個可以跟蹤行號的輸入流。
①④InputStreamReader：包裝流，可以將位元組輸出流包裝成字元輸入流。
①⑤OutputStreamWriter：包裝流，可以將位元組輸出流包裝成字元輸出流。
①⑥其他IO流：

裝飾設計模式：
通過包裝一個類，動態的為他增加功能的一種設計模式。

Java GUI：
GUI是使用者圖形介面，Java GUI的豐富類庫在java.awt和javax.swing包中。
①AWT：提供了視窗，按鈕，文字框，對話方塊等。佈局管理器有五種：流式佈局管理器FlowLayout，邊界佈局管理器BorderLayout，網格佈局管理器GridLayout，網格包佈局管理器GridBagLayout，卡片佈局管理器CardLayout。在java.awt包中專門提供了一個Graphics類，類似於一個畫筆，其中提供了各種繪製圖形的方法。
②Swing：相對於AWT而言，Swing包中提供更加豐富的GUI元件，由於有Java編寫，AWT叫做重量級元件，而不依賴於本地平臺的Swing元件叫輕量級元件。

Java網路程式設計：
①TCP/IP協議四層結構：應用層(HTTP，FTP，DNS)→傳輸層(TCP，UDP)→網路層(IP，ICMP，IGMP)→鏈路層(驅動程式，介面)
②JDK中提供了一個InetAddress類，用於封裝一個IP地址，並提供了一些列和IP地址相關的方法，此類在java.net包中。
③UDP協議：無連線的通訊協議，傳送端不會確認接收端的存在而去傳送，接收端也不會向傳送端反饋。UDP協議消耗資源小，通訊效率高，常用於音訊視訊和普通資料傳輸。
④TCP協議：面向連線的通訊協議，在TCP連線中要明確客戶端和服務端，客戶端向服務端傳送連線請求，每次連線的建立都需要經過“三次握手”，第一次握手，客戶向伺服器傳送連線請求，等待伺服器確認；第二次握手，伺服器向客戶端回送一個響應，通知客戶端收到連線請求；第三次握手，客戶端再次向服務端傳送確認資訊，確定下載檔案時必須採用TCP協議連線。
⑤TCP的三次握手：第一次握手：建立連線時,客戶端傳送syn包，(syn=j)到伺服器,並進入SYN_SEND狀態,等待伺服器確認；第二次握手：伺服器收到syn包,必須確認客戶的SYN（ack=j+1）,同時自己也傳送一個SYN包（syn=k）,即SYN+ACK包,此時伺服器進入SYN_RECV狀態； 第三次握手：客戶端收到伺服器的SYN＋ACK包,向伺服器傳送確認包ACK(ack=k+1),此包傳送完畢,客戶端和伺服器進入ESTABLISHED狀態,完成三次握手。完成三次握手,客戶端與伺服器開始傳送資料。
⑥TCP報文：需要注意的是TCP協議的報文格式是有"Seq序號"佔32位，對傳送資料一方進行標記；有"確認序號Ack"，佔32位，只有ACK=1時，確認序號欄位才有效，Ack=1+Seq；標誌位共有6個：URG，ACK，PSH，PST，SYN，FIN等，其中ACK確認序號有效欄位，SYN發起一個新連線，FIN釋放一個連線。注意一定不要把Ack確認序號和標誌位中ACK欄位搞混了。

Java UDP/TCP通訊：
在JDK中提供了InetAdress類，用於封裝一個IP地址，並提供了與IP相關的一系列方法。
①UDP通訊：是無連線的通訊協議。消耗資源小，通訊效率高，可能丟包。DatagramPacket類用於封裝UDP通訊中傳送的資料包，其中提供了許多方法用於獲取資料相關的資訊，如InetAddress getAddress(),int getPort(),byte[] getData(),int getLength(),DatagramSocket類用來接收和傳送DatagramSocket資料包。

/*receive端*/
import java.net.*;
public class Example{
	public static void main(String args[]) throws Exception {
		DatagramSocket ds=new DatagramSocket(8954); // 建立接收端的Socket，監聽埠為8954

		byte[] buf=new byte[1024];
		DatagramPacket dp=new DatagramPacket(buf,1024); // 建立一個數據包集裝箱
		
		ds.receive(dp); // 等待接受資料，若沒有資料則會阻塞

		ds.close(); // 關閉套接字
	}
}

/*send端*/
import java.net.*
public class Example2{
	public static void main(String args[]){
		DatagramSocket ds=new DatagramSocket(3000);建立傳送端的Socket，監聽的埠為3000
		
		String str="hello world";
                // 建立一個要傳送的資料包集裝箱，有要發的資料，資料長度，接收端IP，目的埠號
                DatagramPacket dp=new DatagramPacket(str.getBytes(),str.length(),InetAddress.getByName("localhost"),8954);
                ds.send(dp); // 傳送資料
                ds.close(); // 關閉套接字
       }
}

②TCP通訊：是面向連線的通訊協議，其中存在"三次握手"，JDK中提供了兩個類用於實現TCP通訊，一個是ServerSocket表示服務端，另一個是Socket表示客戶端。ServerSocket類中有Socket accept(),InetAddress getInetAddress(),boolean isClosed(),void bind(SocketAddress endpoint);Socket類中有int getPort(),InetAddress getLocalAddress(),void close(),InputStream getInputStream(),OutputStream getOutputStream()。

/*server端*/
import java.io.*;
import java.net.*;
public class Example3{
	public static void main(String args[]) throws Exception {
        /* 建立服務端Socket，並監聽7788埠。注意，若這裡沒有指明埠號，意味著沒有監聽埠，則後面還需要用bind(SocketAddress endpoint)方法監聽繫結到指定的埠號，才可以正常使用 */
		ServerSocket serverSocket=new ServerSocket(7788); 
		
		Socket client=serverSocket.accept(); // 呼叫accept方法接收資料，連線之前是阻塞態

		OutputStream os=client.getOutputStream(); // Socket的輸出流
		os.write( ("hello world").getBytes() );
		
		os.close();
		client.close(); // 關閉套接字
	}
}

/*client端*/
import java.io.*;
import java.net.*;
public class Example4{
	public static void main(String args[]) throws Exception {
        /* 指定目標IP和目標埠號。注意，若這裡沒有指定目標IP和目標埠號，意味著沒有去連線任何的server，則後面還需要用connect(SocketAddress endpoint)方法，才能完成與指定伺服器端的連線 */
		Socket client=new Socket(InetAddress.getLocalHost(),7788);
		
		InputStream is=clinet.getInputStream(); // 接收資料的流
		byte[] buf=new byte[1024]; // 緩衝陣列
		int len=is.read(buf); // 將資料讀到緩衝中

		client.close();
	}
}