Java 課程影片

達內與Java

一．達內Java課程企業級應用課程優勢

1. 紮實Java 基礎：當前的Java 新技術層出不窮，各企業有不同的側重，根據企業用人需求，只有具備堅實的Java 基礎功底的工程師才能快速掌握新技術。達內的Java 基礎課程體系的深度在行業內首屈一指，學員會在核心算法、面向對象應用、數據結構及集合 框架、反射、輸入輸出、多線程、異常處理等方面深入細致地學習，而這些正是企業面試中最常涉及的問題，是學員獲得高薪的基礎。

2. 熟習Linux 操作系統：Linux 是當前使用最廣泛的服務器操作系統。達內的Java 授課過程全程在Linux 環境中完成（學員使用電腦全部為Linux 環境），同時還專門設有Linux 的相關課程。學員在成為合格的Java 工程師的同時還會具備熟練的Linux 操作技巧，這正是在企業面試中獲得加分的重要指標之一。

3. 深入學習數據庫技術：當前的企業及互聯網應用完全離不開數據庫技術。在任何一個大中型應用中，數據庫設計的好壞、數據庫訪問的效率直接決定了該專案的成敗。達內的數據庫技術包括當前最主流的Oracle 和MySQL 兩種數據庫，內容全面深入。除了數據庫體系結構和SQL 語句之外，還在數據庫設計、SQL 語句優化方面有很大的加強。

4. 系統的Web 前端技術：伴隨著互聯網技術由Web2.0 向Web3.0 邁進，Web 前端技術，包括HTML、CSS 特別是JavaScript 語言越來越被企業所看重。很多企業專門為此新增 “Web 前端工程師”職位。達內的Java 課程體系為此設置充足時間學習JavaScript 及其相關的Ajax、JQuery 框架、Ext-JS 框架。毫不誇張地說，如果完全掌握了達內的Web 前端技術，甚至僅憑借JavaScript 技能就可收獲一份不錯的工作。

5. 企業級框架：Java 是組體和框架的世界，幾乎所有的Java 工程師和Java 應用企業都了解Java 框架的重要性。達內技術專家經過嚴謹調研，了解Java 企業客戶實際應用需求，按照企業需要定制了企業級框架課程。

(1) 在Servlet/JSP 課程中會獨立完成一個Struts1 的框架， 這樣就既了解了Struts1，又深入學習了MVC 框架的底層原理。

(2) 作為Java 框架的佼佼者，Spring 在企業應用中的地位一路攀升。新課程體系中進一步增加Spring 的課程量，增加對其深入的了解，並且會涉及到由Spring 衍生出的SpringSide 等“腳手架”型框架。

(3) 在深入領悟Spring 核心基礎之上，重點加強目前最熱的Spring MVC 和Spring JDBC 內容，與企業實際應用接軌。

(4) 數據持久層框架重點學習編碼簡潔，運行高效的MyBatis 框架，並且也保留經典的輕量級框架Hibernate 課程內容。

(5) 在學習了流行的Spring MVC + MyBatis 框架整體解決方案之後也要學習經典的SSH 整合使用技術，全面且不落伍。

6. 專門的企業開發及部署環境：企業在開發、測試、部署實際專案時需要有特定的軟體環境。很多企業和學員不太重視這些環境，導致在工作中出現很多問題和失誤甚至被淘汰。達內Java 課程體系中加入了專門的企業開發及部署環境課程，重點講述Linux 高級命令及腳本編程、遠程登錄、Ant、單元測試技術、Maven 構建技術、SVN 應用技術等等。

7. 規範的企業開發流程及文檔：軟體開發是團隊合作，因此企業開發流程和文檔規範尤為重要。這也是企業區分“菜鳥工程師”和“資深工程師”的重要指標之一。達內Java 課程所有的實踐專案，無論規模大小，都嚴格按照企業開發的流程進行（需求分析、系統設計、編碼實現、單元測試、系統測試、部署上線），所有的開發文檔完全達到甚至已經超過了大多數企業的要求。

8. 雲計算與互聯網架構技術：雲計算和互聯網架構技術已經廣泛應用到互聯網軟體開發與生產過程中，已經成為軟體開發不可或缺的一部分。達內與阿裏雲合作提供了雲計算和互聯網架構應用課程，從基礎的雲服務器到完整的互聯網架構搭建，從基礎Java 環境安裝到Redis、Nginx 應用詳實完整，全力助力學員的全棧能力。

二．Java大數據課程三大獨特優勢

1．JAVAEE 深度開發

達內Java 大數據課程不僅要讓學生掌握如何使用框架開發系統，而且要深入框架內部源代碼，這樣的做法為學生後續在企業通往架構師的道路做了很好的鋪墊，學生可以更加自信的進入企業工作。

2.互聯網架構

在這個互聯網的時代，每一個軟體公司都在往互聯網化的方向發展，所以掌握了互聯網架構的內容等於緊跟時代，做公司最出色的工程師。達內Java 大數據課程體系在互聯網架構方面涉及比較全面，既有負載均衡Nginx，也有基於搜尋Solr，緩存Redis 等。當學習完這些課程以後，已經對互聯網架構有一定實操和熟練。

3.大數據開發

達內Java 大數據課程註重底層的學習，在學習hadoop 之前，要通過一個專案學習hadoop 的底層知識點。有NIO,RPC,AVRO 等內容。同時還註重上層應用。既有基於電信的zebra 專案，也有基於電商的大數據分析專案讓學生通過大數據階段的學習，能夠快速在公司上手開發。

三．達內Java名師

劉蒼松JAVA教研部總監

工作經歷：具有10 年的Java 企業應用開發經驗。曾經歷任德國Software AG 技術顧問，美國Dachieve 系統架構師，美國AngelEngineers Inc. 系統架構師。

授課風格：授課思維嚴謹靈活，將復雜的業務應用邏輯以直觀淺顯的方式闡述

程祖紅JAVA總監級講師

工作經歷：先後在神州數碼、根網科技、托普軟體、北大方正春元、國信易博等軟體公司從事軟體開發、設計及管理工作。

授課風格：講授以細膩見長，善於以日常生活的例子加以類比、引導學生建立起編程中的邏輯思維能力。

王克晶JAVA總監級講師

工作經歷：浪潮集團前資深專案經理。精通Java與.NET 技術， 熟練的跨平台面向對象開發經驗，技術功底深厚。

授課風格：授課風格清新自然、條理清晰、主次分明、重點難點突出、引人入勝。

範傳奇JAVA總監級講師

工作經歷：曾任職聯想集團，參與開發了新疆省電信公司政企客戶管理系統。任職萬遊在線，先後參與了《鬥破蒼穹》《 時空之門》等網路遊戲的後台服務端開發。

授課風格：授課自然、幽默、生動，教學效果優秀。

李洪鶴JAVA總監級講師

工作經歷：曾任用友公司軟體設計師，具有7 年的JAVA 企業應用開發和內訓經驗。

授課風格：授課幽默風趣、深入淺出。以企業核心應用為導向，教學時引導學員建立起企業開發模式的思維。

劉雪松JAVA總監級講師

工作經歷：十多年金融行業軟體的開發和部門管理經驗 。曾先後在人大金倉、萬得時代和贏時勝擔任高級開發工程師職務。在贏時勝研發中心的開發部擔任了八年的部門經理。

授課風格：定位教練而非演講家。課堂上重視實操、案例豐富、可操作性強，貼近真實應用。講課深入淺出，通俗易懂，能結合鮮活事例增強學員註意力和聽課興趣。

更多教程 》

Java 簡介

Java是由Sun Microsystems公司於1995年5月推出的Java面向對象程序設計語言和Java平台的總稱。由James Gosling和同事們共同研發，並在1995年正式推出。

Java分為三個體系：

• JavaSE（J2SE）（Java2 Platform Standard Edition，java平台標準版）

• JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企業版)

• JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

主要特性

• Java語言是簡單的：

Java語言的語法與C語言和C++語言很接近，使得大多數工程師很容易學習和使用。另一方面，Java丟棄了C++中很少使用的、很難理解的、令人迷惑的那些特性，如操作符重載、多繼承、自動的強制類型轉換。特別地，Java語言不使用指針，而是引用。並提供了自動的廢料收集，使得工程師不必為內存管理而擔憂。

• Java語言是面向對象的：

Java語言提供類、接口和繼承等原語，為了簡單起見，只支持類之間的單繼承，但支持接口之間的多繼承，並支持類與接口之間的實現機制（關鍵字為implements）。Java語言全面支持動態綁定，而C++語言只對虛函數使用動態綁定。總之，Java語言是一個純的面向對象程序設計語言。

• Java語言是分布式的：

Java語言支持Internet應用的開發，在基本的Java應用編程接口中有一個網路應用編程接口（java net），它提供了用於網路應用編程的類庫，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（遠程方法激活）機制也是開發分布式應用的重要手段。

• Java語言是健壯的：

Java的強類型機制、異常處理、垃圾的自動收集等是Java程序健壯性的重要保證。對指針的丟棄是Java的明智選擇。Java的安全檢查機制使得Java更具健壯性。

• Java語言是安全的：

Java通常被用在網路環境中，為此，Java提供了一個安全機制以防惡意代碼的攻擊。除了Java語言具有的許多安全特性以外，Java對通過網路下載的類具有一個安全防範機制（類ClassLoader），如分配不同的名字空間以防替代本地的同名類、字節代碼檢查，並提供安全管理機制（類SecurityManager）讓Java應用設置安全哨兵。

• Java語言是體系結構中立的：

Java程序（後綴為java的文體）在Java平台上被編譯為體系結構中立的字節碼格式（後綴為class的文體），然後可以在實現這個Java平台的任何系統中運行。這種途徑適合於異構的網路環境和軟體的分發。

• Java語言是可移植的：

這種可移植性來源於體系結構中立性，另外，Java還嚴格規定了各個基本數據類型的長度。Java系統本身也具有很強的可移植性，Java編譯器是用Java實現的，Java的運行環境是用ANSI C實現的。

• Java語言是解釋型的：

如前所述，Java程序在Java平台上被編譯為字節碼格式，然後可以在實現這個Java平台的任何系統中運行。在運行時，Java平台中的Java解釋器對這些字節碼進行解釋執行，執行過程中需要的類在聯接階段被載入到運行環境中。

• Java是高性能的：

