如何實現J2SE入門

這期內容當中小編將會給大家帶來有關如何實現J2SE入門，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

J2SE入門：
1. 預備知識
2. 存儲方式和操作控制
3. 面向對象技術
4. 常用數據結構
5. 異常處理機制
6. 圖像處理和音頻操作
7. 圖形化界面（swing）
8. 多線程技術
9. I/O操作
10. 基本網絡技術
預備知識：
㈠Java的歷史背景不用多說了
㈡環境變量設置及原理
開發Java程序的第一步必須設置環境變量，它主要包括PATH和CLASSPATH的設置，理解PATH和CLASSPATH的作用對于Java程序的運行是有一定好處的。
PATH：操作系統執行某一命令時都會通過PATH進行搜索；如果將Java的一些工具諸如Java、Javac、Javadoc等的路徑也加入PATH，則當運行Java的編譯器或解釋器時系統就可以搜索到這些工具并執行操作，這些工具都在jdk目錄下的bin目錄下。
PATH的設置如下(設jdk裝在C:j2sdk1.4.2)：
PATH=%PATH%;C:j2sdk1.4.2bin;
注：%PATH%表示將原來的PATH路徑保留，也可不設此項而直接將jdk路徑加到原PATH路徑下。;為Windows下的分隔符（Linux下為:）。
CLASSPATH：為一個路徑列表，用于搜索Java編譯或者運行時需要用到的類。虛擬機按以下順序搜索并裝載所有需要的類:
引導類: 組成 java 平臺的類, 包含 rt.jar 和 i18n.jar 中的類.
擴展類: 使用 java 擴展機制的類, 都是位于擴展目錄($JAVA_HOME/jre/lib/ext)中的 .jar 檔案包.
用戶類: 開發者定義的類或者沒有使用 java 擴展機制的第三方產品.
CLASSPATH的設置如下：
CLASSPATH=.;C:j2sdk1.4.2libtools.jar; C:j2sdk1.4.2_05jrelibrt.jar
注：.表示當前目錄，如果覺得這個目錄名太繁瑣，可以先設一個JAVA_HOME，并令JAVA_HOME=C:j2sdk1.4.2，然后再設CLASSPATH的格式為：%JAVA_HOME%libtools.jar等就可以了。dt.jar是關于運行環境的類庫，tools.jar是關于一些工具的類庫

注意事項：
程序與類
Java源程序中只能有一個public類，但可以有任意個普通類，且此程序文件名必須與public類的類名相同。
包操作
一般為方便管理都將Java的類各自作成一個文件，再放入一個Package中，即一個包中包含若干類包括主類和普通類。運行編譯后的程序格式為：
java 包名.主類名
編碼習慣
Java開發過程中一定要養成良好的編碼習慣(要從娃娃抓起^_^)，如編寫見文識義的標識符、代碼縮進格式、標準而詳細的注釋等等。


--------------------------------------------------------------------------------



存儲方式和操作控制
所謂的存儲方式和操作控制其實就是數據結構的選擇和算法的設計。程序寫多了這方面的能力自然能慢慢提高。
㈠存儲方式指的是Java的數據類型，在程序設計時變量的選擇也是很重要的，在符合要求的情況下應盡量考慮性能。
簡單數據類型包括：
　　　　　整數類型（Integer）：byte， short， int， long
　　　　　浮點類型（Floating）：float，double
　　　　　字符類型（Textual）：char
　　　　　布爾類型（Logical）：boolean

復合數據類型包括：
字符串類型：String
數組
　　class
interface
　　　　　
㈡操作方法主要是指程序設計中經常用到的順序、轉移、循環等控制語句。無論再復雜的程序，都離不開這些控制語句。因此熟練掌握這些語句的運用，才能寫出優美而高效的代碼。
順序執行

條件轉移
Ⅰ if(exp) {

}else(exp) {

}
Ⅱ switch(exp) {
case ? : break;
case ? : break;
…….
default : break;
}

循環操作
Ⅰ for( ; ; ) {

}
Ⅱ while(exp) {

}
跳轉指令
Ⅰ break;
Ⅱ continue;
Ⅲ return;

注：
在操作中有些技巧可以采用：如在循環操作時可將判斷結束條件設為死循環的類型（如while(true)）,再在程序段內部設置條件break。
break與continue的區別：break語句是跳出它所指定的塊，不再進行終止條件的判斷，并從緊跟該塊的第一條語句處執行；continue語句用來結束本次循環，跳過循環體中下面尚未執行的語句，接著進行終止條件的判斷，以決定是否繼續循環。



--------------------------------------------------------------------------------



面向對象技術
OO是一門高深的思想，也是現代軟件設計的常用思想。OO中有許多前人總結的原則，應該盡量借鑒。比如優先使用類聚合而非繼承、針對接口編程、力求松耦合高內聚等等。《設計模式精解》一書中的第一章對于OO和設計模式入門非常不錯，講得深入淺出。一般OO和設計模式配合進行軟件設計能夠發揮令人出乎意料的效果，所以力薦OO和設計模式一起學，在此再介紹一本設計模式的圣經《設計模式--可復用面向對象軟件的基礎》(雖然是用C++實現的，不過思想與語言無關)，書中所介紹的23種模式是對以往軟件開發中的一些解決方案的精煉萃取，讓人耳目一新，值得一讀。

