Java學習筆記

Java概述

java語言是解釋執行，java源碼是通過編譯生成一種特殊.class中間字解碼文獻，然后再有JVM進行解釋執行。

java語言對指針進行了上層封裝，它保證可以通過這個指針（引用）來訪問有效內存單元。

java語言不容許多繼承，使繼承關系成樹裝圖，每個類都只能由一種父類。

java語言開發效率高，但執行效率低。（相稱于c++55%）

java垃圾回收機制，在java中new對象不需要向c++同樣進行delete操作，JVM會依照狀況回收垃圾對象。（懶漢機制，等待資源沒有時候才回收）咱們只可以建議JVM進行垃圾回收，例如（System.gc()RunTime.gc()這兩個辦法就是建議JVM進行垃圾回收辦法）

JDK，java開發工具包（類庫和運營命令），JRE，java運營環境，JVM，java虛擬機（解釋執行核心，對字節碼進行翻譯成運營環境機器碼，它可以屏蔽平臺差別。JVM是不跨平臺。）

JAVA_HOME,指明JDK安裝位置，CLASSPATH，指明類文獻位置，PATH，指明命令可執行文獻位置。

java源文獻文獻名必要和文獻中定義publicclass類名（大小寫頁要相似）相似。

java源代碼中main辦法定義寫法。main辦法是程序入口。

publicstaticvoidmain(String[]args){

System.out.println("Helloworld")；

}

java源文獻也要先編譯，使用javacxxx.java格式命令得來編譯，使用javaxxx來運營。

定義包構造要放在有效代碼第一行，packagexxx.xxx，包定義在一種程序中只能由一種，在加上包定義之后編譯可以使用javac-d途徑xxxx.java,這個-d這個命令行參數可以指定包構造位置“.”代表當前目錄。在運營時要使用類全名

javaxxx.xxx.xxxx用包名以點分隔。運營時要在包構造上一層目錄來運營。

java中注釋

單行注釋//......

多行注釋/*.......*/

文檔注釋/**........<p>(換行標簽)*/,用javadoc命令可以依照原碼中文檔注釋生成注釋文檔（html格式）。文檔注釋中可以使用html標簽。

javadoc-d途徑（指定注釋文檔保存途徑）

文檔注釋普通寫在類定義之前，辦法之前，屬性之前。

在文檔注釋中可以用@author表達程序作者，@version表達程序版本，前兩個注釋符號要寫在類定義之前，用于辦法注釋@param對參數進行注釋,@return對返回值進行注釋@throws對拋出異常注釋。

jar命令用于打一種xxx.jar文獻

用法：jar{ctxu}[vfm0Mi][jar-文獻][manifest-文獻][-C目錄]文獻名...

選項：

-c創立新存檔

-t列出存檔內容列表

-x展開存檔中命名（或所有〕文獻

-u更新已存在存檔

-v生成詳細輸出到原則輸出上

-f指定存檔文獻名

-m包括來自標明文獻標明信息

-0只存儲方式；未用ZIP壓縮格式

-M不產生所有項清單（manifest〕文獻

-i為指定jar文獻產生索引信息

-C變化到指定目錄，并且包括下列文獻：

如果一種文獻名是一種目錄，它將被遞歸解決。

清單（manifest〕文獻名和存檔文獻名都需要被指定，按'm'和'f'標志指定相似順序

示例1：將兩個class文獻存檔到一種名為'classes.jar'存檔文獻中：

jarcvfclasses.jarFoo.classBar.class

示例2：用一種存在清單（manifest）文獻'mymanifest'將foo/目錄下所有

文獻存檔到一種名為'classes.jar'存檔文獻中：

jarcvfmclasses.jarmymanifest-Cfoo/。

普通在使用使用jarcvf文獻名.jar文獻所在途徑（xxx/xxx/xxx.class）也可以壓縮一種目錄,只要在制定途徑是指定為文獻夾，jar命令命令行參數在使用時可以以“-”開頭，也可以不用。

java程序運營過程，一方面是啟動java虛擬機，然后就是去找.class文獻，先是從系統類庫中找（系統之會在跟目錄下查找，因此需要完整類名），如果找不到話會去CLASSPATH所設立目錄去找。然后加載到java虛擬機中。

系統會在每個java程序中隱含導入了java.lang這個包，import包名，導入包中類文獻。

java.lang包，這是一種基本包。

java.util包,這個包是工具類包。

java.io包,這個包是用于輸入輸出操作

包,這個包是用于網絡編程。

java.awt，java.swing，javax.swing，java.event等包用于圖形編程用包。

applactionjava應用程序，java應用程序中必要有一種main()辦法。

標記符和核心字

Java代碼中“；”、“{}”、“”

Java語句以分號分隔，Java代碼塊包括在大括號內，忽視空格.標記符

1)用以命名類、辦法和變量、以及包遵守JAVA命名規范類以每個單詞都以大寫字母開頭。辦法和變量第一種字母不大寫，其她照舊。

2)只能以字符、“_”或“$”開頭；

3)無長度限制。

java中核心字

goto和const在java中雖然不再使用但是還作為核心字存在

java中沒有sizeof這個核心字了，java中boolean類型值只能用true和false，且這兩值也是核心字。

java語言中沒有無符號這個核心字（unsigned）

java中數據類型

1)整型

byte1字節 8位-128到127

short2字節 16位-2^15到2^15-1

int4字節 32位-2^31到2^31-1

long8字節 64位-2^63到2^63-1

2)浮點類型

float4字節 32位

double8字節 64位

3)字符類型

char2字節 16位

4)布爾型

booleanfalse/true

注：1)char是無符號16位整數,字面值必要用單引號括起來；‘a’

2)String是類，非原始數據類型；

3)長整型數字有一種后綴為“L”或“l”，八進制前綴為“0”，十六進制前綴為“0x”；

4)黙認浮點類型為double；

5)float數據類型有一種后綴為“f”或“F”,Double數據類型后可跟后綴“D”或“d“

6)char類型也可以用通用轉譯字符，但是不能用ASCII碼。可以用“\u0000”這種格式，由于char型中使用是unicode編碼方式。

注：整型值存儲，正數存儲原碼（二進制碼），負數則存儲補碼（原碼按位取反末位加一）。

注：實型值在存儲時會損失精度，因此不要直接比較兩個實型值。系統默認實型都是double型，要使用時要在數據后加個f，或者強行轉換。強轉（占字節數大類型轉到占字節數小類型）時會放棄高位值只取低位值。

java中數字數據類型減災由占字節數小類型到占字節數大類型可以有自動轉換，反之則需要強行轉換，char型和int型之間可以互相轉換。char和short不能像戶轉換。

注意：隱式類型轉換；

a運算符b，如果a，b中有任意一種是double型，前面運算成果就是double型，如果a，b中有任意一種是float型，前面運算成果就是float型，如果a，b中有任意一種是long型，前面運算成果就是long型，如果a，b中沒有double、float、long型，那么其成果就為int型。

所有基本數據類型在使用時會事先分派空間，只自身就存在空間中，在傳遞時，就是值傳遞，不是引用傳遞。

在類中定義辦法在返回值前加上static修飾符就可以在main辦法中調用了。如果不用static那就需要在main辦法中創立對象，使用對象來調用對象辦法。

