java完美經典讀書筆記
第一章 概述
第二章 JAVA語言基礎
※關鍵字：
基本數據類型： byte short int char long float double boolean
循環控制： do while for break continue
分支控制： if else switch case default break
方法 變量 和類得修飾府： private public protected final static abstract
synchronized volatile strictfp transient
字面值常量： false true null
方法相關得關鍵字： return void
包相關得關鍵字： package import
異常處理： try catch finally throw throws
對象相關： new extends implements super class instanceof this
※很多算術運算操作可以產生浮點型無法表達的數字，如無限大，無限小等，這些數據的表達通過浮點數封裝類（Float和Double）所提供的特殊屬性來表達。
Float.NaN 非數字
Float.NEGATIVE_INFINITY 無限小
Float.POSITIVE_INFINITY 無限大
Double.NaN 非數字
Double.NEGATIVE_INFINITY 無限小
Double.POSITIVE_INFINITY 無限大
數據類型的自動轉換圖：
char--->{
int-->long-->float-->double
byte-->short-->{
※內置類對應的基本類型：
Byte-->byte;Short-->short;Integer-->int;Long-->long;Float-->float;Double-->double
Boolean-->boolean;Character-->char;String-->char[]
※將基本數據類型轉爲String類型：string str1; int intv1=300; str1=String.valueOf(intv1);
將string類型轉爲基本數據類型：string str1="126"; int i1=Integer.parseInt(str1);
※取得string對象內含的char[]值，必須使用它的toCharArray()方法來取得。
String str3=new String("this is str3");
char[] c1=str3.toCharArray();
System.out.println("c1數組的第一個字符＝") + c1[0];
※'/n'換行符
'/r'回車符
'/t'製表符
'/b'返回符
'/f'走紙符
'/''單引號
'/"'雙引號
'//'反斜線符
※負數取模的計算技巧：a%b可以這樣計算，首先將a和b都變成正數進行取模
運算，得到的結果添加上和a相同的正負符號即可。例如：
-10%-3=10%3=-1; 10%-3=10%3=1;
※switch表達式的值類型，只能是 byte 、char 、short 、int 而不能是long、
float、double、boolean
※java包含兩個循環語句break、continue；break使程序可以在特定條件滿足時跳出循環
體，而continue則使當次的循環忽略當次循環的後續代碼，立即開始下一輪的循環。
※可視域修飾符描述了類、方法或值域對外開放的程度，按開放程度由高到低的順序是：
public -->protected -->默認 -->private
※類的值域和方法前都可以加一個可視域修飾符。對於public成員，外部的任何類都可以訪問這個成員；protected的成員可以被同一個包的類及其子類訪問；默認的可視域的成員可以被處於同一個包中的類訪問；private的成員只能在類內部訪問。
※除可視域修飾符外，還可以添加另外兩個修飾符，分別是static和final。static稱爲靜態的修飾符，帶static的值域表示這個類不管有多少個實例，只會保留一份值域拷貝，即類的多個實例對應同一份變量值，該類的任何一個實例更改了這個值域，該類的其它實例都可以馬上看到，所以帶static的變量是類級的變量。而帶final修飾符的值域表示在第一次賦值後不可改變，這種值域一般用於標識一個常量。
※子類的實例對象可以賦給父類的變量，保存在父類變量中的子類實例可以用
轉型將其賦給子類的變量。 super AClass sub BClass
AClass a= new BClass(1,2,3);
Bclass b=(BClass)a;
※一個類只能有一個父類，但卻可以同時實現多個接口。
子類或實現了接口的類可以將其實例傳給父類或接口的變量。
只實現了父類中部分的虛方法，或只實現接口部分方法的類是虛類，不能進行
實例化。
一個類如果不顯示繼承一個類，那它就是默認繼承java.lang.Object。
接口中的任何值域都是 public static final 類型，接口不允許定義其它類型
的變量。
※static成員變量，它的有效範圍可以跨類，甚至可達整個應用程序之內。它除了能在定義它的類內存取，還能直接以“類名.成員變量”的方式在其它的類內使用。它是java程序的“全局變量”。
定義爲static的方法有以下幾條限制：
1.它只能調用其他的static方法
2.它只能訪問static數據
3.它不能以任何方式引用this和super
4.在一個static方法中引用任何實例變量都是非法的。
※super有兩種通用形式：1.調用超類的構造函數 2.用來訪問被子類的成員隱藏的超類成員
super必須是在子類構造函數中第一個被執行的語句。
動態方法調度：超類的引用變量可以引用子類對象。當一個重載方法通過超類引用被調用，java根據當前被引用對象的類型來決定執行哪個版本的方法。如果引用的對象類型不同，就會調用一個重載方法的不同版本。換句話說，是被引用對象的類型，而不是引用變量的類型。
※final：定義成final的方法不能被重載，定義成final的類不能被繼承
第三章 java的數組與對象基礎
※兩個類型相同的數組GradeA和GradeB可以相互引用，當GradeA引用GradeB數組後，這兩個數組的元素值是完全一樣的。而當GradeA的元素值改變後，GradeB的元素值也隨之改變了，可知GradeA和GradeB數組的實例根本是同一個，而不是複製出另一個實例。
對於一個多維數組，前面維度若未指定索引時，後面維度的索引就不可以先指定。
String 類對象：
String c="dfdkfdf";
String c=new String ("dfdkfdf");
int a="wo shi yi ge cheng xu yuan".length();
String s1="wo shi yi ge cheng xu yuan".getClass().getName();
導入一個 StringBuffer 對象
String ( StringBuffer buffer)
StringBuffer buffer1=new StringBuffer ("fish");
String str1=new String(buffer1);
方法：
1.取得 String 對象中一些與其內含字符串有關的屬性：j02060402
int length() 取得內含字符串的長度。
char charAt(int index) 由此對象內含字符串中，取得index參數指定的索引的那個字符
char[] toCharArray() 將此 String 對象含有的字符串轉化爲char[]類型的值。
byte[] GetBytes() 將此 String 對象含有的字符串轉化爲byte[]類型的值。
String[] toString 返回此對象本身的實例（引用地址）
2.從 String 對象內含的字符串中找尋字符或字符串，且找到時回傳該目標所在的索引位置 j02060403
int indexOf(int ch)
在此對象內含的字符串（char[]類型）中尋找ch參數指定的字符，找到第一個後就返回他的索引，若找不到則返回-1
int indexOf(int ch,int fromIndex)
與前者同名異式，用fromIndex參數指定由此對象內含的字符串（char[]類型）的某個字符（用索引指定）開始向後找
int indexOf(String str)
同名異式，在此字符串中尋找str參數指定的字符串
int indexOf(String str,int fromIndex)
同名異式，在此字符串中尋找str參數指定的字符串，用fromIndex參數指定由此字符串（char[]類型）的某個字符（用索引指定）開始向後對比字符串
int lastIndexOf(int ch)
在此對象內含的字符串（char[]類型）中尋找ch參數指定的字符，若要找的字符有兩個以上，會返回最後一個它的索引值，若找不到則返回-1
int lastIndexOf(int ch,int fromIndex)
與前者同名異式，用fromIndex參數指定欲尋找的範圍只到該字符爲止
int lastIndexOf(String str)
同名異式，在此字符串中尋找某個字符串
int lastIndexOf(String str,int fromIndex)
同名異式，在此字符串中尋找str參數指定的字符串，用fromIndex參數指定欲尋找的範圍只到該字符爲止
3.比較或檢查該 String 對象的字符串內容：j02060404
boolean startsWith(String prefix)
檢查此字符串的開頭是否爲prefix參數指定的字符串內容
boolean startsWith(String prefix,int toffset)
從toffset參數指定的索引開始，往後檢查此字符串的開頭是否爲prefix參數所指的字符串內容
boolean endsWith(String suffix)
檢查此字符串的結尾是否爲suffix參數所指的字符串內容
int compareTo(String anotherString)
以字符爲單位，逐一比較對象的內含字符串與另一個 String 對象內含字符串字符值（編碼）的大小，只有遇到一個不同字符，就不往下比較，直接返回。若此對象這方的字符值較大，就返回代表兩者之差的正整數，反之，則返回值爲負整數；若兩個字符串完全相同，就返回0
int compartToIgnoreCase(String str)
與前者相似，不考慮英文的大小寫
boolean equals(Object anObject)
與某個對象作比較，若另一個 String 對象和它含有完全相同的字符串，就返回true；反之，返回false。與 Object 和 Integer 等類的equals()不同，參考j02060413
boolean equalsIgnoreCase(String anotherString)
與某個 String 對象作比較，作用與equals()相似，不考慮英文大小寫
boolean matches(String regex)
檢查內含字符串的樣式是否吻合regex參數所指定的規則（正則表達式）。regex參數值的寫法看java.util.regex.Pattern
boolean regionMatches(int toffset,String other,int ooffset,int len)
比較內含字符串的某部分內容，是否完全同於other參數導入字符串的某部分內容。toffset參數指定由此對象內含字符串的這個字符開始往後比較，ooffset參數則指定要和other參數的這個字符以後的字符串比較，而且欲比較這部分字符串的長度由len參數指定。
boolean regionMatches(boolean ignoreCse,int toffset,String other,int ooffset,int len)
與前者同名異式，多處的ignoreCase參數用來決定在比較時是否忽略英文字母的大小寫差異。若參數爲true，就忽略大小寫差別；若爲false，則得考慮大小寫不同。
boolean contentEquals(StringBuffer sb)
比較內含字符串得內容，是否完全同於某個 StringBuffer 對象內得字符串
4.取得 String 對象內含得字符串，經一番處理後，再拿處理後得字符串內容來產生新的 String 對象： j02060405
String concat(String str)
將str參數內含得字符串連接到此對象所含的字符串的尾端，結果類似“＋”運算符的作用
String replace(char oldChar,char newChar)
取得內含的字符串，然後將其中某個特定的字符全部替換成另一個字符。由oldChar參數指定要被替換的字符值，newChar參數指定用來取代的新字符值
String replaceAll(String regex,String replacement)
取得內含的字符串，然後將其中符合某種格式的字符串全部替換成另一個字符串。由regex參數指定要被替換掉的字符串的格式，replacement參數則指定要用來取代的新字符串
String replaceFirst(String regex,String replacement)
取得內含的字符串，然後將其中符合某種格式的字符串第一次出現的地方替換成另一個字符串。由regex參數指定要被替換掉的字符串的格式，replacement參數則指定要用來取代的新字符串
String substring(int beginIndex)
取得此字符串中，beginIndex參數所指定索引之後的所有字符，以此產生一個 String 對象。
String substring(int beginIndex,int endIndex)
取得此字符串中，由beginIndex索引值到endIndex索引之前（不包括它）的所有字符，以此產生一個 string對象
String toLowerCase()
取得此對象內含的字符串，將其中的英文字母全轉成小寫
String toUpperCase()
取得此對象內含的字符串，將其中的英文字母全轉成大寫
String trim()
取得此對象內含的字符串，將它去掉尾端的空白符
String[] split(String regex)
以regex參數代表的字符串爲分界線，將此字符串分爲多個字符串，以此產生一個 String[]數組
String[] splet(String regex,int limit)
以regex參數代表的字符串爲分界線，將此字符串分爲多個字符串，且由limit參數決定最多隻將它分爲多少個字符串，以此產生一個 String[]數組
5. String 類可以直接使用的static方法，不需構造對象實例就能使用 j02060406
static String copyValue(char[]data)
複製某個char[]數組所含的所有字符，以產生一個字符串（string 對象）
static String copyValueOf(char[]data,int offset,int count)
複製某個char[]數組所含的部分字符，以產生一個字符串（string 對象）。由offset參數指定由這個字符開始複製，int參數則指定欲複製字符的數量
static String valueOf(參數)
返回一個內含字符串的意義能代表導入參數的 String 對象。且參數形式有許多種。
StringBuffer 類對象：
不能直接使用“字符串常數”來初始化StringBuffer對象
StringBuffer 對象方法：
1.取得此StringBuffer 對象的一些屬性：j02060408
int length()
取得內含字符串的長度
int capacity()
取得目前內部緩衝區容量的大小
void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)
取得此對象內含字符串中，由srcBegin索引開始到srcEnd索引之前（不包括此字符）的所有字符，然後複製其值作爲dst參數代表的數組在 dstBegin參數索引開始後的元素
char charAt(int index)
由此對象內含字符串中，取得index參數所指定的索引的那個字符
String substring(int start)
取得此 StringBuffer 對象內含字符串，start參數指定的索引開始以後的所有字符，以此產生一個 String 對象
String substring(int start,int end)
取得此 StringBuffer 對象內含字符串，start參數指定的索引開始直到end索引之前（不包括此字符）的所有字符，以此產生一個 String 對象
String toString()
取得此StringBuffer 對象內含字符串，以此產生一個 String 對象
CharSequence subsequence(int start,int end)
取得此 StringBuffer 對象內含字符串中，由start索引開始直到end索引之前（不包括此字符）的所有字符，並以charSequence對象的格式返回。
2.賦值與此 StringBuffer 對象內字符串有關的一些屬性 j02060409
void setCharAt(int index,char ch)
設定此StringBuffer 對象內含字符串中某個索引位置上的字符值。index參數指定該字符索引的位置，ch參數決定該字符的值
void setLength(int newLength)
設定此StringBuffer 對象內含字符串的長度。若新的長度比原來小，則後面在範圍外的字符會被捨棄；若長度比原來大，則後面會新增字符，而且每個都初始化爲特殊字符“/u0000”，其意是“回車換行”
void ensureCapacity(int minimumCapacity)
要求此對象的內部緩衝區目前至少要配置到minimumCapacity參數指定的容量。若目前緩衝區已超過參數指定容量，或參數值小於0，其他並不會因此縮小。
3.直接對 StringBuffer 對象內含的字符串作處理，之後會回傳它自己本身的實例（引用地址）
j02060410
StringBuffer append(一個參數)
將導入參數的值轉爲字符串，然後連接到此 StringBuffer 對象所含之字符串的尾端，和“＋”運算符對字符串的處理相似，但此對象本身內含字符串會改變
StringBuffer append(char[]str,int offset,ing len)
從str參數取得字符串連接到此 StringBuffer 對象內含字符串的尾端。而利用offset參數決定從str字符串的這個索引位開始取字符串，且欲取得的字符串長度由len參數指定。
StringBuffer delete(int start,int end)
刪除此StringBuffer 對象內含的部分字符串，由start參數指定開始刪除第一個字符的索引位置，end參數決定從此字符開始就不刪除的索引位置
StringBuffer deleteCharAt(int index)
刪除此StringBuffer 對象內含字符串中的一個字符，其索引位置由index參數指定
StringBuffer insert(int offset,char[]str)
將str參數代表的字符串插入到此StringBuffer 對象內含字符串中，而插入的目標索引位置由offset參數決定。
StringBuffer insert(int index,char[]str,int offset,int len)
從str參數取得字符串插入到此StringBuffer 對象內含字符串中。而插入的目標索引位置由offset參數決定，offset參數則決定從str的這個索引位置開始取字符串，且len參數決定欲取得的字符串長度
StringBuffer replace(int start,int end,String str)
將此StringBuffer 對象內的某一部分取代爲str參數指定的字符串。而start指定要被取代掉第一個字符的索引位置，end參數則指定由此索引位置開始就不再取代字符，則此字符不會被取代掉。
StringBuffer reverse()
將從StringBuffer 對象內含字符串的排列順序完全倒轉。
4.在StringBuffer 對象內含字符串中尋找某個字符串，然後回傳目標所在的索引位置 參考j02060402
int indexOf(String str)
在此對象內含的字符串（char[]類型）中尋找某個字符串。找到第一個符合的字符串後，就返回它第一個字符的索引；若找不到則返回-1
int indexOf(String str,int fromIndex)
同名異式，在此字符串中尋找某個字符串，且由fromIndex參數指定由此字符串（char[]類型）的某字符（用索引指定）開始向後對比字符串，找到第一個符合的字符就返回
int lastIndexOf(String str)
在此對象內含的字符串（char[]類型）中尋找某個字符串。若要找的字符串由兩個以上，會返回最後一個它的第一個字符的索引值；若找不到則返回-1
int lastIndexOf(String str,int fromIndex)
同名異式，在此字符串中尋找某個字符串，且由fromIndex參數指定由此字符串（char[]類型）的某字符
（用索引指定）開始向後對比字符串
複製string對象 j02060411 複製stringbuffer對象j02060412
第八章 JAVA的一般類：
類的構造函數：
1.“封住等級”通常是public
2.此“函數名”與“類名”完全相同
3.無返回類型
4.無修飾符
5.構造函數只能配合new來自動調用，而無法讓對象使用。
成員的修飾符
abstract
此修飾符只能用在一般“成員函數”，而不能用於成員變量或構造函數，且不能與其他修飾符（封裝修飾符除外）同時用於一個成員函數。帶此修飾符的成員函數，只會有聲明部分，其後只需一個“;”作爲結尾，不能有實現部分。在一個類中，只要擁有一個以上有加abstract修飾符的成員函數，就得將其聲明爲abstract類，且不能以此abstract類的構造函數來產生對象實例。
static
第十章 java的窗體應用程序基礎
***** 窗口應用程序通常在窗口內會需要許多組件，通常不直接使用Frame類產生組件，而是要聲明一個
繼承自 Frame的類，並在裏面加入組件作爲它的成員，然後再利用該類去產生一個“擁有所需的組件內容
與功能的窗口”。而此類繼承自frame組件類，則程序代碼結構可以如下：
import java.lang.*;
import java.awt.*;使用到AWT組件
//import javax.swing.*;若使用到Swing組件
[封裝] class 窗口類名 extends Frame {
組件區：Button、Label等類的對象（變量）==>類成員
public 窗口類名 (){
決定何種版面佈局方式==》窗口框架的setLayout（）方法
構造各組件的對象實例==》使用組件的構造函數
設定各組件的屬性：外觀位置==》各組件setBounds（）方法
設定各組件所對應的事件監聽機制（搭配Inner Class）
將各組件加入此窗口框架中==》此窗口框架的add（）方法
設定此窗口框架的屬性：外觀位置等等==》setBounds（）等方法
設定此窗口框架對應的事件監聽機制（搭配Inner Class）
顯示此窗口==》使用show（）、setVisible（）方法
}
public static void main(String args[]){
窗口類名 窗口對象=new 窗口類的構造函數；
//也可在其它類內建立此種窗口對象
操作窗口框架==》窗口對象.方法
操作窗口內的組件==》窗口對象.組件.方法
}
Inner class (自定的事件類)==>類的類型成員
}
倘若此類要繼承JFrame組件類，則可按下面的程序代碼架構來聲明我們的窗口框架類：
import java.lang.*;
//import java.awt.*;若使用到AWT組件
import javax.swing.*;使用到Swing組件
[封裝] class 窗口類名 extends JFrame {
組件區：JButton、JLabel等類的對象（變量）==>類成員
public 窗口類名 (){
決定何種版面佈局方式==》ContentPane的setLayout（）方法
構造各組件的對象實例==》使用組件的構造函數
將各組件加入ContentPane中==》使用此ContentPane的add（）方法
設定此ContentPane的屬性：背景顏色等等==》setBounds（）等方法
設定此窗口框架的屬性：外觀位置等等==》setBounds（）等方法
設定此窗口框架對應的事件監聽機制（搭配Inner Class）
顯示此窗口==》使用show（）、setVisible（）方法
}
public static void main(String args[]){
窗口類名 窗口對象=new 窗口類的構造函數；
//也可在其它類內建立此種窗口對象
操作窗口框架==》窗口對象.方法
操作窗口內的組件==》窗口對象.組件.方法
}
Inner class (自定的事件類)==>類的類型成員
}
第十一章 窗口程序的事件機制 //Shijian.java
*****建立GUI事件的做法，主要有兩種方式：一.一般標準做法--implements XXXListener
1.加入所需的監聽能力 首先爲組件註冊一個負責處理某方面事件的listener對象（事件監聽者），也
就是使組件具備監聽某一類事件的能力，方式如下：組件.addXXXListener（XXXListener對象）
2.自定義一個實現XXXListener接口的類（class）
在上一步中需要導入一個XXXListener對象，但java提供的XXXListener接口類，無法直接用來產生對象實例，因此我們得要自定一個繼承該接口的一般類。既然是繼承接口類，那麼就要實現該接口的所有方法。
假設要制定鼠標按鍵單擊該組件時執行的動作，那麼就要override它的mouseClickd（MouseEvent e）事件函數
3.產生Listener對象實例
Button1.addMouseListener（new Button1MouseListener（））;
二.繼承Adapter類的作法－－extends XXXAdapter
若 XXXAdapter接口中的事件函數有兩個以上，java就會提供一個對應它的XXXAdapter類（即：適配器類）給我們，它是一個已經 implements XXXListener的類。此種作法的實現步驟如下：
1.加入所需的監聽能力
組件.addXXXListener(給XXXAdapter對象);
2.自定義一個繼承XXXAdapter的類：extends XXXAdapter
由於XXXAdapter類是標準的一般類，所以繼承此類之後，我們只要override所需要的事件函數即可。
3.產生Listener對象實例
*****AWT事件類
awt的事件類的繼承關係圖：
java.lang.Object
|
java.EventObject
| |
java.AWTEvent java.beans.PropertyChangeEvent
|
java.awt.event. java.awt.event. java.awt.event. java.awt.event. java.awt.event.
ComponentEvent TextEvent ItemEvent ActionEvent AdjustmentEvent
|
FocusEvent InputEvent ContainerEvent WindowEvent PaintEvent
|
KeyEvent MouseEvent
|6.5
MouseWheelEvent
EventObject 類--所有事件類的始祖
它提供了一個getSource()方法，讓我們知道事件源發生自哪個組件。
public Object getSource()
AWTEvent 類--它是繼承自EventObject的一個abstract類，它是所有AWT事件的父類。
*****Frame組件擁有的監聽能力與常用的Listener接口
一.由Component類繼承來的監聽能力
Component 類定義的 addXXXListener()方法
void addComponentListener(ComponentListener l)
void addFocusListener(FocusListener l)
void addHierarchyBoundsListener(HierarchyBoundsListener l)
void addHierarchyListener(HierarchyListener l)
void addInputMethodListener(InputMethodListener l)
void addKeyListener(KeyListener l)
void addMouseListener(MouseListener l)
void addMouseMotionListener(MouseMotionListener l)
void addMouseWheelListener(MouseWheelListener l)
這些“監聽者”的Listener接口： 所有事件的返回類型皆爲void
1.ComponentListener 接口
此接口擁有的事件函數如下：
事件函數 觸發時機
componentHidden(ComponentEvent e) 組件從屏幕上隱藏起來，例如使用 setVisible(false)方法，或使用舊版hide()方法
componentShown(ComponentEvent e) 組件由隱藏改爲顯示到屏幕上，例如使用 setVisible(false)方法，或使用舊版show()方法
componentMoved(ComponentEvent e) 組件在容器內位置變動時，若是獨立浮動的Frame 組件，其容器可視爲屏幕（screen）
componentResized(ComponentEvent e) 組件的外觀大小改變時
2.FocusListener 接口
事件函數 觸發時機
focusGained(FocusEvent e) 鍵盤焦點由另一個組件進入此組件時
focusLost(FocusEvent e) 鍵盤焦點由此組件進入另一個組件時
注：如果組件本身是一個容器，而其內又容納了能接受鍵盤輸入焦點的組件，那麼FocusListener所處理的FocusEvent事件，會發生在其內所包含
的組件上。因此，對於象Frame這樣的窗口，若要針對它是否接受Focus作控制，一般會使用WindowFocusListener來實現。
3.KeyListener 接口
事件函數 觸發時機
keyPressed(KeyEvent e) 當鍵盤焦點在此組件內，將鍵盤的任何一個按鍵 按下（在放開或其他按鍵被按前，會不斷偵測到 KeyPressed事件，則按下到放開爲止，可能有多 次KeyPressed發生）
keyRelease(KeyEvent e) 當鍵盤焦點在此組件內，將鍵盤的任何一個被按 下的按鍵放開彈起
keyTyped(KeyEvent e) 當鍵盤焦點在此組件內，將鍵盤的任何一個文字 輸入（包括空格）鍵按下，亦即每用鍵盤打一個 字。或按下Esc、Enter特殊功能鍵時，也會觸發 此事件。例如：在一個文本框內輸入一個“Y”字 符，總共會觸發keyPressed、keyRelease、 keyTyped三個事件。若按下F1鍵再放開，就只會 觸發keyPressed、keyRelease
4.MouseListener 接口
事件函數 觸發時機
mousePressed(MouseEvent e) 在此組件內按下鼠標按鍵（到放開爲止，算一次 mousePressed）
mouseClicked(MouseEvent e) 相當經歷一回mousePressed+mouseReleased。可 偵測的鼠標點擊狀況，包括按一下和連按多下
mouseReleased(MouseEvent e) 在此組件內將鼠標按鍵放開
mouseEntered(MouseEvent e) 鼠標光標移入此組件內
mouseExited(MouseEvent e) 鼠標光標由此組件移出
5.MouseMotionListener 接口
事件函數 觸發時機
mouseMoved(MouseEvent e) 鼠標在此組件內移動
mouseDragged(MouseEvent e) 鼠標在此組件內進行拖拽並放開的動作
6.MouseWheelListener 接口
事件函數 觸發時機
mouseWheelMoved(MouseWheelEvent e) 鼠標滾輪在此組件內滾動
二.Frame由Container類繼承來的監聽能力
Container 類定義的addXXXListener()方法
void addContainerListener(ContainerListener l)
void addPropertyChangeListener(PropertyChangeListener l)
void addPropertyChangeListener(String propertyName,PropertyChangeListener listener)
1.ContainerListener 接口
事件函數 觸發時機
componentAdded(ContainerEvent e) 有一個組件移入此Container組件中
componentRemoved(ContainerEvent e) 有一個組件由此Container組件中移出
注：因Container的子類Window，覆蓋了由Container繼承的兩個addPropertyChangeListener()方法，而Frame組件又繼承自Window類，所以Frame組件使用的是Window類定義的addPropertyChangeListener()方法。
三.有Window類繼承而來的監聽能力
Window 類定義的addXXXlistener()方法
void addPropertyChangeListener(PropertyChangeListener listener)
void addPropertyChangeListener(String propertyName,PropertyChangeListener listener)
void addWindowFocusListener(WindowFocusListener l)
void addWindowListener(WindowListener l)
void addWindowStateListener(WindowStateListener l)
1.WindowFocusListener 接口：
事件函數 觸發時機
windowGainedFocus(WindowEvent e) 當此Window組件取得程序焦點
windowLostFocus(WindowEvent e) 當此Window組件失去程序焦點
2.WindowListener 接口：
事件函數 觸發時機
windowActivated(WindowEvent e) 當此Window組件現在設定爲活動中的窗口
windowDeactivated(WindowEvent e) 當此Window組件現在要由活動中的窗口改成非 活動中的窗口
windowClosed(WindowEvent e) 當系統確實要處理掉（dispose）此Window組 件，而要關閉此窗口時
windowClosing(WindowEvent e) 用戶通過窗口窗體企圖關閉此Window組件時
windowDeiconified(WindowEvent e) 此Window組件由最小化的狀態變成一般正常大 小時
windowIconified(WindowEvent e) 此Window組件由一般正常大小變成最小化的狀 態
windowOpened(WindowEvent e) 此Window組件第一次被設定爲visible的時候
3.WindowStateListener 接口：
事件函數 觸發時機
windowStateChanged(WindowEvent e) 此Window組件的狀態改變時
四.其他組件擁有的監聽能力和常用的Listener接口
1.Button 組件擁有的監聽能力
Button 類定義了一個註冊事件監聽者的方法，如下：
public void addActionListener(ActionListener l)
實現此“事件監聽者”的Listener 接口如下：
ActionListener 接口:
此接口只擁有一個事件方法，因此沒有一個與它對應的Adapter類
事件函數 觸發時機
actionPerformed(ActionEvent e) 當ActionEvent對象產生時
2.TextComponent 組件擁有的監聽能力
TextComponent 類定義了一個註冊事件監聽者的方法，如下：
public void addTextListener(TextListener l)
實現此“事件監聽者”的Listener 接口如下：
TextListener 接口:
此接口只擁有一個事件方法，因此沒有一個與它對應的Adapter類
事件函數 觸發時機
textValueChanged(TextListener l) 當此組件的text值改變時
3.List 組件擁有的監聽能力
List 類定義了兩個註冊事件監聽者的方法，如下：
List 類定義的addXXXListener()方法
public void addActionListener(ActionListener l)
public void addItemListener(ItemListener l)
ItemListener 接口
此接口只擁有一個事件方法，因此沒有一個與它對應的Adapter類
事件函數 觸發時機
itemStateChanged(ItemEvent e) 當此組件的一個選項被用戶“選取”或“反選”的 時候
4.Scrollbar 組件擁有的監聽能力
Scrollbar 類定義了一個註冊事件監聽者的方法，如下：
public void addAdjustmentListener(AdjustmentListener l)
AdjustmentListener 接口：
此接口只擁有一個事件方法，因此沒有一個與它對應的Adapter類
事件函數 觸發時機
adjustmentValueChanged(AdjustmentEvent e) 當此組件某個可調整的值被改變的時候
第十三章、I/O處理
*****java內置流類（stream classes）根據它所操作的數據單位的類型分爲兩大類：一類是以字符（char）爲單位的“字符流”（character streams），另一類是以字節爲單位的“字節流”（byte streams）。它們負責輸入和輸出的基本代表分別是Reader和Writer類，以及InputStream和OutPutStream
1.字符流 Reader和Writer
|-CharArrayReader
|-StringReader
|-InputStreamReader---FileReader
Reader|-PipedReader
|-BufferedReader---LineNumberReader
|-FilterReader ---PushbackReader
|-CharArrayWriter
|-StringWriter
|-OutputStreamWriter---FileWriter
Writer |-PipedWriter
|-BufferedWriter
|-FilterWriter
|-PrintWriter
以上字符流類主要可以分爲兩大類，其中一類是負責不同數據存放方式的流類，如：CharArray、String、Pipe、File；另一類是對數據作額外處理的類，如：Buffered、Filter
2.字節流 InputStream和OutPutStream
一般用來讀入和寫出二進制數據，例如圖象、聲音。像字符流無法正常處理的可執行文件、壓縮文件等，只要是“非純文本”的數據，就要以此種流來處理。
|---ByteArrayInputStream
|---FileInputStream
|---StringBufferedInputStream
|---PipedInputStream |--BufferedInputStream
InputStream |---FilterInputStream----------------|--LineNumberInputStream
|---SequenceInputStream |--PushbackInputStream
|---ObjectInputStream |--DataInputStream
|---ByteArrayOutputStream
|---FileOutputStream
|---PipedOutputStream |--BufferedOutputStream
OutputStream |---FilterOutputStream---------------|--DataOutputStream
|---ObjectOutputStream |--PrintStream
以上字符流類主要可以分爲兩大類，其中一類是負責不同數據存放方式的流類，如：ByteArray、File、StringBuffer、Pipe；另一類是對數據作額外處理的類，如：Buffered、Filter
Buffered這一類得配合前一類的類使用，因此java提供的流類主要可分爲：
無Buffer緩衝 有Buffer緩衝
以char爲單位 Reader(及其子類) BufferedReader(配合 Reader 及其子類使用 )
Writer(及其子類) BufferedWriter(配合 Writer 及其子類使用 )
以byte爲單位 InputStream(及其子類) BufferedInputStream(配合 InputStream 及其子 類使用 )
OutputStream(及其子類) BufferedOutputStream(配合 OutputStream及其
子類使用)
*****InputStream 類---以File存儲類型介紹 j02130201
InputStream 定義的方法：
返回 方法 說明
int available()throws IOException 返回目前可由此輸入流讀入的byte數據的數量。 子類需要覆蓋此方法，否則返回值都會是0
abstract int read()throws IOException 由此輸入流讀取下一個byte數據作爲返回值，但 返回的byte值會以int類型的值展現，其值介於0 -255 之間，若已達流結尾，則返回-1。
int read(byte[]b)throws IOException 由輸入流讀取一些byte數據，並存放在參數代表 的數組中。然後將讀取的byte數據的數量以int 值返回，若已達流結尾，則返回-1。
int read(byte[],int off,int len) 由輸入流讀取一些byte數據，並存放在參數代表
throws IOException 的數組的某段位置。然後將讀取的byte數據的數 量以int值返回，若已達流結尾，則返回-1。
void reset() 將流內的位置移到上次以mark()方法標記的位置 。要看該流是否支持mark()和reset()，而 InputStream 的 mark()無實際作用，所以總是 拋出 IOException。
void mark(int readlimit) 標記目前於此輸入流內的位置，直到再讀入 readlimit個byte爲止，這個標記都維持有效。 之後若使用reset()方法，會嘗試移到所標記的 位置。但InputStream 的 mark()無實際作用
boolean markSupported() 測試此流是否支持mark()和reset()方法。只要 其中一個不支持，則返回false。
long skip(long n)throws IOException 跳過幾個byte數據，並返回跳過的數量。跳過多 少字符由參數指定
void close()throws IOException 關閉此輸入流，並釋放任何與之關聯的系統資源 。但 InputStream 的close()尚無實際作用。
*****OutputStream 類---以File存儲類型介紹 j02130202
OutputStream定義的方法：
返回 方法 說明
void write(byte[]b)throws IOException 將一個byte[]數組的數據寫到輸入流。
void write(byte[]b,int off,int len) 將一個byte[]數組的部分數據寫到輸入流。
throws IOException
abstract void write(int b)throws IOException 寫出一個byte數據到輸出流，但代表該byte值的 參數爲int類型
void flush() throws IOException 將流內的數據清出，並迫使緩衝區暫存的數據寫 出。但OutputStream的flush()尚無實際意義。 void close()throws IOException 關閉此輸入流，並釋放任何與之關聯的系統資源 。但 OutputStream 的close()尚無實際作用。
*****以char位爲數據單位的流類
1.Reader 類----以File存儲類型介紹 j02130301
返回 方法 說明
boolean ready()throws IOException 判斷此數據流是否已就緒，之後能被讀取。
int read()throws IOException 讀入一個字符。讀取的字符會以int類型表示， 其值的範圍在0-65535（0x00-0xffff）之間。但 若已讀到流結尾，無法在往後讀一個字符，則返 回值爲-1。
int read(char[] cbuf)throws IOException 將一些字符讀入某個char[]數組，並返回所讀入 的字符的數量。若已達到流結尾，則返 回值爲- 1。
abstract int read(char[] cbuf,int off,int len) 將一些字符讀入某個char[]數組的某段位置，並 throws IOException 返回所讀入的字符的數量。若已達到流結尾，則 返 回值爲-1。
void reset()throws IOException 重新設定流。如果之前此流內被標記了位置，使 用此方法會嘗試移到之前標記的位置。若之前未 標記位置，將以適合該流的特定方式重新設定它 ，例如將所在位置設到流的其始點。但並非所有 字符流都支持reset()雲作，有些雖支持reset() ，卻並不支持mark()雲作。
void mark(int readAheadLimit) 標記目前在流內的所在位置，直到再讀入 throws IOException readAheadLimit個char爲止，這個標記都維持有 效。之後使用reset()方法，會嘗試移到流內被 標記的位置。並非所有字符流都支持mark()方法 。
boolean markSupported 判斷此數據流是否支持mark()方法。但子類必須 覆蓋此方法纔有效，否則只返回false。
long skip(long n) 跳過字符 ，並返回所跳過的字符的數量。跳過 多少字符由參數指定，若參數值爲負數，會引發 IllegalArgumentException例外
abstract void close() 關閉數據流。當關閉數據流，就不再使用它的 read()，ready()，mark()，reset()方法，否則 會拋出 IOException 例外
2.Writer 類----以File存儲類型介紹 j02130302
返回 方法 說明
void write(char[]cbuf)throws IOException 將一個字符數組的數據寫出。
abstract void write(char[] cbuf,int off,int len) 將某個字符數組的一部分數據寫出。
throws IOException
void write(int c)throws IOException 寫出一個字符，但代表該字符的參數爲int類型
void write(String str)throws IOException 寫出一個字符串。
void write(String str，int off，int len) 將某字符串的一部分寫出。
abstract void flush()throws IOException 將流內未輸出的數據清出。如果流內經write() 方法在緩衝區暫存了數據，使用此方法會令數據 立即輸出到目的地。
abstract void close()throws IOException 讓數據由流輸出，然後關閉此流。當關閉流之後 ，若再使用write()或flush()方法將導致 IOException 例外。
*****有Buffer緩衝的I/O類
一.有Buffer緩衝的byte流 j02130401
BufferedInputStream 類，它的構造函數：
1.BufferedInputStream(InputStream in)
以缺省的緩衝區大小構造一個byte輸入流，以JDK 1.4 而言，此緩衝區缺省大小爲2048個byte，而緩衝數據就存於此類的buf字段。至於輸入的數據來源，就決定於參數in代表的byte流。
2.BufferedInputStream(InputStream in,int size)
與前者相似，但緩衝區大小由size參數決定。
BufferedOutputStream 類，它的構造函數：
當byte數據寫到內部緩衝區時，當下列任何一種情況發生時，裏面的數據就會寫到輸出流中，情況包括：緩衝區內數據已飽和、輸出流被關閉、或以flush()明確要求輸出流清出。
構造函數：
1.BufferedOutputStream(OutputStream out)
以缺省的緩衝區大小構造一個byte輸出流，以JDK 1.4 而言，此緩衝區缺省大小爲512個byte，而緩衝數據就存於此類的buf字段。至於輸出的數據來源，就決定於參數out代表的byte流。
2.BufferedOutputStream(OutputStream out,int size)
與前者相似，但緩衝區大小由size參數決定。
二.有Buffer緩衝的char流 j02130402
除了能支持mark()、reset()、skip()、flush()方法外，還提供了能就我們一次讀寫“一行文字”的readLine()和newLine()方法
BufferedReader 類，構造函數：
1.BufferedReader(Reader in)
以缺省的緩衝區大小構造一個char輸入流，以JDK 1.4 而言，此緩衝區缺省大小爲8192個char，輸入的數據來源，就決定於參數in代表的char流。
2.BufferedReader(Reader in,int sz)
與前者相似，但緩衝區大小由sz參數決定。
此類新增的方法爲readLine()，方法定義如下：
返回 方法 說明
String readLine()throws IOException 讀入一行文字。“一行”意思，就是一連串文字以 '/n'或'/r'等字符做結尾。而此方法將返回代表 讀入的內容的 String ，但並不包含該行的結尾 字符。若已達結尾而未讀入任何文字，則返null
BufferedWriter 類，構造函數：
1.BufferedWriter(Writer out)
以缺省的緩衝區大小構造一個char輸出流，以JDK 1.4 而言，此緩衝區缺省大小爲8192個char，輸入的數據來源，就決定於參數out代表的char流。
2.BufferedWriter(Writer out,int sz)
與前者相似，但緩衝區大小由sz參數決定。
此類新增的方法爲newLine(),方法定義如下：
返回 方法 說明
void newLine()throws IOException 寫出一個“一行文字的結尾”。若在windows平臺，此方法寫出的結尾是 '/n'字符，但並非所有平臺都以'/n'字符作爲一行的結尾，以何種字符作結尾是由系統的“line.separator”屬性決定
*****各種I/O存儲類型
基於I/O存儲類型，主要可分爲：Memory、File和Pipe三大類型。其中，Memory一類的流類，是用來對Memory作存取；File一類的流類，則是對操作系統上的文件作存取；而Pipe一類的流類，則是用來實現構成一個Pipe（管道）的輸入及輸出流。
數據存儲類型 流類
Memory CharArrayReader
CharArrayWriter
ByteArrayInputStream
ByteArrayOutputStream
StringReader
StringWriter
StringBufferInputStream
File FileReader
FileWriter
FileInputStream
FileOutputStream
Pipe PipedReader
PipedWriter
PipedInputStream
PipedOutputStream
1.數組的I/O
利用CharArrayReader或ByteArrayInputStream 能在Memory中現存的數組（char[]或byte[]）建立輸入流，也就是以數組作爲數據來源。之後就使用read()方法，由來源數組讀入數據。利用CharArrayWriter或 ByteArrayOutputStream類建立輸出流，建立時會自動在Memory配置一塊作爲存放輸出的數據的數組。之後就使用writer()方法，將數據寫出到目的數組，而此數組存儲的數據可利用toCharArray()(或toByteArray())和toString()方法取得。
ByteArrayInputStream 的構造函數
ByteArrayInputStream(byte[] buf)
建立一個ByteArrayInputStream流，並以參數代表的byte[]數組的數據，作爲輸入流的數據來源。
ByteArrayInputStream(byte[] buf,int offset,int length)
建立一個ByteArrayInputStream流，並以參數代表的byte[]數組的某部分數據，作爲輸入流的數據來源。
ByteArrayInputStream 也支持mark(),reset(),skip()等方法，但close()方法沒有實際作用
ByteArrayOutputStream 的構造函數
ByteArrayOutputStream()
建立一個ByteArrayOutputStream流，其目的地數組的初始化長度爲默認值。
ByteArrayOutputStream（int size）
建立一個ByteArrayOutputStream流，並以seze參數指定目的地數組的初始化長度
它的flush()和close()都沒有實際作用
ByteArrayInputStream 新增方法：
返回 方法 說明
void reset() 將此ByteArrayInputStream的count字段值設定
爲0，如此則目前積累輸出到目的地的數據將全
被放棄。
int size() 返回此時目的數組的長度
byte[] toByteArray() 返回一個新建的byte[]數組，其長度和數據內 容同於此輸出流的目的數組。
String toString() 將目的數組的內容轉換爲一個字符串。
void writeTo(OutputStream out) 將目的數組內所有內容寫出到out參數指定的另
throws IOException 一個字節輸出流，其功能如同以out代表的流使 用write(buf,0,count)方法將數據寫出。
CharArrayReader 的構造函數
CharArrayReader(char[] buf)
建立一個以buf數組爲數據來源的CharArrayReader流
CharArrayReader(char[] buf,int offset,int length)
建立一個以buf數組的部分內容爲數據來源的CharArrayReader流
它也支持mark(),reset(),skip()等方法，但它的close()方法會取消對來源數組的參考，使用此方法後就無法再由該流讀入數據
CharArrayWriter 的構造函數
CharArrayWriter()
建立一個CharArrayWriter流，其目的地數組的初始化長度爲默認值。
CharArrayWriter(int initialSize)
建立一個CharArrayWriter流，並由initialSize參數指定目的地數組的初始化長度
此類的close()方法並不會將目的數組釋放，故其內的數據內容仍然會存在。
CharArrayWriter 新增方法：
返回 方法 說明
void reset() 將此CharArrayWriter的count字段值設定爲0， 如此則目前積累輸出到目的地的數據將全被放 棄，如此可重複利用此流將數據輸入到內存
int size() 返回此時目的數組的長度
char[] toCharArray() 返回一個新建的byte[]數組，其長度和數據內
容同於此輸出流的目的數組。
String toString() 將輸出的目的數組的內容轉換爲一個字符串。
void writeTo(Writer out) 將目的數組內所有內容寫出到out參數指定的另
throws IOException 一個字符輸出流
使用上述4個流的例子 j02130501
2.字符串的I/O
StringReader 的構造函數
StringReader(String s)
建立一個以參數指定的 String 爲數據來源的StringReader流
它也支持mark(),reset(),skip()等方法，但它的close()方法會取消對來源 String 的參考，使用此方法後就無法再由該流讀入數據
StringWriter 構造函數
StringWriter()
建立一個StringWriter流，其目的字符串（ StringBuffer ）的初始化長度爲默認值
StringWriter(int initialSize)
建立一個StringWriter流，並以initialSize參數指定其目的字符串（ StringBuffer ）的初始化長度
此類的close()方法並不會將目的字符串釋放，故其內的數據內容仍然會存在。
StringWriter 新增的方法；
返回 方法 說明
StringBuffer getBuffer() 返回此輸出流本身存儲數據的StringBuffer對 象
String toString() 將此輸出流的目的StringBuffer內含的字符串 內容轉換爲一個 String
3.對File的I/O
FileInputStream 的構造函數：
FileInputStream(File File(小寫))throws FileNotFoundException
以打開對某一實際文件的連接的方式，建立一個 FileInputStream 流，所連接的源文件是由file參數代表的File對象決定
FileInputStream(FileDescriptor fdObj)
以使用FileDescriptor對象決定源文件的方式，建立一個 FileInputStream 流。而fdObj參數導入的FileDescriptor對象，代表一個目前存在、對某個實際文件的連接
FileInputStream(String name)throws FileNotFoundException
以打開對某一實際文件的連接的方式，建立一個 FileInputStream 流，所連接的源文件是由name參數
決定，而name字符串內容包括文件的目錄和名稱
FileInputStream 新增的方法：
返回 方法 說明
protected void finalize()throws IOException 確保不再有任何地方參考此流對象時，有調用 它的close()方法，適時關閉流
FileChannel getChannel() 返回此FileInputStream流所結合的 FileChannel對象
FileDescriptor getFD()throws IOException 返回一個代表此FileInputStream流現在所連接 的文件來源的FileDescriptor 對象
FileOutputStream 的構造函數：
FileOutputStream(File File(小寫))throws FileNotFoundException
建立一個FileOutputStream流，而輸出的目的文件由file參數決定
FileOutputStream(File File,boolean append)throws FileNotFoundException
與前一個構造函數相似，但以append參數決定將byte數據寫大目的文件的開頭，還是續接於原有數據之後，當append的值爲true時，數據就續接於後。
FileOutputStream(FileDescriptor fdObj)
建立一個FileOutputStream流，輸出的目的文件由fdObj參數指定，它代表一個目前存在、對某個實際文件的連接。
FileOutputStream(String name)throws FileNotFoundException
建立一個FileOutputStream流，輸出的目的文件由name參數指定，而name字符串內容包含文件的目錄和名稱
FileOutputStream(String name,boolean append)throws FileNotFoundException
與前一個構造函數相似，但以append參數決定將byte數據寫大目的文件的開頭，還是續接於原有數據之後，當append的值爲true時，數據就續接於後。
FileOutputStream 新增的方法：與 FileInputStream 新增的方法相同
FileReader 的構造函數：
FileReader(File File(小寫))throws FileNotFoundException
建立一個 FileReader流，並以File類的參數指定源文件
FileReader(FileDescriptor fd)
建立一個FileReader流，並以FileDescriptor類的參數指定源文件
FileReader(String fileName)throws FileNotFoundException
建立一個FileReader流，並以fileName參數指定源文件的目錄及名稱
FileReader 繼承了 FileInputStream ，因此除了繼承自 Reader 的基本方法外，它還擁有一個getEncoding()方法(參考 InputStreamReader)，而它的close()也會讓此 FileReader 取消對源文件的連接，所以使用後不能再由源文件讀取數據。另外 FileReader 擁有的mark()、reset()、skip()方法仍然是由 Reader 提供，無實際作用。
FileWriter 的構造函數：
FileWriter(File File（小寫）)throws IOException
建立一個 FileWriter流，並以File類的參數指定源文件
FileWriter(File File,boolean append)throws IOException
與前一個構造函數相似，但以append參數決定將char數據寫到目的文件的開頭，還是續接於原有數據之後，當append的值爲true時，數據就續接於後。
FileWriter(FileDescriptor fd)throws IOException
建立一個 FileWriter 流，並以fd參數指定所連接的目的文件
FileWriter(String fileName)throws IOException
建立一個FileWriter流，輸出的目的文件由fileName參數決定，而fileName字符串內容包含文件的目錄和名稱。
FileWriter(String fileName,boolean append)throws IOException
與前一個構造函數相似，但以append參數決定將char數據寫到目的文件的開頭，還是續接於原有數據之後，當append的值爲true時，數據就續接於後。
FileWriter 流類，它繼承來的flush()和close()都已經由 OutputStreamWriter 改寫過，因此使用close()之後，就無法再以此 FileWriter 輸出數據。它還擁有一個getEncoding()方法(參考 outputstreamreader)
*****File類介紹
File 類的構造函數：
File(File parent,String child)
建立一個 File 對象，以parent參數導入的 File 對象代表的抽象路徑作爲前半段的路徑，以child字符串指定後半段的路徑
File(String pathname)
建立一個 File 對象，以pathname參數導入的字符串轉換爲抽象路徑
File(String parent,String child)
建立一個File 對象，以parent參數指定前半段的路徑，以child參數指定後半段的路徑
File(URI uri)
建立一個File 對象，以uri參數導入的URI（Uniform Resource Identifier）對象轉換爲抽象路徑
File 類的 static 字段
類型 字段名稱 說明
static String pathSeparator 以 String 類型的值，代表此操作系統獨特的名稱分 隔符，windows系統下此字段的值爲“；”
static char pathSeparatorChar 與前者相似，但是以char類型的值代表名稱分隔符， 則此字段的值爲“：”或“；”。
static sting separator 以 String 類型的值，代表此操作系統獨特的路徑分 隔符，在windows系統下，標準的路徑分隔符爲“/”， 但java的程序代碼要以“//”字符串表示，故此字段的 值爲“//”.
static char separatorChar 與前者相似，但是以char類型的值代表路徑分隔符，
則此字段的值爲“/”或“//”。
File 類基本常用方法：
返回 方法 說明
boolean canRead() 檢驗此程序是否能讀取File代表的文件
boolean canWrite() 檢驗此程序是否能將數據寫入此File代表的文件
String getName() 以 String 類型返回此 File 代表的文件或目錄（最 末層）例如：“test/data”,則返回“data”
String getParent() 返回此 File代表的文件或目錄所在的抽象路徑，如： “test/data/A01”則返回“test/data”，若構造時未指 定上層目錄，則返回null
String getPath() 以 String 類型返回此 File 代表的抽象路徑，其值 相當於getName()＋getParent()
File getParentFile() 與前者相似，但返回的時代表上層目錄的 File 對象
boolean isDirectory() 檢驗此 File 代表的是否爲“目錄”
boolean isFile() 檢驗此 File 代表的是否爲“文件”
boolean creatNewFile() 若此 File 代表的文件不存在，且上層目錄存在時，
throws IOException 就會新建此文件，但只是一個空的文件。但方法無法 自動判斷此 File 是否代表文件，即使抽象路徑爲“ mydir”，仍會建立一個名爲“mydir”的文件（無擴展名
boolean mkdir() 若此 File 代表的目錄不存在，且上層目錄存在時， 就會新建此目錄。但不會自動判斷此 File 是否代表 目錄，即使抽象路徑爲"myFile.txt",仍會建立一個名 爲“myFile.txt”的目錄。
boolean mkdirs() 與前者相似，但上層目錄若不存在，會自動建立上層 目錄（parent）以及此目錄。
boolean delete() 刪除此 File 代表的文件或目錄，若成功刪除則返回 true。它若是目錄，則其內不能有任何文件或目錄才 能成功刪除。
boolean renameTo(File dest) 將此 File 代表的文件或目錄改名稱，以dest參數代 表的抽象路徑指定新路徑（包含上層路徑）。但前提 是dest的上層路徑（parent）必須已經存在，否則更 名行爲無效，返回值爲false。成功返回true。
long length() 返回此 File 代表的文件的大小，單位是字節（byte ）。若文件不存在，或代表的是目錄，都會返回0
boolean exists() 檢驗此 File 代表的文件或目錄是否存在。
int compareTo(File pathname) 比較此 File 與另一 File 所代表的兩個抽象路徑。 File 型若兩者代表的抽象路徑相同則返回0，若表示 此 File 的字符串值較大，則返回正數值，反之，則 返回負數值
int compareTo(Object o) 與前者相似，但導入作比較的對象若不滿足 File 類 型，則會拋出 ClassCastException 例外.
boolean equals(Object obj) 比較此 File 與obj導入的對象，若參數導入的是 File 類型的對象，而且它代表的抽象路徑又同於此
File 時，返回值纔會是true。
File 類的方法，用來取得此 File 代表的目錄下的各文件或目錄，或者用來取得本機系統的所有根目錄
返回 方法 說明
String[] List() 以 String[]類型返回此 File 代表的目錄內 的所有子目錄或文件
String[] List(FilenameFilter filter) 與前者相似，但利用filter參數指定的 FilenameFilter 對象過濾出所要的子目錄或 文件
File[] listFiles() 以 File[] 類型返回此 File 代表的目錄內的 所有子目錄或文件
File[] listFiles(FileFilter filter) 與前者相似，但利用filter參數指定的 FileFilter 對象過濾出所要的子目錄或文件
File[] listFiles(FilenameFilter filter) 與前者相似，但利用filter參數指定的 FilenameFilter 對象過濾出所要的子目錄或 文件
static File[] listRoots() 返回該平臺下所有文件系統根目錄，如 :"C:/","D:/"
File 類的其他方法：
返回 方法 說明
boolean setLastModified(long Time) 設定此 File 代表的文件最後一次修改的時 間。以long類型的time參數指定時間，其值 0L代表1970年1月1日0時0分0秒
long lastModified() 以long類型返回最後一次修改此文件的時間
boolean setReadOnly() 將此 File 代表的文件或目錄設爲“只讀”
boolean isHidden() 檢驗此 File 代表的文件或目錄是否處於“隱 藏”狀態
boolean isAbsolute() 檢驗此 File 代表的是否爲“絕對路徑”
File getAbsoluteFile() 以“絕對路徑”的格式返回此 File 對象代表 的抽象路徑。若此 File 代表“test/t1.txt” ,此方法返回的 File 可能代表“ c:/test/t1.txt”
String getAbsolutePath() 與前者相似，但返回值是代表路徑的字符串
File getCanonicalFile() 以“標準實際路徑”的格式返回此 File 對象 代表的抽象路徑
String getCanonicalpath() 與前者相似，但返回值是代表路徑的字符串
static File createTempFile(String prefix, 以缺省的臨時文件路徑建立一個空的 File
String suffix) ，並以prefix參數指定文件的前綴，以 suffix參數指定文件的字尾
static File createTempFile(String prefix, 以directory參數指定的路徑建立一個空的
String suffix,File directory) File ，並以prefix參數指定文件的前綴， 以 suffix參數指定文件的字尾
void deleteOnExit() 要求此 File 代表的文件或目錄在JVM結束 時能刪除此文件或目錄
int hashCode() 計算此 File 代表的文件或目錄的哈希碼
String toString() 以string類型返回此 File 代表的抽象路徑
URI toURI() 以此file代表的抽象路徑建立一個URI對象
URL toURL() 以此file代表的抽象路徑建立一個URI對象
利用 File 配合 BufferedInputStream 和 BufferedOutputStream 的例子 j02130502
4.對Pipe的I/O: 例子：j02130503
PipedInputStream 類：
構造函數：
PipedInputStream()
建立一個 PipedInputStream ，但尚未連接到任何的 PipedOutputStream 流
PipedInputStream(PipedOutputStream src)throws IOException
建立一個 PipedInputStream ，並且連接到src參數指定的 PipedOutputStream 流
此類新增的方法：
返回 方法 說明
void connect(PipedOutputStream src) 連接src參數指定的PipedOutputStream流。
throws IOException 但欲連接的流若已經和其他流連接，會拋出 IOException
protected void receive(int b) 將某個byte數據接收到PipedInputStream
throws IOException 的緩衝區中。此方法一般是由此流所連接的
PipedOutputStream 自動調用，當它將數據
寫出到Pipe時，會調用此方法讓數據接收到
對方的緩衝區。
此外，PipedInputStream 繼承自 InputStream 的方法中，availble()和close()都經過了改寫，有實際作用，但是mark()和reset()未經過改寫，無實際作用
PipedOutputStream 類：
它的構造函數：
PipedOutputStream()
建立一個PipedOutputStream，但尚未連接到任何的 PipedInputStream 流
PipedOutputStream(PipedInputStream snk)throws IOException
建立一個 PipedOutputStream ，並且連接到snk參數指定的 PipedInputStream 流
此類新增方法：
返回 方法 說明
void connect(PipedInputStream snk) 連接snk參數指定的PipedInputStream流。
throws IOException 但欲連接的流若已經和其他流連接，會拋出 IOException
PipedOutputStream 類也覆蓋了flush()和close()方法，它的flush()方法除了將緩衝的數據清出外，還會通知Pipe輸入流：“在Pipe內有byte數據等待被讀取”
PipedInputStream 和 PipedOutputStream 的建立不分先後順序，都能在兩個流之間建立Pipe
PipedReader 類：
它的構造函數：
PipedReader()
建立一個PipedReader，但尚未連接到任何的 PipedWriter 流
PipedReader(PipedWriter src)throws IOException
建立一個 PipedReader ，並且連接到src參數指定的 PipedWriter 流
此類新增方法：
返回 方法 說明
void connect(PipedWriter src) 連接src參數指定的PipedWriter 流。
throws IOException 但欲連接的流若已經和其他流連接，會拋出 IOException
PipedWriter 類：
它的構造函數：
PipedWriter()
建立一個PipedWriter，但尚未連接到任何的 PipedReader 流
PipedWriter(PipedReader,snk)throws IOException
建立一個 PipedWriter ，並且連接到snk參數指定的 PipedReader 流
此類新增方法：
返回 方法 說明
void connect(PipedReader snk) 連接snk參數指定的PipedReader 流。
throws IOException 但欲連接的流若已經和其他流連接，會拋出 IOException
*****各種I/O類處理方式：
特殊處理方式 流類
轉換byte流爲char流 InputStreamReader
OutputStreamWriter
輸出數據 PrintWriter
PrintStream
連接多各流 SequenceInputStream
過濾數據 FilterReader
FilterWriter
FilterInputStream
FilterOutputStream
(以上4者的各個類)
預視數據（Peeking Ahead） PushbackReader
PushbackInputStream
數據轉換 DataInputStream
DataOutputStream
計算行數 LineNumberReader
LineNumberInputStream
對象序列化（Object Serialization） ObjectInputStream
ObjectOutputStream
轉換byte流爲char流：例子 j02130601
InputStreamReader 類：
構造函數：
InputStreamReader(InputStream in)
建立一個InputStreamReader 流，以缺省的字符集（charset），轉換in參數指定的InputStream流
InputStreamReader(InputStream in,Charset cs)
建立一個InputStreamReader 流，以cs參數指定的字符集（charset），轉換in參數指定的InputStream流
InputStreamReader(InputStream in,CharsetDecoder dec)
建立一個InputStreamReader 流，以dec參數指定的CharsetDecoder對象，轉換in參數指定的InputStream 流
InputStreamReader(InputStream in,String charsetName)throws UnsupportedEncodingException
建立一個InputStreamReader 流，以charsetName字符串指定的字符集，轉換in參數指定的InputStream 流
此類新增的方法：
返回 方法 說明
String getEncoding() 以 String 類型返回此InputStreamReader流使用的 字符編碼（character encoding）
OutputStreamWriter 類：
構造函數：
OutputStreamWriter(OutputStream out)
建立一個OutputStreamWriter 流，以缺省的字符集（charset），轉換out參數指定的OutputStream流
OutputStreamWriter(OutputStream out,Charset cs)
建立一個OutputStreamWriter 流，以cs參數指定的字符集（charset），轉換out參數指定的OutputStream流
OutputStreamWriter(OutputStream out,CharsetEncoder enc)
建立一個OutputStreamWriter 流，以dec參數指定的CharsetDecoder對象，轉換out參數指定的OutputStream 流
OutputStreamWriter(OutputStream out,String charsetName)throws UnsupportedEncodingException
建立一個InputStreamReader 流，以charsetName字符串指定的字符集，轉換out參數指定的OutputStream 流
此類新增的方法：
返回 方法 說明
String getEncoding() 以 String 類型返回此OutputStreamWriter流使用的 字符編碼（character encoding）
利用 System 類的in字段，取得用戶在console模式中輸入的文字 例子 j02130602
***** 打印數據 例子 j02130603
主要有 PrintStream 和 PrintWriter 兩個類，分別負責處理byte和char流
PrintStream 類：
此類的構造函數：
PrintStream(OutputStream out)
以一個現存的OutputStream 流建立一個PrintStream 流，但此流不具有自動flush的能力
PrintStream(OutputStream out,boolean autoFlush)
以一個現存的OutputStream 流建立一個PrintStream 流，而autoFlush參數決定是否要有自動flush的能力
PrintStream(OutputStream out,boolean autoFlush,String encoding)throws
UnsupportedEncodingException
以一個現存的OutputStream 流建立一個PrintStream 流，與前者相似，並且以encoding參數指定此流支持的字符編碼（character encodidng）
若一個PrintStream類構在時導入的autoFlush參數爲true,則當一個byte數組的數據被寫出（writer()）、或使用任一種print()方法（因爲它會調用write()）、或使用了任一種println()方法、或者一個“一行的結尾”（如：“/n”）被寫出時，都會自動調用此流的flush()。
PrintWriter 類：
此類的構造函數：
PrintWriter(Writer out)
以一個現存的Writer流建立一個PrintWriter流，但此流不具有自動flush的能力
PrintWriter(Writer out,boolean autoFlush)
以一個現存的Writer流建立一個PrintWriter流，而autoFlush參數決定是否要有自動flush的能力
PrintWriter(OutputStream out)
以一個現存的OutputStream流建立一個PrintWriter流，但此流不具有自動flush的能力
PrintWriter(OutputStream out,boolean autoFlus)
以一個現存的OutputStream流建立一個PrintWriter流，而autoFlush參數決定是否要有自動flush的能力
此類，若autoFlush參數爲true，則唯有使用println()方法纔會自動調用flush()。
PrintStream 類和 PrintWriter 類，不像其他的 OutputStream 會拋出 IOException ，若想知道此流在處理過程中是否產生例外，可使用checkError()方法，清空（flush）緩衝區並檢查是否有例外。
※※※※※連接多個流（Concatenation） 例子j02130604
一個 SequenceInputStream 流，實際上是代表其他多個 InputStream 流的邏輯連續。它提供的處理，是由組成此連續流的第一個 InputStream 流開始讀入數據，待第一個流讀完後，接着就讀第二個流的數據，如此直到讀完此 SequenceInputStream 所連接最後一個 InputStream 流爲止。
SequenceInputStream 類的構造函數：
SequenceInputStream(Enumeration e)
建立一個SequenceInputStream 流，以e參數指定的Enumeration（枚舉）對象提供諸多InputStream 流，作爲數據來源。所讀取的數據爲e枚舉內所有 InputStream 流的連接。
SequenceInputStream(InputStream s1,InputStream s2)
建立一個SequenceInputStream 流，以s1和s2參數所指定的InputStream 流，作爲數據來源。所能讀取的數據爲s1與s2流的連接。
此種流除了 InputStream 定義的那些方法外，沒由新增方法。但使用available()時要特別注意，它在讀取數據的過程種，當其內第一個流讀完時，availabel()方法返回的值會是0，但等到自動讀完第二個流時，available()返回的值就不再是0，而是第二個流當時能被讀取的數據量。
※※※※※ 預視數據（Pushback） j02130605
PushbackInputStream 和 PushbackReader 分別適用於 byte 流和char流
PushbackInputStream 構造函數：
PushbackInputStream(InputStream in)
建立一個PushbackInputStream 流，以in參數指定的 InputStream 流爲處理對象，並以 1 byte作爲回推緩衝區的大小。
PushbackInputStream(InputStream in,int size)
與前者相似，另外以size參數指定回推緩衝區的大小
此類新增的方法：
返回 方法 說明
void unread(byte[] b) 將b數組所含的byte值回推至流，也就是將b
throws IOException 數組所含的值複製到回推緩衝區的最前面
void unread(byte[] b,int off,int len) 將b數組所含的byte值的一部分回推至流，也
throws IOException 就是將b數組所含的值複製到回推緩衝區的最 前面
void unread(int b)throws 將參數b指定的byte值回推至流，也就是將b
IOException 的值複製到回推緩衝區的最前面
PushbackReader 的構造函數：
PushbackReader(Reader in)
建立一個 PushbackReader流，以in參數指定的 Reader 流爲處理對象，並以 1 byte作爲回推緩衝區的大小(pushback buffer)
PushbackReader(Reader in,int size)
與前者相似，另外以size參數指定回推緩衝區的大小
此類新增的方法:
返回 方法 說明
void unread(char[] cbuf) 將cbuf數組所含的char值回推至流，也就是
throws IOException 將cbuf數組所含的值複製到回推緩衝區的最 前面
void unread(char[] cbuf,int off,int len) 將cbuf數組所含的char值的一部分回推至流
throws IOException 就是將cbuf數組所含的值複製到回推緩衝區 的最前面
void unread(int c)throws 將參數c指定的char值回推至流，也就是將c
IOException 的值複製到回推緩衝區的最前面
※※※※※數據轉換 例子 j02130606
DataInputStream 類構造函數：
DataInputStream(InputStream in)
建立一個DataInputStream流，以in參數指定的 InputStream 爲處理的對象
此類實現了 DataInput 接口。擁有將各類數據依不同類型格式讀入的方法。
此類常用方法:
返回 方法 說明
int skipBytes(int n)throws IOException 嘗試跳過n各byte的數據，返回的值爲真正
跳過的byte數量
boolean readBoolean()throws IOException 由所配合的流讀取 1 個byte，返回爲java 基本數據類型的boolean值。當來源的byte
值不爲0時，讀取的值爲true，反之當來源
的byte值爲0，則讀取的值爲false
byte readByte()throws IOException 由所配合的流讀取 1 個byte，返回爲java
基本數據類型的byte值
char readChar()throws IOException 由所配合的流讀取 1 個byte，返回爲java
基本數據類型的char值
short readShort()throws IOException 由所配合的流讀取 2 個byte，返回爲java
基本數據類型的short值
int readInt()throws IOException 由所配合的流讀取 4 個byte，返回爲java
基本數據類型的int值
long readLong()throws IOException 由所配合的流讀取 8 個byte，返回爲java
基本數據類型的long值
float readFloat()throws IOException 由所配合的流讀取 4 個byte，返回爲java
基本數據類型的float值
double readDouble()throws IOException 由所配合的流讀取 8 個byte，返回爲java
基本數據類型的double值
void readFully(byte[] b) 由所配合的流讀取若干byte的數據，並將數
據存入參數指定的b數組
void readFully(byte[] b,int off,int len) 由所配合的流讀取若干byte的數據，並將數
throws IOException 據存入參數指定的b數組某一部分
int readUnsignedByte()throws 由所配合的流讀取 1 個byte，返回爲無負
IOException 號的整數值，即其值範圍在0－255
int readUnsignedShort()throws 由所配合的流讀取 2 個byte，返回爲無負
IOException 號的整數值，即其值範圍在0－65535
String readUTF()throws IOException 讀取所配合的流內的數據，返回一個使用可
修改的UTF-8 編碼格式的字符串
DataOutputStream 構造函數：
DataOutputStream(OutputStream out)
建立一個DataOutputStream流，以out參數指定的OutputStream爲處理的對象
此類實現了 DataOutput 接口。 擁有將各種不同類型的數據寫出的方法。
此類常用方法：
返回 方法 說明
int size() 返回到目前爲止些到此DataOutputStream流
的byte數量
void writeBoolean(boolean v) 將一個java的boolean值寫出爲所配合的輸出
throws IOException 流的 1 個byte
void writeByte(int v) 將一個java的byte值寫出爲所配合的輸出
throws IOException 流的 1 個byte
void writeBytes(String s) 將一個java的String值寫出爲所配合的輸出
throws IOException 流的一連串byte
void writeChars(String s) 將一個java的String值寫出爲所配合的輸出
throws IOException 流的一連串char
void writeShort(int v) 將一個java的short值寫出爲所配合的輸出
throws IOException 流的 2 個byte,由高位開始
void writeInt(int v) 將一個java的int值寫出爲所配合的輸出
throws IOException 流的 4 個byte,由高位開始
void writeLong(long v) 將一個java的long值寫出爲所配合的輸出
throws IOException 流的 8 個byte,由高位開始
void writeFloat(float v) 以Float類的floatToIntBits()將v參數的值
throws IOException 轉爲int類型，再將此int值寫出爲所配合的
輸出流的 1 個 4 byte的量，由高位開始
void writeDouble(double v) 以Double類的DoubleToLongBits()將v參數值
轉爲long類型，再將此long值寫出爲所配合的
輸出流的 1 個 8 byte的量，由高位開始
void writeUTF(String str) 依機器平臺獨立的模式，將java的string以
throws IOException UTF-8 編碼寫出爲所配合的輸出流的字符串
※※※※※計算行數 例子 j02130607
LineNumberReader 類：
由於LineNumberReader 類繼承自 BufferedReader，故此流是一種由緩衝的char輸入流，其主要功能是能記錄所讀入的數據的行數。缺省行數是由0開始，每當讀入一行文字時，行數就會加 1 。而所謂的一行是再碰到“結尾字符”（'/n'）或“回返字符”（'/r'）之前那一連串的字符
LineNumberReader 類構造函數：
LineNumberReader(Reader in)
建立一個LineNumberReader 流，而擁有缺省大小的輸入緩衝區
LineNumberReader(Reader in,int sz)
建立一個LineNumberReader 流，並以sz參數指定緩衝區的大小
LineNumberReader 新增常用方法：
返回 方法 說明
String readLine()throws IOException 讀一行的文字
int getLineNumber() 取得現在已讀入的行數
void setLineNumber(int lineNumber) 設定現在已讀入的行數
※※※※※對象序列化（Object Serialization）
這方面的功能處理，主要是將對象寫到輸出流，或者由輸入流將對象讀入，這個處理就稱爲“對象序列化”。一個對象若要寫出到流，就必須經過序列化（serialize），相對的，若從流讀入對象，必須將它反序列化（deserialize），這些功能就分別由 ObjectInputStream 和 ObjectOutputStream 提供處理
對象的序列化的用途：
1.RMI（Remote Method Invocation）機制，通過各個Socket，作對象之間的通訊。
2.將對象存成文件，以備將來讓同一個程序連續着使用。
只有實現 java.io.Serializable 接口的類，其所產生的對象才能被序列化。 Serializable 接口並不含任何方法定義，因此不必實現任何特定的方法。像 String,Integer,Double 等，這些內置類就都有實現 Serializable 接口，所以它們的對象都可被序列化。
對象實例的序列化是由 ObjectOutputStream 類的defaultWriteObject() 方法控制，自動幫我們將重建此對象時所需的內容都寫出到流包括：
1.此對象的類類型。
2.類的簽名
3.此對象內所有“非static”和“非transient”成員的值，包括參考到其他對象的成員在內。
倘若該對象某些字段的狀態並不需要保存到以後使用，例如一個記錄現在時間的字段，則可將它定義爲transient成員
對象實例的反序列化則是由 ObjectInputStream 類的defaultWriteObject()方法負責處理。而defaultWriteObject() 是要由writeObject()調用，defaultReadObject()則要由readObject()調用，否則將產生NotActiveException例外。
例子 j02130608
ObjectOutputStream 和 ObjectInputStream 類： j02130609
ObjectOutputStream 的構造函數：
ObjectOutputStream (OutputStream out)
建立一個ObjectOutputStream ，而數據要寫出到out指定的OutputStream
ObjectOutputStream 主要常用方法;
返回 方法 說明
void writeObject(Object obj) 將obj參數指定的對象（可被序列化者）寫至
throws IOException 此ObjectOutputStream
void writeUnshared(Object obj) 寫出一個“unshared”的對象（可被序列化者
throws IOException ）到此ObjectOutputStream。此方法與
writeObject()大致相似，其差異是此方法總
是給予此流一個最新而唯一的對象。
void reset()throws IOException 此方法將忽視之前已寫入此流的任何對象的 狀態，也就是它將令此流成爲全新的 ObjectOutputStream
ObjectInputStream 的構造函數如下：
ObjectInputStream (InputStream in)
建立一個 ObjectInputStream ，而數據要從in指定的InputStream 讀取
ObjectInputStream 主要常用方法：
返回 方法 說明
Object readObject()throws IOException , 由此ObjectInputStream讀入一個對象
ClassNotFoundException
Object readUnshared()throws IOException, 由此ObjectInputStream讀入一個“
ClassNotFoundException unshared”的對象。此方法與 readObject() 和 readUnshared()
調用，在返回時獲得對反序列化後對象
實例額外的參考。
第十五章
ServerSocket 類介紹
此類實現了“Server端Socket”，它的主要功用是等候來自網絡上的“請求”，而它所展現的一些動作，正是以那些“請求” 爲基礎，並且也可能返回一個結果給“請求者”。
關於ServerSocket 的實際運作，其實是由一個 SocketImpl 實例來展現，當應用程序建立一個新的 ServerSocket 對象時，“Socket生產處”的createSocketImp()方法會被調用，以產生實際的 Socket 實現。應用程序能通過變更來產生 Socket 實現的“Socket生產處”，使它本身產生適用於本地端防火牆的 Socket
ServerSocket 類的構造函數：
ServerSocket()throws IOException
建立一個尚未綁定到本地端的ServerSocket
ServerSocket(int port)throws IOException
建立一個由port指定本機端口的ServerSocket。若port指定爲0，則會在任一可自由使用的端口上建立ServerSocket
ServerSocket(int port，int backlog)throws IOException
建立一個ServerSocket，使它綁定到port所指的本機端口，並以backlog參數指定進入的“連接指示”的最大隊列長度，默認值爲50。當隊列已滿時，若有“連接指示”（連接的請求），則會拒絕該項連接
ServerSocket(int port，int backlog,InetAddress bindAddr)throws IOException
與前一個構造函數相似，另外多一個bindAddr參數，用來指定此 ServerSocket要綁定的本機IP地址
ServerSocket 類常用的方法：
返回 方法 說明
Socket accept()throws IOException 監聽一個到此ServerSocket的連
連線要求，並接受、取得該 Socket。使用此方法的線程會維
持封鎖狀態，直到確實建立一個
連接爲止。
void bind(SocketAddress endpoint) 令此ServerSocket綁定到
throws IOException endpoint指定的SocketAddress
代表的本機IP地址和連接端口
void bind(SocketAddress endpoint, 與前一個方法類似，另外多一個
int backlog) throws IOException backlog參數用來指定進入的“連 接指示”的最大隊列長度
void close()throws IOException 關閉此ServerSocket。若現在有 任何線程尚未封鎖在此
ServerSocket 的accept()方法
，將會引發 SocketException
ServerSocketChannel getChannel() 返回此ServerSocket所關聯而唯
一的ServerSocketChannel對象
，若無則返回null
InetAddress getInetAddress () 返回一個代表此ServerSocket
連接的本機IP的InetAddress
int getLocalPort() 返回此ServerSocket現在監聽的
端口編號
SocketAddress getLocalSocketAddress() 返回一個代表此ServerSocket所
綁定的本地端的SocketAddress
物件，若無則返回null
static void setSocketFactory(SocketImplFactory fac) 設定應用程序的ServerSocket
實現生產處
boolean isBound() 判斷此ServerSocket是否已綁定
到本地端
boolean isClosed() 判斷此ServerSocket是否已關閉
String toString() 返回一個代表此ServerSocket
的字符串，內容包含IP地址與連 接端口
TCP程序範例－－－網絡點對點的文件傳輸 j02150401
TCP的Server端程序的實現步驟：
1.建立serverSocket對象，如：
ServerSocket severTcp=new ServerSocket(2222);
2.監聽並接受Client端Socket對它的連接，然後取得Socket，如：
Socket connSocket= severTcp.accept()
3.由 Socket取得從Client端讀入數據的 InputStream ，如：
InputStream serveInput=connSocket.getInputStream()
4.利用取得的InputStream 從Client端讀入數據，如：
serveInput.read(theData)
5.關閉 InputStream ，如：
serveInput.close()
6.關閉 Socket，如：
connSocket.close()
7.關閉ServerSocket（注：當Server端程序完全不需要再用它接收數據時才關閉），如：
severTcp.close()
TCP的Client端程序的實現步驟：
1.建立Socket對象，並連接到Server主機（Server端必須作了accept()，連接纔會成功），如：
Socket tcpSocket=new Socket("192.168.0.22",2222)
或
Socket tcpSocket=new Socket();
...
tcpSocket.connect(new InetSocketAddress("192.168.0.22",2222));
2.取得對Server端作數據輸出的 OutputStream ，如：
OutputStream opStream=tcpSocket.getOutStream();
3.利用取得的 OutputStream 送數據到Server端，如：
opStream.write(欲送出的數據)
4.關閉 OutputStream ，如：
opStream.close();
5.關閉Sockeet，如;
tcpSocket.close();
TCP程序範例二－－－掃描特定IP地址可用的連接端口 －－－j02150402
與WEB服務器互動的程序－－－運用URL及URLConnection
URL 類的構造函數：
URL(String spec)throws MalformedURLException
建立一個URL對象，依spec指定代表的URL（統一資源定位器）
URL(String protocol,String host,String File)throws MalformedURLException
建立一個URL對象，以protocol參數指定“協議”部分，以host指定“主機”，file指定目標主機上的文件
URL(String protocol,String host,int port,String File)throws MalformedURLException
建立一個URL對象，以protocol參數指定“協議”部分，以host指定“主機”，port指定連接端口，file指定目標主機上的文件
URL(String protocol,String host,int port,String File,URLStreamHandler handler)throws MalformedURLException
與前一個構造函數相似，多一個handler參數指定此URL使用的URLStreamHandler
URL(URL context,String spec)throws MalformedURLException
依據context參數指定的URL對象，以及spec代表的URI語法：<scheme>://<authority><path>?<query>#<fragment>,建立一個URL對象
URL(URL context,String spec,URLStreamHandler handler )throws MalformedURLException
與前一個構造函數相似，多一個handler參數指定此URL使用的 URLStreamHandler
URL 類常用方法：
返回 方法 說明
URLConnection openConnection()throws IOException 返回一個對此URL所指的遠程資源連接
的URLConnection對象
Object getContent()throws IOException 返回此URL的內容，它是一個滿足 URLConnection的實例。相當於使用 openConnection().getConnection()
Object setContent(Class[] classes) 返回此URL的內容，並以classes指定
throws IOException 檢查返回的對象是否擁有指定的類（ 其中一個Class）的實例，若類型態
與預期都不符，則返回null。相當於
openConnection().getConnection(Class[])
InputStream openSteam()throws IOException 打開一個對此URL的連接，並且返回
一個用來從連接讀取數據的
InputStream 對象。相當於
openConnection().getInputStream()
int getDefaultPort() 返回此URL所關聯的“協議”的預設“
端口編號”
String getProtocol() 取得此URL的協議名稱
String getHost() 取得此URL的主機名稱
int getPort() 取得此URL的端口編號，若未設定則
返回-1
String getFile() 取得此URL的文件名稱
String getAuthority() 取得此URL中“authority”這部分
String getPath() 取得此URL中“path”這部分
String getQuery() 取得此URL中“query”這部分
String getUserInfo() 取得此URL中“userinfo”這部分
String getRef() 取得此URL中“anchor”這部分
int hashCode() 產生一個適當的int值作爲哈希表
索引
boolean equals(Object obj) 比較此URL與obj參數指定的對象，
唯有當obj對象也是一個URL對象，
且兩者代表的URL相同時，纔會
返回true
boolean sameFile(URL other) 比較兩個URL，但“fragment”這部 分不列入考慮
String toExternlForm() 返回一個代表此URL的字符串
URLConnection 類介紹： abstract 類
可利用URL類 openConnection()來產生一個URLConnection對象實例，通過此對象，能夠對URL所指的資源作數據的“讀”或“寫”
URLConnection 類常用方法：
返回 方法 說明
Object getContent()throws IOException 重新取得此URLConnection
Object getContent(Class[] classes) 重新取得此URLConnection，但以
throws IOException classes指定檢查返回的對象是否擁有
指定的類（其中一個Class）的實例
InputStream getInputStream()throws IOException 返回一個能由此URLConnection讀取數
據的InputStream
OutputStream getOutputStream()throws IOException 返回一個能將數據寫到此 URLConnection的OutputStream
abstract void connect()throws IOException 若之前尚未建立連接，就建立一個到此
URL所指的資源的連接
String toString() 返回一個代表此URLConnection的字符 串
URL getURL() 返回此URLConnection的URL字段值
boolean getAllowUserInteraction() 返回此URLConnection對象的
allowUserInteraction字段值，其值若
爲true，則表示該URL現在被設定成允
許用戶的互動，例如彈出一個確認的
對話框
String getContentEncoding() 返回一個代表“內容編碼”的header
filed的字符串
int getContentLength() 返回一個代表“內容長度”的header
filed的int值
String getContentType() 返回一個代表“內容類型”的header
filed的字符串
long getDate() 返回一個代表“日期”的header filed
的long值。
建立URL對象 j02150501 ；利用URL對象直接讀取遠程數據 j02150502；利用URLConnection對象讀取遠程資源 j02150503
取得Web服務器的信息：
建立並使用URLConnection的主要步驟：
1.使用URL對象的openConnection()方法，取得代表連接的URLConnection對象。而且根據此URL的protocol的不同，所取得URLConnection實例的類也不同。例如：從一個protocol爲http的URL，取得的 URLConnection，是HttpURLConnection類的實例。
2.取得URLConnection的對象後，可操作、或設定此URLConnection的一些“參數”和一般“request 屬性”（注：這些參數或屬性一般只對HTTP協議有效），藉此能影響此 URLConnection對遠程資源的連接。參考它的setAllowUserInteraction(),setDoInput(),setDoOutput(),setIfModifiedSince(),
setUserCaches(),setRequestProperty()等方法
3.利用URLConnection對象的connect()方法，對目標的遠程資源作實際的連接。連接成功後不可作上一步的那些設定，否則異常。
4.此後，該遠程資源就爲我們所用
讀取Web服務器信息的範例
讀取MIME標頭信息 j02150504 ；利用 URLConnection下載二進制文件 j02150505；設計與Web服務器互動的程序 j02150506
本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/edg_edu/archive/2009/04/07/4051291.aspx