㈠OO基本思想是使用類、對象、繼承、封裝、消息等基本概念來進行程序設計。
基本特性為封裝性、繼承性、多態性：
封裝性：將對象的屬性和操作結合成一個實體，對外盡量隱藏內部細節，只對類用戶提供接口。基本原則是不對外提供public的成員變量，而利用bean的特點提供存取成員變量的set、get方法。
繼承性：可以不太準確地歸結為父類擁有共性，子類擁有特性，如客輪是輪船和客運工具的特殊類，輪船是父類，客輪是實現客運功能的子類。
多態性：對象的多態性是指在一般類中定義的屬性或服務被特殊類繼承之后，可以具有不同的數據類型或表現出不同的行為。如："幾何圖形"的"繪圖"方法，"橢圓"和"多邊形"都是"幾何圖"的子類，其"繪圖"方法功能不同。

㈡關鍵性技術：
類、對象
類和對象的關系就像模具和鑄件的關系。
類聲明：
[public][abstract|final] class className [extends superclassName]
[implements interfaceNameList] {
成員變量；
成員方法；
}
成員變量：
[public | protected | private ] [static]
　　[final] [transient] [volatile] type variableName; 　　　　　　　　　　　　　　　　
　　變量聲明中限定詞的含義：
　　static: 靜態變量（類變量）；相對于實例變量
　　final: 常量
　　transient: 暫時性變量，用于對象存檔
　　volatile: 貢獻變量，用于并發線程的共享
成員方法：
[public | protected | private ] [static]
　　[final　| abstract] [native] [synchronized]
　　returnType methodName([paramList]) [throws exceptionList] {statements}
　　方法聲明中的限定詞的含義：
　　static: 類方法，可通過類名直接調用
　　abstract: 抽象方法，沒有方法體，由子類實現
　　final: 方法不能被重寫
　　native: 集成其它語言的代碼
　　synchronized: 控制多個并發線程的訪問
類中的限定詞：
private
類中限定為private的成員，只能被這個類本身訪問。如果一個類的構造方法聲明為private,則其它類不能生成該類的一個實例。
Default
類中不加任何訪問權限限定的成員屬于缺省的（default）訪問狀態，可以被這個類本身和同一個包中的類所訪問。
protected
類中限定為protected的成員，可以被這個類本身、它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問。
public
類中限定為public的成員，可以被所有的類訪問

構造方法：
構造方法是一個特殊的方法。Java 中的每個類都有構造方法，用來初始化該類的一個對象。構造方法具有和類名相同的名稱，而且不返回任何數據類型。
重載經常用于構造方法。構造方法只能由new運算符調用。

方法重載和方法重寫：
方法重載是指多個方法享有相同的名字，但是這些方法的參數必須不同，或者是參數的個數不同，或者是參數類型不同。返回類型不能用來區分重載的方法。
方法重寫是指具有繼承關系的父子類的方法享有相同名字，子類中重寫的方法和父類中被重寫的方法要具有相同的名字，相同的參數表和相同的返回類型，只是函數體不同。java運行時系統根據調用該方法的實例，來決定調用哪個方法。對子類的一個實例，如果子類重寫了父類的方法，則運行時系統調用子類的方法；如果子類繼承了父類的方法（未重寫），則運行時系統調用父類的方法。
方法重寫時應遵循的原則：
1）改寫后的方法不能比被重寫的方法有更嚴格的訪問權限（可以相同）。
2）改寫后的方法不能比重寫的方法產生更多的例外。
注：重載用于同一個類中的同名方法，重寫用于具有繼承關系的父子類的同名方法。

常用關鍵字釋疑
1）static
static變量：所有此類實例共享此靜態變量，也就是說在類裝載時，只分配一塊存儲空間，所有此類的對象都可以操控此塊存儲空間。
static方法：無需本類的對象即可調用此方法，調用一個靜態方法就是“類名.方法名”。
static類：通常一個普通類不允許聲明為靜態的，只有一個內部類才可以。這時這個聲明為靜態的內部類可以直接作為一個普通類來使用，而不需實例一個外部類。
2）final
final成員：對基本類型來說是其值不可變，而對于對象變量來說其引用不可再變。初始化可以在兩個地方，一是其定義處，也就是說在final變量定義時直接給其賦值，二是在構造函數中。這兩個地方只能選其一，要么在定義時給值，要么在構造函數中給值，不能同時既在定義時給了值，又在構造函數中給另外的值。
final方法：將方法聲明為final，那就說明你已經知道這個方法提供的功能已經滿足你要求，不需要進行擴展，并且也不允許任何從此類繼承的類來覆寫這個方法，但是繼承仍然可以繼承這個方法，也就是說可以直接使用。
final類：final類與普通類的使用幾乎沒有差別，只是它失去了被繼承的特性。
3）super、this（常用于構造方法中）
super的用法：
訪問父類被隱藏的成員變量，如：
super.variable;
調用父類中被重寫的方法，如：
super.Method([paramlist]);
調用父類的構造函數，如：
super([paramlist]);
this通常指代當前對象，super通常指代父類。在構造方法中super后加參數的是用來調用父類中具有相同形式的構造函數；this后加參數則調用的是當前具有相同參數的構造函數

對象的操作控制
對象的生成：
聲明：聲明并不為對象分配內存空間，而只是分配一個引用空間；對象的引用類似于指針，是32位的地址空間，它的值指向一個中間的數據結構，它存儲有關數據類型的信息以及當前對象所在的堆的地址，而對于對象所在的實際的內存地址是不可操作的，這就保證了安全性。實例化：運算符new為對象分配內存空間，它調用對象的構造方法，返回引用；一個類的不同對象分別占據不同的內存空間。
對象的使用：
由于封裝性的基本原則是指對外提供接口而盡量不提供public的成員變量，所以一般也只能使用“.”來引用類中的成員方法。對象的使用實際是傳遞消息以改變某些屬性或進行某些操作。
對象的清除：
Java的垃圾收集器自動掃描對象的動態內存區，把沒有引用的對象作為垃圾收集起來并釋放。System.gc( );　當系統內存用盡或調用System.gc( )要求垃圾回收時，垃圾回收線程與系統同步運行。