publicclassTest{

publicstaticvoidmain(String[]args){

Testt=newTest()；

intb=1；

intc=2；

int[]a=newint[10]；

t.sqort(a)；

add(b,c)

}

publicint[]sqort(int[]a){

.......

}

staticintadd(b,c){

.......

}

}

java中運算符（java運算符優先級和結合性和c++相似）

System.out.println(3/2)按整型計算得1

1)>>=前面是零補零，前面是一補一；

2)>>>=無符號右移（強制右移都會移進一），

>>=和>>>=對于負數不同樣

正數：右移n位等于除以2n次方

負數：變成正數。

3)&&短路與，前面為假，表達式為假，背面操作不會進行，&會對所有條件進行判斷。

4)||短路或，前面為真，表達式為真，背面操作不會進行，|會對所有條件進行判斷。

例：

if(a<3&(b=a)==0)b賦值

if(a<3&&(b=a)==0)b不賦值

5)instanceof，是用于判斷一種對象與否屬于某個類型

6)java中求余運算符“%”可以對兩個實型變量求余

注：按位與是為了讓某些位置一，按位或是令某些位置零，按位異或是令某些位取反。

注：使用左右位移和無符號右移運算符用法是變量名<<=位移位數，變量名>>=位移位數(前兩個運算符是不會忽視整形符號位，也稱邏輯位移),變量名>>>=位移位數

注意：左右位移和無符號右移運算符只能用于整形及其兼容類型（byte，int，short，long）

注意：java程序運營過程，一方面是啟動java虛擬機，然后就是去找。class文獻，先是從系統類庫中找（系統之會在跟目錄下查找，因此需要完整類名），如果找不到話會去CLASSPATH所設立目錄去找。然后加載到java虛擬機中。如果要使用到其她在JAVA_HOME中沒有類或者是其她公司提供第三方。jar（jar包）文獻時，要把它途徑及文獻名加到CLASSPATH中。

java流程控制

控制流

if()

if()….else

if()…..elseif()….else

注意：else只是和其上面同層近來if()來配對。

switch(){

case'a':……..

case1:……break；

default:

…………

}

注解：switch()內數據類型為byteshortcharint類型，只有以上四種類型才可以在switch()中使用。case塊中不加break時順序執行下面語句。

循環語句

for(inti=0；i<n；i++){}

while(){}

do{}while()；-----------注意加分號

例子：

loop:for(inti=0；i<n；i++)

{

for(intj=0；j<m；j++)

{

if(3==j)

{

breakloop；//--loop為標簽只能用在循環語句中，用于循環跳到外層循環

}

}

}

辨析：

intx,a=6,b=7；

x=a+++b++；//----------a=7,b=8,x=13

intx=6；x=~x；//----------------6二進制0110取反得11001再轉成補碼（取反加一） 10111＝－7

break，跳出本層循環，執行背面代碼，continue，提前終結本次循環，再一次進行循環或循環條件滿足或不滿足后退出循環。break標簽名；continue標簽名；這兩條語句知識表達跳出有標簽循環和提前終結本次有標簽循環，只能用在循環語句（多層循環嵌套）中，循環嵌套中用于跳到外層循環。

注意：for循環在使用時一定要注意不要忘掉()中兩個"；"，死循環寫法for(；；){}或者是用

while(true){}

注意：System.out.println("..."+a)在使用這個語句時，它會將其中非字符串（String）值轉換成字符串（不是所有數據類型都可以）。

java中數組Array，其包括兩個某些，分別是數組引用和數組空間兩某些。

聲明數組

1)一組相似類型(可以是類)數據集合；

2)一種數組是一種對象；

3)聲明一種數組沒有創立一種對象；

4)數組能如下列形式聲明：

int[]i或inti[]

Car[]c或Carc[]

*C++中只能Carc[]

*JAVA中推薦用Car[]c；

5)數組定義如：

int[]a（數組引用聲明）=newint[10]（數組空間聲明，并把空間首地址賦值給數組引用）

int[]a；

a=newint[20]；

創立數組

1)創立基本數據類型數組int[]i=newint[2]；

2)創立引用數據類型數組Car[]c=newCar[100]；

3)數組創立后有初始值。

數字類型為0布爾類型為false引用類型為null

注意：訪問沒有初始化數組中值，是會拋出異常（NullPointerException）,java中只保證一位數組地址是持續，二維數組事實上是一維數組中有存儲了一維數組引用。

初始化數組

1)初始化、創立、和聲明分開

int[]i；

i=newint[2]；

i[0]=0；

i[1]=1；

2）初始化、創立、和聲明在同一時間

int[]i={0,1}；

Car[]c={newCar(),newCar()}；

多維數組

1）有效定義

int[][]i1=newint[2][3]；（同步給定一維，二維空間）

int[][]i2=newint[2][]；（給定一維空間，二維空間待定）

i2[0]=newint[2],i2[1]=newint[3]；

*C++中int[][]=newint[][3]；有效

2）無效定義

int[][]i1=newint[][3]；

3）數組長度------------數組屬性length（在二維數組中這個屬性只代表第一維長度）

int[]i=newint[5]；

intlen=i.length；//len=5；

Student[][]st=newStudent[4][6]；

len=st.length；//len=4；

len=st[0].length；//len=6；

數組拷貝

System.arrayCopy(Objectsrc，intsrcPos，Objectdest，intdestPos，intlength)；

src源數組，srcPos從第幾位開始拷貝，dest目的數組，destPos目的數組放置起始位置，length，表達要拷貝長度。

拷貝一種數組到另一種數組。

類對象創立和對象數組

一種xxx.Java文獻中可以定義各種類但是只能由一種public修飾類，也只能以這個類類名作為.java文獻名。

java中類對象創立，要先創立這個對象引用，例如：Carc；然后用new這個核心字創立一種對象實例（對象空間）例如：c=newCar()；，然后對象實例空間首地址賦值給對象引用。各種對象引用可以同步引用自同一種對象實例，但是對象引用只能引用一種對象實例。

對象引用和對象實例間就像是牽著氣球線和氣球同樣。

注意：只有一種沒有被任何對象引用所引用對象實例才會邊城垃圾等待被垃圾回收。

對象數組

例：Car[]c=newCar[3]；

c[0]=newCar()；

注意：存儲基本類型數組數據是直接存儲在數組空間中，而對象數組在數組空間中存儲則是對象引用。

定義在類中類屬性是實例變量，定義在類辦法中變量是局部變量。實例變量是保存在對象空間中，而局部變量則是在辦法調用分派空間，調用結束后就釋放空間。

注意：在類定義中屬性定義和辦法定義必要寫在類里。

注意：系統會自動初始化實例變量，數字類型為0，布爾類型為false，引用類型為null。局部變量需要初始化，必要賦初值。如果不賦初值無法通過編譯。

Java中辦法調用中參數傳遞有兩種，一種是對于參數是基本類型使用是值傳遞（直接傳參數值），另一種是引用傳遞，它是用于參數是類對象，它傳遞是這個對象引用。

面向對象思想

anythingisObject（萬物皆對象）

抽象，從對詳細對象中抽取有用信息。

對象有其固有屬性，對象辦法，即對象行為（對象能做什么）

對象自身是簡樸（功能簡樸），各種對象可以構成復雜系統（對象之間彼此調用對方辦法）

