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平臺微型版)。

2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各類版本已經改名以取消其中的數字"2"：J2EE改名爲Java EE, J2SE改名爲Java SE，J2ME改名爲Java ME。

主要特性

• 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中的類有一個運行時刻的表示，能進行運行時刻的類型檢查。

發展歷史

• 1995年5月23日，Java語言誕生
• 1996年1月，第一個JDK-JDK1.0誕生
• 1996年4月，10個最主要的操做系統供應商申明將在其產品中嵌入JAVA技術
• 1996年9月，約8.3萬個網頁應用了JAVA技術來製做
• 1997年2月18日，JDK1.1發佈
• 1997年4月2日，JavaOne會議召開，參與者逾一萬人，創當時全球同類會議規模之紀錄
• 1997年9月，JavaDeveloperConnection社區成員超過十萬
• 1998年2月，JDK1.1被下載超過2,000,000次
• 1998年12月8日，JAVA2企業平臺J2EE發佈
• 1999年6月，SUN公司發佈Java的三個版本：標準版（JavaSE,之前是J2SE）、企業版（JavaEE之前是J2EE）和微型版（JavaME，之前是J2ME）
• 2000年5月8日，JDK1.3發佈
• 2000年5月29日，JDK1.4發佈
• 2001年6月5日，NOKIA宣佈，到2003年將出售1億部支持Java的手機
• 2001年9月24日，J2EE1.3發佈
• 2002年2月26日，J2SE1.4發佈，自此Java的計算能力有了大幅提高
• 2004年9月30日18:00PM，J2SE1.5發佈，成爲Java語言發展史上的又一里程碑。爲了表示該版本的重要性，J2SE1.5改名爲Java SE 5.0
• 2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各類版本已經改名，以取消其中的數字"2"：J2EE改名爲Java EE，J2SE改名爲Java SE，J2ME改名爲Java ME
• 2006年12月，SUN公司發佈JRE6.0
• 2009年04月20日，甲骨文74億美圓收購Sun。取得java的版權。
• 2010年11月，因爲甲骨文對於Java社區的不友善，所以Apache揚言將退出JCP[4]。
• 2011年7月28日，甲骨文發佈 Java7.0 的正式版。
• 2014年3月18日，Oracle公司發表 Java SE 8。
• 2017年9月21日，Oracle公司發表 Java SE 9
• 2018年3月21日，Oracle公司發表 Java SE 10
• 2018年9月25日，Java SE 11 發佈
• 2019年3月20日，Java SE 12 發佈

 

Java 開發環境配置

window系統安裝java

下載JDK

首先咱們須要下載java開發工具包JDK，下載地址：http://www.oracle.com/technetwork/java/javase/downloads/index.html

配置環境變量

變量設置參數以下：

• 變量名：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;

測試JDK是否安裝成功

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

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

 

Java 基礎語法

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

• 對象：對象是類的一個實例，有狀態和行爲。例如，一條狗是一個對象，它的狀態有：顏色、名字、品種；行爲有：搖尾巴、叫、吃等。
• 類：類是一個模板，它描述一類對象的行爲和狀態。
• 方法：方法就是行爲，一個類能夠有不少方法。邏輯運算、數據修改以及全部動做都是在方法中完成的。
• 實例變量：每一個對象都有獨特的實例變量，對象的狀態由這些實例變量的值決定。

基本語法

編寫 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, static, synchronized

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

---

Java 變量

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

• 局部變量
• 類變量（靜態變量）
• 成員變量（非靜態變量）

---

Java 數組

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

---

Java 枚舉

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

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

Java 關鍵字

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

類別	關鍵字	說明
訪問控制	private	私有的
	protected	受保護的
	public	公共的
類、方法和變量修飾符	abstract	聲明抽象
	class	類
	extends	擴充,繼承
	final	最終值,不可改變的
	implements	實現（接口）
	interface	接口
	native	本地，原生方法（非 Java 實現）
	new	新,建立
	static	靜態
	strictfp	嚴格,精準
	synchronized	線程,同步
	transient	短暫
	volatile	易失
程序控制語句	break	跳出循環
	case	定義一個值以供 switch 選擇
	continue	繼續
	default	默認
	do	運行
	else	不然
	for	循環
	if	若是
	instanceof	實例
	return	返回
	switch	根據值選擇執行
	while	循環
錯誤處理	assert	斷言表達式是否爲真
	catch	捕捉異常
	finally	有沒有異常都執行
	throw	拋出一個異常對象
	throws	聲明一個異常可能被拋出
	try	捕獲異常
包相關	import	引入
	package	包
基本類型	boolean	布爾型
	byte	字節型
	char	字符型
	double	雙精度浮點
	float	單精度浮點
	int	整型
	long	長整型
	short	短整型
變量引用	super	父類,超類
	this	本類
	void	無返回值
保留關鍵字	goto	是關鍵字，但不能使用
	const	是關鍵字，但不能使用
	null	空

 

Java 空行

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

---

繼承

在 Java 中，一個類能夠由其餘類派生。若是你要建立一個類，並且已經存在一個類具備你所須要的屬性或方法，那麼你能夠將新建立的類繼承該類。

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

---

接口

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

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

 

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

以下圖所示：

 

 

 

 

Java 對象和類

Java做爲一種面嚮對象語言。支持如下基本概念：

• 多態
• 繼承
• 封裝
• 抽象
• 類
• 對象
• 實例
• 方法
• 重載

本節咱們重點研究對象和類的概念。

• 對象：對象是類的一個實例（對象不是找個女友），有狀態和行爲。例如，一條狗是一個對象，它的狀態有：顏色、名字、品種；行爲有：搖尾巴、叫、吃等。
• 類：類是一個模板，它描述一類對象的行爲和狀態。

Java中的對象

 

如今讓咱們深刻了解什麼是對象。看看周圍真實的世界，會發現身邊有不少對象，車，狗，人等等。全部這些對象都有本身的狀態和行爲。

拿一條狗來舉例，它的狀態有：名字、品種、顏色，行爲有：叫、搖尾巴和跑。

對比現實對象和軟件對象，它們之間十分類似。

軟件對象也有狀態和行爲。軟件對象的狀態就是屬性，行爲經過方法體現。

在軟件開發中，方法操做對象內部狀態的改變，對象的相互調用也是經過方法來完成。

一個類能夠包含如下類型變量：

• 局部變量：在方法、構造方法或者語句塊中定義的變量被稱爲局部變量。變量聲明和初始化都是在方法中，方法結束後，變量就會自動銷燬。
• 成員變量：成員變量是定義在類中，方法體以外的變量。這種變量在建立對象的時候實例化。成員變量能夠被類中方法、構造方法和特定類的語句塊訪問。
• 類變量：類變量也聲明在類中，方法體以外，但必須聲明爲static類型。

構造方法

每一個類都有構造方法。若是沒有顯式地爲類定義構造方法，Java編譯器將會爲該類提供一個默認構造方法。

在建立一個對象的時候，至少要調用一個構造方法。構造方法的名稱必須與類同名，一個類能夠有多個構造方法。

建立對象

對象是根據類建立的。在Java中，使用關鍵字new來建立一個新的對象。建立對象須要如下三步：

• 聲明：聲明一個對象，包括對象名稱和對象類型。
• 實例化：使用關鍵字new來建立一個對象。
• 初始化：使用new建立對象時，會調用構造方法初始化對象。

訪問實例變量和方法

經過已建立的對象來訪問成員變量和成員方法，

 

源文件聲明規則