與那些解釋型的高級腳本語言相比，Java的確是高性能的。事實上，Java的運行速度隨著JIT(Just-In-Time）編譯器技術的發展越來越接近於C++。

• Java語言是多線程的：

在Java語言中，線程是一種特殊的對象，它必須由Thread類或其子（孫）類來創建。通常有兩種方法來創建線程：其一，使用型構為Thread(Runnable)的構造子將一個實現了Runnable接口的對象包裝成一個線程，其二，從Thread類派生出子類並重寫run方法，使用該子類創建的對象即為線程。值得註意的是Thread類已經實現了Runnable接口，因此，任何一個線程均有它的run方法，而run方法中包含了線程所要運行的代碼。線程的活動由一組方法來控制。Java語言支持多個線程的同時執行，並提供多線程之間的同步機制（關鍵字為synchronized）。

• Java語言是動態的：

Java語言的設計目標之一是適應於動態變化的環境。Java程序需要的類能夠動態地被載入到運行環境，也可以通過網路來載入所需要的類。這也有利於軟體的升級。另外，Java中的類有一個運行時刻的表示，能進行運行時刻的類型檢查。

Java開發工具

Java語言盡量保證系統內存在1G以上，其他工具如下所示：

• Linux 系統、Mac OS 系統、Windows 95/98/2000/XP，WIN 7/8系統。

• Java JDK 7、8……

• Notepad 編輯器或者其他編輯器。

• IDE：Eclipse

更多教程 》

Java 開發環境配置

window系統安裝java

下載JDK

首先我們需要下載java開發工具包JDK，
下載地址：https://www.oracle.com/technetwork/java/javase/downloads/index.html，
點擊如下下載按鈕：

在下載頁面中你需要選擇接受許可，並根據自己的系統選擇對應的版本，本文以 Window 64位系統為例：

下載後JDK的安裝根據提示進行，還有安裝JDK的時候也會安裝JRE，一並安裝就可以了。

安裝JDK，安裝過程中可以自定義安裝目錄等信息，例如我們選擇安裝目錄為 C:\Program Files (x86)\Java\jdk1.8.0_91。

配置環境變量

1.安裝完成後，右擊"我的電腦"，點擊"屬性"，選擇"高級系統設置"；

2.選擇"高級"選項卡，點擊"環境變量"；

然後就會出現如下圖所示的畫面：

在"系統變量"中設置3項屬性，JAVA_HOME,PATH,CLASSPATH(大小寫無所謂),若已存在則點擊"編輯"，不存在則點擊"新建"。變量設置參數如下：

變量名：JAVA_HOME

變量值：C:\Program Files (x86)\Java\jdk1.8.0_91 // 要根據自己的實際路徑配置

變量名：CLASSPATH

變量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //記得前面有個"."

變量名：Path

變量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

JAVA_HOME 設置

PATH設置

CLASSPATH 設置

這是 Java 的環境配置，配置完成後，你可以啟動 Eclipse 來編寫代碼，它會自動完成java環境的配置。

註意：如果使用1.5以上版本的JDK，不用設置CLASSPATH環境變量，也可以正常編譯和運行Java程序。

測試JDK是否安裝成功

1、"開始"->"運行"，鍵入"cmd"；

2、鍵入命令: java -version、java、javac 幾個命令，出現以下信息，說明環境變量配置成功；

Linux，UNIX，Solaris，FreeBSD環境變量設置

環境變量PATH應該設定為指向Java二進制文體安裝的位置。如果設置遇到困難，請參考shell文檔。

例如，假設你使用bash作為shell，你可以把下面的內容添加到你的 .bashrc文體結尾: export PATH=/path/to/java:$PATH

流行JAVA開發工具

正所謂工欲善其事必先利其器，我們在開發java語言過程中同樣需要依款不錯的開發工具，目前市場上的IDE很多，本文為大家推薦以下下幾款java開發工具：

Eclipse（推薦）:另一個免費開源的java IDE，下載地址： https://www.eclipse.org/

選擇 Eclipse IDE for Java Developers：

Notepad++ : Notepad++ 是在微軟視窗環境之下的一個免費的代碼編輯器，下載地址： https://notepad-plus-plus.org/

Netbeans:開源免費的java IDE，下載地址： https://www.netbeans.org/index.html

更多教程 》

Java 基礎語法

一個Java程序可以認為是一系列對象的集合，而這些對象通過調用彼此的方法來協同工作。下面簡要介紹下類、對象、方法和實例變量的概念。

對象：對象是類的一個實例，有狀態和行為。例如，一條狗是一個對象，它的狀態有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。

類：類是一個模板，它描述一類對象的行為和狀態。

方法：方法就是行為，一個類可以有很多方法。邏輯運算、數據修改以及所有動作都是在方法中完成的。

實例變量：每個對象都有獨特的實例變量，對象的狀態由這些實例變量的值決定。

第一個Java程序

下面看一個簡單的Java程序，它將打印字符串 Hello World

下面將逐步介紹如何保存、編譯以及運行這個程序：

打開Notepad，把上面的代碼添加進去；

把文體名保存為：HelloWorld.java；

打開cmd命令窗口，進入目標文體所在的位置，假設是C:\

在命令行窗口鍵入 javac HelloWorld.java 按下enter鍵編譯代碼。如果代碼沒有錯誤，cmd命令提示符會進入下一行。（假設環境變量都設置好了）。

再鍵入java HelloWorld 按下Enter鍵就可以運行程序了

你將會在窗口看到 Hello World

Gif 圖演示：

基本語法

編寫Java程序時，應註意以下幾點：

大小寫敏感：Java是大小寫敏感的，這就意味著標識符Hello與hello是不同的。

類名：對於所有的類來說，類名的首字母應該大寫。如果類名由若幹單詞組成，那麽每個單詞的首字母應該大寫，例如 MyFirstJavaClass 。

方法名：所有的方法名都應該以小寫字母開頭。如果方法名含有若幹單詞，則後面的每個單詞首字母大寫。

源文體名：源文體名必須和類名相同。當保存文體的時候，你應該使用類名作為文體名保存（切記Java是大小寫敏感的），文體名的後綴為.java。（如果文體名和類名不相同則會導致編譯錯誤）。

主方法入口：所有的Java 程序由public static void main(String []args)方法開始執行。

Java標識符

Java所有的組成部分都需要名字。類名、變量名以及方法名都被稱為標識符。

關於Java標識符，有以下幾點需要註意：

所有的標識符都應該以字母（A-Z或者a-z）,美元符（$）、或者下劃線（_）開始

首字符之後可以是字母（A-Z或者a-z）,美元符（$）、下劃線（_）或數字的任何字符組合

關鍵字不能用作標識符

標識符是大小寫敏感的

合法標識符舉例：age、$salary、_value、__1_value

非法標識符舉例：123abc、-salary

Java修飾符

像其他語言一樣，Java可以使用修飾符來修飾類中方法和屬性。主要有兩類修飾符：

訪問控制修飾符 : default, public , protected, private

非訪問控制修飾符 : final, abstract, strictfp

在後面的章節中我們會深入討論Java修飾符。

Java變量

Java中主要有如下幾種類型的變量

局部變量

類變量（靜態變量）

成員變量（非靜態變量）

Java數組

數組是儲存在堆上的對象，可以保存多個同類型變量。在後面的章節中，我們將會學到如何聲明、構造以及初始化一個數組。

Java枚舉

Java 5.0引入了枚舉，枚舉限制變量只能是預先設定好的值。使用枚舉可以減少代碼中的bug。

例如，我們為果汁店設計一個程序，它將限制果汁為小杯、中杯、大杯。這就意味著它不允許顧客點除了這三種尺寸外的果汁。

實例

註意：枚舉可以單獨聲明或者聲明在類裏面。方法、變量、構造函數也可以在枚舉中定義。

Java關鍵字

下面列出了Java保留字。這些保留字不能用於常量、變量、和任何標識符的名稱。

關鍵字	描述
abstract	抽象方法，抽象類的修飾符
assert	斷言條體是否滿足
boolean	布爾數據類型
break	跳出循環或者label代碼段
byte	8-bit 有符號數據類型
case	switch語句的一個條體
catch	和try搭配捕捉異常信息
char	16-bit Unicode字符數據類型
class	定義類
const	未使用
continue	不執行循環體剩余部分
default	switch語句中的默認分支
do	循環語句，循環體至少會執行一次
double	64-bit雙精度浮點數
else	if條體不成立時執行的分支
enum	枚舉類型
extends	表示一個類是另一個類的子類
final	表示一個值在初始化之後就不能再改變了 表示方法不能被重寫，或者一個類不能有子類
finally	為了完成執行的代碼而設計的，主要是為了程序的健壯性和完整性，無論有沒有異常發生都執行代碼。
float	32-bit單精度浮點數
for	for循環語句
goto	未使用
if	條體語句
implements	表示一個類實現了接口
import	導入類
instanceof	測試一個對象是否是某個類的實例
int	32位整型數
interface	接口，一種抽象的類型，僅有方法和常量的定義
long	64位整型數
native	表示方法用非java代碼實現
new	分配新的類實例
package	一系列相關類組成一個包
private	表示私有字段，或者方法等，只能從類內部訪問
protected	表示字段只能通過類或者其子類訪問 子類或者在同一個包內的其他類
public	表示共有屬性或者方法
return	方法返回值
short	16位數字
static	表示在類級別定義，所有實例共享的
strictfp	浮點數比較使用嚴格的規則
super	表示基類
switch	選擇語句
synchronized	表示同一時間只能由一個線程訪問的代碼塊
this	表示調用當前實例 或者調用另一個構造函數
throw	拋出異常
throws	定義方法可能拋出的異常
transient	修飾不要序列化的字段
try	表示代碼塊要做異常處理或者和finally配合表示是否拋出異常都執行finally中的代碼
void	標記方法不返回任何值
volatile	標記字段可能會被多個線程同時訪問，而不做同步
while	while循環

Java註釋

類似於C/C++，Java也支持單行以及多行註釋。註釋中的字符將被Java編譯器忽略。

Java 空行

空白行，或者有註釋的行，Java編譯器都會忽略掉。

繼承

在Java中，一個類可以由其他類派生。如果你要創建一個類，而且已經存在一個類具有你所需要的屬性或方法，那麽你可以將新創建的類繼承該類。

利用繼承的方法，可以重用已存在類的方法和屬性，而不用重寫這些代碼。被繼承的類稱為超類（super class），派生類稱為子類（subclass）。

接口

在Java中，接口可理解為對象間相互通信的協議。接口在繼承中扮演著很重要的角色。

接口只定義派生要用到的方法，但是方法的具體實現完全取決於派生類。

Java 源程序與編譯型運行區別

如下圖所示：

更多教程 》

Java 基本數據類型

變量就是申請內存來存儲值。也就是說，當創建變量的時候，需要在內存中申請空間。

內存管理系統根據變量的類型為變量分配存儲空間，分配的空間只能用來儲存該類型數據。

因此，通過定義不同類型的變量，可以在內存中儲存整數、小數或者字符。

Java 的兩大數據類型:

內置數據類型

引用數據類型

內置數據類型

Java語言提供了八種基本類型。六種數字類型（四個整數型，兩個浮點型），一種字符類型，還有一種布爾型。

byte：

byte 數據類型是8位、有符號的，以二進制補碼表示的整數；

最小值是 -128（-2^7）；

最大值是 127（2^7-1）；

默認值是 0；

byte 類型用在大型數組中節約空間，主要代替整數，因為 byte 變量占用的空間只有 int 類型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short 數據類型是 16 位、有符號的以二進制補碼表示的整數

最小值是 -32768（-2^15）；

最大值是 32767（2^15 - 1）；

Short 數據類型也可以像 byte 那樣節省空間。一個short變量是int型變量所占空間的二分之一；

默認值是 0；

例子：short s = 1000，short r = -20000。

int：

int 數據類型是32位、有符號的以二進制補碼表示的整數；

最小值是 -2,147,483,648（-2^31）；

最大值是 2,147,483,647（2^31 - 1）；

一般地整型變量默認為 int 類型；

默認值是 0 ；

例子：int a = 100000, int b = -200000。

long：

long 數據類型是 64 位、有符號的以二進制補碼表示的整數；

最小值是 -9,223,372,036,854,775,808（-2^63）；

最大值是 9,223,372,036,854,775,807（2^63 -1）；

這種類型主要使用在需要比較大整數的系統上；

默認值是 0L；

例子： long a = 100000L，Long b = -200000L。

"L"理論上不分大小寫，但是若寫成"l"容易與數字"1"混淆，不容易分辯。所以最好大寫。

float：

float 數據類型是單精度、32位、符合IEEE 754標準的浮點數；

float 在儲存大型浮點數組的時候可節省內存空間；

默認值是 0.0f；

浮點數不能用來表示精確的值，如貨幣；

例子：float f1 = 234.5f。

double：

double 數據類型是雙精度、64 位、符合IEEE 754標準的浮點數；

浮點數的默認類型為double類型；

double類型同樣不能表示精確的值，如貨幣；

默認值是 0.0d；

例子：double d1 = 123.4。

boolean：

boolean數據類型表示一位的信息；

只有兩個取值：true 和 false；

這種類型只作為一種標誌來記錄 true/false 情況；

默認值是 false；

例子：boolean one = true。

char：

char類型是一個單一的 16 位 Unicode 字符；

最小值是 \u0000（即為0）；

最大值是 \uffff（即為65,535）；

char 數據類型可以儲存任何字符；

例子：char letter = 'A';。

實例

對於數值類型的基本類型的取值範圍，我們無需強制去記憶，因為它們的值都已經以常量的形式定義在對應的包裝類中了。請看下面的例子：

編譯以上代碼輸出結果如下所示：

Float和Double的最小值和最大值都是以科學記數法的形式輸出的，結尾的"E+數字"表示E之前的數字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。

實際上，JAVA中還存在另外一種基本類型void，它也有對應的包裝類 java.lang.Void，不過我們無法直接對它們進行操作。

引用類型

在Java中，引用類型的變量非常類似於C/C++的指針。引用類型指向一個對象，指向對象的變量是引用變量。這些變量在聲明時被指定為一個特定的類型，比如 Employee、Puppy 等。變量一旦聲明後，類型就不能被改變了。

對象、數組都是引用數據類型。

所有引用類型的默認值都是null。

一個引用變量可以用來引用與任何與之兼容的類型。

例子：Site site = new Site("Runoob")。

Java常量

常量在程序運行時，不會被修改的量。

在 Java 中使用 final 關鍵字來修飾常量，聲明方式和變量類似：

final double PI = 3.1415927;

雖然常量名也可以用小寫，但為了便於識別，通常使用大寫字母表示常量。

字面量可以賦給任何內置類型的變量。例如：

byte a = 68;

char a = 'A'

byte、int、long、和short都可以用十進制、16進制以及8進制的方式來表示。

當使用常量的時候，前綴0表示8進制，而前綴0x代表16進制。例如：

int decimal = 100;

int octal = 0144;

int hexa = 0x64;

和其他語言一樣，Java的字符串常量也是包含在兩個引號之間的字符序列。下面是字符串型字面量的例子：

"Hello World"

"two\nlines"

"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';

String a = "\u0001";

Java語言支持一些特殊的轉義字符序列。

符號	字符含義
符號	字符含義
\n	換行 (0x0a)
\r	回車 (0x0d)
\f	換頁符(0x0c)
\b	退格 (0x08)
\0	空格 (0x20)
\s	字符串
\t	制表符
\"	雙引號
\'	單引號
\\	反斜杠
\ddd	八進制字符 (ddd)
\uxxxx	16進制Unicode字符 (xxxx)

自動類型轉換

整型、實型（常量）、字符型數據可以混合運算。運算中，不同類型的數據先轉化為同一類型，然後進行運算。

轉換從低級到高級。

低 ------------------------------------> 高

byte,short,char—> int —> long—> float —> double

數據類型轉換必須滿足如下規則：

1. 不能對boolean類型進行類型轉換。

2. 不能把對象類型轉換成不相關類的對象。

3. 在把容量大的類型轉換為容量小的類型時必須使用強制類型轉換。

4. 轉換過程中可能導致溢出或損失精度，例如：

int i =128;

byte b = (byte)i;

因為byte類型時8位，最大值為127，所以當強制轉換為int類型值128時候就會導致溢出。

5. 浮點數到整數的轉換是通過舍棄小數得到，而不是四舍五入，例如：

(int)23.7 == 23;

(int)-45.89f == -45

自動類型轉換

必須滿足轉換前的數據類型的位數要低於轉換後的數據類型，例如: short數據類型的位數為16位，就可以自動轉換位數為32的int類型，同樣float數據類型的位數為32，可以自動轉換為64位的double類型。

實例

運行結果為:

char自動類型轉換為int後的值等於97

char類型和int計算後的值等於66

解析：c1的值為字符'a',查ascii碼表可知對應的int類型值為97，'A'對應值為65，所以i2=65+1=66。

強制類型轉換

1. 條體是轉換的數據類型必須是兼容的。

2. 格式：(type)value type是要強制類型轉換後的數據類型 實例：

實例

運行結果：

int強制類型轉換為byte後的值等於123

隱含強制類型轉換

1. 整數的默認類型是 int。

2. 浮點型不存在這種情況，因為在定義 float 類型時必須在數字後面跟上 F 或者 f。

這一節講解了 Java 的基本數據類型。下一節將探討不同的變量類型以及它們的用法。

更多教程 》

Java 變量類型

在Java語言中，所有的變量在使用前必須聲明。聲明變量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

格式說明：type為Java數據類型。identifier是變量名。可以使用逗號隔開來聲明多個同類型變量。

以下列出了一些變量的聲明實例。註意有些包含了初始化過程。

int a, b, c; // 聲明三個int型整數：a、 b、c

int d = 3, e = 4, f = 5; // 聲明三個整數並賦予初值

byte z = 22; // 聲明並初始化 z

String s = "runoob"; // 聲明並初始化字符串 s

double pi = 3.14159; // 聲明了雙精度浮點型變量 pi

char x = 'x'; // 聲明變量 x 的值是字符 'x'。

Java語言支持的變量類型有：

類變量：獨立於方法之外的變量，用 static 修飾。

實例變量：獨立於方法之外的變量，不過沒有 static 修飾。

局部變量：類的方法中的變量。

Java 局部變量

局部變量聲明在方法、構造方法或者語句塊中；

局部變量在方法、構造方法、或者語句塊被執行的時候創建，當它們執行完成後，變量將會被銷毀；

訪問修飾符不能用於局部變量；

局部變量只在聲明它的方法、構造方法或者語句塊中可見；

局部變量是在棧上分配的。

局部變量沒有默認值，所以局部變量被聲明後，必須經過初始化，才可以使用。

實例 1

在以下實例中age是一個局部變量。定義在pupAge()方法中，它的作用域就限制在這個方法中。

以上實例編譯運行結果如下:

小狗的年齡是: 7

實例 2

在下面的例子中 age 變量沒有初始化，所以在編譯時會出錯：

以上實例編譯運行結果如下:

實例變量

實例變量聲明在一個類中，但在方法、構造方法和語句塊之外；

當一個對象被實例化之後，每個實例變量的值就跟著確定；

實例變量在對象創建的時候創建，在對象被銷毀的時候銷毀；

實例變量的值應該至少被一個方法、構造方法或者語句塊引用，使得外部能夠通過這些方式獲取實例變量信息；

實例變量可以聲明在使用前或者使用後；

訪問修飾符可以修飾實例變量；

實例變量對於類中的方法、構造方法或者語句塊是可見的。一般情況下應該把實例變量設為私有。通過使用訪問修飾符可以使實例變量對子類可見；

實例變量具有默認值。數值型變量的默認值是0，布爾型變量的默認值是false，引用類型變量的默認值是null。變量的值可以在聲明時指定，也可以在構造方法中指定；

實例變量可以直接通過變量名訪問。但在靜態方法以及其他類中，就應該使用完全限定名：ObejectReference.VariableName。

實例

Employee.java 文體代碼：

以上實例編譯運行結果如下:

$ javac Employee.java

$ java Employee

名字 : RUNOOB

薪水 : 1000.0

類變量（靜態變量）

類變量也稱為靜態變量，在類中以static關鍵字聲明，但必須在方法構造方法和語句塊之外。

無論一個類創建了多少個對象，類只擁有類變量的一份拷貝。

靜態變量除了被聲明為常量外很少使用。常量是指聲明為public/private，final和static類型的變量。常量初始化後不可改變。

靜態變量儲存在靜態存儲區。經常被聲明為常量，很少單獨使用static聲明變量。

靜態變量在程序開始時創建，在程序結束時銷毀。

與實例變量具有相似的可見性。但為了對類的使用者可見，大多數靜態變量聲明為public類型。

默認值和實例變量相似。數值型變量默認值是0，布爾型默認值是false，引用類型默認值是null。變量的值可以在聲明的時候指定，也可以在構造方法中指定。此外，靜態變量還可以在靜態語句塊中初始化。

靜態變量可以通過：ClassName.VariableName的方式訪問。

類變量被聲明為public static final類型時，類變量名稱一般建議使用大寫字母。如果靜態變量不是public和final類型，其命名方式與實例變量以及局部變量的命名方式一致。

實例：

Employee.java 文體代碼：

以上實例編譯運行結果如下:

開發人員平均工資:10000.0

註意：如果其他類想要訪問該變量，可以這樣訪問：Employee.DEPARTMENT。

更多教程 》

Java 運算符

計算機的最基本用途之一就是執行數學運算，作為一門計算機語言，Java也提供了一套豐富的運算符來操縱變量。我們可以把運算符分成以下幾組：

算術運算符

關系運算符

位運算符

邏輯運算符

賦值運算符

其他運算符

算術運算符

算術運算符用在數學表達式中，它們的作用和在數學中的作用一樣。下表列出了所有的算術運算符。

表格中的實例假設整數變量A的值為10，變量B的值為20：

操作符	描述	例子
+	加法 - 相加運算符兩側的值	A + B 等於 30
-	減法 - 左操作數減去右操作數	A – B 等於 -10
*	乘法 - 相乘操作符兩側的值	A * B等於200
/	除法 - 左操作數除以右操作數	B / A等於2
％	取模 - 左操作數除以右操作數的余數	B%A等於0
++	自增: 操作數的值增加1	B++ 或 ++B 等於 21（區別詳見下文）
--	自減: 操作數的值減少1	B-- 或 --B 等於 19（區別詳見下文）

實例

下面的簡單示例程序演示了算術運算符。復制並粘貼下面的 Java 程序並保存為 Test.java 文體，然後編譯並運行這個程序：

以上實例編譯運行結果如下：

a + b = 30

a - b = -10

a * b = 200

b / a = 2

b % a = 0

c % a = 5

a++ = 10

a-- = 11

d++ = 25

++d = 27

自增自減運算符

1、自增（++）自減（--）運算符是一種特殊的算術運算符，在算術運算符中需要兩個操作數來進行運算，而自增自減運算符是一個操作數。

實例

運行結果為：

進行自增運算後的值等於4

進行自減運算後的值等於2

解析：

int b = ++a; 拆分運算過程為: a=a+1=4; b=a=4, 最後結果為b=4,a=4

int d = --c; 拆分運算過程為: c=c-1=2; d=c=2, 最後結果為d=2,c=2

2、前綴自增自減法(++a,--a): 先進行自增或者自減運算，再進行表達式運算。

3、後綴自增自減法(a++,a--): 先進行表達式運算，再進行自增或者自減運算 實例：

實例

運行結果為：

自增運算符前綴運算後a=6，x=12

自增運算符後綴運算後b=6，y=10

關系運算符

下表為Java支持的關系運算符

表格中的實例整數變量A的值為10，變量B的值為20：

運算符	描述	例子
==	檢查如果兩個操作數的值是否相等，如果相等則條體為真。	（A == B）為假(非真)。
!=	檢查如果兩個操作數的值是否相等，如果值不相等則條體為真。	(A != B) 為真。
>	檢查左操作數的值是否大於右操作數的值，如果是那麽條體為真。	（A>B）非真。
<	檢查左操作數的值是否小於右操作數的值，如果是那麽條體為真。	（A < B）為真。
>=	檢查左操作數的值是否大於或等於右操作數的值，如果是那麽條體為真。	（A > = B）為假。
<=	檢查左操作數的值是否小於或等於右操作數的值，如果是那麽條體為真。	（A <= B）為真。

實例

下面的簡單示例程序演示了關系運算符。復制並粘貼下面的Java程序並保存為Test.java文體，然後編譯並運行這個程序：

Test.java 文體代碼：

以上實例編譯運行結果如下：

a == b = false

a != b = true

a > b = false

a < b = true

b >= a = true

b <= a = false

位運算符

Java定義了位運算符，應用於整數類型(int)，長整型(long)，短整型(short)，字符型(char)，和字節型(byte)等類型。

位運算符作用在所有的位上，並且按位運算。假設a = 60，b = 13;它們的二進制格式表示將如下：

A = 0011 1100

B = 0000 1101

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

A&b = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A= 1100 0011

下表列出了位運算符的基本運算,假設整數變量A的值為60和變量B的值為13：

操作符	描述	例子
＆	如果相對應位都是1，則結果為1，否則為0	（A＆B），得到12，即0000 1100
|	如果相對應位都是0，則結果為0，否則為1	（A | B）得到61，即 0011 1101
^	如果相對應位值相同，則結果為0，否則為1	（A ^ B）得到49，即 0011 0001
〜	按位補運算符翻轉操作數的每一位，即0變成1，1變成0。	（〜A）得到-61，即1100 0011
<<	按位左移運算符。左操作數按位左移右操作數指定的位數。	A << 2得到240，即 1111 0000
>>	按位右移運算符。左操作數按位右移右操作數指定的位數。	A >> 2得到15即 1111
>>>	按位右移補零操作符。左操作數的值按右操作數指定的位數右移，移動得到的空位以零填充。	A>>>2得到15

實例

下面的簡單示例程序演示了位運算符。復制並粘貼下面的Java程序並保存為Test.java文體，然後編譯並運行這個程序：

Test.java 文體代碼：

以上實例編譯運行結果如下：

a & b = 12

a | b = 61

a ^ b = 49

~a = -61

a << 2 = 240

a >> 15

a >>> 15

邏輯運算符

下表列出了邏輯運算符的基本運算，假設布爾變量A為真，變量B為假

操作符	描述	例子
&&	稱為邏輯與運算符。當且僅當兩個操作數都為真，條體才為真。	（A && B）為假。
| |	稱為邏輯或操作符。如果任何兩個操作數任何一個為真，條體為真。	（A | | B）為真。
！	稱為邏輯非運算符。用來反轉操作數的邏輯狀態。如果條體為true，則邏輯非運算符將得到false。	！（A && B）為真。

實例

下面的簡單示例程序演示了邏輯運算符。復制並粘貼下面的Java程序並保存為Test.java文體，然後編譯並運行這個程序：

以上實例編譯運行結果如下：

a && b = false

a || b = true

!(a && b) = true

短路邏輯運算符

當使用與邏輯運算符時，在兩個操作數都為true時，結果才為true，但是當得到第一個操作為false時，其結果就必定是false，這時候就不會再判斷第二個操作了。

實例

使用短路邏輯運算符的結果為false

a的結果為5

解析： 該程序使用到了短路邏輯運算符(&&)，首先判斷 a<4 的結果為 false，則 b 的結果必定是 false，所以不再執行第二個操作 a++<10 的判斷，所以 a 的值為 5。

賦值運算符

下面是Java語言支持的賦值運算符：

操作符	描述	例子
=	簡單的賦值運算符，將右操作數的值賦給左側操作數	C = A + B將把A + B得到的值賦給C
+ =	加和賦值操作符，它把左操作數和右操作數相加賦值給左操作數	C + = A等價於C = C + A
- =	減和賦值操作符，它把左操作數和右操作數相減賦值給左操作數	C - = A等價於C = C - A
* =	乘和賦值操作符，它把左操作數和右操作數相乘賦值給左操作數	C * = A等價於C = C * A
/ =	除和賦值操作符，它把左操作數和右操作數相除賦值給左操作數	C / = A等價於C = C / A
(%)=	取模和賦值操作符，它把左操作數和右操作數取模後賦值給左操作數	C％= A等價於C = C％A
<< =	左移位賦值運算符	C << = 2等價於C = C << 2
>> =	右移位賦值運算符	C >> = 2等價於C = C >> 2
＆=	按位與賦值運算符	C＆= 2等價於C = C＆2
^ =	按位異或賦值操作符	C ^ = 2等價於C = C ^ 2
| =	按位或賦值操作符	C | = 2等價於C = C | 2

實例

面的簡單示例程序演示了賦值運算符。復制並粘貼下面的Java程序並保存為Test.java文體，然後編譯並運行這個程序：

Test.java 文體代碼：

以上實例編譯運行結果如下：

c = a + b = 30

c += a = 40

c -= a = 30

c *= a = 300

c /= a = 1

c %= a = 5

c <<= 2 = 20

c >>= 2 = 5

c >>= 2 = 1

c &= a = 0

c ^= a = 10

c |= a = 10

條體運算符（?:）

條體運算符也被稱為三元運算符。該運算符有3個操作數，並且需要判斷布爾表達式的值。該運算符的主要是決定哪個值應該賦值給變量。

variable x = (expression) ? value if true : value if false

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

Value of b is : 30

Value of b is : 20

instanceof 運算符

該運算符用於操作對象實例，檢查該對象是否是一個特定類型（類類型或接口類型）。

instanceof運算符使用格式如下：

( Object reference variable ) instanceof (class/interface type)

如果運算符左側變量所指的對象，是操作符右側類或接口(class/interface)的一個對象，那麽結果為真。

下面是一個例子：

String name = "James";

boolean result = name instanceof String; // 由於 name 是 String 類型，所以返回真

如果被比較的對象兼容於右側類型,該運算符仍然返回true。

看下面的例子：

以上實例編譯運行結果如下：

true

Java運算符優先級

當多個運算符出現在一個表達式中，誰先誰後呢？這就涉及到運算符的優先級別的問題。在一個多運算符的表達式中，運算符優先級不同會導致最後得出的結果差別甚大。

例如，（1+3）＋（3+2）*2，這個表達式如果按加號最優先計算，答案就是 18，如果按照乘號最優先，答案則是 14。

再如，x = 7 + 3 * 2;這裏x得到13，而不是20，因為乘法運算符比加法運算符有較高的優先級，所以先計算3 * 2得到6，然後再加7。

下表中具有最高優先級的運算符在的表的最上面，最低優先級的在表的底部。

類別	操作符	關聯性
後綴	() [] . (點操作符)	左到右
一元	+ + - ！〜	從右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
關系	>> = << =	左到右
相等	== !=	左到右
按位與	＆	左到右
按位異或	^	左到右
按位或	|	左到右
邏輯與	&&	左到右
邏輯或	| |	左到右
條體	？：	從右到左
賦值	= + = - = * = / =％= >> = << =＆= ^ = | =	從右到左
逗號	，	左到右

更多教程 》

Java 循環結構 - for, while 及 do...while

順序結構的程序語句只能被執行一次。如果您想要同樣的操作執行多次,，就需要使用循環結構。

Java中有三種主要的循環結構：

while 循環

do…while 循環

for 循環

在Java5中引入了一種主要用於數組的增強型for循環。

while 循環

while是最基本的循環，它的結構為：

只要布爾表達式為 true，循環體會一直執行下去。

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

value of x : 10

value of x : 11

value of x : 12

value of x : 13

value of x : 14

value of x : 15

value of x : 16

value of x : 17

value of x : 18

value of x : 19

do…while 循環

對於 while 語句而言，如果不滿足條體，則不能進入循環。但有時候我們需要即使不滿足條體，也至少執行一次。

do…while 循環和 while 循環相似，不同的是，do…while 循環至少會執行一次。

註意：布爾表達式在循環體的後面，所以語句塊在檢測布爾表達式之前已經執行了。 如果布爾表達式的值為 true，則語句塊一直執行，直到布爾表達式的值為 false。

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

value of x : 10

value of x : 11

value of x : 12

value of x : 13

value of x : 14

value of x : 15

value of x : 16

value of x : 17

value of x : 18

value of x : 19

for循環

雖然所有循環結構都可以用 while 或者 do...while表示，但 Java 提供了另一種語句 —— for 循環，使一些循環結構變得更加簡單。

for循環執行的次數是在執行前就確定的。語法格式如下：

關於 for 循環有以下幾點說明：

最先執行初始化步驟。可以聲明一種類型，但可初始化一個或多個循環控制變量，也可以是空語句。

然後，檢測布爾表達式的值。如果為 true，循環體被執行。如果為false，循環終止，開始執行循環體後面的語句。

執行一次循環後，更新循環控制變量。

再次檢測布爾表達式。循環執行上面的過程。

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

value of x : 10

value of x : 11

value of x : 12

value of x : 13

value of x : 14

value of x : 15

value of x : 16

value of x : 17

value of x : 18

value of x : 19

Java 增強 for 循環

Java5 引入了一種主要用於數組的增強型 for 循環。

Java 增強 for 循環語法格式如下:

聲明語句：聲明新的局部變量，該變量的類型必須和數組元素的類型匹配。其作用域限定在循環語句塊，其值與此時數組元素的值相等。

表達式：表達式是要訪問的數組名，或者是返回值為數組的方法。

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

10,20,30,40,50,

James,Larry,Tom,Lacy,

break 關鍵字

break 主要用在循環語句或者 switch 語句中，用來跳出整個語句塊。

break 跳出最裏層的循環，並且繼續執行該循環下面的語句。

語法

break 的用法很簡單，就是循環結構中的一條語句：

break;

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

10

20

continue 關鍵字

continue 適用於任何循環控制結構中。作用是讓程序立刻跳轉到下一次循環的叠代。

在 for 循環中，continue 語句使程序立即跳轉到更新語句。

在 while 或者 do…while 循環中，程序立即跳轉到布爾表達式的判斷語句。

語法

continue 就是循環體中一條簡單的語句：

continue;

實例

Test.java 文體代碼：

以上實例編譯運行結果如下：

10

20

40

50

更多教程 》

Java 正則表達式

正則表達式定義了字符串的模式。

正則表達式可以用來搜索、編輯或處理文本。

正則表達式並不僅限於某一種語言，但是在每種語言中有細微的差別。

正則表達式實例

一個字符串其實就是一個簡單的正則表達式，例如 Hello World 正則表達式匹配 "Hello World" 字符串。

.（點號）也是一個正則表達式，它匹配任何一個字符如："a" 或 "1"。

下表列出了一些正則表達式的實例及描述：

正則表達式	描述
this is text	匹配字符串 "this is text"
this\s+is\s+text	註意字符串中的 \s+。 匹配單詞 "this" 後面的 \s+ 可以匹配多個空格，之後匹配 is 字符串，再之後 \s+ 匹配多個空格然後再跟上 text 字符串。 可以匹配這個實例：this is text
^\d+(\.\d+)?	^ 定義了以什麽開始 \d+ 匹配一個或多個數字 ? 設置括號內的選項是可選的 \. 匹配 "." 可以匹配的實例："5", "1.5" 和 "2.21"。

Java 正則表達式和 Perl 的是最為相似的。

java.util.regex 包主要包括以下三個類：

Pattern 類：

pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要創建一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式作為它的第一個參數。

Matcher 類：

Matcher 對象是對輸入字符串進行解釋和匹配操作的引擎。與Pattern 類一樣，Matcher 也沒有公共構造方法。你需要調用 Pattern 對象的 matcher 方法來獲得一個 Matcher 對象。

PatternSyntaxException：

PatternSyntaxException 是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。

以下實例中使用了正則表達式 .*runoob.* 用於查找字符串中是否包了 runoob 子串：

實例

實例輸出結果為：

字符串中是否包含了 'runoob' 子字符串? true

捕獲組

捕獲組是把多個字符當一個單獨單元進行處理的方法，它通過對括號內的字符分組來創建。

例如，正則表達式 (dog) 創建了單一分組，組裏包含"d"，"o"，和"g"。

捕獲組是通過從左至右計算其開括號來編號。例如，在表達式（（A）（B（C））），有四個這樣的組：

((A)(B(C)))

(A)

(B(C))

(C)

可以通過調用 matcher 對象的 groupCount 方法來查看表達式有多少個分組。groupCount 方法返回一個 int 值，表示matcher對象當前有多個捕獲組。

還有一個特殊的組（group(0)），它總是代表整個表達式。該組不包括在 groupCount 的返回值中。

實例

下面的例子說明如何從一個給定的字符串中找到數字串：

RegexMatches.java 文體代碼：

以上實例編譯運行結果如下：

Found value: This order was placed for QT3000! OK?

Found value: This order was placed for QT

Found value: 3000

Found value: ! OK?

正則表達式語法

字符	說明
\	將下一字符標記為特殊字符、文本、反向引用或八進制轉義符。例如，"n"匹配字符"n"。"\n"匹配換行符。序列"\\"匹配"\"，"\("匹配"("。
^	匹配輸入字符串開始的位置。如果設置了 RegExp 對象的 Multiline 屬性，^ 還會與"\n"或"\r"之後的位置匹配。
$	匹配輸入字符串結尾的位置。如果設置了 RegExp 對象的 Multiline 屬性，$ 還會與"\n"或"\r"之前的位置匹配。
*	零次或多次匹配前面的字符或子表達式。例如，zo* 匹配"z"和"zoo"。* 等效於 {0,}。
+	一次或多次匹配前面的字符或子表達式。例如，"zo+"與"zo"和"zoo"匹配，但與"z"不匹配。+ 等效於 {1,}。
?	零次或一次匹配前面的字符或子表達式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效於 {0,1}。
{n}	n 是非負整數。正好匹配 n 次。例如，"o{2}"與"Bob"中的"o"不匹配，但與"food"中的兩個"o"匹配。
{n,}	n 是非負整數。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有 o。"o{1,}"等效於"o+"。"o{0,}"等效於"o*"。
{n,m}	M 和 n 是非負整數，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的頭三個 o。'o{0,1}' 等效於 'o?'。註意：您不能將空格插入逗號和數字之間。
?	當此字符緊隨任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之後時，匹配模式是"非貪心的"。"非貪心的"模式匹配搜索到的、盡可能短的字符串，而默認的"貪心的"模式匹配搜索到的、盡可能長的字符串。例如，在字符串"oooo"中，"o+?"只匹配單個"o"，而"o+"匹配所有"o"。
.	匹配除"\r\n"之外的任何單個字符。若要匹配包括"\r\n"在內的任意字符，請使用諸如"[\s\S]"之類的模式。
(pattern)	匹配 pattern 並捕獲該匹配的子表達式。可以使用 $0…$9 屬性從結果"匹配"集合中檢索捕獲的匹配。若要匹配括號字符 ( )，請使用"\("或者"\)"。
(?:pattern)	匹配 pattern 但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，不存儲供以後使用的匹配。這對於用"or"字符 (|) 組合模式部體的情況很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更經濟的表達式。
(?=pattern)	執行正向預測先行搜索的子表達式，該表達式匹配處於匹配 pattern 的字符串的起始點的字符串。它是一個非捕獲匹配，即不能捕獲供以後使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。預測先行不占用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配之後，而不是在組成預測先行的字符後。
(?!pattern)	執行反向預測先行搜索的子表達式，該表達式匹配不處於匹配 pattern 的字符串的起始點的搜索字符串。它是一個非捕獲匹配，即不能捕獲供以後使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。預測先行不占用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配之後，而不是在組成預測先行的字符後。
x|y	匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。
[xyz]	字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
[^xyz]	反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。
[a-z]	字符範圍。匹配指定範圍內的任何字符。例如，"[a-z]"匹配"a"到"z"範圍內的任何小寫字母。
[^a-z]	反向範圍字符。匹配不在指定的範圍內的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"範圍內的任何字符。
\b	匹配一個字邊界，即字與空格間的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
\B	非字邊界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
\cx	匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回車符。x 的值必須在 A-Z 或 a-z 之間。如果不是這樣，則假定 c 就是"c"字符本身。
\d	數字字符匹配。等效於 [0-9]。
\D	非數字字符匹配。等效於 [^0-9]。
\f	換頁符匹配。等效於 \x0c 和 \cL。
\n	換行符匹配。等效於 \x0a 和 \cJ。
\r	匹配一個回車符。等效於 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、換頁符等。與 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。與 [^ \f\n\r\t\v] 等效。
\t	制表符匹配。與 \x09 和 \cI 等效。
\v	垂直制表符匹配。與 \x0b 和 \cK 等效。
\w	匹配任何字類字符，包括下劃線。與"[A-Za-z0-9_]"等效。
\W	與任何非單詞字符匹配。與"[^A-Za-z0-9_]"等效。
\xn	匹配 n，此處的 n 是一個十六進制轉義碼。十六進制轉義碼必須正好是兩位數長。例如，"\x41"匹配"A"。"\x041"與"\x04"&"1"等效。允許在正則表達式中使用 ASCII 代碼。
\num	匹配 num，此處的 num 是一個正整數。到捕獲匹配的反向引用。例如，"(.)\1"匹配兩個連續的相同字符。
\n	標識一個八進制轉義碼或反向引用。如果 \n 前面至少有 n 個捕獲子表達式，那麽 n 是反向引用。否則，如果 n 是八進制數 (0-7)，那麽 n 是八進制轉義碼。
\nm	標識一個八進制轉義碼或反向引用。如果 \nm 前面至少有 nm 個捕獲子表達式，那麽 nm 是反向引用。如果 \nm 前面至少有 n 個捕獲，則 n 是反向引用，後面跟有字符 m。如果兩種前面的情況都不存在，則 \nm 匹配八進制值 nm，其中 n 和 m 是八進制數字 (0-7)。
\nml	當 n 是八進制數 (0-3)，m 和 l 是八進制數 (0-7) 時，匹配八進制轉義碼 nml。
\un	匹配 n，其中 n 是以四位十六進制數表示的 Unicode 字符。例如，\u00A9 匹配版權符號 (©)。

根據 Java Language Specification 的要求，Java 源代碼的字符串中的反斜線被解釋為 Unicode 轉義或其他字符轉義。因此必須在字符串字面值中使用兩個反斜線，表示正則表達式受到保護，不被 Java 字節碼編譯器解釋。例如，當解釋為正則表達式時，字符串字面值 "\b" 與單個退格字符匹配，而 "\\b" 與單詞邊界匹配。字符串字面值 "\(hello\)" 是非法的，將導致編譯時錯誤；要與字符串 (hello) 匹配，必須使用字符串字面值 "\\(hello\\)"。

Matcher 類的方法

索引方法

索引方法提供了有用的索引值，精確表明輸入字符串中在哪能找到匹配：

序號	方法及說明
1	public int start() 返回以前匹配的初始索引。
2	public int start(int group) 返回在以前的匹配操作期間，由給定組所捕獲的子序列的初始索引。
3	public int end() 返回最後匹配字符之後的偏移量。
4	public int end(int group) 返回在以前的匹配操作期間，由給定組所捕獲子序列的最後字符之後的偏移量。

研究方法

研究方法用來檢查輸入字符串並返回一個布爾值，表示是否找到該模式：

序號	方法及說明
1	public boolean lookingAt() 嘗試將從區域開頭開始的輸入序列與該模式匹配。
2	public boolean find() 嘗試查找與該模式匹配的輸入序列的下一個子序列。
3	public boolean find(int start） 重置此匹配器，然後嘗試查找匹配該模式、從指定索引開始的輸入序列的下一個子序列。
4	public boolean matches() 嘗試將整個區域與模式匹配。

替換方法

替換方法是替換輸入字符串裏文本的方法：

序號	方法及說明
1	public Matcher appendReplacement(StringBuffer sb, String replacement) 實現非終端添加和替換步驟。
2	public StringBuffer appendTail(StringBuffer sb) 實現終端添加和替換步驟。
3	public String replaceAll(String replacement) 替換模式與給定替換字符串相匹配的輸入序列的每個子序列。
4	public String replaceFirst(String replacement) 替換模式與給定替換字符串匹配的輸入序列的第一個子序列。
5	public static String quoteReplacement(String s) 返回指定字符串的字面替換字符串。這個方法返回一個字符串，就像傳遞給Matcher類的appendReplacement 方法一個字面字符串一樣工作。

start 和 end 方法

下面是一個對單詞 "cat" 出現在輸入字符串中出現次數進行計數的例子：

RegexMatches.java 文體代碼：

以上實例編譯運行結果如下：

Match number 1

start(): 0

end(): 3

Match number 2

start(): 4

end(): 7

Match number 3

start(): 8

end(): 11

Match number 4

start(): 19

end(): 22

可以看到這個例子是使用單詞邊界，以確保字母 "c" "a" "t" 並非僅是一個較長的詞的子串。它也提供了一些關於輸入字符串中匹配發生位置的有用信息。

Start 方法返回在以前的匹配操作期間，由給定組所捕獲的子序列的初始索引，end 方法最後一個匹配字符的索引加 1。

matches 和 lookingAt 方法

matches 和 lookingAt 方法都用來嘗試匹配一個輸入序列模式。它們的不同是 matcher 要求整個序列都匹配，而lookingAt 不要求。

lookingAt 方法雖然不需要整句都匹配，但是需要從第一個字符開始匹配。

這兩個方法經常在輸入字符串的開始使用。

我們通過下面這個例子，來解釋這個功能：

RegexMatches.java 文體代碼：

以上實例編譯運行結果如下：

Current REGEX is: foo

Current INPUT is: fooooooooooooooooo

Current INPUT2 is: ooooofoooooooooooo

lookingAt(): true

matches(): false

lookingAt(): false

replaceFirst 和 replaceAll 方法

replaceFirst 和 replaceAll 方法用來替換匹配正則表達式的文本。不同的是，replaceFirst 替換首次匹配，replaceAll 替換所有匹配。

下面的例子來解釋這個功能：

RegexMatches.java 文體代碼：

以上實例編譯運行結果如下：

The cat says meow. All cats say meow.

appendReplacement 和 appendTail 方法

Matcher 類也提供了appendReplacement 和 appendTail 方法用於文本替換：

看下面的例子來解釋這個功能：

RegexMatches.java 文體代碼：

以上實例編譯運行結果如下：

-foo-foo-foo-

PatternSyntaxException 類的方法

PatternSyntaxException 是一個非強制異常類，它指示一個正則表達式模式中的語法錯誤。

PatternSyntaxException 類提供了下面的方法來幫助我們查看發生了什麽錯誤。

序號	方法及說明
1	public String getDescription() 獲取錯誤的描述。
2	public int getIndex() 獲取錯誤的索引。
3	public String getPattern() 獲取錯誤的正則表達式模式。
4	public String getMessage() 返回多行字符串，包含語法錯誤及其索引的描述、錯誤的正則表達式模式和模式中錯誤索引的可視化指示。

更多教程 》

Java 繼承

繼承的概念

繼承是java面向對象編程技術的一塊基石，因為它允許創建分等級層次的類。

繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

生活中的繼承：

兔子和羊屬於食草動物類，獅子和豹屬於食肉動物類。

食草動物和食肉動物又是屬於動物類。

所以繼承需要符合的關系是：is-a，父類更通用，子類更具體。

雖然食草動物和食肉動物都是屬於動物，但是兩者的屬性和行為上有差別，所以子類會具有父類的一般特性也會具有自身的特性。

類的繼承格式

在 Java 中通過 extends 關鍵字可以申明一個類是從另外一個類繼承而來的，一般形式如下：

類的繼承格式

為什麽需要繼承

接下來我們通過實例來說明這個需求。

開發動物類，其中動物分別為企鵝以及老鼠，要求如下：

企鵝：屬性（姓名，id），方法（吃，睡，自我介紹）

老鼠：屬性（姓名，id），方法（吃，睡，自我介紹）

企鵝類：

老鼠類：

從這兩段代碼可以看出來，代碼存在重復了，導致後果就是代碼量大且臃腫，而且維護性不高(維護性主要是後期需要修改的時候，就需要修改很多的代碼，容易出錯)，所以要從根本上解決這兩段代碼的問題，就需要繼承，將兩段代碼中相同的部分提取出來組成 一個父類：

公共父類：

這個Animal類就可以作為一個父類，然後企鵝類和老鼠類繼承這個類之後，就具有父類當中的屬性和方法，子類就不會存在重復的代碼，維護性也提高，代碼也更加簡潔，提高代碼的復用性（復用性主要是可以多次使用，不用再多次寫同樣的代碼） 繼承之後的代碼：

企鵝類：

老鼠類：

繼承的特性

子類擁有父類非private的屬性，方法。

子類可以擁有自己的屬性和方法，即子類可以對父類進行擴展。

子類可以用自己的方式實現父類的方法。

Java的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如A類繼承B類，B類繼承C類，所以按照關系就是C類是B類的父類，B類是A類的父類，這是java繼承區別於C++繼承的一個特性。

提高了類之間的藕合性（繼承的缺點，藕合度高就會造成代碼之間的聯系）。

繼承關鍵字

繼承可以使用 extends 和 implements 這兩個關鍵字來實現繼承，而且所有的類都是繼承於 java.lang.Object，當一個類沒有繼承的兩個關鍵字，則默認繼承object（這個類在 java.lang 包中，所以不需要 import）祖先類。

extends關鍵字

在 Java 中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，所以 extends 只能繼承一個類。

extends 關鍵字

implements關鍵字

使用 implements 關鍵字可以變相的使java具有多繼承的特性，使用範圍為類繼承接口的情況，可以同時繼承多個接口（接口跟接口之間采用逗號分隔）。

implements 關鍵字

super 與 this 關鍵字

super關鍵字：我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。

this關鍵字：指向自己的引用。

實例

輸出結果為：

super.i = 50, this.i = 100

final關鍵字

final 關鍵字聲明類可以把類定義為不能繼承的，即最終類；或者用於修飾方法，該方法不能被子類重寫：

聲明類：

final class 類名 {//類體}

聲明方法：

修飾符(public/private/default/protected) final 返回值類型 方法名(){//方法體}

註:實例變量也可以被定義為 final，被定義為 final 的變量不能被修改。被聲明為 final 類的方法自動地聲明為 final，但是實例變量並不是 final

構造器

子類不能繼承父類的構造器（構造方法或者構造函數），但是父類的構造器帶有參數的，則必須在子類的構造器中顯式地通過super關鍵字調用父類的構造器並配以適當的參數列表。

如果父類有無參構造器，則在子類的構造器中用super調用父類構造器不是必須的，如果沒有使用super關鍵字，系統會自動調用父類的無參構造器。

實例

輸出結果為：

SuperClass(int n)

SubClass

SuperClass()

SubClass(int n):200

更多教程 》

Java 多態

多態是同一個行為具有多個不同表現形式或形態的能力。

多態就是同一個接口，使用不同的實例而執行不同操作，如圖所示：

多態性是對象多種表現形式的體現。

現實中，比如我們按下 F1 鍵這個動作：

如果當前在 Flash 界面下彈出的就是 AS 3 的幫助文檔；

如果當前在 Word 下彈出的就是 Word 幫助；

在 Windows 下彈出的就是 Windows 幫助和支持。

同一個事體發生在不同的對象上會產生不同的結果。

多態的優點

1. 消除類型之間的藕合關系

2. 可替換性

3. 可擴充性

4. 接口性

5. 靈活性

6. 簡化性

多態存在的三個必要條體

繼承

重寫

父類引用指向子類對象

比如：

Parent p = new Child();

當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。

多態的好處：可以使程序有良好的擴展，並可以對所有類的對象進行通用處理。

以下是一個多態實例的演示，詳細說明請看註釋：

Test.java 文體代碼：

執行以上程序，輸出結果為：

吃魚

抓老鼠

吃骨頭

看家

吃魚

抓老鼠

虛方法

我們將介紹在Java中，當設計類時，被重寫的方法的行為怎樣影響多態性。

我們已經討論了方法的重寫，也就是子類能夠重寫父類的方法。

當子類對象調用重寫的方法時，調用的是子類的方法，而不是父類中被重寫的方法。

要想調用父類中被重寫的方法，則必須使用關鍵字super。

Employee.java 文體代碼：

假設下面的類繼承Employee類：

Salary.java 文體代碼：

現在我們仔細閱讀下面的代碼，嘗試給出它的輸出結果：

VirtualDemo.java 文體代碼：

以上實例編譯運行結果如下：

Employee 構造函數

Employee 構造函數

使用 Salary 的引用調用 mailCheck --

Salary 類的 mailCheck 方法

郵寄支票給：員工 A ，工資為：3600.0

使用 Employee 的引用調用 mailCheck--

Salary 類的 mailCheck 方法

郵寄支票給：員工 B ，工資為：2400.0

例子解析

實例中，實例化了兩個 Salary 對象：一個使用 Salary 引用 s，另一個使用 Employee 引用 e。

當調用 s.mailCheck() 時，編譯器在編譯時會在 Salary 類中找到 mailCheck()，執行過程 JVM 就調用 Salary 類的 mailCheck()。

因為 e 是 Employee 的引用，所以調用 e 的 mailCheck() 方法時，編譯器會去 Employee 類查找 mailCheck() 方法 。

在編譯的時候，編譯器使用 Employee 類中的 mailCheck() 方法驗證該語句， 但是在運行的時候，Java虛擬機(JVM)調用的是 Salary 類中的 mailCheck() 方法。

以上整個過程被稱為虛擬方法調用，該方法被稱為虛擬方法。

Java中所有的方法都能以這種方式表現，因此，重寫的方法能在運行時調用，不管編譯的時候源代碼中引用變量是什麽數據類型。

多態的實現方式

方式一：重寫：

這個內容已經在上一章節詳細講過，就不再闡述，詳細可訪問：Java 重寫(Override)與重載(Overload)。

方式二：接口

1. 生活中的接口最具代表性的就是插座，例如一個三接頭的插頭都能接在三孔插座中，因為這個是每個國家都有各自規定的接口規則，有可能到國外就不行，那是因為國外自己定義的接口類型。

2. java中的接口類似於生活中的接口，就是一些方法特征的集合，但沒有方法的實現。具體可以看 java接口 這一章節的內容。

方式三：抽象類和抽象方法

更多教程 》

Java 接口

接口（英文：Interface），在JAVA編程語言中是一個抽象類型，是抽象方法的集合，接口通常以interface來聲明。一個類通過繼承接口的方式，從而來繼承接口的抽象方法。

接口並不是類，編寫接口的方式和類很相似，但是它們屬於不同的概念。類描述對象的屬性和方法。接口則包含類要實現的方法。

除非實現接口的類是抽象類，否則該類要定義接口中的所有方法。

接口無法被實例化，但是可以被實現。一個實現接口的類，必須實現接口內所描述的所有方法，否則就必須聲明為抽象類。另外，在 Java 中，接口類型可用來聲明一個變量，他們可以成為一個空指針，或是被綁定在一個以此接口實現的對象。

接口與類相似點：

一個接口可以有多個方法。

接口文體保存在 .java 結尾的文體中，文體名使用接口名。

接口的字節碼文體保存在 .class 結尾的文體中。

接口相應的字節碼文體必須在與包名稱相匹配的目錄結構中。

接口與類的區別：

接口不能用於實例化對象。

接口沒有構造方法。

接口中所有的方法必須是抽象方法。

接口不能包含成員變量，除了 static 和 final 變量。

接口不是被類繼承了，而是要被類實現。

接口支持多重繼承。

接口特性

接口中每一個方法也是隱式抽象的,接口中的方法會被隱式的指定為 public abstract（只能是 public abstract，其他修飾符都會報錯）。

接口中可以含有變量，但是接口中的變量會被隱式的指定為 public static final 變量（並且只能是 public，用 private 修飾會報編譯錯誤。

接口中的方法是不能在接口中實現的，只能由實現接口的類來實現接口中的方法。

抽象類和接口的區別

1. 抽象類中的方法可以有方法體，就是能實現方法的具體功能，但是接口中的方法不行。

2. 抽象類中的成員變量可以是各種類型的，而接口中的成員變量只能是 public static final 類型的。

3. 接口中不能含有靜態代碼塊以及靜態方法(用 static 修飾的方法)，而抽象類是可以有靜態代碼塊和靜態方法。

4. 一個類只能繼承一個抽象類，而一個類卻可以實現多個接口。

接口的聲明

接口的聲明語法格式如下：

Interface關鍵字用來聲明一個接口。下面是接口聲明的一個簡單例子。

NameOfInterface.java 文體代碼：

接口有以下特性：

接口是隱式抽象的，當聲明一個接口的時候，不必使用abstract關鍵字。

接口中每一個方法也是隱式抽象的，聲明時同樣不需要abstract關鍵子。

接口中的方法都是公有的。

實例

Animal.java 文體代碼：

接口有以下特性：

接口是隱式抽象的，當聲明一個接口的時候，不必使用abstract關鍵字。

接口中每一個方法也是隱式抽象的，聲明時同樣不需要abstract關鍵子。

接口中的方法都是公有的。

實例

Animal.java 文體代碼：

接口的實現

當類實現接口的時候，類要實現接口中所有的方法。否則，類必須聲明為抽象的類。

類使用implements關鍵字實現接口。在類聲明中，Implements關鍵字放在class聲明後面。

實現一個接口的語法，可以使用這個公式：

Animal.java 文體代碼：

...implements 接口名稱[, 其他接口, 其他接口..., ...] ...

實例

MammalInt.java 文體代碼：

以上實例編譯運行結果如下:

Mammal eats

Mammal travels

重寫接口中聲明的方法時，需要註意以下規則：

類在實現接口的方法時，不能拋出強制性異常，只能在接口中，或者繼承接口的抽象類中拋出該強制性異常。

類在重寫方法時要保持一致的方法名，並且應該保持相同或者相兼容的返回值類型。

如果實現接口的類是抽象類，那麽就沒必要實現該接口的方法。

在實現接口的時候，也要註意一些規則：

一個類可以同時實現多個接口。

一個類只能繼承一個類，但是能實現多個接口。

一個接口能繼承另一個接口，這和類之間的繼承比較相似。

接口的繼承

一個接口能繼承另一個接口，和類之間的繼承方式比較相似。接口的繼承使用extends關鍵字，子接口繼承父接口的方法。

下面的Sports接口被Hockey和Football接口繼承：

Hockey接口自己聲明了四個方法，從Sports接口繼承了兩個方法，這樣，實現Hockey接口的類需要實現六個方法。

相似的，實現Football接口的類需要實現五個方法，其中兩個來自於Sports接口。

接口的多重繼承

在Java中，類的多重繼承是不合法，但接口允許多重繼承，。

在接口的多重繼承中extends關鍵字只需要使用一次，在其後跟著繼承接口。 如下所示：

public interface Hockey extends Sports, Event

以上的程序片段是合法定義的子接口，與類不同的是，接口允許多重繼承，而 Sports及 Event 可能定義或是繼承相同的方法

標記接口

最常用的繼承接口是沒有包含任何方法的接口。

標識接口是沒有任何方法和屬性的接口.它僅僅表明它的類屬於一個特定的類型,供其他代碼來測試允許做一些事情。

標識接口作用：簡單形象的說就是給某個對象打個標（蓋個戳），使對象擁有某個或某些特權。

例如：java.awt.event 包中的 MouseListener 接口繼承的 java.util.EventListener 接口定義如下：

package java.util;

public interface EventListener

{}

沒有任何方法的接口被稱為標記接口。標記接口主要用於以下兩種目的：

建立一個公共的父接口：

正如EventListener接口，這是由幾十個其他接口擴展的Java API，你可以使用一個標記接口來建立一組接口的父接口。例如：當一個接口繼承了EventListener接口，Java虛擬機(JVM)就知道該接口將要被用於一個事體的代理方案。

向一個類添加數據類型：

這種情況是標記接口最初的目的，實現標記接口的類不需要定義任何接口方法(因為標記接口根本就沒有方法)，但是該類通過多態性變成一個接口類型。

更多教程 》

Java 數據結構

Java工具包提供了強大的數據結構。在Java中的數據結構主要包括以下幾種接口和類：

枚舉（Enumeration）

位集合（BitSet）

向量（Vector）

棧（Stack）

字典（Dictionary）

哈希表（Hashtable）

屬性（Properties）

以上這些類是傳統遺留的，在Java2中引入了一種新的框架-集合框架(Collection)，我們後面再討論。

枚舉（Enumeration）

枚舉（Enumeration）接口雖然它本身不屬於數據結構,但它在其他數據結構的範疇裏應用很廣。 枚舉（The Enumeration）接口定義了一種從數據結構中取回連續元素的方式。

例如，枚舉定義了一個叫nextElement 的方法，該方法用來得到一個包含多元素的數據結構的下一個元素。

關於枚舉接口的更多信息，請參見枚舉（Enumeration）。

位集合（BitSet）

位集合類實現了一組可以單獨設置和清除的位或標誌。

該類在處理一組布爾值的時候非常有用，你只需要給每個值賦值一"位"，然後對位進行適當的設置或清除，就可以對布爾值進行操作了。

關於該類的更多信息，請參見位集合（BitSet）。

向量（Vector）

向量（Vector）類和傳統數組非常相似，但是Vector的大小能根據需要動態的變化。

和數組一樣，Vector對象的元素也能通過索引訪問。

使用Vector類最主要的好處就是在創建對象的時候不必給對象指定大小，它的大小會根據需要動態的變化。

關於該類的更多信息，請參見向量(Vector)

棧（Stack）

棧（Stack）實現了一個後進先出（LIFO）的數據結構。

你可以把棧理解為對象的垂直分布的棧，當你添加一個新元素時，就將新元素放在其他元素的頂部。

當你從棧中取元素的時候，就從棧頂取一個元素。換句話說，最後進棧的元素最先被取出。

關於該類的更多信息，請參見棧（Stack）。

字典（Dictionary）

字典（Dictionary） 類是一個抽象類，它定義了鍵映射到值的數據結構。

當你想要通過特定的鍵而不是整數索引來訪問數據的時候，這時候應該使用Dictionary。

由於Dictionary類是抽象類，所以它只提供了鍵映射到值的數據結構，而沒有提供特定的實現。

關於該類的更多信息，請參見字典（ Dictionary）。

哈希表（Hashtable）

Hashtable類提供了一種在用戶定義鍵結構的基礎上來組織數據的手段。

例如，在地址列表的哈希表中，你可以根據郵政編碼作為鍵來存儲和排序數據，而不是通過人名。

哈希表鍵的具體含義完全取決於哈希表的使用情景和它包含的數據。

關於該類的更多信息，請參見哈希表（HashTable）。

屬性（Properties）

Properties 繼承於 Hashtable.Properties 類表示了一個持久的屬性集.屬性列表中每個鍵及其對應值都是一個字符串。

Properties 類被許多Java類使用。例如，在獲取環境變量時它就作為System.getProperties()方法的返回值。

關於該類的更多信息，請參見屬性（Properties）。

更多教程 》

Java 集合框架

早在Java 2中之前，Java就提供了特設類。比如：Dictionary, Vector, Stack, 和Properties這些類用來存儲和操作對象組。

雖然這些類都非常有用，但是它們缺少一個核心的，統一的主題。由於這個原因，使用Vector類的方式和使用Properties類的方式有著很大不同。

集合框架被設計成要滿足以下幾個目標。

該框架必須是高性能的。基本集合（動態數組，鏈表，樹，哈希表）的實現也必須是高效的。

該框架允許不同類型的集合，以類似的方式工作，具有高度的互操作性。

對一個集合的擴展和適應必須是簡單的。

為此，整個集合框架就圍繞一組標準接口而設計。你可以直接使用這些接口的標準實現，諸如： LinkedList, HashSet, 和 TreeSet等,除此之外你也可以通過這些接口實現自己的集合。

集合框架是一個用來代表和操縱集合的統一架構。所有的集合框架都包含如下內容：

接口：是代表集合的抽象數據類型。接口允許集合獨立操縱其代表的細節。在面向對象的語言，接口通常形成一個層次。

實現（類）：是集合接口的具體實現。從本質上講，它們是可重復使用的數據結構。

算法：是實現集合接口的對象裏的方法執行的一些有用的計算，例如：搜索和排序。這些算法被稱為多態，那是因為相同的方法可以在相似的接口上有著不同的實現。

除了集合，該框架也定義了幾個Map接口和類。Map裏存儲的是鍵/值對。盡管Map不是collections，但是它們完全整合在集合中。

集合框架體系如圖所示

Java 集合框架提供了一套性能優良，使用方便的接口和類，java集合框架位於java.util包中， 所以當使用集合框架的時候需要進行導包。

集合接口

集合框架定義了一些接口。本節提供了每個接口的概述：

序號	接口描述
1	Collection 接口 Collection 是最基本的集合接口，一個 Collection 代表一組 Object，Java不提供直接繼承自Collection的類，只提供繼承於的子接口(如List和set)。
2	List 接口 List接口是一個有序的Collection，使用此接口能夠精確的控制每個元素插入的位置，能夠通過索引(元素在List中位置，類似於數組的小標)來訪問List中的元素，而且允許有相同的元素。
3	Set Set 具有與 Collection 完全一樣的接口，只是行為上不同，Set 不保存重復的元素。
4	SortedSet 繼承於Set保存有序的集合。
5	Map 將唯一的鍵映射到值。
6	Map.Entry 描述在一個Map中的一個元素（鍵/值對）。是一個Map的內部類。
7	SortedMap 繼承於Map，使Key保持在升序排列。
8	Enumeration 這是一個傳統的接口和定義的方法，通過它可以枚舉（一次獲得一個）對象集合中的元素。這個傳統接口已被叠代器取代。

Set和List的區別

1. Set 接口實例存儲的是無序的，不重復的數據。List 接口實例存儲的是有序的，可以重復的元素。

2. Set檢索效率低下，刪除和插入效率高，插入和刪除不會引起元素位置改變 <實現類有HashSet,TreeSet>。

3. List和數組類似，可以動態增長，根據實際存儲的數據的長度自動增長List的長度。查找元素效率高，插入刪除效率低，因為會引起其他元素位置改變 <實現類有ArrayList,LinkedList,Vector> 。

集合實現類（集合類）

Java提供了一套實現了Collection接口的標準集合類。其中一些是具體類，這些類可以直接拿來使用，而另外一些是抽象類，提供了接口的部分實現。

標準集合類匯總於下表：

序號	類描述
1	AbstractCollection 實現了大部分的集合接口。
2	AbstractList 繼承於AbstractCollection 並且實現了大部分List接口。
3	AbstractSequentialList 繼承於 AbstractList ，提供了對數據元素的鏈式訪問而不是隨機訪問。
4	LinkedList 該類實現了List接口，允許有null（空）元素。主要用於創建鏈表數據結構，該類沒有同步方法，如果多個線程同時訪問一個List，則必須自己實現訪問同步，解決方法就是在創建List時候構造一個同步的List。例如： Listlist=Collections.synchronizedList(newLinkedList(...)); LinkedList 查找效率低。
5	ArrayList 該類也是實現了List的接口，實現了可變大小的數組，隨機訪問和遍歷元素時，提供更好的性能。該類也是非同步的,在多線程的情況下不要使用。ArrayList 增長當前長度的50%，插入刪除效率低。
6	AbstractSet 繼承於AbstractCollection 並且實現了大部分Set接口。
7	HashSet 該類實現了Set接口，不允許出現重復元素，不保證集合中元素的順序，允許包含值為null的元素，但最多只能一個。
8	LinkedHashSet 具有可預知叠代順序的 Set 接口的哈希表和鏈接列表實現。
9	TreeSet 該類實現了Set接口，可以實現排序等功能。
10	AbstractMap 實現了大部分的Map接口。
11	HashMap HashMap 是一個散列表，它存儲的內容是鍵值對(key-value)映射。 該類實現了Map接口，根據鍵的HashCode值存儲數據，具有很快的訪問速度，最多允許一條記錄的鍵為null，不支持線程同步。
12	TreeMap 繼承了AbstractMap，並且使用一顆樹。
13	WeakHashMap 繼承AbstractMap類，使用弱密鑰的哈希表。
14	LinkedHashMap 繼承於HashMap，使用元素的自然順序對元素進行排序.
15	IdentityHashMap 繼承AbstractMap類，比較文檔時使用引用相等。

在前面的教程中已經討論通過java.util包中定義的類，如下所示：

序號	類描述
1	Vector 該類和ArrayList非常相似，但是該類是同步的，可以用在多線程的情況，該類允許設置默認的增長長度，默認擴容方式為原來的2倍。
2	Stack 棧是Vector的一個子類，它實現了一個標準的後進先出的棧。
3	Dictionary Dictionary 類是一個抽象類，用來存儲鍵/值對，作用和Map類相似。
4	Hashtable Hashtable 是 Dictionary(字典) 類的子類，位於 java.util 包中。
5	Properties Properties 繼承於 Hashtable，表示一個持久的屬性集，屬性列表中每個鍵及其對應值都是一個字符串。
6	BitSet 一個Bitset類創建一種特殊類型的數組來保存位值。BitSet中數組大小會隨需要增加。

一個Bitset類創建一種特殊類型的數組來保存位值。BitSet中數組大小會隨需要增加。

集合算法

集合框架定義了幾種算法，可用於集合和映射。這些算法被定義為集合類的靜態方法。

在嘗試比較不兼容的類型時，一些方法能夠拋出 ClassCastException異常。當試圖修改一個不可修改的集合時，拋出UnsupportedOperationException異常。

集合定義三個靜態的變量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。這些變量都不可改變。

序號	算法描述
1	Collection Algorithms 這裏是一個列表中的所有算法實現。

如何使用叠代器

通常情況下，你會希望遍歷一個集合中的元素。例如，顯示集合中的每個元素。

一般遍歷數組都是采用for循環或者增強for，這兩個方法也可以用在集合框架，但是還有一種方法是采用叠代器遍歷集合框架，它是一個對象，實現了Iterator 接口或ListIterator接口。

叠代器，使你能夠通過循環來得到或刪除集合的元素。ListIterator 繼承了Iterator，以允許雙向遍歷列表和修改元素。

序號

叠代器方法描述

1 使用 Java Iterator

這裏通過實例列出Iterator和listIterator接口提供的所有方法。

遍歷 ArrayList

實例

解析：

三種方法都是用來遍歷ArrayList集合，第三種方法是采用叠代器的方法，該方法可以不用擔心在遍歷的過程中會超出集合的長度。

遍歷 Map

實例

如何使用比較器

TreeSet和TreeMap的按照排序順序來存儲元素. 然而，這是通過比較器來精確定義按照什麽樣的排序順序。

這個接口可以讓我們以不同的方式來排序一個集合。

序號	比較器方法描述
1	使用 Java Comparator 這裏通過實例列出Comparator接口提供的所有方法

總結

Java集合框架為工程師提供了預先包裝的數據結構和算法來操縱他們。

集合是一個對象，可容納其他對象的引用。集合接口聲明對每一種類型的集合可以執行的操作。

集合框架的類和接口均在java.util包中。

任何對象加入集合類後，自動轉變為Object類型，所以在取出的時候，需要進行強制類型轉換。

更多教程 》

Java 網路編程

網路編程是指編寫運行在多個設備（計算機）的程序，這些設備都通過網路連接起來。

java.net 包中 J2SE 的 API 包含有類和接口，它們提供低層次的通信細節。你可以直接使用這些類和接口，來專註於解決問題，而不用關註通信細節。

java.net 包中提供了兩種常見的網路協議的支持：

TCP：TCP 是傳輸控制協議的縮寫，它保障了兩個應用程序之間的可靠通信。通常用於互聯網協議，被稱 TCP / IP。

UDP：UDP 是用戶數據報協議的縮寫，一個無連接的協議。提供了應用程序之間要發送的數據的數據包。

本教程主要講解以下兩個主題。

Socket 編程：這是使用最廣泛的網路概念，它已被解釋地非常詳細。

URL 處理：這部分會在另外的篇幅裏講，點擊這裏更詳細地了解在 Java 語言中的 URL 處理。

Socket 編程

套接字使用TCP提供了兩台計算機之間的通信機制。 客戶端程序創建一個套接字，並嘗試連接服務器的套接字。

當連接建立時，服務器會創建一個 Socket 對象。客戶端和服務器現在可以通過對 Socket 對象的寫入和讀取來進行進行通信。

java.net.Socket 類代表一個套接字，並且 java.net.ServerSocket 類為服務器程序提供了一種來監聽客戶端，並與他們建立連接的機制。

以下步驟在兩台計算機之間使用套接字建立TCP連接時會出現：

服務器實例化一個 ServerSocket 對象，表示通過服務器上的端口通信。

服務器調用 ServerSocket 類的 accept() 方法，該方法將一直等待，直到客戶端連接到服務器上給定的端口。

服務器正在等待時，一個客戶端實例化一個 Socket 對象，指定服務器名稱和端口號來請求連接。

Socket 類的構造函數試圖將客戶端連接到指定的服務器和端口號。如果通信被建立，則在客戶端創建一個 Socket 對象能夠與服務器進行通信。

在服務器端，accept() 方法返回服務器上一個新的 socket 引用，該 socket 連接到客戶端的 socket。

連接建立後，通過使用 I/O 流在進行通信，每一個socket都有一個輸出流和一個輸入流，客戶端的輸出流連接到服務器端的輸入流，而客戶端的輸入流連接到服務器端的輸出流。

TCP 是一個雙向的通信協議，因此數據可以通過兩個數據流在同一時間發送.以下是一些類提供的一套完整的有用的方法來實現 socket。

ServerSocket 類的方法

服務器應用程序通過使用 java.net.ServerSocket 類以獲取一個端口,並且偵聽客戶端請求。

ServerSocket 類有四個構造方法：

序號	方法描述
1	public ServerSocket(int port) throws IOException 創建綁定到特定端口的服務器套接字。
2	public ServerSocket(int port, int backlog) throws IOException 利用指定的 backlog 創建服務器套接字並將其綁定到指定的本地端口號。
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException 使用指定的端口、偵聽 backlog 和要綁定到的本地 IP 地址創建服務器。
4	public ServerSocket() throws IOException 創建非綁定服務器套接字。

創建非綁定服務器套接字。 如果 ServerSocket 構造方法沒有拋出異常，就意味著你的應用程序已經成功綁定到指定的端口，並且偵聽客戶端請求。

這裏有一些 ServerSocket 類的常用方法：

序號	方法描述
1	public int getLocalPort() 返回此套接字在其上偵聽的端口。
2	public Socket accept() throws IOException 偵聽並接受到此套接字的連接。
3	public void setSoTimeout(int timeout) 通過指定超時值啟用/禁用 SO_TIMEOUT，以毫秒為單位。
4	public void bind(SocketAddress host, int backlog) 將 ServerSocket 綁定到特定地址（IP 地址和端口號）。

Socket 類的方法

java.net.Socket 類代表客戶端和服務器都用來互相溝通的套接字。客戶端要獲取一個 Socket 對象通過實例化 ，而 服務器獲得一個 Socket 對象則通過 accept() 方法的返回值。

Socket 類有五個構造方法.

序號	方法描述
1	public Socket(String host, int port) throws UnknownHostException, IOException. 創建一個流套接字並將其連接到指定主機上的指定端口號。
2	public Socket(InetAddress host, int port) throws IOException 創建一個流套接字並將其連接到指定 IP 地址的指定端口號。
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. 創建一個套接字並將其連接到指定遠程主機上的指定遠程端口。
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. 創建一個套接字並將其連接到指定遠程地址上的指定遠程端口。
5	public Socket() 通過系統默認類型的 SocketImpl 創建未連接套接字

當 Socket 構造方法返回，並沒有簡單的實例化了一個 Socket 對象，它實際上會嘗試連接到指定的服務器和端口。

下面列出了一些感興趣的方法，註意客戶端和服務器端都有一個 Socket 對象，所以無論客戶端還是服務端都能夠調用這些方法。

序號	方法描述
1	public void connect(SocketAddress host, int timeout) throws IOException 將此套接字連接到服務器，並指定一個超時值。
2	public InetAddress getInetAddress() 返回套接字連接的地址。
3	public int getPort() 返回此套接字連接到的遠程端口。
4	public int getLocalPort() 返回此套接字綁定到的本地端口。
5	public SocketAddress getRemoteSocketAddress() 返回此套接字連接的端點的地址，如果未連接則返回 null。
6	public InputStream getInputStream() throws IOException 返回此套接字的輸入流。
7	public OutputStream getOutputStream() throws IOException 返回此套接字的輸出流。
8	public void close() throws IOException 關閉此套接字。

InetAddress 類的方法

這個類表示互聯網協議(IP)地址。下面列出了 Socket 編程時比較有用的方法：

序號	方法描述
1	static InetAddress getByAddress(byte[] addr) 在給定原始 IP 地址的情況下，返回 InetAddress 對象。
2	static InetAddress getByAddress(String host, byte[] addr) 根據提供的主機名和 IP 地址創建 InetAddress。
3	static InetAddress getByName(String host) 在給定主機名的情況下確定主機的 IP 地址。
4	String getHostAddress() 返回 IP 地址字符串（以文本表現形式）。
5	String getHostName() 獲取此 IP 地址的主機名。
6	static InetAddress getLocalHost() 返回本地主機。
7	String toString() 將此 IP 地址轉換為 String。

Socket 客戶端實例

如下的 GreetingClient 是一個客戶端程序，該程序通過 socket 連接到服務器並發送一個請求，然後等待一個響應。

GreetingClient.java 文體代碼：

Socket 服務端實例

如下的GreetingServer 程序是一個服務器端應用程序，使用 Socket 來監聽一個指定的端口。

GreetingServer.java 文體代碼：

編譯以上兩個 java 文體代碼，並執行以下命令來啟動服務，使用端口號為 6066：

$ java GreetingServer 6066

Waiting for client on port 6066...

新開一個命令窗口，執行以上命令來開啟客戶端：

$ java GreetingClient localhost 6066

Connecting to localhost on port 6066

Just connected to localhost/127.0.0.1:6066

Server says Thank you for connecting to /127.0.0.1:6066

Goodbye!

更多教程 》

Java Applet 基礎

Applet 是一種 Java 程序。它一般運行在支持 Java 的 Web 瀏覽器內。因為它有完整的 Java API支持,所以Applet 是一個全功能的 Java 應用程序。

如下所示是獨立的 Java 應用程序和 applet 程序之間重要的不同：

Java 中 Applet 類繼承了 java.applet.Applet 類。

Applet 類沒有定義 main()，所以一個 Applet 程序不會調用 main() 方法。

Applet 被設計為嵌入在一個 HTML 頁面。

當用戶瀏覽包含 Applet 的 HTML 頁面，Applet 的代碼就被下載到用戶的機器上。

要查看一個 Applet 需要 JVM。 JVM 可以是 Web 瀏覽器的一個插體，或一個獨立的運行時環境。

用戶機器上的 JVM 創建一個 Applet 類的實例，並調用 Applet 生命周期過程中的各種方法。

Applet 有 Web 瀏覽器強制執行的嚴格的安全規則，Applet 的安全機制被稱為沙箱安全。

Applet 需要的其他類可以用 Java 歸檔（JAR）文體的形式下載下來。

Applet的生命周期

Applet 類中的四個方法給你提供了一個框架，你可以再該框架上開發小程序：

init: 該方法的目的是為你的 Applet 提供所需的任何初始化。在 Applet 標記內的 param 標簽被處理後調用該方法。

start: 瀏覽器調用 init 方法後，該方法被自動調用。每當用戶從其他頁面返回到包含 Applet 的頁面時，則調用該方法。

stop: 當用戶從包含 Applet 的頁面移除的時候，該方法自動被調用。因此，可以在相同的 Applet 中反復調用該方法。

destroy: 此方法僅當瀏覽器正常關閉時調用。因為 Applet 只有在 HTML 網頁上有效，所以你不應該在用戶離開包含 Applet 的頁面後遺漏任何資源。

paint: 該方法在 start() 方法之後立即被調用，或者在 Applet 需要重繪在瀏覽器的時候調用。paint() 方法實際上繼承於 java.awt。

"Hello, World" Applet:

下面是一個簡單的 Applet 程序 HelloWorldApplet.java:

HelloWorldApplet.java 文體代碼：

這些 import 語句將以下類導入到我們的 Applet 類中：

java.applet.Applet.

java.awt.Graphics.

沒有這些 import 語句，Java 編譯器就識別不了 Applet 和 Graphics 類。

Applet 類

每一個 Applet 都是 java.applet.Applet 類的子類，基礎的 Applet 類提供了供衍生類調用的方法,以此來得到瀏覽器上下文的信息和服務。

這些方法做了如下事情：

得到 Applet 的參數

得到包含 Applet 的 HTML 文體的網路位置

得到 Applet 類目錄的網路位置

打印瀏覽器的狀態信息

獲取一張圖片

獲取一個音頻片段

播放一個音頻片段

調整此 Applet 的大小

除此之外，Applet 類還提供了一個接口，該接口供 Viewer 或瀏覽器來獲取 Applet 的信息，並且來控制 Applet 的執行。

Viewer 可能是：

請求 Applet 作者、版本和版權的信息

請求 Applet 識別的參數的描述

初始化 Applet

銷毀 Applet

開始執行 Applet

結束執行 Applet

Applet 類提供了對這些方法的默認實現，這些方法可以在需要的時候重寫。

"Hello，World"applet 都是按標準編寫的。唯一被重寫的方法是 paint 方法。

Applet 的調用

Applet 是一種 Java 程序。它一般運行在支持 Java 的 Web 瀏覽器內。因為它有完整的 Java API 支持,所以 Applet 是一個全功能的 Java 應用程序。

<applet> 標簽是在HTML文體中嵌入 Applet 的基礎。以下是一個調用"Hello World"applet的例子；

HTML 代碼：

註意: 你可以參照 HTML Applet 標簽來更多的了解從 HTML 中調用 applet 的方法。

<applet> 標簽的屬性指定了要運行的 Applet 類。width 和 height 用來指定 Applet 運行面板的初始大小。Applet 必須使用 </applet> 標簽來關閉。

如果 Applet 接受參數，那麽參數的值需要在 <param> 標簽裏添加，該標簽位於 <applet> 和 </applet> 之間。瀏覽器忽略了 applet 標簽之間的文本和其他標簽。

不支持 Java 的瀏覽器不能執行 <applet> 和 </applet>。因此，在標簽之間顯示並且和 applet 沒有關系的任何東西，在不支持的 Java 的瀏覽器裏是可見的。

Viewer 或者瀏覽器在文檔的位置尋找編譯過的 Java 代碼，要指定文檔的路徑，得使用 <applet> 標簽的 codebase 屬性指定。

如下所示：

<applet codebase="https://amrood.com/applets"code="HelloWorldApplet.class" width="320" height="120">

如果 Applet 所在一個包中而不是默認包，那麽所在的包必須在 code 屬性裏指定，例如：

<applet code="mypackage.subpackage.TestApplet.class"width="320" height="120">

獲得applet參數

下面的例子演示了如何使用一個 Applet 響應來設置文體中指定的參數。該 Applet 顯示了一個黑色棋盤圖案和第二種顏色。

第二種顏色和每一列的大小通過文檔中的 Applet 的參數指定。

CheckerApplet 在 init() 方法裏得到它的參數。也可以在 paint() 方法裏得到它的參數。然而，在 Applet 開始得到值並保存了設置，而不是每一次刷新的時候都得到值，這樣是很方便，並且高效的。

Applet viewer 或者瀏覽器在 Applet 每次運行的時候調用 init() 方法。在加載 Applet 之後，Viewer 立即調用 init() 方法（Applet.init()什麽也沒做），重寫該方法的默認實現，添加一些自定義的初始化代碼。

Applet.getParameter() 方法通過給出參數名稱得到參數值。如果得到的值是數字或者其他非字符數據，那麽必須解析為字符串類型。

下例是 CheckerApplet.java 的修改：

CheckerApplet.java 文體代碼：

下面是 CheckerApplet 類的 init() 方法和私有的 parseSquareSize() 方法：

該 Applet 調用 parseSquareSize()，來解析 squareSize 參數。parseSquareSize() 調用了庫方法 Integer. parseInt() 該方法將一個字符串解析為一個整數，當參數無效的時候，Integer.parseInt() 拋出異常。

因此，parseSquareSize() 方法也是捕獲異常的，並不允許 Applet 接受無效的輸入。

Applet 調用 parseColor()方法將顏色參數解析為一個 Color 值。parseColor() 方法做了一系列字符串的比較，來匹配參數的值和預定義顏色的名字。你需要實現這些方法來使 Applet 工作。

指定 applet 參數

如下的例子是一個HTML文體，其中嵌入了 CheckerApplet 類。HTML文體通過使用 <param>標簽的方法給 applet 指定了兩個參數。

註意: 參數名字大小寫不敏感。

應用程序轉換成 Applet

將圖形化的 Java 應用程序（是指，使用AWT的應用程序和使用 java 程序啟動器啟動的程序）轉換成嵌入在web頁面裏的applet是很簡單的。

下面是將應用程序轉換成 Applet 的幾個步驟：

編寫一個 HTML 頁面，該頁面帶有能加載 applet 代碼的標簽。

編寫一個 JApplet 類的子類，將該類設置為 public。否則，Applet 不能被加載。

消除應用程序的 main()方法。不要為應用程序構造框架窗口，因為你的應用程序要顯示在瀏覽器中。

將應用程序中框架窗口的構造方法裏的初始化代碼移到 Applet 的 init() 方法中，你不必顯示的構造 Applet 對象，瀏覽器將通過調用 init() 方法來實例化一個對象。

移除對 setSize() 方法的調用，對於 Applet 來講，大小已經通過 HTML 文體裏的 width 和 height 參數設定好了。

移除對 setDefaultCloseOperation() 方法的調用。Applet 不能被關閉，它隨著瀏覽器的退出而終止。

如果應用程序調用了 setTitle() 方法，消除對該方法的調用。applet 不能有標題欄。（當然你可以給通過 html 的 title 標簽給網頁自身命名）

不要調用 setVisible(true),Applet 是自動顯示的。

事體處理

Applet 類從 Container 類繼承了許多事體處理方法。Container 類定義了幾個方法，例如：processKeyEvent() 和processMouseEvent()，用來處理特別類型的事體，還有一個捕獲所有事體的方法叫做 processEvent。

為了響應一個事體，Applet 必須重寫合適的事體處理方法。

ExampleEventHandling.java 文體代碼：

如下調用該 Applet：

最開始運行，Applet 顯示 "initializing the applet. Starting the applet."，然後你一點擊矩形框，就會顯示 "mouse clicked" 。

顯示圖片

Applet 能顯示 GIF,JPEG,BMP 等其他格式的圖片。為了在 Applet 中顯示圖片，你需要使用 java.awt.Graphics 類的drawImage()方法。

如下實例演示了顯示圖片的所有步驟：

ImageDemo.java 文體代碼：

如下調用該applet：

播放音頻

Applet 能通過使用 java.applet 包中的 AudioClip 接口播放音頻。AudioClip 接口定義了三個方法：

public void play(): 從一開始播放音頻片段一次。

public void loop(): 循環播放音頻片段

public void stop(): 停止播放音頻片段

為了得到 AudioClip 對象，你必須調用 Applet 類的 getAudioClip() 方法。無論 URL 指向的是否是一個真實的音頻文體，該方法都會立即返回結果。

直到要播放音頻文體時，該文體才會下載下來。

如下實例演示了播放音頻的所有步驟：

AudioDemo.java 文體代碼：

如下調用applet：

你可以使用你電腦上的 test.wav 來測試上面的實例。

更多教程 》

Java 8 新特性

Java 8 (又稱為 jdk 1.8) 是 Java 語言開發的一個主要版本。 Oracle 公司於 2014 年 3 月 18 日發布 Java 8 ，它支持函數式編程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。

新特性

Java8 新增了非常多的特性，我們主要討論以下幾個：

Lambda 表達式 − Lambda允許把函數作為一個方法的參數（函數作為參數傳遞進方法中。

方法引用 − 方法引用提供了非常有用的語法，可以直接引用已有Java類或對象（實例）的方法或構造器。與lambda聯合使用，方法引用可以使語言的構造更緊湊簡潔，減少冗余代碼。

默認方法 − 默認方法就是一個在接口裏面有了一個實現的方法。

新工具 − 新的編譯工具，如：Nashorn引擎 jjs、 類依賴分析器jdeps。

Stream API −新添加的Stream API（java.util.stream） 把真正的函數式編程風格引入到Java中。

Date Time API − 加強對日期與時間的處理。

Optional 類 − Optional 類已經成為 Java 8 類庫的一部分，用來解決空指針異常。

Nashorn, JavaScript 引擎 − Java 8提供了一個新的Nashorn javascript引擎，它允許我們在JVM上運行特定的javascript應用。

更多的新特性可以參閱官網：What's New in JDK 8

在關於 Java 8 文章的實例，我們均使用 jdk 1.8 環境，你可以使用以下命令查看當前 jdk 的版本：

$ java -version

java version "1.8.0_31"

Java(TM) SE Runtime Environment (build 1.8.0_31-b13)

Java HotSpot(TM) 64-Bit Server VM (build 25.31-b07, mixed mode)

編程風格

Java 8 希望有自己的編程風格，並與 Java 7 區別開，以下實例展示了 Java 7 和 Java 8 的編程格式：

Java8Tester.java 文體代碼：

執行以上腳本，輸出結果為：

$ javac Java8Tester.java

$ java Java8Tester

使用 Java 7 語法:

[Baidu , Google , Runoob , Sina , Taobao ]

使用 Java 8 語法:

[Baidu , Google , Runoob , Sina , Taobao ]

接下來我們總結 Java 8 的新特性：

序號	特性
1	Lambda 表達式
2	方法引用
3	函數式接口
4	默認方法
5	Stream
6	Optional 類
7	Nashorn, JavaScript 引擎
8	新的日期時間 API
9	Base64

更多教程 》