對象應當是各司其職（功能簡樸），各盡所能（把自己功能作到最佳）。（弱耦合性實現了前面所述對象特點）

對象耦合性，是對象之間聯系，對象和系統之間聯系。對象耦合性要盡量弱，也就是對象之間聯系盡量弱，對象和系統之間聯系盡量弱。

系統可插入性，是在系統中加入新對象之后系統穩定性。

對象可替代性，是在系統中替代原有對象之后系統穩定性。

復用性，即對象可否被重復使用，對象功能越簡樸，復用性就越好。（對象耦合性弱，復用性就比較強）

面向過程是先有算法，后又數據構造（怎么解決問題）

面向對象是先有對象（數據構造），后有算法。（用什么做）

類是某些有著相似屬性集合抽象。

類是一種類對象模板，對象是類詳細化。

類是一種新數據類型，類對象。

注意：局部變量作用范疇是在定義她代碼塊以內，局部變量要先賦值后使用，在以一種重疊作用于范疇內不容許兩個局部變量命名沖突。局部變量局部優先，且在于實例變量同名時會副該局部變量。

變量涉及簡樸變量（原始數據類型），對象變量。

辦法定義：

1，辦法修飾符（各種修飾符浮現順序無關）|

2，辦法返回值類型|順

3，辦法名|序

4，辦法參數表|向

5，辦法中容許拋出異常|下

java中不可以在返回語句后寫任何代碼。JVM+解釋器=JRE，JRE+類庫=JDK

java中辦法重載（overload）辦法名相似，參數表不同，返回值類型可以不同。調用時要給出明確參數并擬定調用某一辦法。在編譯時，編譯器會依照參數選取恰當辦法，因此重載也叫編譯時多態。

就近向上匹配原則

如果辦法參數表中數據類型和調用時給出參數類型不盡相似時會依照向上匹配就近原則。（類型就近向上轉化匹配）

注意：調用時要給出明確參數并擬定調用某一辦法，否則編譯會出錯。

對象使用者（調用其她對象辦法）對象（對象中辦法被調用時依照參數進行自己進行選?。?/p>

一類辦法，但跟據不同參數會有差別，對象回依照參數判斷，對對象調用者透明。

創立對象過程：1，分派空間2，初始化屬性3，調用構造辦法（有前提，不考慮繼承關系）

構造辦法寫法：沒有返回值類型，構造辦法辦法命名必要和類名相似。如果在類中不寫構造辦法，系統會提供一種無參構造辦法。

注意：最佳在寫類時提供一種無參構造辦法。

獲得對象方式

通過new（在堆空間中申請分派空間），new類名（），可以通過這種形式或一種對象，這時對象是無法使用，必要把她地址存儲近一種對象變量才可以使用。例如：Carc=newCar()；

有參構造辦法在被調用時，在用new核心字或對象時初始化，例如：Carc=newCar("yellow")

對象變量中存儲是對象引用（地址封裝形式）

this核心字

表達當前對象（哪個對象調用了辦法，哪個對象就是當前對象），可以用來區別實例變量和局部變量。this(),她表達掉用本類其她構造辦法，注，只能寫在構造辦法第一行。

java中參數傳遞，簡樸類型變量傳遞是數值，對象變量傳遞則傳遞一種引用（地址）

面向對象三大特性

封裝、繼承、多態。

java中封裝

封裝，一種對象和外界聯系應當通過一種統一接口，應當公開公開，應當隱藏隱藏。（對象屬性應當隱藏），一種對象內部是透明，就是把對象內部可透明性和隱藏特性區別開，該透明透明，該隱藏隱藏。

（封裝屬性）java中類屬性訪問權限默認值不是private，要想隱藏該屬性或辦法，就可以加private（私有）修飾符，來限制只可以在類內部進行訪問。

對于類中私有屬性，要對其給出一對辦法（getXxx(),setXxx()）訪問私有屬性，保證對私有屬性操作安全性。

辦法封裝

對于辦法封裝，該公開公開，該隱藏隱藏。辦法公開是辦法聲明（定義），即（只須懂得參數和返回值就可以調用該辦法），隱藏辦法實現會使實現變化對架構影響最小化。。

封裝會使辦法實現變化對架構影響最小化。

完全封裝，類屬性所有私有化，并且提供一對辦法來訪問屬性。

java中繼承

繼承，是對有著共同特性多類事物，進行再抽象成一種類。這個類就是多類事物父類。父類意義在于可以抽取多類事物共性。

java中繼承要使用extends核心字，并且java中只容許單繼承，也就是一種類只能有一種父類。

這樣就是繼承關系呈樹狀，體現了java簡樸性。

子類只能繼承在父類中可以訪問屬性和辦法（事實上父類中私有屬性和辦法也會被繼承但子類中無法訪問罷了）。

訪問控制修飾符（可以修飾屬性和辦法）

private修飾符，表達只有本類內部可以訪問。

default修飾符，辦法不加修飾符，會默以為default，表達在同一種包中可以訪問，父子類在同一包中，子類可以繼承父類相應內容。（可以修飾類）

protected（保護）修飾符，表達同一包中可以訪問，不同包子類也可以訪問繼承。

public修飾符，表達公開，在任何地方都可以訪問。（可以修飾類）

修飾符權限是由上而下逐漸變寬。

繼承意義

在于子類可以在父類基本之上對父類功能進行發展,繼承可以使系統耦合性減少，也就是使對象間聯系便松散，使多類對象間聯系用其父類對象代替。

注意：構造辦法不能被繼承。

父類屬性及辦法擬定

要從子類角度來看子類間共性，當所有子類均有這個屬性時，就應當考慮與否該放在父類中，辦法也是如此，辦法可以被看作是對象行為，而類辦法這時這一類對象所共有行為，因此也應當在辦法擬定期注意是不是所有子類型中都需要有這種辦法，并且會依照不同類型行為方式也不同才可以覆蓋著個辦法。

java中辦法覆蓋

子類中有和父類中可訪問（可繼承到子類）同名同返回類型同參數表辦法，就會覆蓋從父類繼承來辦法。

注意：在jdk1.4此前規定辦法覆蓋時，需要辦法返回值，參數表，辦法名必要嚴格相似，而在jdk1.5中辦法覆蓋，子類中覆蓋辦法返回值可以是父類中被覆蓋辦法返回值類型子類型。

注意：子類辦法覆蓋父類辦法時，辦法修飾符要么相似，要么子類中辦法修飾符表達訪問權限要寬于父類。父類中私有辦法，不能被繼承到子類，就是說子類中雖然將其覆蓋了也不會有多態。

覆蓋意義：對從父類中繼承辦法發展。

注意：父子類中有同名屬性不叫子類覆蓋父類屬性，叫做屬性遮蓋（shadow）。

當構造有繼承關系對象環節

1，遞歸構造父類對象

2，分派空間

3，初始化本類實例變量（屬性）

4，調用本類構造辦法

注意：子類對象中其實包括著父類對象，也就是父類對象加上子類對象，才是完整子類對象實例。

super核心字

super()，表達在子類構造辦法中調用父類構造辦法（可以通過這種辦法在子類構造辦法中初始化父類中屬性），super()也只能出當前構造辦法第一句上.super(),在子類構造方中指明構造父類時調用哪一種父類構造辦法構造父類。