繼承（抽象類）、接口
抽象類：
abstract class abstractClass{ …} //抽象類
　　abstract returnType abstractMethod([paramlist]) //抽象方法
抽象類必須被繼承，抽象方法必須被重寫。抽象方法只需聲明，無需實現；抽象類不能被實例化，抽象類不一定要包含抽象方法。若類中包含了抽象方法，則該類必須被定義為抽象類。
接口：
[public] interface interfaceName[extends listOfSuperInterface] { … }
接口是抽象類的一種，只包含常量和方法的定義，而沒有變量和方法的實現，且其方法都是抽象方法。
注：
一個類只能使用一次繼承關系，但卻可以有多個接口。
抽象類表示的是"is a"關系，接口表示的是"like a"關系。（涉及到設計模式）

內部類
內部類是在一個類的內部嵌套定義的類，它可以是其它類的成員，也可以在一個語句塊的內部定義，還可以在表達式內部匿名定義。
匿名類是一種特殊的內部類，它是在一個表達式內部包含一個完整的類定義(消息響應類等)。
內部類優缺點比較：
　　◇ 優點:節省編譯后產生的字節碼文件的大小
　　◇ 缺點:使程序結構不清楚



--------------------------------------------------------------------------------



常用數據結構
Vector
ArrayList
List
Queue
Map
Tree
Stack
Hashtable
Enumeration
等等。。。
注：一般這些數據結構中的數據存取都是以Oject為對象的，因此從其中取出的數據要進行類型轉換，另int等不能直接存入這些數據結構中，必須使用外覆類（如Integer等）進行重新包裝才能存入。

Java比C++更易于使用的一方面應該就是Java提供了豐富的數據結構給用戶而不必讓用戶自己設計半天數據結構，最后搞了半天卻發現還是錯誤百出，郁悶不已。由于Sun將這些數據結構封裝得很好，所以只要理解這些數據結構的特點和了解他們的接口方法就可以使用他們了。
一般在學習開發中可以在需要時查幫助文檔就可以搞定了，不過只有深刻地理解這些數據結構的特性才能選擇最佳的數據結構開發出優秀的代碼。


--------------------------------------------------------------------------------



異常處理機制
異常實際上是程序中錯誤導致中斷了正常的指令流的一種事件。
所有的例外類都直接或間接地繼承于Throwable類。Throwable又分為兩大子類Error和Exception,其中Error由虛擬機直接處理,部分Exception由用戶處理。

捕獲例外的一般框架：
try{
　　......
}catch( ExceptionName1 e ){
　　　......
System.out.println( "message: " + e.getMessage() ); //e.getMessage( )是類Throwable所提供的方法，用來得到有關異常事件的信息。
}catch( ExceptionName2 e ){
　　　......
e.printStackTrace( System.out ); //e.printStackTrace( )用來跟蹤異常事件發生時執行堆棧的內容。
}
　　　......
}finally{
　　　...... //此部分無論是否產生例外均需執行，除非System.exit(0)
}

當Java運行時系統得到一個例外對象時，它將會沿著方法的調用棧逐層回溯，尋找處理這一例外的代碼。找到能夠處理這種類型的例外的方法后，運行時系統把當前例外對象交給這個方法進行處理，這一過程稱為捕獲(catch)例外。
注：捕獲例外的順序和catch語句的順序有關，當捕獲到一個例外時，剩下的catch語句就不再進行匹配。因此，在安排catch語句的順序時，首先應該捕獲最特殊的例外，然后再逐漸一般化。也就是一般先安排子類，再安排父類。

throws與throw
throw是語句拋出一個異常，throws是方法拋出一個異常。
throw：throw<異常對象>
throws：[<修飾符>]<返回值><方法名>([<參數列表>])[throws<異常類>]
聲明拋棄例外
如果在一個方法中生成了一個例外，但是這一方法并不確切地知道該如何對這一異常事件進行處理，這時，一個方法就應該聲明拋棄例外，使得例外對象可以從調用棧向后傳播，直到有合適的方法捕獲它為止。聲明拋棄例外是在一個方法聲明中的throws子句中指明的。例如：
　　public int read () throws IOException {
　　　　　　　　......
　　}

拋出例外
拋出例外就是產生例外對象的過程，首先要生成例外對象，例外或者由虛擬機生成，或者由某些類的實例生成，也可以在程序中生成。在方法中，拋出例外對象是通過throw語句實現的。
　　例如：
　　IOException e = new IOException();
　　throw e ; //人為拋出異常

注：throw是明確拋出一個異常給上層；throws是標明一個方法可能拋出的各種異常。
throws可以單獨使用，throw不能。

自定義異常
異常是一個類,用戶定義的異常必須繼承自Throwable或Exception類,建議用Exception類。

常見的異常
ArithmeticException
ArrayIndexOutOfBandsException
ArrayStoreException
IOException
FileNotFoundException
NullPointerException
MalformedURLException
NumberFormatException
OutOfMemoryException


--------------------------------------------------------------------------------