• 一個源文件中只能有一個public類
• 一個源文件能夠有多個非public類
• 源文件的名稱應該和public類的類名保持一致。例如：源文件中public類的類名是Employee，那麼源文件應該命名爲Employee.java。
• 若是一個類定義在某個包中，那麼package語句應該在源文件的首行。
• 若是源文件包含import語句，那麼應該放在package語句和類定義之間。若是沒有package語句，那麼import語句應該在源文件中最前面。
• import語句和package語句對源文件中定義的全部類都有效。在同一源文件中，不能給不一樣的類不一樣的包聲明。

類有若干種訪問級別，而且類也分不一樣的類型：抽象類和final類等。這些將在訪問控制章節介紹。

除了上面提到的幾種類型，Java還有一些特殊的類，如：內部類、匿名類。

 

Java包

包主要用來對類和接口進行分類。當開發Java程序時，可能編寫成百上千的類，所以頗有必要對類和接口進行分類。

Import語句

在Java中，若是給出一個完整的限定名，包括包名、類名，那麼Java編譯器就能夠很容易地定位到源代碼或者類。Import語句就是用來提供一個合理的路徑，使得編譯器能夠找到某個類。

 

 

 

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';。     
  

  類型默認值下表列出了 Java 各個類型的默認值

• 數據類型	默認值
  byte	0
  short	0
  int	0
  long	0L
  float	0.0f
  double	0.0d
  char	'u0000'
  String (or any object)	null
  boolean	false

 

 

 

 

 

 

引用類型

• 在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 強制轉換爲 byte 類型時，值 128 時候就會致使溢出。

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

  (int)23.7 == 23;         (int)-45.89f == -45

自動類型轉換

必須知足轉換前的數據類型的位數要低於轉換後的數據類型，例如: short數據類型的位數爲16位，就能夠自動轉換位數爲32的int類型，一樣float數據類型的位數爲32，能夠自動轉換爲64位的double類型。

 

強制類型轉換

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

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

隱含強制類型轉換

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

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

Java 變量類型

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

• 類變量：獨立於方法以外的變量，用 static 修飾。
• 實例變量：獨立於方法以外的變量，不過沒有 static 修飾。
• 局部變量：類的方法中的變量。

Java 局部變量

• 局部變量聲明在方法、構造方法或者語句塊中；
• 局部變量在方法、構造方法、或者語句塊被執行的時候建立，當它們執行完成後，變量將會被銷燬；
• 訪問修飾符不能用於局部變量；
• 局部變量只在聲明它的方法、構造方法或者語句塊中可見；
• 局部變量是在棧上分配的。
• 局部變量沒有默認值，因此局部變量被聲明後，必須通過初始化，纔可使用。

實例變量

• 實例變量聲明在一個類中，但在方法、構造方法和語句塊以外；
• 當一個對象被實例化以後，每一個實例變量的值就跟着肯定；
• 實例變量在對象建立的時候建立，在對象被銷燬的時候銷燬；
• 實例變量的值應該至少被一個方法、構造方法或者語句塊引用，使得外部可以經過這些方式獲取實例變量信息；
• 實例變量能夠聲明在使用前或者使用後；
• 訪問修飾符能夠修飾實例變量；
• 實例變量對於類中的方法、構造方法或者語句塊是可見的。通常狀況下應該把實例變量設爲私有。經過使用訪問修飾符可使實例變量對子類可見；
• 實例變量具備默認值。數值型變量的默認值是0，布爾型變量的默認值是false，引用類型變量的默認值是null。變量的值能夠在聲明時指定，也能夠在構造方法中指定；
• 實例變量能夠直接經過變量名訪問。但在靜態方法以及其餘類中，就應該使用徹底限定名：ObejectReference.VariableName。

類變量（靜態變量）

• 類變量也稱爲靜態變量，在類中以 static 關鍵字聲明，但必須在方法以外。
• 不管一個類建立了多少個對象，類只擁有類變量的一份拷貝。
• 靜態變量除了被聲明爲常量外不多使用。常量是指聲明爲public/private，final和static類型的變量。常量初始化後不可改變。
• 靜態變量儲存在靜態存儲區。常常被聲明爲常量，不多單獨使用static聲明變量。
• 靜態變量在第一次被訪問時建立，在程序結束時銷燬。
• 與實例變量具備類似的可見性。但爲了對類的使用者可見，大多數靜態變量聲明爲public類型。
• 默認值和實例變量類似。數值型變量默認值是0，布爾型默認值是false，引用類型默認值是null。變量的值能夠在聲明的時候指定，也能夠在構造方法中指定。此外，靜態變量還能夠在靜態語句塊中初始化。
• 靜態變量能夠經過：ClassName.VariableName的方式訪問。
• 類變量被聲明爲public static final類型時，類變量名稱通常建議使用大寫字母。若是靜態變量不是public和final類型，其命名方式與實例變量以及局部變量的命名方式一致。

 

Java 修飾符

Java語言提供了不少修飾符，主要分爲如下兩類：

• 訪問修飾符
• 非訪問修飾符

訪問控制修飾符

Java中，可使用訪問控制符來保護對類、變量、方法和構造方法的訪問。Java 支持 4 種不一樣的訪問權限。