super,這里所示是一種父類對象，可以通過super來使用父類中可以訪問辦法（可以在父類中定義setXxx()，getXxx()辦法來訪問父類中私有屬性），super可以屏蔽父子類中同名屬性沖突。

注意：在寫類時候，一定要寫默認無參構造辦法，如果一種構造辦法第一句既不是this(),也不是super()時，那么就會在這里隱含調用她父類無參構造辦法，即隱具有super()。

少覆蓋原則：

既子類應當盡量少覆蓋父類辦法，如果覆蓋了父類大多數辦法，那就應當考慮與否應當有繼承關系

java中多態（以子類覆蓋了父類辦法為前提）

多態，把子類對象主觀看作是其父類型對象，那么父類型就可以是諸各種類型。

多態，編譯時多態（辦法重載）

運營時多態（多態）

編譯時類型，也就是可以被看作類型，主觀認定。

運營時類型，也就是實際對象實例類型，客觀不可變化（也是被看作類型子類型）

對于一種對象來說，在對象產生時，運營時類型就已經擬定不會再變化，編譯時類型可以和運營時類型不同。在對象變量聲明時可以擬定其運營時類型，但是編譯時類型對象變量背后所指向運營時類型則可以是其本類型或者是其子類型。

多態三特性

1，對象實例擬定則不可變化（客觀不可變化）

2，只能調用編譯時類型所定義辦法。

3，運營時會依照運營時類型去調用相應類型中定義辦法。

多態意義：在需要使用一類對象共性時，可以用多來屏蔽掉其子類中差別。

注意：類屬性是沒有多態，只會依照編譯時類型訪問。只有子類覆蓋了父類辦法，且把子類對象黨作父類類型來看時才會有多態。要注意區別子類中辦法重載。對于辦法重載，則是會使用編譯時類型來進行相應辦法調用。

兩種復用

1，白箱復用，也就是繼承復用，父類中可以被子類訪問到就可以被繼承，這樣會有些不需要內容被繼承下來，因此這種方式不太好。

2，黑箱復用，也叫組合復用，也就是把要復用代碼類對象作為本類中一種屬性，然后再通過辦法委托來實現由選取復用，辦法委托就是在本類辦法內部通過該類對象調用要使用類辦法。

注意：盡量用組合復用代替繼承復用。

多態使用

多態用于參數，可以在辦法參數中傳入其父類類型，在運營時會依照實際運營時類型來在辦法中進行相應操作。

多態用于返回值，可以在辦法返回值類型上是用其實際返回值父類型，在有效期返回值時也不比關懷其實際類型。

多態可以使代碼變得更通用，以適應需求變化。也就是定義在父類中辦法，可以在子類中有不同實現將其覆蓋，在為父類型對象變量賦值相應需要功能子類對象實例。

java中修飾符

static表達靜態，它可以修飾屬性，辦法和代碼塊。

1，static修飾屬性（類變量），那么這個屬性就可以用類名.屬性名來訪問，也就是使這個屬性成為本類類變量，為本類對象所共有。這個屬性就是全類公有。（共有類變量與對象無關，只和類關于）。

類加載過程，類自身也是保存在文獻中（字節碼文獻保存著類信息），java會通過I/O流把類文獻（字節碼文獻）讀入JVM（java虛擬機），這個過程成為類加載.JVM（java虛擬機）會通過類途徑（CLASSPATH）來找字節碼文獻。

類變量，會在加載時自動初始化，初始化規則和實例變量相似。

注意：類中實例變量是在創立對象時被初始化，被static修飾屬性，也就是類變量，是在類加載時被創立并進行初始化，類加載過程是進行一次。也就是類變量只會被創立一次。

2，static修飾辦法（靜態辦法），會使這個辦法成為整個類所公有辦法，可以用類名。辦法名訪問。

注意：static修飾辦法，不直接能訪問（可以通過組合方式訪問）本類中非靜態(static)成員（涉及辦法和屬性），本類非靜態（static）辦法可以訪問本類靜態成員（涉及辦法和屬性），可以調用靜態辦法。靜態辦法要慎重使用。在靜態辦法中不能浮現this核心字。

注意：父類中是靜態辦法，子類中不能覆蓋為非靜態辦法，在符合覆蓋規則前提下，在父子類中，父類中靜態辦法可以被子類中靜態辦法覆蓋，但是沒有多態。（在使用對象調用靜態辦法時其實是調用編譯時類型靜態辦法）

注意：父子類中，靜態辦法只能被靜態辦法覆蓋，非靜態辦法只能被非靜態辦法覆蓋。

java中main辦法必要寫成static是由于在類加載時無法創立對象，由于靜態辦法可以不通過對象調用，因此在類main辦法所在類加載時就可以通過main辦法入口來運營程序。

注意：組合方式，就是需要在辦法中創立一種所需要對象，并用這個對象來調用任意所需該對象內容，不會再受只能訪問靜態約束。

3，static修飾初始代碼塊，這時這個初始代碼塊就叫做靜態初始代碼塊，這個代碼塊只在類加載時被執行一次。可以用靜態初始代碼塊初始化一種類。

動態初始代碼塊，寫在類體中“{}”，這個代碼塊是在生成對象初始化屬性是運營。這種代碼塊叫動態初始代碼塊。

類在什么時候會被加載，構造（創立）對象時會加載類，調用類中靜態辦法或訪問靜態屬性也是會加載這個靜態辦法真正所在類。在構造子類對象時必會先加載父類，類加載會有延遲加載原則，只有在必要加載時才會加載。

final修飾符，可以修飾變量，辦法，類

1，final修飾變量

被fianl修飾變量就會變成常量（常量應當大寫），一旦賦值不能變化，（可以在初始化時直接賦值，也可以在構造辦法里也可以賦值，只能在這兩種辦法里二選一，不能不為常量賦值），fianl常量不會有默認初始值，對于直接在初始化是賦值時final修飾符常和static修飾符一起使用。

2，final修飾辦法，被final修飾辦法將不能被其子類覆蓋，保持辦法穩定不能被覆蓋。

3，final修飾類，被final修飾類將不能被繼承。final類中辦法也都是final。

注意：final，不能用來修飾構造辦法，在父類中如果有常量屬性，在子類中使用常量屬性時是不會進行父類類加載。靜態常量如果其值可以擬定，就不會加載該類，如果不能擬定則會加載該常量所在類。

不變模式：對象一旦創立屬性就不會變化。用final修飾屬性，也用final修飾類（強不變模式），用final修飾屬性（弱不變模式）。

不變模式典型體現：java.lang.String類，不變模式可以實現對象共享（可以用一種對象實例賦值給各種對象變量。）

池化思想，把需要共享數據放在池中（節約空間，共享數據）只有String類可以用“”中字面值創立對象。在String類中，以字面值創立時，會到Java辦法空間串池空間中去查找，如果有就返回串池中字符串地址，并把這個地址付給對象變量。如果沒有則會在串池里創立一種字符串對象，并返回其地址付購對象變量，當另一種以字面值創立對象時則會重復上述過程。

如果是new在堆空間中創立String類對象，則不會有上述過程。