圖像處理和音頻操作
圖像處理
Java在桌面程序的功能不是非常的強大，因此較少用于開發桌面程序，但這方面的知識還是需要了解一下。一般圖像處理分為應用程序中和Applet中：
應用程序中的圖像一般都封裝成ImageIcon，在將其貼到Button、Label上，如：
JButton btn = new JButton();
ImageIcon img = new ImageIcon(path);
btn.setIcon(img);
Applet中一般直接從文件從取出圖像直接使用，如：
Image img = new Image();
Img = getImage(getDocumentBase(),imageFile);
……..
2D繪圖一般都在Applet中實現，通過復寫paint方法實現。在應用程序中也可自己new一個Graphics得到繪圖句柄。具體的平移、翻轉等算法不再此述。
注：awt中一般用paint，swing中則用paintComponent
雙緩沖，有時圖像在刷新時會產生閃爍，可以用雙緩沖進行改善。雙緩沖是在圖像進行update時再創建一個繪圖句柄進行繪圖。

音頻操作
音頻操作和圖像處理也是類似的，一般也用于Applet中實現，如：
AudioClip first = getAudioClip(getDocumentBase(),"first.au");
first.play();
如果要在應用程序中實現音頻操作，可以通過Applet轉換，如：
Audio audio = Applet.newAudioClip(audio_path);
audio.play();
注：Java實現的音頻操作是很弱的，一般只用于播放midi、au等格式的音頻文件，而對于mp3等若要播放必須有解碼器，但實現起來是很不劃算的（比較復雜）。


--------------------------------------------------------------------------------



圖形化界面（swing）
Swing簡介
Swing是由100%純Java實現的，Swing組件是用Java實現的輕量級（ light-weight）組件，沒有本地代碼，不依賴操作系統的支持，這是它與AWT組件的最大區別。
Swing采用了一種MVC的設計范式，即"模型-視圖-控制"（Model-View-Controller），其中模型用來保存內容，視圖用來顯示內容，控制器用來控制用戶輸入。

Swing的類層次結構
在javax.swing包中，定義了兩種類型的組件：頂層容器（JFrame，JApplet，JDialog和JWindow）和輕量級組件。Swing組件都是AWT的Container類的直接子類和間接子類。
java.awt.Component
　　　　-java.awt.Container
　　　　　　　-java.awt.Window
　　　　　　　　　　-java.awt.Frame-javax.swing.JFrame
　　　　　　　　　　-javax.Dialog-javax.swing.JDialog
　　　　　　　　　　-javax.swing.JWindow
　　　　　　　-java.awt.Applet-javax.swing.JApplet
　　　　　　　-javax.swing.Box
　　　　　　　-javax.swing.Jcomponet

MVC(Model-View-Control)體系結構
在一個MVC用戶界面中，存三個通訊對象：模型、視圖和控件。模型是指定的邏輯表示法，視圖是模型的可視化表示法，而控件則指定了如何處理用戶輸入。當模型發生改變時，它會通知所有依賴它的視圖，視圖使用控件指定其相應機制。MVC是現有的編程語言中制作圖形用戶界面的一種通用的思想，其思路是把數據的內容本身和顯示方式分離開，這樣就使得數據的顯示更加靈活多樣。

在Swing組件中，使用JComponent類的registerKeyboardAction（）方法，能使用戶通過鍵盤操作來替代鼠標驅動GUI上Swing組件的相應動作。

Swing程序結構簡介
Swing的程序設計一般可按照下列流程進行：
　　1． 引入Swing包
　　2． 選擇"外觀和感覺"
　　3． 設置頂層容器
　　4． 設置按鈕和標簽
　　5． 向容器中添加組件
　　6． 在組件周圍添加邊界
　　7． 進行事件處理

組件的分類：
組件從功能上分可分為：
①頂層容器：JFrame,JApplet,JDialog,JWindow共4個
②中間容器：JPanel,JScrollPane,JSplitPane,JToolBar　
③特殊容器：在GUI上起特殊作用的中間層，如JInternalFrame,JLayeredPane,JRootPane.④基本控件：實現人際交互的組件，如Jbutton, JComboBox, JList, JMenu, JSlider, JtextField。
⑤不可編輯信息的顯示：向用戶顯示不可編輯信息的組件，例如JLabel, JProgressBar, ToolTip。
⑥可編輯信息的顯示：向用戶顯示能被編輯的格式化信息的組件，如JColorChooser, JFileChoose, JFileChooser,Jtable, JtextArea。

JComponent類的特殊功能又分為：
　　1) 邊框設置：使用setBorder()方法可以設置組件外圍的邊框，使用一個EmptyBorder對象能在組件周圍留出空白。
　　2) 雙緩沖區：使用雙緩沖技術能改進頻繁變化的組件的顯示效果。與AWT組件不同，JComponent組件默認雙緩沖區，不必自己重寫代碼。如果想關閉雙緩沖區，可以在組件上施加setDoubleBuffered(false)方法。
　　3) 提示信息：使用setTooltipText()方法，為組件設置對用戶有幫助的提示信息。
　　4) 鍵盤導航：使用registerKeyboardAction( ) 方法，能使用戶用鍵盤代替鼠標來驅動組件。JComponent類的子類AbstractButton還提供了便利的方法－－用setMnemonic( )方法指明一個字符，通過這個字符和一個當前L&F的特殊修飾共同激活按鈕動作。
　　5) 可插入L&F：每個Jcomponent對象有一個相應的ComponentUI對象，為它完成所有的繪畫、事件處理、決定尺寸大小等工作。 ComponentUI對象依賴當前使用的L&F,用UIManager.setLookAndFeel( )方法可以設置需要的L&F.
　　6) 支持布局：通過設置組件最大、最小、推薦尺寸的方法和設置X、Y對齊參數值的方法能指定布局管理器的約束條件，為布局提供支持。