• default (即默認，什麼也不寫）: 在同一包內可見，不使用任何修飾符。使用對象：類、接口、變量、方法。

• private : 在同一類內可見。使用對象：變量、方法。 注意：不能修飾類（外部類）

• public : 對全部類可見。使用對象：類、接口、變量、方法

• protected : 對同一包內的類和全部子類可見。使用對象：變量、方法。 注意：不能修飾類（外部類）。

咱們能夠經過如下表來講明訪問權限：

訪問控制

修飾符	當前類	同一包內	子孫類(同一包)	子孫類(不一樣包)	其餘包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N（說明）	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

默認訪問修飾符-不使用任何關鍵字

使用默認訪問修飾符聲明的變量和方法，對同一個包內的類是可見的。接口裏的變量都隱式聲明爲 public static final,而接口裏的方法默認狀況下訪問權限爲 public。

 

私有訪問修飾符-private

私有訪問修飾符是最嚴格的訪問級別，因此被聲明爲 private 的方法、變量和構造方法只能被所屬類訪問，而且類和接口不能聲明爲 private。

聲明爲私有訪問類型的變量只能經過類中公共的 getter 方法被外部類訪問。

Private 訪問修飾符的使用主要用來隱藏類的實現細節和保護類的數據。

公有訪問修飾符-public

被聲明爲 public 的類、方法、構造方法和接口可以被任何其餘類訪問。

若是幾個相互訪問的 public 類分佈在不一樣的包中，則須要導入相應 public 類所在的包。因爲類的繼承性，類全部的公有方法和變量都能被其子類繼承。

受保護的訪問修飾符-protected

protected 須要從如下兩個點來分析說明：

• 子類與基類在同一包中：被聲明爲 protected 的變量、方法和構造器能被同一個包中的任何其餘類訪問；

• 子類與基類不在同一包中：那麼在子類中，子類實例能夠訪問其從基類繼承而來的 protected 方法，而不能訪問基類實例的protected方法。

protected 能夠修飾數據成員，構造方法，方法成員，不能修飾類（內部類除外）。

 

 

訪問控制和繼承

請注意如下方法繼承的規則：

• 父類中聲明爲 public 的方法在子類中也必須爲 public。

• 父類中聲明爲 protected 的方法在子類中要麼聲明爲 protected，要麼聲明爲 public，不能聲明爲 private。

• 父類中聲明爲 private 的方法，不可以被繼承。

---

非訪問修飾符

爲了實現一些其餘的功能，Java 也提供了許多非訪問修飾符。

static 修飾符，用來修飾類方法和類變量。

final 修飾符，用來修飾類、方法和變量，final 修飾的類不可以被繼承，修飾的方法不能被繼承類從新定義，修飾的變量爲常量，是不可修改的。

abstract 修飾符，用來建立抽象類和抽象方法。

synchronized 和 volatile 修飾符，主要用於線程的編程。

static 修飾符

• 靜態變量：

  static 關鍵字用來聲明獨立於對象的靜態變量，不管一個類實例化多少對象，它的靜態變量只有一份拷貝。 靜態變量也被稱爲類變量。局部變量不能被聲明爲 static 變量。

• 靜態方法：

  static 關鍵字用來聲明獨立於對象的靜態方法。靜態方法不能使用類的非靜態變量。靜態方法從參數列表獲得數據，而後計算這些數據。

對類變量和方法的訪問能夠直接使用 classname.variablename 和 classname.methodname 的方式訪問。

 

final 修飾符

final 變量：

final 表示"最後的、最終的"含義，變量一旦賦值後，不能被從新賦值。被 final 修飾的實例變量必須顯式指定初始值。

final 修飾符一般和 static 修飾符一塊兒使用來建立類常量。

final 方法

父類中的 final 方法能夠被子類繼承，可是不能被之類重寫。

聲明 final 方法的主要目的是防止該方法的內容被修改。

final 類

final 類不能被繼承，沒有類可以繼承 final 類的任何特性。

abstract 修飾符

抽象類：

抽象類不能用來實例化對象，聲明抽象類的惟一目的是爲了未來對該類進行擴充。

一個類不能同時被 abstract 和 final 修飾。若是一個類包含抽象方法，那麼該類必定要聲明爲抽象類，不然將出現編譯錯誤。

抽象類能夠包含抽象方法和非抽象方法。

抽象方法

抽象方法是一種沒有任何實現的方法，該方法的的具體實現由子類提供。

抽象方法不能被聲明成 final 和 static。

任何繼承抽象類的子類必須實現父類的全部抽象方法，除非該子類也是抽象類。

若是一個類包含若干個抽象方法，那麼該類必須聲明爲抽象類。抽象類能夠不包含抽象方法。

synchronized 修飾符

synchronized 關鍵字聲明的方法同一時間只能被一個線程訪問。synchronized 修飾符能夠應用於四個訪問修飾符。

transient 修飾符

序列化的對象包含被 transient 修飾的實例變量時，java 虛擬機(JVM)跳過該特定的變量。

該修飾符包含在定義變量的語句中，用來預處理類和變量的數據類型。

volatile 修飾符

volatile 修飾的成員變量在每次被線程訪問時，都強制從共享內存中從新讀取該成員變量的值。並且，當成員變量發生變化時，會強制線程將變化值回寫到共享內存。這樣在任什麼時候刻，兩個不一樣的線程老是看到某個成員變量的同一個值。

一個 volatile 對象引用多是 null。

 

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（區別詳見下文）

自增自減運算符

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

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

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

 

關係運算符

下表爲Java支持的關係運算符

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

運算符	描述	例子
==	檢查若是兩個操做數的值是否相等，若是相等則條件爲真。	（A == B）爲假。
!=	檢查若是兩個操做數的值是否相等，若是值不相等則條件爲真。	(A != B) 爲真。
>	檢查左操做數的值是否大於右操做數的值，若是是那麼條件爲真。	（A> B）爲假。
<	檢查左操做數的值是否小於右操做數的值，若是是那麼條件爲真。	（A <B）爲真。
>=	檢查左操做數的值是否大於或等於右操做數的值，若是是那麼條件爲真。	（A> = B）爲假。
<=	檢查左操做數的值是否小於或等於右操做數的值，若是是那麼條件爲真。	（A <= B）爲真。

位運算符

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

位運算符做用在全部的位上，而且按位運算。

下表列出了位運算符的基本運算,假設整數變量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爲真，變量B爲假

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

賦值運算符

下面是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

條件運算符（?:）

條件運算符也被稱爲三元運算符。該運算符有3個操做數，而且須要判斷布爾表達式的值。該運算符的主要是決定哪一個值應該賦值給變量。

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

instanceof 運算符

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

instanceof運算符使用格式以下：

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

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 循環

while 循環

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

while( 布爾表達式 ) { //循環內容 }

do…while 循環

對於 while 語句而言，若是不知足條件，則不能進入循環。但有時候咱們須要即便不知足條件，也至少執行一次。

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

do { //代碼語句 }while(布爾表達式);

for循環

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

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

for(初始化; 布爾表達式; 更新) { //代碼語句 }

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

• 最早執行初始化步驟。能夠聲明一種類型，但可初始化一個或多個循環控制變量，也能夠是空語句。
• 而後，檢測布爾表達式的值。若是爲 true，循環體被執行。若是爲false，循環終止，開始執行循環體後面的語句。
• 執行一次循環後，更新循環控制變量。
• 再次檢測布爾表達式。循環執行上面的過程。

Java 加強 for 循環

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

Java 加強 for 循環語法格式以下:

for(聲明語句 : 表達式) { //代碼句子 }

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

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

 

break 關鍵字

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

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

語法

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

continue 關鍵字

continue 適用於任何循環控制結構中。做用是讓程序馬上跳轉到下一次循環的迭代。

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

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

語法

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

 

Java 條件語句 - if...else

語法

if 語句的語法以下：

if(布爾表達式) { //若是布爾表達式爲true將執行的語句 }

if...else語句

if 語句後面能夠跟 else 語句，當 if 語句的布爾表達式值爲 false 時，else 語句塊會被執行。

語法

if…else 的用法以下：

if(布爾表達式){ //若是布爾表達式的值爲true }else{ //若是布爾表達式的值爲false }

if...else if...else 語句

if 語句後面能夠跟 else if…else 語句，這種語句能夠檢測到多種可能的狀況。

使用 if，else if，else 語句的時候，須要注意下面幾點：

• if 語句至多有 1 個 else 語句，else 語句在全部的 else if 語句以後。
• if 語句能夠有若干個 else if 語句，它們必須在 else 語句以前。
• 一旦其中一個 else if 語句檢測爲 true，其餘的 else if 以及 else 語句都將跳過執行。

嵌套的 if…else 語句

使用嵌套的 if…else 語句是合法的。也就是說你能夠在另外一個 if 或者 else if 語句中使用 if 或者 else if 語句。

語法

嵌套的 if…else 語法格式以下：

if(布爾表達式 1){ ////若是布爾表達式 1的值爲true執行代碼 if(布爾表達式 2){ ////若是布爾表達式 2的值爲true執行代碼 } }

Java switch case 語句

語法

switch case 語句語法格式以下：

switch(expression){ case value : //語句 break; //可選 case value : //語句 break; //可選 //你能夠有任意數量的case語句 default : //可選 //語句 }

switch case 語句有以下規則：

• switch 語句中的變量類型能夠是： byte、short、int 或者 char。從 Java SE 7 開始，switch 支持字符串 String 類型了，同時 case 標籤必須爲字符串常量或字面量。

• switch 語句能夠擁有多個 case 語句。每一個 case 後面跟一個要比較的值和冒號。

• case 語句中的值的數據類型必須與變量的數據類型相同，並且只能是常量或者字面常量。

• 當變量的值與 case 語句的值相等時，那麼 case 語句以後的語句開始執行，直到 break 語句出現纔會跳出 switch 語句。

• 當遇到 break 語句時，switch 語句終止。程序跳轉到 switch 語句後面的語句執行。case 語句沒必要需要包含 break 語句。若是沒有 break 語句出現，程序會繼續執行下一條 case 語句，直到出現 break 語句。

• switch 語句能夠包含一個 default 分支，該分支通常是 switch 語句的最後一個分支（能夠在任何位置，但建議在最後一個）。default 在沒有 case 語句的值和變量值相等的時候執行。default 分支不須要 break 語句。

switch case 執行時，必定會先進行匹配，匹配成功返回當前 case 的值，再根據是否有 break，判斷是否繼續輸出，或是跳出判斷。

Java Number & Math 類

當須要使用數字的時候，咱們一般使用內置數據類型，如：byte、int、long、double 等。

全部的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類 Number 的子類。

Java Math 類

Java 的 Math 包含了用於執行基本數學運算的屬性和方法，如初等指數、對數、平方根和三角函數。

Math 的方法都被定義爲 static 形式，經過 Math 類能夠在主函數中直接調用。

Number & Math 類方法

下面的表中列出的是 Number & Math 類經常使用的一些方法：

序號	方法與描述
1	xxxValue() 將 Number 對象轉換爲xxx數據類型的值並返回。
2	compareTo() 將number對象與參數比較。
3	equals() 判斷number對象是否與參數相等。
4	valueOf() 返回一個 Number 對象指定的內置數據類型
5	toString() 以字符串形式返回值。
6	parseInt() 將字符串解析爲int類型。
7	abs() 返回參數的絕對值。
8	ceil() 返回大於等於( >= )給定參數的的最小整數，類型爲雙精度浮點型。
9	floor() 返回小於等於（<=）給定參數的最大整數 。
10	rint() 返回與參數最接近的整數。返回類型爲double。
11	round() 它表示四捨五入，算法爲 Math.floor(x+0.5)，即將原來的數字加上 0.5 後再向下取整，因此，Math.round(11.5) 的結果爲12，Math.round(-11.5) 的結果爲-11。
12	min() 返回兩個參數中的最小值。
13	max() 返回兩個參數中的最大值。
14	exp() 返回天然數底數e的參數次方。
15	log() 返回參數的天然數底數的對數值。
16	pow() 返回第一個參數的第二個參數次方。
17	sqrt() 求參數的算術平方根。
18	sin() 求指定double類型參數的正弦值。
19	cos() 求指定double類型參數的餘弦值。
20	tan() 求指定double類型參數的正切值。
21	asin() 求指定double類型參數的反正弦值。
22	acos() 求指定double類型參數的反餘弦值。
23	atan() 求指定double類型參數的反正切值。
24	atan2() 將笛卡爾座標轉換爲極座標，並返回極座標的角度值。
25	toDegrees() 將參數轉化爲角度。
26	toRadians() 將角度轉換爲弧度。
27	random() 返回一個隨機數。

---

Math 的 floor,round 和 ceil 方法實例比較

參數	Math.floor	Math.round	Math.ceil
1.4	1	1	2
1.5	1	2	2
1.6	1	2	2
-1.4	-2	-1	-1
-1.5	-2	-1	-1
-1.6	-2	-2	-1

Java Character 類

Character 類用於對單個字符進行操做。

Character 類在對象中包裝一個基本類型 char 的值

 

實例

char ch = 'a'; // Unicode 字符表示形式 char uniChar = '\u039A'; // 字符數組 char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

 

 

 

 

 

 

轉義序列

前面有反斜槓（\）的字符表明轉義字符，它對編譯器來講是有特殊含義的。

下面列表展現了Java的轉義序列：

轉義序列	描述
\t	在文中該處插入一個tab鍵
\b	在文中該處插入一個後退鍵
\n	在文中該處換行
\r	在文中該處插入回車
\f	在文中該處插入換頁符
\'	在文中該處插入單引號
\"	在文中該處插入雙引號
\\	在文中該處插入反斜槓

Character 方法

下面是Character類的方法：

序號	方法與描述
1	isLetter() 是不是一個字母
2	isDigit() 是不是一個數字字符
3	isWhitespace() 是不是一個空白字符
4	isUpperCase() 是不是大寫字母
5	isLowerCase() 是不是小寫字母
6	toUpperCase() 指定字母的大寫形式
7	toLowerCase() 指定字母的小寫形式
8	toString() 返回字符的字符串形式，字符串的長度僅爲1

Java String 類

字符串普遍應用 在 Java 編程中，在 Java 中字符串屬於對象，Java 提供了 String 類來建立和操做字符串。

建立字符串最簡單的方式以下:

String greeting = "這是一個字符串";

字符串長度

 

用於獲取有關對象的信息的方法稱爲訪問器方法。

String 類的一個訪問器方法是 length() 方法，它返回字符串對象包含的字符數。

建立格式化字符串

咱們知道輸出格式化數字可使用 printf() 和 format() 方法。

String 類使用靜態方法 format() 返回一個String 對象而不是 PrintStream 對象。

String 類的靜態方法 format() 能用來建立可複用的格式化字符串，而不只僅是用於一次打印輸出。

 

String 方法

下面是 String 類支持的方法，更多詳細，參看 Java String API 文檔:

SN(序號)	方法描述
1	char charAt(int index) 返回指定索引處的 char 值。
2	int compareTo(Object o) 把這個字符串和另外一個對象比較。
3	int compareTo(String anotherString) 按字典順序比較兩個字符串。
4	int compareToIgnoreCase(String str) 按字典順序比較兩個字符串，不考慮大小寫。
5	String concat(String str) 將指定字符串鏈接到此字符串的結尾。
6	boolean contentEquals(StringBuffer sb) 當且僅當字符串與指定的StringBuffer有相同順序的字符時候返回真。
7	static String copyValueOf(char[] data) 返回指定數組中表示該字符序列的 String。
8	static String copyValueOf(char[] data, int offset, int count) 返回指定數組中表示該字符序列的 String。
9	boolean endsWith(String suffix) 測試此字符串是否以指定的後綴結束。
10	boolean equals(Object anObject) 將此字符串與指定的對象比較。
11	boolean equalsIgnoreCase(String anotherString) 將此 String 與另外一個 String 比較，不考慮大小寫。
12	byte[] getBytes()  使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
13	byte[] getBytes(String charsetName) 使用指定的字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
14	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 將字符今後字符串複製到目標字符數組。
15	int hashCode() 返回此字符串的哈希碼。
16	int indexOf(int ch) 返回指定字符在此字符串中第一次出現處的索引。
17	int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
18	int indexOf(String str)  返回指定子字符串在此字符串中第一次出現處的索引。
19	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
20	String intern()  返回字符串對象的規範化表示形式。
21	int lastIndexOf(int ch)  返回指定字符在此字符串中最後一次出現處的索引。
22	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。
23	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右邊出現處的索引。
24	int lastIndexOf(String str, int fromIndex)  返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。
25	int length() 返回此字符串的長度。
26	boolean matches(String regex) 告知此字符串是否匹配給定的正則表達式。
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 測試兩個字符串區域是否相等。
28	boolean regionMatches(int toffset, String other, int ooffset, int len) 測試兩個字符串區域是否相等。
29	String replace(char oldChar, char newChar) 返回一個新的字符串，它是經過用 newChar 替換此字符串中出現的全部 oldChar 獲得的。
30	String replaceAll(String regex, String replacement) 使用給定的 replacement 替換此字符串全部匹配給定的正則表達式的子字符串。
31	String replaceFirst(String regex, String replacement)  使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
32	String[] split(String regex) 根據給定正則表達式的匹配拆分此字符串。
33	String[] split(String regex, int limit) 根據匹配給定的正則表達式來拆分此字符串。
34	boolean startsWith(String prefix) 測試此字符串是否以指定的前綴開始。
35	boolean startsWith(String prefix, int toffset) 測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
36	CharSequence subSequence(int beginIndex, int endIndex)  返回一個新的字符序列，它是此序列的一個子序列。
37	String substring(int beginIndex) 返回一個新的字符串，它是此字符串的一個子字符串。
38	String substring(int beginIndex, int endIndex) 返回一個新字符串，它是此字符串的一個子字符串。
39	char[] toCharArray() 將此字符串轉換爲一個新的字符數組。
40	String toLowerCase() 使用默認語言環境的規則將此 String 中的全部字符都轉換爲小寫。
41	String toLowerCase(Locale locale)  使用給定 Locale 的規則將此 String 中的全部字符都轉換爲小寫。
42	String toString()  返回此對象自己（它已是一個字符串！）。
43	String toUpperCase() 使用默認語言環境的規則將此 String 中的全部字符都轉換爲大寫。
44	String toUpperCase(Locale locale) 使用給定 Locale 的規則將此 String 中的全部字符都轉換爲大寫。
45	String trim() 返回字符串的副本，忽略前導空白和尾部空白。
46	static String valueOf(primitive data type x) 返回給定data type類型x參數的字符串表示形式。

Java StringBuffer 和 StringBuilder 類

當對字符串進行修改的時候，須要使用 StringBuffer 和 StringBuilder 類。

和 String 類不一樣的是，StringBuffer 和 StringBuilder 類的對象可以被屢次的修改，而且不產生新的未使用對象。

StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不一樣在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。

因爲 StringBuilder 相較於 StringBuffer 有速度優點，因此多數狀況下建議使用 StringBuilder 類。然而在應用程序要求線程安全的狀況下，則必須使用 StringBuffer 類。

StringBuffer 方法

如下是 StringBuffer 類支持的主要方法：

序號	方法描述
1	public StringBuffer append(String s) 將指定的字符串追加到此字符序列。
2	public StringBuffer reverse()  將此字符序列用其反轉形式取代。
3	public delete(int start, int end) 移除此序列的子字符串中的字符。
4	public insert(int offset, int i) 將 int 參數的字符串表示形式插入此序列中。
5	replace(int start, int end, String str) 使用給定 String 中的字符替換此序列的子字符串中的字符。

下面的列表裏的方法和 String 類的方法相似：

序號	方法描述
1	int capacity() 返回當前容量。
2	char charAt(int index) 返回此序列中指定索引處的 char 值。
3	void ensureCapacity(int minimumCapacity) 確保容量至少等於指定的最小值。
4	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 將字符今後序列複製到目標字符數組 dst。
5	int indexOf(String str) 返回第一次出現的指定子字符串在該字符串中的索引。
6	int indexOf(String str, int fromIndex) 從指定的索引處開始，返回第一次出現的指定子字符串在該字符串中的索引。
7	int lastIndexOf(String str) 返回最右邊出現的指定子字符串在此字符串中的索引。
8	int lastIndexOf(String str, int fromIndex) 返回 String 對象中子字符串最後出現的位置。
9	int length()  返回長度（字符數）。
10	void setCharAt(int index, char ch) 將給定索引處的字符設置爲 ch。
11	void setLength(int newLength) 設置字符序列的長度。
12	CharSequence subSequence(int start, int end) 返回一個新的字符序列，該字符序列是此序列的子序列。
13	String substring(int start) 返回一個新的 String，它包含此字符序列當前所包含的字符子序列。
14	String substring(int start, int end) 返回一個新的 String，它包含此序列當前所包含的字符子序列。
15	String toString() 返回此序列中數據的字符串表示形式。

Java 數組

聲明數組變量

首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法：

dataType[] arrayRefVar; // 首選的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首選方法

建立數組

Java語言使用new操做符來建立數組，語法以下：

arrayRefVar = new dataType[arraySize];

處理數組

數組的元素類型和數組的大小都是肯定的，因此當處理數組元素時候，咱們一般使用基本循環或者 For-Each 循環。

For-Each 循環

JDK 1.5 引進了一種新的循環類型，被稱爲 For-Each 循環或者增強型循環，它能在不使用下標的狀況下遍歷數組。

數組做爲函數的參數

數組能夠做爲參數傳遞給方法。

多維數組

多維數組能夠當作是數組的數組，好比二維數組就是一個特殊的一維數組，其每個元素都是一個一維數組，例如：

String str[][] = new String[3][4];

 

多維數組的動態初始化（以二維數組爲例）

1. 直接爲每一維分配空間，格式以下：

type[][] typeName = new type[typeLength1][typeLength2];

type 能夠爲基本數據類型和複合數據類型，arraylength1 和 arraylength2 必須爲正整數，arraylength1 爲行數，arraylength2 爲列數。

例如：

int a[][] = new int[2][3];

 

 

 

 

 

Arrays 類

java.util.Arrays 類能方便地操做數組，它提供的全部方法都是靜態的。

具備如下功能：

• 給數組賦值：經過 fill 方法。
• 對數組排序：經過 sort 方法,按升序。
• 比較數組：經過 equals 方法比較數組中元素值是否相等。
• 查找數組元素：經過 binarySearch 方法能對排序好的數組進行二分查找法操做。

具體說明請查看下錶：

序號	方法和說明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。若是查找值包含在數組中，則返回搜索鍵的索引；不然返回 (-(插入點) - 1)。
2	public static boolean equals(long[] a, long[] a2) 若是兩個指定的 long 型數組彼此相等，則返回 true。若是兩個數組包含相同數量的元素，而且兩個數組中的全部相應元素對都是相等的，則認爲這兩個數組是相等的。換句話說，若是兩個數組以相同順序包含相同的元素，則兩個數組是相等的。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 將指定的 int 值分配給指定 int 型數組指定範圍中的每一個元素。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。
4	public static void sort(Object[] a) 對指定對象數組根據其元素的天然順序進行升序排列。一樣的方法適用於全部的其餘基本數據類型（Byte，short，Int等）。

Java 日期時間

java.util 包提供了 Date 類來封裝當前的日期和時間。 Date 類提供兩個構造函數來實例化 Date 對象。

第一個構造函數使用當前日期和時間來初始化對象。

Date( )

第二個構造函數接收一個參數，該參數是從1970年1月1日起的毫秒數。

Date(long millisec)

 

Date對象建立之後，能夠調用下面的方法。

序號	方法和描述
1	boolean after(Date date) 若當調用此方法的Date對象在指定日期以後返回true,不然返回false。
2	boolean before(Date date) 若當調用此方法的Date對象在指定日期以前返回true,不然返回false。
3	Object clone( ) 返回此對象的副本。
4	int compareTo(Date date) 比較當調用此方法的Date對象和指定日期。二者相等時候返回0。調用對象在指定日期以前則返回負數。調用對象在指定日期以後則返回正數。
5	int compareTo(Object obj) 若obj是Date類型則操做等同於compareTo(Date) 。不然它拋出ClassCastException。
6	boolean equals(Object date) 當調用此方法的Date對象和指定日期相等時候返回true,不然返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。
8	int hashCode( )  返回此對象的哈希碼值。
9	void setTime(long time)   用自1970年1月1日00:00:00 GMT之後time毫秒數設置時間和日期。
10	String toString( ) 把此 Date 對象轉換爲如下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一週中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

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 是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。

捕獲組

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

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

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

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

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

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

正則表達式語法

在其餘語言中，\\ 表示：我想要在正則表達式中插入一個普通的（字面上的）反斜槓，請不要給它任何特殊的意義。

在 Java 中，\\ 表示：我要插入一個正則表達式的反斜線，因此其後的字符具備特殊的意義。

因此，在其餘的語言中（如Perl），一個反斜槓 \ 就足以具備轉義的做用，而在 Java 中正則表達式中則須要有兩個反斜槓才能被解析爲其餘語言中的轉義做用。也能夠簡單的理解在 Java 的正則表達式中，兩個 \\ 表明其餘語言中的一個 \，這也就是爲何表示一位數字的正則表達式是 \\d，而表示一個普通的反斜槓是 \\\\。

字符	說明
\	將下一字符標記爲特殊字符、文本、反向引用或八進制轉義符。例如，"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 方法一個字面字符串同樣工做。

Java 方法

• println() 是一個方法。
• System 是系統類。
• out 是標準輸出對象。

這句話的用法是調用系統類 System 中的標準輸出對象 out 中的方法 println()。

 

那麼什麼是方法呢？

Java方法是語句的集合，它們在一塊兒執行一個功能。

• 方法是解決一類問題的步驟的有序組合
• 方法包含於類或對象中
• 方法在程序中被建立，在其餘地方被引用

方法的優勢

• 1. 使程序變得更簡短而清晰。
• 2. 有利於程序維護。
• 3. 能夠提升程序開發的效率。
• 4. 提升了代碼的重用性。

方法的命名規則

• 1.方法的名字的第一個單詞應以小寫字母做爲開頭，後面的單詞則用大寫字母開頭寫，不使用鏈接符。例如：addPerson。
• 2.下劃線可能出如今 JUnit 測試方法名稱中用以分隔名稱的邏輯組件。一個典型的模式是：test<MethodUnderTest>_<state>，例如 testPop_emptyStack。

---

方法的定義

通常狀況下，定義一個方法包含如下語法：

修飾符 返回值類型 方法名(參數類型 參數名){ ... 方法體 ... return 返回值; }

方法包含一個方法頭和一個方法體。下面是一個方法的全部部分：

• 修飾符：修飾符，這是可選的，告訴編譯器如何調用該方法。定義了該方法的訪問類型。
• 返回值類型 ：方法可能會返回值。returnValueType 是方法返回值的數據類型。有些方法執行所需的操做，但沒有返回值。在這種狀況下，returnValueType 是關鍵字void。
• 方法名：是方法的實際名稱。方法名和參數表共同構成方法簽名。
• 參數類型：參數像是一個佔位符。當方法被調用時，傳遞值給參數。這個值被稱爲實參或變量。參數列表是指方法的參數類型、順序和參數的個數。參數是可選的，方法能夠不包含任何參數。
• 方法體：方法體包含具體的語句，定義該方法的功能。

方法調用

Java 支持兩種調用方法的方式，根據方法是否返回值來選擇。

當程序調用一個方法時，程序的控制權交給了被調用的方法。當被調用方法的返回語句執行或者到達方法體閉括號時候交還控制權給程序。

經過值傳遞參數

調用一個方法時候須要提供參數，你必須按照參數列表指定的順序提供。

 

變量做用域

變量的範圍是程序中該變量能夠被引用的部分。

方法內定義的變量被稱爲局部變量。

局部變量的做用範圍從聲明開始，直到包含它的塊結束。

局部變量必須聲明纔可使用。

方法的參數範圍涵蓋整個方法。參數其實是一個局部變量。

for循環的初始化部分聲明的變量，其做用範圍在整個循環。

但循環體內聲明的變量其適用範圍是從它聲明到循環體結束。它包含以下所示的變量聲明：

你能夠在一個方法裏，不一樣的非嵌套塊中屢次聲明一個具備相同的名稱局部變量，但你不能在嵌套塊內兩次聲明局部變量。

命令行參數的使用

有時候你但願運行一個程序時候再傳遞給它消息。這要靠傳遞命令行參數給main()函數實現。

命令行參數是在執行程序時候緊跟在程序名字後面的信息。

構造方法

當一個對象被建立時候，構造方法用來初始化該對象。構造方法和它所在類的名字相同，但構造方法沒有返回值。

一般會使用構造方法給一個類的實例變量賦初值，或者執行其它必要的步驟來建立一個完整的對象。

無論你是否自定義構造方法，全部的類都有構造方法，由於Java自動提供了一個默認構造方法，默認構造方法的訪問修改符和類的訪問修改符相同(類爲 public，構造函數也爲 public；類改成 private，構造函數也改成 private)。

一旦你定義了本身的構造方法，默認構造方法就會失效。

可變參數

JDK 1.5 開始，Java支持傳遞同類型的可變參數給一個方法。

finalize() 方法

Java 容許定義這樣的方法，它在對象被垃圾收集器析構(回收)以前調用，這個方法叫作 finalize( )，它用來清除回收對象。

例如，你可使用 finalize() 來確保一個對象打開的文件被關閉了。

在 finalize() 方法裏，你必須指定在對象銷燬時候要執行的操做。

finalize() 通常格式是：

protected void finalize() { // 在這裏終結代碼 }

關鍵字 protected 是一個限定符，它確保 finalize() 方法不會被該類之外的代碼調用。

 

Java 流(Stream)、文件(File)和IO

Java.io 包幾乎包含了全部操做輸入、輸出須要的類。全部這些流類表明了輸入源和輸出目標。

Java.io 包中的流支持不少種格式，好比：基本類型、對象、本地化字符集等等。

一個流能夠理解爲一個數據的序列。輸入流表示從一個源讀取數據，輸出流表示向一個目標寫數據。

Java 爲 I/O 提供了強大的而靈活的支持，使其更普遍地應用到文件傳輸和網絡編程中。

但本節講述最基本的和流與 I/O 相關的功能。咱們將經過一個個例子來學習這些功能。

---

讀取控制檯輸入

Java 的控制檯輸入由 System.in 完成。

爲了得到一個綁定到控制檯的字符流，你能夠把 System.in 包裝在一個 BufferedReader 對象中來建立一個字符流。

下面是建立 BufferedReader 的基本語法：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

BufferedReader 對象建立後，咱們即可以使用 read() 方法從控制檯讀取一個字符，或者用 readLine() 方法讀取一個字符串。

---

從控制檯讀取多字符輸入

從 BufferedReader 對象讀取一個字符要使用 read() 方法，它的語法以下：

int read( ) throws IOException

每次調用 read() 方法，它從輸入流讀取一個字符並把該字符做爲整數值返回。 當流結束的時候返回 -1。該方法拋出 IOException。

從控制檯讀取字符串

從標準輸入讀取一個字符串須要使用 BufferedReader 的 readLine() 方法。

它的通常格式是：

String readLine( ) throws IOException

 

控制檯輸出

在此前已經介紹過，控制檯的輸出由 print( ) 和 println() 完成。這些方法都由類 PrintStream 定義，System.out 是該類對象的一個引用。

PrintStream 繼承了 OutputStream類，而且實現了方法 write()。這樣，write() 也能夠用來往控制檯寫操做。

PrintStream 定義 write() 的最簡單格式以下所示：

void write(int byteval)

該方法將 byteval 的低八位字節寫到流中。

讀寫文件

如前所述，一個流被定義爲一個數據序列。輸入流用於從源讀取數據，輸出流用於向目標寫數據。

下圖是一個描述輸入流和輸出流的類層次圖。

下面將要討論的兩個重要的流是 FileInputStream 和 FileOutputStream：

---

FileInputStream

該流用於從文件讀取數據，它的對象能夠用關鍵字 new 來建立。

有多種構造方法可用來建立對象。

可使用字符串類型的文件名來建立一個輸入流對象來讀取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可使用一個文件對象來建立一個輸入流對象來讀取文件。咱們首先得使用 File() 方法來建立一個文件對象：

File f = new File("C:/java/hello"); InputStream out = new FileInputStream(f);

建立了InputStream對象，就可使用下面的方法來讀取流或者進行其餘的流操做。

序號	方法及描述
1	public void close() throws IOException{} 關閉此文件輸入流並釋放與此流有關的全部系統資源。拋出IOException異常。
2	protected void finalize()throws IOException {} 這個方法清除與該文件的鏈接。確保在再也不引用文件輸入流時調用其 close 方法。拋出IOException異常。
3	public int read(int r)throws IOException{} 這個方法從 InputStream 對象讀取指定字節的數據。返回爲整數值。返回下一字節數據，若是已經到結尾則返回-1。
4	public int read(byte[] r) throws IOException{} 這個方法從輸入流讀取r.length長度的字節。返回讀取的字節數。若是是文件結尾則返回-1。
5	public int available() throws IOException{} 返回下一次對此輸入流調用的方法能夠不受阻塞地今後輸入流讀取的字節數。返回一個整數值。

除了 InputStream 外，還有一些其餘的輸入流，更多的細節參考下面連接：

• ByteArrayInputStream
• DataInputStream

---

FileOutputStream

該類用來建立一個文件並向文件中寫數據。

若是該流在打開文件進行輸出前，目標文件不存在，那麼該流會建立該文件。

有兩個構造方法能夠用來建立 FileOutputStream 對象。

使用字符串類型的文件名來建立一個輸出流對象：

OutputStream f = new FileOutputStream("C:/java/hello")

也可使用一個文件對象來建立一個輸出流來寫文件。咱們首先得使用File()方法來建立一個文件對象：

File f = new File("C:/java/hello"); OutputStream f = new FileOutputStream(f);

建立OutputStream 對象完成後，就可使用下面的方法來寫入流或者進行其餘的流操做。

序號	方法及描述
1	public void close() throws IOException{} 關閉此文件輸入流並釋放與此流有關的全部系統資源。拋出IOException異常。
2	protected void finalize()throws IOException {} 這個方法清除與該文件的鏈接。確保在再也不引用文件輸入流時調用其 close 方法。拋出IOException異常。
3	public void write(int w)throws IOException{} 這個方法把指定的字節寫到輸出流中。
4	public void write(byte[] w) 把指定數組中w.length長度的字節寫到OutputStream中。

Java Scanner 類

java.util.Scanner 是 Java5 的新特徵，咱們能夠經過 Scanner 類來獲取用戶的輸入。

下面是建立 Scanner 對象的基本語法：

Scanner s = new Scanner(System.in);

接下來咱們演示一個最簡單的數據輸入，並經過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字符串，在讀取前咱們通常須要 使用 hasNext 與 hasNextLine 判斷是否還有輸入的數據：

使用 next 方法：

ScannerDemo.java 文件代碼：

import java.util.Scanner; public class ScannerDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); // 從鍵盤接收數據 // next方式接收字符串 System.out.println("next方式接收："); // 判斷是否還有輸入 if (scan.hasNext()) { String str1 = scan.next(); System.out.println("輸入的數據爲：" + str1); } scan.close(); } }

執行以上程序輸出結果爲：

$ javac ScannerDemo.java $ java ScannerDemo next方式接收： runoob com 輸入的數據爲：runoob

使用 nextLine 方法：

ScannerDemo.java 文件代碼：

import java.util.Scanner; public class ScannerDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); // 從鍵盤接收數據 // nextLine方式接收字符串 System.out.println("nextLine方式接收："); // 判斷是否還有輸入 if (scan.hasNextLine()) { String str2 = scan.nextLine(); System.out.println("輸入的數據爲：" + str2); } scan.close(); } }

執行以上程序輸出結果爲：

$ javac ScannerDemo.java $ java ScannerDemo nextLine方式接收： runoob com 輸入的數據爲：runoob com

能夠看到 com 字符串輸出。

next() 與 nextLine() 區別

next():

• 一、必定要讀取到有效字符後才能夠結束輸入。
• 二、對輸入有效字符以前遇到的空白，next() 方法會自動將其去掉。
• 三、只有輸入有效字符後纔將其後面輸入的空白做爲分隔符或者結束符。
• next() 不能獲得帶有空格的字符串。

nextLine()：

• 一、以Enter爲結束符,也就是說 nextLine()方法返回的是輸入回車以前的全部字符。
• 二、能夠得到空白。

若是要輸入 int 或 float 類型的數據，在 Scanner 類中也有支持，可是在輸入以前最好先使用 hasNextXxx() 方法進行驗證，再使用 nextXxx() 來讀取：

ScannerDemo.java 文件代碼：

import java.util.Scanner; public class ScannerDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); // 從鍵盤接收數據 int i = 0; float f = 0.0f; System.out.print("輸入整數："); if (scan.hasNextInt()) { // 判斷輸入的是不是整數 i = scan.nextInt(); // 接收整數 System.out.println("整數數據：" + i); } else { // 輸入錯誤的信息 System.out.println("輸入的不是整數！"); } System.out.print("輸入小數："); if (scan.hasNextFloat()) { // 判斷輸入的是不是小數 f = scan.nextFloat(); // 接收小數 System.out.println("小數數據：" + f); } else { // 輸入錯誤的信息 System.out.println("輸入的不是小數！"); } scan.close(); } }

執行以上程序輸出結果爲：

$ javac ScannerDemo.java $ java ScannerDemo 輸入整數：12 整數數據：12 輸入小數：1.2 小數數據：1.2

如下實例咱們能夠輸入多個數字，並求其總和與平均數，每輸入一個數字用回車確認，經過輸入非數字來結束輸入並輸出執行結果：

ScannerDemo.java 文件代碼：

import java.util.Scanner; class ScannerDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); double sum = 0; int m = 0; while (scan.hasNextDouble()) { double x = scan.nextDouble(); m = m + 1; sum = sum + x; } System.out.println(m + "個數的和爲" + sum); System.out.println(m + "個數的平均值是" + (sum / m)); scan.close(); } }

執行以上程序輸出結果爲：

$ javac ScannerDemo.java $ java ScannerDemo 12 23 15 21.4 end 4個數的和爲71.4 4個數的平均值是17.85

Java 異常處理

 

異常是程序中的一些錯誤，但並非全部的錯誤都是異常，而且錯誤有時候是能夠避免的。

好比說，你的代碼少了一個分號，那麼運行出來結果是提示是錯誤 java.lang.Error；若是你用System.out.println(11/0)，那麼你是由於你用0作了除數，會拋出 java.lang.ArithmeticException 的異常。

異常發生的緣由有不少，一般包含如下幾大類：

• 用戶輸入了非法數據。
• 要打開的文件不存在。
• 網絡通訊時鏈接中斷，或者JVM內存溢出。

這些異常有的是由於用戶錯誤引發，有的是程序錯誤引發的，還有其它一些是由於物理錯誤引發的。-

要理解Java異常處理是如何工做的，你須要掌握如下三種類型的異常：

• 檢查性異常：最具表明的檢查性異常是用戶錯誤或問題引發的異常，這是程序員沒法預見的。例如要打開一個不存在文件時，一個異常就發生了，這些異常在編譯時不能被簡單地忽略。
• 運行時異常： 運行時異常是可能被程序員避免的異常。與檢查性異常相反，運行時異常能夠在編譯時被忽略。
• 錯誤： 錯誤不是異常，而是脫離程序員控制的問題。錯誤在代碼中一般被忽略。例如，當棧溢出時，一個錯誤就發生了，它們在編譯也檢查不到的。

---

Exception 類的層次

全部的異常類是從 java.lang.Exception 類繼承的子類。

Exception 類是 Throwable 類的子類。除了Exception類外，Throwable還有一個子類Error 。

Java 程序一般不捕獲錯誤。錯誤通常發生在嚴重故障時，它們在Java程序處理的範疇以外。

Error 用來指示運行時環境發生的錯誤。

例如，JVM 內存溢出。通常地，程序不會從錯誤中恢復。

異常類有兩個主要的子類：IOException 類和 RuntimeException 類。

在 Java 內置類中(接下來會說明)，有大部分經常使用檢查性和非檢查性異常。

---

Java 內置異常類

Java 語言定義了一些異常類在 java.lang 標準包中。

標準運行時異常類的子類是最多見的異常類。因爲 java.lang 包是默認加載到全部的 Java 程序的，因此大部分從運行時異常類繼承而來的異常均可以直接使用。

Java 根據各個類庫也定義了一些其餘的異常，下面的表中列出了 Java 的非檢查性異常。

異常	描述
ArithmeticException	當出現異常的運算條件時，拋出此異常。例如，一個整數"除以零"時，拋出此類的一個實例。
ArrayIndexOutOfBoundsException	用非法索引訪問數組時拋出的異常。若是索引爲負或大於等於數組大小，則該索引爲非法索引。
ArrayStoreException	試圖將錯誤類型的對象存儲到一個對象數組時拋出的異常。
ClassCastException	當試圖將對象強制轉換爲不是實例的子類時，拋出該異常。
IllegalArgumentException	拋出的異常代表向方法傳遞了一個不合法或不正確的參數。
IllegalMonitorStateException	拋出的異常代表某一線程已經試圖等待對象的監視器，或者試圖通知其餘正在等待對象的監視器而自己沒有指定監視器的線程。
IllegalStateException	在非法或不適當的時間調用方法時產生的信號。換句話說，即 Java 環境或 Java 應用程序沒有處於請求操做所要求的適當狀態下。
IllegalThreadStateException	線程沒有處於請求操做所要求的適當狀態時拋出的異常。
IndexOutOfBoundsException	指示某排序索引（例如對數組、字符串或向量的排序）超出範圍時拋出。
NegativeArraySizeException	若是應用程序試圖建立大小爲負的數組，則拋出該異常。
NullPointerException	當應用程序試圖在須要對象的地方使用 null 時，拋出該異常
NumberFormatException	當應用程序試圖將字符串轉換成一種數值類型，但該字符串不能轉換爲適當格式時，拋出該異常。
SecurityException	由安全管理器拋出的異常，指示存在安全侵犯。
StringIndexOutOfBoundsException	此異常由 String 方法拋出，指示索引或者爲負，或者超出字符串的大小。
UnsupportedOperationException	當不支持請求的操做時，拋出該異常。

下面的表中列出了 Java 定義在 java.lang 包中的檢查性異常類。

異常	描述
ClassNotFoundException	應用程序試圖加載類時，找不到相應的類，拋出該異常。
CloneNotSupportedException	當調用 Object 類中的 clone 方法克隆對象，但該對象的類沒法實現 Cloneable 接口時，拋出該異常。
IllegalAccessException	拒絕訪問一個類的時候，拋出該異常。
InstantiationException	當試圖使用 Class 類中的 newInstance 方法建立一個類的實例，而指定的類對象由於是一個接口或是一個抽象類而沒法實例化時，拋出該異常。
InterruptedException	一個線程被另外一個線程中斷，拋出該異常。
NoSuchFieldException	請求的變量不存在
NoSuchMethodException	請求的方法不存在

---

異常方法

下面的列表是 Throwable 類的主要方法:

序號	方法及說明
1	public String getMessage() 返回關於發生的異常的詳細信息。這個消息在Throwable 類的構造函數中初始化了。
2	public Throwable getCause() 返回一個Throwable 對象表明異常緣由。
3	public String toString() 使用getMessage()的結果返回類的串級名字。
4	public void printStackTrace() 打印toString()結果和棧層次到System.err，即錯誤輸出流。
5	public StackTraceElement [] getStackTrace() 返回一個包含堆棧層次的數組。下標爲0的元素表明棧頂，最後一個元素表明方法調用堆棧的棧底。
6	public Throwable fillInStackTrace() 用當前的調用棧層次填充Throwable 對象棧層次，添加到棧層次任何先前信息中。

---

捕獲異常

使用 try 和 catch 關鍵字能夠捕獲異常。try/catch 代碼塊放在異常可能發生的地方。

try/catch代碼塊中的代碼稱爲保護代碼，使用 try/catch 的語法以下：

try { // 程序代碼 }catch(ExceptionName e1) { //Catch 塊 }

Catch 語句包含要捕獲異常類型的聲明。當保護代碼塊中發生一個異常時，try 後面的 catch 塊就會被檢查。

若是發生的異常包含在 catch 塊中，異常會被傳遞到該 catch 塊，這和傳遞一個參數到方法是同樣。

多重捕獲塊

一個 try 代碼塊後面跟隨多個 catch 代碼塊的狀況就叫多重捕獲。

多重捕獲塊的語法以下所示：

try{ // 程序代碼 }catch(異常類型1 異常的變量名1){ // 程序代碼 }catch(異常類型2 異常的變量名2){ // 程序代碼 }catch(異常類型2 異常的變量名2){ // 程序代碼 }

上面的代碼段包含了 3 個 catch塊。

能夠在 try 語句後面添加任意數量的 catch 塊。

若是保護代碼中發生異常，異常被拋給第一個 catch 塊。

若是拋出異常的數據類型與 ExceptionType1 匹配，它在這裏就會被捕獲。

若是不匹配，它會被傳遞給第二個 catch 塊。

如此，直到異常被捕獲或者經過全部的 catch 塊。

throws/throw 關鍵字：

若是一個方法沒有捕獲到一個檢查性異常，那麼該方法必須使用 throws 關鍵字來聲明。throws 關鍵字放在方法簽名的尾部。

也可使用 throw 關鍵字拋出一個異常，不管它是新實例化的仍是剛捕獲到的。

下面方法的聲明拋出一個 RemoteException 異常：

import java.io.*; public class className { public void deposit(double amount) throws RemoteException { // Method implementation throw new RemoteException(); } //Remainder of class definition }

一個方法能夠聲明拋出多個異常，多個異常之間用逗號隔開。

 

finally關鍵字

finally 關鍵字用來建立在 try 代碼塊後面執行的代碼塊。

不管是否發生異常，finally 代碼塊中的代碼總會被執行。

在 finally 代碼塊中，能夠運行清理類型等收尾善後性質的語句。

finally 代碼塊出如今 catch 代碼塊最後，語法以下：

try{ // 程序代碼 }catch(異常類型1 異常的變量名1){ // 程序代碼 }catch(異常類型2 異常的變量名2){ // 程序代碼 }finally{ // 程序代碼 }

 

注意下面事項：

• catch 不能獨立於 try 存在。
• 在 try/catch 後面添加 finally 塊並不是強制性要求的。
• try 代碼後不能既沒 catch 塊也沒 finally 塊。
• try, catch, finally 塊之間不能添加任何代碼。

聲明自定義異常

在 Java 中你能夠自定義異常。編寫本身的異常類時須要記住下面的幾點。

• 全部異常都必須是 Throwable 的子類。
• 若是但願寫一個檢查性異常類，則須要繼承 Exception 類。
• 若是你想寫一個運行時異常類，那麼須要繼承 RuntimeException 類。

能夠像下面這樣定義本身的異常類：

class MyException extends Exception{ }

只繼承Exception 類來建立的異常類是檢查性異常類。

下面的 InsufficientFundsException 類是用戶定義的異常類，它繼承自 Exception。

一個異常類和其它任何類同樣，包含有變量和方法。

通用異常

在Java中定義了兩種類型的異常和錯誤。

• JVM(Java虛擬機) 異常：由 JVM 拋出的異常或錯誤。例如：NullPointerException 類，ArrayIndexOutOfBoundsException 類，ClassCastException 類。
• 程序級異常：由程序或者API程序拋出的異常。例如 IllegalArgumentException 類，IllegalStateException 類。