String類中intern()辦法會將在堆空間中創立String類對象中字符串和串池中比對，如果有相似串就返回這個串串池中地址。

不變模式在對于對象進行修改，添加操作是使相稱麻煩，她會產生諸多中間垃圾對象。創立和銷毀資源開銷是相稱大。

String類在字符串連接時會先效率很低，就是由于它所產生對象書性是不可以修改，當連接字符串時也就是只能創立新對象。

對于諸多字符串連接，應當使用StringBuffer類，在使用這個類對象來進行字符串連接時就不會有多余中間對象生成，從而優化了效率。

abstract（抽象）修飾符，可以修飾類和辦法

1，abstract修飾類，會使這個類成為一種抽象類，這個類將不能生成對象實例，但可以做為對象變量聲明類型，也就是編譯時類型，抽象類就像當于一類半成品，需要子類繼承并覆蓋其中抽象辦法。

2，abstract修飾辦法，會使這個辦法變成抽象辦法，也就是只有聲明（定義）而沒有實現，實現某些以"；"代替。需要子類繼承實現（覆蓋）。

注意：有抽象辦法類一定是抽象類。但是抽象類中不一定都是抽象辦法，也可以全是詳細辦法。

abstract修飾符在修飾類時必要放在類名前。

abstract修飾辦法就是規定其子類覆蓋（實現）這個辦法。調用時可以以多態方式調用子類覆蓋（實現）后辦法，也就是說抽象辦法必要在其子類中實現，除非子類自身也是抽象類。

注意：父類是抽象類，其中有抽象辦法，那么子類繼承父類，并把父類中所有抽象辦法都實現（覆蓋）了，子類才有創立對象實例能力，否則子類也必要是抽象類。抽象類中可以有構造辦法，是子類在構造子類對象時需要調用父類（抽象類）構造辦法。

final和abstract，private和abstract，static和abstract，這些是不能放在一起修飾符，由于abstract修飾辦法是必要在其子類中實現（覆蓋），才干以多態方式調用，以上修飾符在修飾辦法時期子類都覆蓋不了這個辦法，final是不可以覆蓋，private是不可以繼承到子類，因此也就不能覆蓋，static是可以覆蓋，但是在調用時會調用編譯時類型辦法，由于調用是父類辦法，而父類辦法又是抽象辦法，又不可以調用，因此上修飾符不能放在一起。

抽象（abstract）辦法代表了某種原則，定義原則，定義功能，在子類中去實現功能（子類繼承了父類并需要給出從父類繼承抽象辦法實現）。

辦法一時間想不到怎么被實現，或故意要子類去實現而定義某種原則，這個辦法可以被定義為抽象。(abstract)

模板辦法模式：用abstract把制定原則和實現原則分開，制定原則就是模板，實現就是按模板原則來實現，也就是繼承模板，實現模板中相應功能辦法。模板中不容許修改辦法可以用fianl來修飾，這個辦法不能使抽象辦法，為保證安全，封裝，把模板中不公開某些用protected（保護）修飾。

Java中接口

接口是一種程序構造，是特殊抽象類。接口中辦法必要都是公開抽象辦法（publicabstract），接口中屬性都是公開靜態常量（publicstaticfinal）。

聲明一種接口用 interface 核心字,接口也是一種類型，編譯之后也有生成相應字節碼，她聲明規范也要符合類型定義(一種源文獻中只能有一種public interface，接口名和源文獻名相似，有public interface，就不能在寫public class了)。接口中屬性可以不加修飾符，辦法也不用加修飾符。

接口也可以繼承，但是只能由接口繼承，在用類去繼承時要換用implements 核心字，這時類和接口也不叫做繼承關系，而是實現關系，但其實質也是繼承。

一種類可以繼承也只能繼承此外一種類，但是可以實現各種接口，其語法是在implements背面寫接口名，各種接口以“，”分隔。

接口之間是可以多繼承，其語法和類繼承語法是相似，在接口多繼承時，在extends后寫接口名如果要繼承各種接口，接口名以“，”分隔，接口繼承關系只是把其父接口中抽象辦法繼承到子接口中。要實現接口就必要實現接口中所有辦法。

一種類可以在繼承一種類同步，也可以實現一種或各種接口。采用接口就繞開了單繼承限制。

接口類型也可以做為編譯時類型使用，但其實際運營時類型必要是完全實現接口類對象實例，這樣就使多態變得很靈活了，

注意：實現接口時，在實現(覆蓋)抽象辦法時，注意必要要在辦法返回值類型前加public修飾符。如果沒有完全實現接口中辦法，那么這個類就只可以是個抽象類，不能創立對象。接口是實質就是特殊抽象類。接口沒有構造辦法。

接口意義：

1，接口可以實現多繼承。

2，用接口可以實現混合類型（主類型，副類型），java中可以通過接口分出主次類型。主類型使用繼承，副類型，使用接口實現。

3，接口進一步深化了原則思想，接口自身就是一種原則，她起到了減少耦合性作用，接口可以使辦法定義和實現相分離，也就是將接口定義者和實現者相分離，接口也可以用于減少模塊間或系統間耦合性。針對接口編程可以屏蔽不同實現間差別，看到只是實現好功能，

接口：定義原則，

接口實現：實現原則

接口調用者：原則使用

針對接口編程原則，也就是按照原則實現。

接口回調：先有接口定義（接口實現者），再有接口使用者，最后把接口實現對象傳入接口使用者中，接口使用者會通過接口來調用接口實現者辦法。

接口回調：接口定義者定義好了原則，接口使用者先寫好了使用代碼，接口實現者寫好實現之后把實現對象傳入接口使用者中。她調用接口中辦法也就是掉用接口實現中辦法。這種過程叫做接口回調。

盡量使用接口類型作為編譯時類型，盡量將抽取到共性行為寫在接口中。

用若干個小接口取代一種大接口。（接口隔離原則）

把一種類功能作成接口，只暴露想暴露辦法，接口隔離原則可以實現更高層次封裝，針對對象不同，暴露辦法也不同。

java中根類Object

java中所有類父類或直接或間接或隱含都是Object類。

java不容許循環繼承，也就是互相繼承是不可以。

Object類中finalize()一種對象被垃圾收集時候，最后會由JVM調用這個對象finalize辦法

Object類中有一種String toString()辦法，返回該對象字符串表達。Object類中toString()辦法她返回是類名加上她地址一種字符串。在子類中推薦覆蓋toString()辦法。

Object類中boolean equals(Objecto)辦法是用來比較對象內容與否相等，其返回值是boolean類型值，相似為真，不同則為假。事實上還是比較對象地址與否相似。String類覆蓋了equals()辦法，她比較是對象中內容與否相似。子類中也推薦覆蓋Object類中繼承equals()辦法

equals()覆蓋原則：

自反性：x.equals(x)為true

對稱性：y.equals(x)和x.equals(y)值要相似，要么都為true，要么都為false。

傳遞性：x.equals(y)為true，y.equals(z)也為true，那么x.equals(z)一定也為true。

覆蓋equals()辦法環節：

booleanequals(Objecto)

{

if(this==o)returntrue；//1,看看是不是一種對象

if(o==null)returntrue；//2,看看對象是不是空

if(!(oinstanceof本類類名))returnfalse；//看看是不是本類對象

......//依照本類設計。

}

封裝類