使用Swing的基本規則
與AWT組件不同，Swing組件不能直接添加到頂層容器中，它必須添加到一個與Swing頂層容器相關聯的內容面板（content pane）上。內容面板是頂層容器包含的一個普通容器，它是一個輕量級組件。基本規則如下：
　　（1）把Swing組件放入一個頂層Swing容器的內容面板上
　　（2）避免使用非Swing的重量級組件。
對JFrame添加組件有兩種方式：
　　1) 用getContentPane( )方法獲得JFrame的內容面板，再對其加入組件：frame.getContentPane().add(childComponent)
　　2) 建立一個Jpanel或 JDesktopPane之類的中間容器，把組件添加到容器中，用setContentPane()方法把該容器置為JFrame的內容面板：
　　　　Jpanel contentPane=new Jpanel( );
　　　　 ...... //把其它組件添加到Jpanel中;
　　　　frame.setContentPane(contentPane);
　　　　 //把contentPane對象設置成為frame的內容面板

各種容器面板和組件
根面板
根面板由一個玻璃面板（glassPane)、一個內容面板（contentPane)和一個可選擇的菜單條（JMenuBar)組成，而內容面板和可選擇的菜單條放在同一分層。玻璃面板是完全透明的，缺省值為不可見，為接收鼠標事件和在所有組件上繪圖提供方便。
根面板提供的方法：
　　Container getContentPane(); //獲得內容面板
　　setContentPane(Container); //設置內容面
　　JMenuBar getMenuBar( ); //活動菜單條
　　setMenuBar(JMenuBar); //設置菜單條
　　JLayeredPane getLayeredPane(); //獲得分層面板
　　setLayeredPane(JLayeredPane); //設置分層面板
　　Component getGlassPane(); //獲得玻璃面板
　　setGlassPane(Component); //設置玻璃面板

分層面板
Swing提供兩種分層面板：JlayeredPane和JDesktopPane。 JDesktopPane是JLayeredPane的子類，專門為容納內部框架（JInternalFrame）而設置。向一個分層面板中添加組件，需要說明將其加入哪一層，指明組件在該層中的位置：
add(Component c, Integer Layer, int position)。

滾動窗口（JScrollPane）

分隔板（JSplitPane）

選項板（JTabbedPane）

工具欄（JToolBar）

內部框架（JInternalFrame）
內部框架JInternalFrame就如同一個窗口在另一個窗口內部，其特點如下：
1) 必須把內部框架添加到一個容器中（通常為JDesktopPane),否則不顯示；
2) 不必調用show()或setVisible()方法，內部框架隨所在的容器一起顯示；
3) 必須用setSize()或pack()或setBounds方法設置框架尺寸，否則尺寸為零，框架不能顯示；
4) 可以用setLocation()或setBounds( ) 方法設置內部框架在容器中的位置，缺省值為0，0，即容器的左上角；
5) 象頂層JFrame一樣，對內部框架添加組件也要加在它的內容面板上；
6) 在內部框架中建立對話框，不能使用JDialog作為頂層窗口，必須用JOptionPane或JInternalFrame;
7) 內部框架不能監聽窗口事件，可以通過監聽與窗口事件類似的內部框架（JInternalFrameEvent）處理內部框架窗口的操作。

按鈕（JButton）

復選框（JCheckBox）

單選框（JRadioButton）

選擇框（JComboBox）

文件選擇器（JFileChooser）

標簽（JLabel）

列表（List）

菜單（JMenu）

進程條（JProgressBar）

滑動條（JSlider）

表格（JTable）

樹（JTree）

布局管理器
Swing雖然有頂層容器，但是我們不能把組件直接加到頂層容器中，Swing窗體中含有一個稱為內容面板的容器（ContentPane），在頂層容器上放內容面板，然后把組件加入到內容面板中BoxLayout布局管理器按照自上而下（y軸）或者從左到右（x軸）的順序布局依次加入組件。建立一個BoxLayout對象，必須指明兩個參數：被布局的容器和BoxLayout的主軸。缺省情況下，組件在縱軸方向上居中對齊。
設置布局管理器的方法如下：
　　pane.setLayout(new BoxLayout(pane，BoxLayout.Y-AXIS));

圖形化界面需要了解但不必花太大精力，因為這方面知識更新太快，而且也不是主流技術。最近又興SWT了，不知會否代替Swing成為開發人員的新歡。而且隨著開發工具的發展，圖形化界面將變得非常簡單易用（不只會不會做得和Delphi一樣），JBuider就做得不錯，所以最好還是將精力花在其它技術上，對于圖形界面的美化在需要的時候再即學即用為好，個人觀點。

--------------------------------------------------------------------------------


多線程技術
㈠線程的實現
Thread類
定義一個線程類，它繼承線程類Thread并重寫其中的方法 run（），這時在初始化這個類的實例時，目標target可為null，表示由這個實例來執行線程體。由于Java只支持單重繼承，用這種方法定義的類不能再繼承其它父類。
直接繼承Thread類：
1) 不能再從其他類繼承;
2) 編寫簡單，可以直接操縱線程，無需使用Thread.currentThread()。
Runnable接口：
提供一個實現接口Runnable的類作為一個線程的目標對象，在初始化一個Thread類或者Thread子類的線程對象時，把目標對象傳遞給這個線程實例，由該目標對象提供線程體 run（）。這時，實現接口Runnable的類仍然可以繼承其它父類。
使用Runnable接口：
　　　1) 可以將CPU、代碼和數據分開，形成清晰的模型;
　　　2) 還可以從其他類繼承;
　　　3) 保持程序風格的一致性。
例：
Thread t1 = new MyThread("T1"); //extends
clockThread = new Thread(this, "Clock"); //Runnable