java為每一種簡樸數據類型提供了一種封裝類，使每個簡樸數據類型可以被Object來裝載。

除了int（Integer）和char（Character），別的類型首字母大寫即成封裝類類型名。

轉換字符方式：

intI=10；

Strings=I+””；

Strings1=String.valueOf(i)；

IntI=10；

IntergerI_class=newinteger(I)；

封裝類、字符串、基本類型間轉換

Interger--------------------(Double(x.toString))------------>Double

String-----------------(Integer.valueOf())---------------->Integer

Integer-----------------(x.toString())--------------------->String

int----------------------(100+””)------------------------->String

String------------------(Integer.parseInt())--------------->int

Integer-----------------(IValue())--------------->int

學會查看javadoc協助文檔。要先關注要用法返回值類型，也就是要獲得內容類型，然后看辦法名，JDK中辦法名基本上是見名知義，參數表，就是看需要什么才可以獲得需要那些內容，也要看自己可以提供什么。

注意：“==”在任何時候都是比較地址，這種比較永遠不會被覆蓋。

程序員自己編寫類和JDK類是一種合伙關系。（由于多態存在，也許存在咱們調用JDK類狀況，也也許存在JDK自動調用咱們類狀況。）

注意：類型轉換中double\Interger\String之間轉換最多。

（注：所有使用內部類地方都可以不用內部類，但使用內部類可以使程序更加簡潔，便于命名規范和劃分層次構造）。

內部類是指在一種外部類內部再定義一種類。

*內部類可為靜態，可用protected和private修飾。（而外部類不可以：頂級類只能使用public和default）。

*java文獻中沒有publicclass，容許類名和文獻不同名。

內部類

內部類也就是定義在類內部類。

內部類分類

1，成員內部類、

2，局部內部類、

3，靜態內部類、

4，匿名內部類（圖形是要用到，必要掌握）。

成員內部類

四個訪問權限修飾符都可以修飾成員內部類。

內部類和外部類在編譯時時不同兩個類，內部類對外部類沒有任何依賴。

內部類是一種編譯時語法，在編譯時生成各自字節碼文獻，內部類和外部類沒關于系。

內部類中可以訪問外部類私有成員。

作為外部類一種成員存在，與外部類屬性、辦法并列。

內部類和外部類實例變量可以共存。

在內部類中訪問實例變量：this.屬性

在內部類訪問外部類實例變量：外部類名，this.屬性。

在外部類外部訪問內部類，使用out.inner。

成員內部類特點：

1.內部類作為外部類成員，可以訪問外部類私有成員或屬性。（雖然將外部類聲明為private，但是對于處在其內部內部類還是可見。）

2.用內部類定義在外部類中不可訪問屬性。這樣就在外部類中實現了比外部類private還要小訪問權限。

注意：內部類是個編譯時概念，一旦編譯成功，就會成為完全不同兩類。

對于一種名為outer外部類和其內部定義名為inner內部類。編譯

完畢后浮現outer.class和outer$inner.class兩類。

3.成員內部類不能具有靜態成員。

建立內部類對象時應注意：

在外部類內部可以直接使用inners=newinner()；（由于外部類懂得inner是哪個類，因此可以生成對象。）

而在外部類外部，要生成（new）一種內部類對象，需要一方面建立一種外部類對象（外部類可用），然后在生成一種內部類對象，內部類類名是外部類類名.內部類類名。

Outero=newOuter()；

Outer.Innerin=o.new.Inner()

靜態內部類

（注意：前三種內部類與變量類似，因此可以對照參照變量）

靜態內部類定義在類中，任何辦法外，用staticclass定義。

靜態內部類只能訪問外部類靜態成員。

生成（new）一種靜態內部類不需要外部類成員：這是靜態內部類和成員內部類區別。

靜態內部類對象可以直接生成：

Outer.Innerin=newOuter.Inner()；

而不需要通過生成外部類對象來生成，這樣事實上使靜態內部類成為了一種頂級類。靜態內部類不可用private來進行定義。

注意：當類與接口（或者是接口與接口）發生辦法命名沖突時候，此時必要

使用內部類來實現。用接口不能完全地實現多繼承，用接口配合內部類

才干實現真正多繼承。

例子：

對于兩個類，擁有相似辦法：

classPeople

{

run()；

}

interfaceMachine

{

run()；

}

有一種robot類：classRobotextendsPeopleimplementMachine，run()不可直接實現。

interfaceMachine

{

voidrun()；

}

classPerson

{

voidrun()

{

System.out.println("run")；

}

}

classRobotextendsPerson

{

privateclassMachineHeartimplementsMachine

{

publicvoidrun()

{

System.out.println("heartrun")；

}

}

publicvoidrun()

{

System.out.println("Robotrun")；

}

MachinegetMachine()

{

returnnewMachineHeart()；

}

}

classTest

{

publicstaticvoidmain(String[]args)

{

Robotrobot=newRobot()；

Machinem=robot.getMachine()；

m.run()；

robot.run()；

}

}

局部內部類

在辦法中定義內部類稱為局部內部類。

與局部變量類似，在局部內部類前不加修飾符public和private，其范疇為定義它代碼塊。

注意：局部內部類不但可以訪問外部類私有實例變量，但可以訪問外部類局

部常量（也就是局部變量必要為final）。

在類外不可直接訪問局部內部類（保證局部內部類對外是不可見）。

在辦法中才干調用其局部內部類。

通過內部類和接口達到一種強制弱耦合，用局部內部類來實現接口，并在辦法中返回接口類型，使局部內部類不可見，屏蔽實現類可見性。

局部內部類寫法

publicclassTestLocalInnerClass

{

publicstaticvoidmain(String[]args)

{

Outero=newOuter()；

finalinta=9；

o.print(a)；

}

}

classOuter

{

privateintindex=100；

publicvoidprint(finalinta)

{

finalintb=10；

System.out.println(a)；

classInner

{

publicvoidprint()

{

System.out.println(index)；

System.out.println(a)；

System.out.println(b)；

}

}

Inneri=newInner()；

i.print()；

}

}

匿名內部類

匿名內部類是一種特殊局部內部類，它是通過匿名類實現接口。

匿名內部類特點：

1，一種類用于繼承其她類或是實現接口，并不需要增長額外辦法，只是對繼承辦法事先或是覆蓋。

2，只是為了獲得一種對象實例，不許要懂得其實際類型。

3，類名沒故意義，也就是不需要使用到。

注意：一種匿名內部類一定是在new背面，用其隱含實現一種接口或實現一

個類，沒有類名，依照多態，咱們使用其父類名。

因其為局部內部類，那么局部內部類所有限制都對其生效。

匿名內部類是唯一一種無構造辦法類。

大某些匿名內部類是用于接口回調用。

匿名內部類在編譯時候由系統自動起名Out$1.class。

如果一種對象編譯時類型是接口，那么其運營類型為實現這個接口類。

因匿名內部類無構造辦法，因此其使用范疇非常有限。

當需要各種對象時使用局部內部類，因而局部內部類應用相對比較多。匿名內部類中不能定義構造辦法。

匿名內部類寫法：

interfaceA

{

voidia()；

}

classB

{

publicAbc()

{

returnnewA

{

voidia()

{

}

}；

}

}

使用匿名內部類：

Bb=newB()；

Aa=b.bc()；

a.ia()；

Exception（例外/異常）

對于程序也許浮現錯誤應當做出預案。

例外是程序中所有出乎意料成果。（關系到系統健壯性）

java會將所有異常封裝成為一種對象，其主線父類為Throwable。

異常分類

Error和Exception。

一種Error對象表達一種程序錯誤，指是底層、低檔、不可恢復嚴重錯誤。此時程序一定會退出，由于已經失去了運營所必要物理環境。對于Error錯誤咱們無法進行解決，由于咱們是通過程序來應對錯誤，可是程序已經退出了。

咱們可以解決Throwable類中只有Exception類對象（例外/異常）。

Exception有兩個子類：

Runtimeexception（未檢查異常）可以在編程時避免，可解決可不解決

非Runtimeexception（已檢查異常）必要進行解決。

注意：無論是未檢查異常還是已檢查異常在編譯時候都不會被發現，在編譯過程中檢查是程序語法錯誤，而異常是一種運營時程序出錯概念。

在Exception中，所有非未檢查異常都是已檢查異常，沒有此外異常??！

未檢查異常是由于程序員沒有進行必要檢查，由于她疏忽和錯誤而引起異常。一定是屬于虛擬機內部異常（例如空指針）。

應對未檢查異常就是養成良好檢查習慣。

已檢查異常是不可避免，對于已檢查異常必要實現定義好應對辦法。

已檢查異常必定跨越出了虛擬機范疇。（例如“未找到文獻”）

異常傳遞

如何解決已檢查異常（對于所有已檢查異常都要進行解決）：

一方面理解異常形成機制：

當一種辦法中有一條語句浮現了異常，它就會throw（拋出）一種例外對象（throw異常對象），然后背面語句不會執行返回上一級辦法，其上一級辦法接受到了例外對象之后，有也許對這個異常進行解決，也也許將這個異常轉到它上一級。

注意：當一種辦法中浮現異常，沒有進行異常解決，辦法就會把異常對象作為返回值返回。如果有異常進入虛擬機，那么虛擬機就會立即中斷程序執行。

異常解決方式

非RuntimeException（已檢查異常）異常必要解決。如果不解決編譯出錯。

對于接受到已檢查異常有兩種解決方式：throws和try..catch(...){}辦法。

注意：出錯辦法有也許是JDK，也也許是程序員寫程序，無論誰寫，拋出一定用throw。

在辦法定義中聲明辦法也許拋出異常，用（throws異常類名，異常類名），聲明這個辦法將不解決異常，并把異常交給上一級辦法解決。可以拋出是實際產生異常父類異常對象。

例：publicvoidprint()throwsException。

對于辦法a，如果它定義了throwsException。那么當它調用辦法b返回異常對象時，辦法a并不解決，而將這個異常對象向上一級返回，如果所有辦法均不進行解決，返回到主辦法，程序中斷。（要避免所有辦法都返回用法，由于這樣浮現一種很小異常就會令程序中斷）。

如果在辦法程序中有一行thrownewException()，返回錯誤，那么其后程序不執行。由于錯誤返回后，背面程序必定沒有機會執行，那么JAVA以為后來程序沒有存在必要。

Try..catch捕獲異常

對于try……catch格式：

try{也許浮現錯誤代碼塊}catch(exceptione){進行解決代碼}；

對象變量聲明

用這種辦法，如果代碼對的，那么程序不通過catch語句直接向下運營；

如果代碼不對的，則將返回異常對象和e進行匹配，如果匹配成功，則解決其背面異常解決代碼。（如果用exception來聲明e話，由于exception為所有exception對象父類，所有必定匹配成功）。解決完代碼后這個例外就完全解決完畢，程序會接著從浮現異常地方向下執行（是從浮現異常地方還是在catch背面呢？運用程序進行驗證）。最后程序正常退出。

try塊中代碼如果沒有浮現異常，就會跳過catch，正常執行。

try中如果發現錯誤，即跳出try塊去匹配catch，那么try背面語句就不會被執行。

一種try可以跟進各種catch語句，用于解決不同狀況。當一種try只能匹配一種catch。

咱們可以寫各種catch語句，但是不能將父類型exception位置寫在子類型excepiton之前，由于這樣父類型必定先于子類型被匹配，所有子類型就成為廢話，java中是不容許寫廢話，因此編譯會出錯。

在try，catch后還可以再跟一子句finally。其中代碼語句無論如何（無論有無異常）都會被執行（由于finally子句這個特性，因此普通將釋放資源，關閉連接語句寫在里面）。finally中代碼在和try中代碼沖突時，finally中代碼一定會被執行且會忽視try中代碼。但是System.exit(0)；(虛擬機退出語句)則不會去執行fianlly中代碼。

try{..}catch(..){..}

try{..}catch(..){}finally{..}

try{..}finally{}

以上三種寫法都可以.

如果在程序中書寫了檢查（拋出）exception但是沒有對這個也許浮現檢查成果進行解決，那么程序就會報錯。而如果只有解決狀況（try）而沒有相應catch子句，則編譯還是通但是。

如何懂得在編寫程序中會浮現例外呢

1.調用辦法，查看API中查看辦法中與否有已檢查錯誤。

2.在編譯過程中看提示信息，然后加上相應解決。

Throwable有一種message屬性，在使用catch時候可以調用：

Catch(IOExceptione){System.out.println(e.message())}；

Catch(IOExceptione){e.printStackTrace()}；

以上兩條語句都是可以打印出錯過程信息，告訴咱們出錯類型所歷通過程，在調試中非常有用。

開發中兩個道理：

①如何控制try范疇：依照操作連動性和有關性，如果前面程序代碼塊拋出錯誤影響了背面程序代碼運營，那么這個咱們就說這兩個程序代碼存在關聯，應當放在同一種try中。

②對已經查出來例外，有throw(悲觀)和trycatch（積極）兩種解決辦法。

對于throws把異常拋到trycatch可以較好地解決例外位置（即放在具備對例外進行解決能力位置）。如果沒有解決能力就繼續上拋。

當咱們自己定義一種例外類時候必要使其繼承excepiton或者RuntimeException。

throw是一種語句，用來做拋出例外功能。

而throws是表達如果下級辦法中如果有例外拋出，那么本辦法不做解決，繼續向上拋出。

throws后跟是例外類型。

注意：辦法覆蓋中，如果子類辦法拋出例外是父類辦法拋出例外父類型，那么編譯就會出錯：子類無法覆蓋父類。

結論：子類辦法不可比父類辦法拋出更多例外。子類拋出例外或者與父類拋出例外一致，或者是父類拋出例外子類型?；蛘咦宇愋筒粧伋隼狻Ｈ绻割愋蜔othrows時，子類型也不容許浮現throws。此時只能使用trycatch。

斷言是一種調試工具（assert）

斷言(assert)其后跟是布爾類型表達式，如果表達式成果為真不影響程序運營。如果為假系統浮現低檔錯誤，在屏幕上浮現assert信息。

Assert只是用于調試。在產品編譯完畢后上線assert代碼就被刪除了。

集合類

集合（集合類對象）是用來管理其她若干對象，它類似于C++原則模板庫中容器，但是在JAVA集合類對象中可以用來存儲各種類型對象。