㈡線程的調度
線程調度器按線程的優先級高低選擇高優先級線程（進入運行中狀態）執行。線程的優先級用數字來表示范圍從1到10，即Thread.MIN_PRIORITY到Thread.MAX_PRIORITY。一個線程的缺省優先級是5，即Thread.NORM_PRIORITY。
例：void setPriority(int newPriority);

線程的控制
終止線程
stop()來終止線程
測試線程狀態
通過Thread 中的isAlive() 方法來獲取線程是否處于活動狀態
線程的暫停和恢復
1) sleep() 方法
2) join()
線程的互斥與同步
為解決操作的不完整性問題，在Java 語言中，引入了對象互斥鎖的概念，來保證共享數據操作的完整性。每個對象都對應于一個可稱為" 互斥鎖" 的標記，這個標記用來保證在任一時刻，只能有一個線程訪問該對象。關鍵字synchronized 來與對象的互斥鎖聯系。
例：
public void push(char c) {
synchronized(this) { //this表示Stack的當前對象
data[idx] = c;
idx++;
}
}
public char pop() {
synchronized(this) {
idx--;
return data[idx];
}
}
synchronized還可修飾方法和類
注意：
wait、nofity、notifyAll必須在已經持有鎖的情況下執行,所以它們只能出現在synchronized作用的范圍內，也就是出現在用synchronized修飾的方法或類中。
線程組
線程是被個別創建的，但可以將它們歸類到線程組中，以便于調試和監視。只能在創建線程的同時將它與一個線程組相關聯。在使用大量線程的程序中，使用線程組組織線程可能很有幫助。
線程間通信
當線程在繼續執行前需要等待一個條件時，僅有 synchronized 關鍵字是不夠的。雖然 synchronized 關鍵字阻止并發更新一個對象，但它沒有實現線程間發信。Object 類為此提供了三個函數：wait()、notify() 和 notifyAll()。

--------------------------------------------------------------------------------



I/O操作
兩大基類：InputStream和OutputStream、Reader和Writer
Ⅰ字節流：
從InputStream和OutputStream派生出來的一系列類。這類流以字節(byte)為基本處理單位。
　　◇ InputStream、OutputStream
　　◇ FileInputStream、FileOutputStream
　　◇ PipedInputStream、PipedOutputStream
　　◇ ByteArrayInputStream、ByteArrayOutputStream
　　◇ FilterInputStream、FilterOutputStream
　　◇ DataInputStream、DataOutputStream
　　◇ BufferedInputStream、BufferedOutputStream
Ⅱ字符流：
從Reader和Writer派生出的一系列類，這類流以16位的Unicode碼表示的字符為基本處理單位。
　　◇ Reader、Writer //抽象基類
　　◇ InputStreamReader、OutputStreamWriter
　　◇ FileReader、FileWriter
　　◇ CharArrayReader、CharArrayWriter
　　◇ PipedReader、PipedWriter
　　◇ FilterReader、FilterWriter
　　◇ BufferedReader、BufferedWriter
　　◇ StringReader、StringWriter
Ⅲ對象流
　　◇ ObjectInputStream、ObjectOutputStream
Ⅳ其它
　　◇ 文件處理：
　　File、RandomAccessFile；
　　◇ 接口
　　DataInput、DataOutput、ObjectInput、ObjectOutput；

類File提供了一種與機器無關的方式來描述一個文件對象的屬性。

類FileInputStream和FileOutputStream用來進行文件I/O處理，由它們所提供的方法可以打開本地主機上的文件，并進行順序的讀/寫。

隨機訪問文件則允許對文件內容進行隨機讀/寫。在java中，類RandomAccessFile 提供了隨機訪問文件的方法。

過濾流在讀/寫數據的同時可以對數據進行處理，它提供了同步機制，使得某一時刻只有一個線程可以訪問一個I/O流，以防止多個線程同時對一個I/O流進行操作所帶來的意想不到的結果。類FilterInputStream和FilterOutputStream分別作為所有過濾輸入流和輸出流的父類。

幾種常見的過濾流
◇ BufferedInputStream和BufferedOutputStream
　　　 緩沖流，用于提高輸入/輸出處理的效率。
　　◇ DataInputStream 和 DataOutputStream
　　　 不僅能讀/寫數據流，而且能讀/寫各種的java語言的基本類型。
　　◇ LineNumberInputStream
　　　 除了提供對輸入處理的支持外，LineNumberInputStream可以記錄當前的行號。
　　◇ PushbackInputStream
　　　 提供了一個方法可以把剛讀過的字節退回到輸入流中，以便重新再讀一遍。
　　◇ PrintStream
　　　 打印流的作用是把Java語言的內構類型以其字符表示形式送到相應的輸出流。

字符流的處理
java中提供了處理以16位的Unicode碼表示的字符流的類，即以Reader和Writer 為基類派生出的一系列類。
ⅠReader類是處理所有字符流輸入類的父類。
ⅡWriter類是處理所有字符流輸出類的父類。
這兩個類是抽象類，只是提供了一系列用于字符流處理的接口，不能生成這兩個類的實例，只能通過使用由它們派生出來的子類對象來處理字符流。如InputStreamReader和OutputStreamWriter；BufferedReader和BufferedWriter等.