接口和類共同構成了一種集合框架，集合概念，一種對象可以裝載各種對象，這個對象就是集合對象。

集合框架

1，接口

Collection用來管理各種對象，集合中每個元素都是對象。

Map，Map中沒有對象，而是鍵值對，由Key，value構成鍵值對，Key是不可重復。value是可以相似,一種Key和一種value一一相應。

集合中用到類，接口在java.util包中，在使用時注意將其引入import。

Collection接口（如下簡介其子接口）

1)List一種List實現類對象在管理各種對象時會按順序組織對象（即按照將對象放入順序存儲），List實現類對象是有順序，List實現類對象中內容是是可重復。（注意，順序和排序區別）

2)Set一種Set實現類表達一種數學概念上集合，Set實現類對象中元素是無順序，也就是不會按照輸入順序來存儲，Set實現類對象中元素是不重復。

3)SortedSet,她是Set子接口，她實現類會對集合中元素進行排序。但是要指定排序規則，她會按排序規則進行排序。

Map接口（如下簡介其子接口）

SortedMap，這個接口實現類同樣可以實現，但是是對鍵值對中Key進行排序，這個接口實現類也是要指定排序規則。

List接口實現類

1>ArrayList是接近于功能集合類，ArryList實質就是一種會自動增長數組，ArrayList是用封裝數組來實現List接口。

Collection實現類對象遍歷方式是用迭代來實現。

在使用迭代器時先要活得一種迭代器對象，Iterator（迭代器接口）這是一種接口，迭代器是在集合類中實現，也就是說，她是一種內部類（匿名內部類）實現。

Iterator接口中定義慣用辦法辦法hasNext()，next()。

hasNext(),這個辦法會使用一種游標，并通過判斷游標指向位置與否存儲有對象。

next()辦法也是Iterator接口中定義好辦法，這個辦法會使游標指向下一種元素位置，游標會跳過第一種元素，并返回其中內容。

Collections這是一種工具類，也是java.util包中，這個類中sort(list接口實現類對象)辦法，其參數是一種集合類對象，這個辦法使用來對集合類對象進行排序。后來，我將以集合這個名字來稱呼集合類對象。，對于字符串對象內容集合來說會按字典順序排序（升序），對于數字內容集合排序也會按照升序排序。

排序可一份為兩某些內容，一種是排序規則，也就是按照什么來進行排序，并且排成什么樣順序。第二個就是排序算法，她決定了排序效率。

在對自定義集合內容類型排序時，需要先定義那個類型排序規則。

Comparable接口，這個接口中只定義了一種compareTo(Objecto)，辦法返回至類型是整型，如果當前對象不不大于參數對象就返回正數，當前對象等于參數對象是就返回0，當前對象不大于參數對象時就返回負值，這樣寫就是升序排列，反之則是進行降序排列，在實現這個接口中辦法時，返回值定義方式，只有這兩種。

依照指定類型排序規則實現了Comparable接口，那么就可以對存有這個類型集合進行整體排序。Comparable接口，也叫做可比較接口。這個接口在java.lang包下。只要實現了這個接口，就是可排序。

接下來簡介此外一種對自定義類型對象集合整體排序辦法，也就是實現比較器接口（Comparator），這個接口中定義了一種compare(Objecto1，Objecto2)辦法來比較兩個對象，這個辦法返回值定義和上面簡介那個辦法是同樣。

注意：在API，協助文檔中以上兩個辦法參數類型是T，這代表模板類型，也就是集合中存儲內容類型，在JDK1。4中其參數就是Object類型，模板類型詳細內容會在最后JDK5。0新特性中講到。

Comparator接口可以在匿名內部類中實現，Collections中sort(集合了對象，比較器)辦法，可以對自定義類型內容集合進行整體排序。

2>LinkedList，它是List接口實現類，其底層是用雙向循環鏈表來實現。

注意：ArrayList查詢效率比較高，增刪動作效率比較差，合用于查詢比較

頻繁，增刪動作較少元素管理集合。

LinkedList查詢效率低，但是增刪效率很高。合用于增刪動作比較頻繁，查詢次數較少元素管理集合。

ArrayList，LinkedList都是線程不安全。

實現堆棧

1，數組（ArrayList，增刪效率比較低，不適合）

2，LinkedList（實現堆棧好辦法）

3，java。util。Stack類，Stack是Vector子類，Vector類是一種線程安全（是一種重量級類），并繼承了Vector辦法，Verctor類（這個類也是List接口實現類）和ArrayList功能近乎相似。（不推薦使用Stack類來實現堆棧）。

Set接口實現類

HashSet

Set實現類集合對象中不可以有重復元素，HashSet也同樣她是使用了一種標記來擬定元素不重復，HashSet用一種算法來保證HashSet中元素是不重復，HashSet底層實現還是數組。

Object類中hashCode()辦法是所有子類都會繼承這個辦法，這個辦法會用Hash算法算出一種Hash（哈希）碼值返回，HashSet會用Hash碼值去和數組長度取模，模（這個模就是對象要存儲在數組中位置）相似時才會判斷數組中元素和要加入對象內容與否相似，如果不同才會添加進去。

Hash算法是一種散列算法。

注意：因此要存入HashSet集合對象中自定義類必要覆蓋hashCode(),equals()兩個辦法，才干保證集合中元素容不重復。在覆蓋和hashCode()辦法時，要使相似對象hashCode()辦法返回相似值，覆蓋equals()辦法再判斷其內容。為了保證效率，因此在覆蓋hashCode()辦法時，也要盡量使不同對象盡量返回不同Hash碼值。

如果數組中元素和要加入對象hashCode()返回了相似Hash值（相似對象）,才會用equals()辦法來判斷兩個對象內容與否相似。

SortedSet接口是Set子接口。

TreeSet是SortedSet接口實現類，她可以對集合中元素進行排序。

要存儲在TreeSet中自定義類對象，這個類要么是已經實現了Comparable接口，要么是能給出Comparator比較器，TreeSet可以自動過濾掉重復元素因此不用重載hashCode()辦法，TreeSet會依照比較規則判斷元素內容與否相似，TreeSet會在元素存入世就進行了排序。（在TreeSet給出排序規則時，一定要注意對象內容相等條件，一定要注旨在主觀以為兩個對象內容相似時，才可以使用比較少條件來進行判斷）

在要排序時才使用TreeSet類（存儲效率比較低），HashSet存儲效率比較高，在需要為HashSet對象排序時，就可以把HashSet中元素放入TreeSet。

Map接口實現類

Map中只可以存儲鍵值對（Key，value），其中Key是不可以重復。Key和value是一一相應。

HashMap是Map接口實現類，Key時無序存儲，其中Key是不可以重復，它也是通過Hash碼值來保證Key不重復，Key和value是一一相應。如果要加入鍵值對和HashMap中鍵值對Key是相似就會將這個集合中Key所隊應value值進行覆蓋，在使用自定義類型作為Key時，那就是要覆蓋hashCode(),equals()辦法，也就是和HashSet中要放入自定義類型是解決辦法相似。這個類對象是線程不安全。

在遍歷Map時，要使用其keySet()辦法獲得Key一種Set集合，可以通過遍歷這個Set，用get()辦法來獲得Key所相應value，也就遍歷了Map。

H