對象串行化
對象的壽命通常隨著生成該對象的程序的終止而終止。有時候，可能需要將對象的狀態保存下來，在需要時再將對象恢復。我們把對象的這種能記錄自己的狀態以便將來再生的能力，叫做對象的持續性(persistence)。對象通過寫出描述自己狀態的數值來記錄自己，這個過程叫對象的串行化(Serialization)。實現串行化需繼承 Serializable接口。java.io包中，提供了ObjectInputStream和ObjectOutputStream將數據流功能擴展至可讀寫對象。
串行化能保存的元素
只能保存對象的非靜態成員變量，不能保存任何的成員方法和靜態的成員變量，而且串行化保存的只是變量的值，對于變量的任何修飾符，都不能保存。
transient關鍵字
對于某些類型的對象，其狀態是瞬時的，這樣的對象是無法保存其狀態的，例如一個Thread對象，或一個FileInputStream對象，對于這些字段，我們必須用transient關鍵字標明
定制串行化
缺省的串行化機制，對象串行化首先寫入類數據和類字段的信息，然后按照名稱的上升排列順序寫入其數值。如果想自己明確地控制這些數值的寫入順序和寫入種類，必須定義自己的讀取數據流的方式。就是在類的定義中重寫writeObject()和readObject()方法。
注意：在使用完流(或文件)后必須記得講流(或文件)關閉：in.close(); out.close(); f.close();

流類處理的幾種常見情況(流間組合)：
Ⅰ BufferedInputStream bis = new BufferedInputStream(System.in);
BufferedOutputStream bos = new BufferedOutputStream(new File("filename"));

Ⅱ InputStreamReader in = new InputStreamReader(System.in);
OutputStreamWriter out = new OutputStreamWriter(new
FileOutputStream("filename.txt"));

Ⅲ BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new
FileOutputStream ("filename.txt"));
PrintWriter out = new PrintWriter(new FileWriter("filename.txt"));

Ⅳ FileInputStream fin = new FileInputStream(filename); /
FileOutputStream fos = new FileOutputStream(new File("filename"));

Ⅴ DataInputStream din = new DataInputStream(new FileInputStream("filename.dat")));
DataInputStream din = new DataInputStream(newBufferedInputStream (new
FileInputStream ("filename.dat")));

Ⅵ ObjectInputStream s = new ObjectInputStream(new FileInputStream("filename.ser"));
ObjectOutputStream s = new ObjectOutputStream(new
FileOutputStream("filename.ser"));

Ⅶ RandomAccessFile inOut = new RandomAccessFile("filename.dat", "rw");


--------------------------------------------------------------------------------


基本網絡技術
原理：
在TCP/IP協議中IP層主要負責網絡主機的定位，數據傳輸的路由，由IP地址可以唯一地確定Internet上的一臺主機。而TCP層則提供面向應用的可靠的或非可靠的數據傳輸機制，這是網絡編程的主要對象，一般不需要關心IP層是如何處理數據的。目前較為流行的網絡編程模型是客戶機/服務器（C/S）結構。即通信雙方一方作為服務器等待客戶提出請求并予以響應。客戶則在需要服務時向服務器提出申請。服務器一般作為守護進程始終運行，監聽網絡端口，一旦有客戶請求，就會啟動一個服務進程來響應該客戶，同時自己繼續監聽服務端口，使后來的客戶也能及時得到服務。

網絡基本概念
IP地址：標識計算機等網絡設備的網絡地址，由四個8位的二進制數組成，中間以小數點分隔。
主機名(hostname)：網絡地址的助記名，按照域名進行分級管理。
端口號(port number)：網絡通信時同一機器上的不同進程的標識。
服務類型(service)：網絡的各種服務。
注意：通常一臺主機上總是有很多個進程需要網絡資源進行網絡通訊。網絡通訊的對象準確的講不是主機，而應該是主機中運行的進程。這時候光有主機名或IP地址來標識這么多個進程顯然是不夠的。端口號就是為了在一臺主機上提供更多的網絡資源而采取得一種手段，也是TCP層提供的一種機制。只有通過主機名或IP地址和端口號的組合才能唯一的確定網絡通訊中的對象：進程。

兩類傳輸協議：TCP；UDP
TCP是Tranfer Control Protocol的簡稱，是一種面向連接的保證可靠傳輸的協議。通過TCP協議傳輸，得到的是一個順序的無差錯的數據流。發送方和接收方的成對的兩個socket之間必須建立連接，以便在TCP協議的基礎上進行通信，當一個socket（通常都是server socket）等待建立連接時，另一個socket可以要求進行連接，一旦這兩個socket連接起來，它們就可以進行雙向數據傳輸，雙方都可以進行發送或接收操作。

UDP是User Datagram Protocol的簡稱，是一種無連接的協議，每個數據報都是一個獨立的信息，包括完整的源地址或目的地址，它在網絡上以任何可能的路徑傳往目的地，因此能否到達目的地，到達目的地的時間以及內容的正確性都是不能被保證的。

注意：既然有了保證可靠傳輸的TCP協議，為什么還要非可靠傳輸的UDP協議呢？主要的原因有兩個。一是可靠的傳輸是要付出代價的，對數據內容正確性的檢驗必然占用計算機的處理時間和網絡的帶寬，因此TCP傳輸的效率不如UDP高。二是在許多應用中并不需要保證嚴格的傳輸可靠性，比如視頻會議系統，并不要求音頻視頻數據絕對的正確，只要保證連貫性就可以了，這種情況下顯然使用UDP會更合理一些。

創建一個URL
類URL的構造方法都聲明拋棄非運行時例外（MalformedURLException），因此生成URL對象時，我們必須要對這一例外進行處理，通常是用try-catch語句進行捕獲。格式如下：

try {
URL myURL = new URL(...);
}catch(MalformedURLException e) {
....
}

從URL讀取WWW網絡資源
當我們得到一個URL對象后，就可以通過它讀取指定的WWW資源。這時我們將使用URL的方法openStream()，其定義為：
InputStream openStream();
方法openSteam()與指定的URL建立連接并返回InputStream類的對象以從這一連接中讀取數據。
ex: BufferedReader in = new BufferedReader(new InputStreamReader((new URL(...)).openStream()));

通過URLConnetction連接WWW
類URLConnection提供了很多方法來設置或獲取連接參數，程序設計時最常使用的是getInputStream()和getOurputStream(),其定義為：
　　 InputSteram getInputSteram();
　　 OutputSteram getOutputStream();

通過返回的輸入/輸出流我們可以與遠程對象進行通信。看下面的例子：
　　URL url =new URL ("http://www.javasoft.com/cgi-bin/backwards");
　　//創建一URL對象
　　URLConnectin con=url.openConnection();
　　//由URL對象獲取URLConnection對象
　　DataInputStream dis=new DataInputStream (con.getInputSteam());
　　//由URLConnection獲取輸入流，并構造DataInputStream對象
　　PrintStream ps=new PrintSteam(con.getOutupSteam());
　　//由URLConnection獲取輸出流，并構造PrintStream對象
　　String line=dis.readLine(); //從服務器讀入一行
　　ps.println("client…"); //向服務器寫出字符串 "client…"
　　
基于Socket（套接字）的低層次Java網絡編程
網絡上的兩個程序通過一個雙向的通訊連接實現數據的交換，這個雙向鏈路的一端稱為一個Socket。Socket通常用來實現客戶方和服務方的連接。Socket是TCP/IP協議的一個十分流行的編程界面，一個Socket由一個IP地址和一個端口號唯一確定。
Socket通訊的一般過程:
使用Socket進行Client/Server程序設計的一般連接過程是這樣的：Server端Listen(監聽)某個端口是否有連接請求，Client端向Server端發出Connect(連接)請求，Server端向Client端發回Accept（接受）消息。一個連接就建立起來了。Server端和Client端都可以通過Send，Write等方法與對方通信。
對于一個功能齊全的Socket，都要包含以下基本結構，其工作過程包含以下四個基本的步驟：
　　（1）創建Socket；
　　（2）打開連接到Socket的輸入/出流；
　　（3）按照一定的協議對Socket進行讀/寫操作；
　　（4）關閉Socket.
注意，在選擇端口時，必須小心。每一個端口提供一種特定的服務，只有給出正確的端口，才能獲得相應的服務。0~1023的端口號為系統所保留

客戶端的Socket
try {
Socket socket = new Socket("127.0.0.1",8080);
}catch(IOException e) {
System.out.println("Error: " + e);
}
服務器端的ServerSocket
ServerSocket server = null;
try {
server = new ServerSocket(8080);
}catch(IOException e) {
System.out.println("can not listener to : " + e);
}
Socket socket = null;
try {
//accept()是一個阻塞方法,一旦有客戶請求,它就會返回一個Socket對象用于同客戶進行交互
socket = server.accept();
}catch(IOException e) {
System.out.println("Error : " + e);
}
打開輸入/出流類Socket提供了方法getInputStream ()和getOutStream()來得到對應的輸入/輸出流以進行讀/寫 操作，這兩個方法分別返回InputStream和OutputSteam類對象。為了便于讀/寫數據，我們可以在返回的輸入/輸出流對象上建立過濾流，如DataInputStream、DataOutputStream或PrintStream類對象，對于文本方式流對象，可以采用InputStreamReader和OutputStreamWriter、PrintWirter等處理。

關閉Socket
每一個Socket存在時，都將占用一定的資源，在Socket對象使用完畢時，要其關閉。關閉Socket可以調用Socket的Close（）方法。在關閉Socket之前，應將與Socket相關的所有的輸入/輸出流全部關閉，以釋放所有的資源。而且要注意關閉的順序，與Socket相關的所有的輸入/輸出該首先關閉，然后再關閉Socket。
數據報（Datagram）
所謂數據報（Datagram）就跟日常生活中的郵件系統一樣，是不能保證可靠的寄到的，而面向鏈接的TCP就好比電話，雙方能肯定對方接受到了信息。
Datagram通訊的表示方法：DatagramSocket；DatagramPacket
原理:
包java.net中提供了兩個類DatagramSocket和DatagramPacket用來支持數據報通信，DatagramSocket用于在程序之間建立傳送數據報的通信連接， DatagramPacket則用來表示一個數據報。用數據報方式編寫client/server程序時，無論在客戶方還是服務方，首先都要建立一個DatagramSocket對象，用來接收或發送數據報，然后使用DatagramPacket類對象作為傳輸數據的載體。在接收數據前，應該采用上面的第一種方法生成一個DatagramPacket對象，給出接收數據的緩沖區及其長度。然后調用DatagramSocket 的方法receive()等待數據報的到來，receive()將一直等待，直到收到一個數據報為止。
　　DatagramPacket packet=new DatagramPacket(buf, 256);
　　Socket.receive (packet);
發送數據前，也要先生成一個新的DatagramPacket對象，這時要使用上面的第二種構造方法，在給出存放發送數據的緩沖區的同時，還要給出完整的目的地址，包括IP地址和端口號。發送數據是通過DatagramSocket的方法send()實現的，send()根據數據報的目的地址來尋徑，以傳遞數據報。
　　DatagramPacket packet=new DatagramPacket(buf, length, address, port);
Socket.send(packet)；

上述就是小編為大家分享的如何實現J2SE入門了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。