Thinking in java讀書筆記資料

Thinkinginjava讀書筆t己

第一章對象導論

1.因為類描述了具有相同特征（數(shù)據(jù)元素、靜態(tài)）和行為（功能、動態(tài)）的對象集

合。public表示緊隨其后的元素對任何人都是可用的，而private這個關鍵字表示除類

型創(chuàng)建者和類型的內部方法之外的任何人都不能訪問的元素。Private就像你與客戶端

程序之前的一堵破墻，如果有人試圖訪問private成員，就會在編譯時得到錯誤信息。

篇protected關鍵字與private作用相當，差別僅在于繼承的類可以訪問protected成

員，但是不能訪問private成員。java中還有包訪問權限。

2.在使用對象時，最關鍵的問題之一便是它們的生成和銷毀方式。每個對象為了生存

都需要資源，尤其是內存。在堆棧中創(chuàng)建存儲空間和釋放存儲空間通常各需要一條匯

編指令即可，分別對應將棧頂指針向下移動和將棧頂指針向上移動。創(chuàng)建堆存儲空間

的時間依賴于存儲機制的設計。

第二章一切都是對象

2.1用弓I用操縱對象（用地址指針操縱對象）

1.操縱的標識符實際上是對象的一個“引用"（reference）?；蛘呓小暗刂贰保浔臇|

西。

2.你擁有一個引用，并不一定需要有一個對象與它關聯(lián)。

如：Strings;

如果向s發(fā)送一個消息，就會返回一個運行時錯誤。一種安全的做法就是：創(chuàng)建一

個引用的同時便進行初始化（強烈建議）。如：Strings=newString（""）;

2.2必須由你創(chuàng)建所有對象。

2.2.1存儲到什么地方

1）寄存器。

2）棧。位于通用RAM（隨機訪問存儲器）：一級cache,二級cache.雖然某些JAVA

數(shù)據(jù)存儲在堆棧中——特別是對象引用，但是JAVA對象不存儲其中。

3）堆（heap）o一種通用性的內存池（也存在于RAM中），用于存放所有的JAVA

對象（對象本身）。堆不同于堆棧的好處是：編譯器不需要知道要從堆里分配多

少存儲區(qū)域，也不必知道存儲的數(shù)據(jù)在堆里存活多長時間。因此，在堆里分配存

儲有很大的靈活性。當你需要創(chuàng)建一個對象的時候，只需要new寫一行簡單的代

碼，當執(zhí)行這行代碼時，會自動在堆里進行存儲分配。當然，為這種靈活性必須

要付出相應的代價-用堆進行存儲分配比用棧進行存儲存儲需要更多的時間。

4）靜態(tài)存儲（staticstorage）□這里的“靜態(tài)”是指“在固定的位置”。靜態(tài)存儲里存放

程序運行時一直存在的數(shù)據(jù)。你可用關鍵字static來標識一個對象的特定元素是靜

態(tài)的，但JAVA對象本身從來不會存放在靜態(tài)存儲空間里。

5）常量存儲（constantstorage）。常量值（final）程序代碼內部，這樣做是安全的，

因為它們永遠不會被改變。有時，在嵌入式系統(tǒng)中，常量本身會和其他部分分割

離開，所以在這種情況下，可以選擇將其放在ROM中（從硬盤加載源代碼）

6）非RAM存儲。如果數(shù)據(jù)完全存活于程序之外，那么它可以不受程序的任何控制，

在程序沒有運行時也可以存在。在流對象中，對象轉化成字節(jié)流。通常被發(fā)送給

另外一臺機器。在“持久化對象“中，對象被存放于磁盤上。

就速度來說，有如下關系：

寄存器(堆棧<堆<其他

2.2.2特例：基本類型

基本類型不用new來創(chuàng)建變量，而是創(chuàng)建一個并非是引用的”自動“變量。這個

變量直接存儲”值“，并置于棧中，因此更加高效。這里僅指八種基本類型(長度固

定)。

Java語言提供了八種基本類型。六種數(shù)字類型(四個整數(shù)型，兩個浮點型)，一種字

符類型，還有一種布爾型。

1、整數(shù)：包括int,short,byte,long,初始值為0

2、浮點型：float,double,初始值為0.0

3、字符：char,初始值為空格，即”"，如果輸出，在Console上是看不到效果的。

4、布爾：boolean,初始值為false。

基本型別大小最小值最大值

boolean———

char16-bitUnicode0Unicode2八16-1

byte8-bit-128+127

short16-bit-2*15+2~15-1

int32-bit-2*31+2'31-1

long64-bit-2*63+2*63-1

float32-bitIEEE754IEEE754

double64-bitIEEE754IEEE754

void

注意：表格里的人代表的是次方;

java米用unicode,2個字節(jié)來表示一個字符。

所有數(shù)值類型都有正負號。

byte(8bit)<char,short(16bit)<int(32bit)

基本類型具有包裝類，使得可以在堆中創(chuàng)建一個非基本對象。用來表示基本類型。

charc='x';〃存放在棧

Characterch=newCharacter('x');

高精度數(shù)字

Java提供了兩個高精度計算的類：Biginteger和BigDecimaL

Biginteger支持任意精度的整數(shù)。

BigDecimal支持任何精度的定點數(shù)。

2.2.3java中的數(shù)組

java確保數(shù)組會被初始化，而且不能在它的范圍之外被訪問。是以每個數(shù)組上少量的

內存開銷及運行時的下標檢查為代價的。

創(chuàng)建一個數(shù)組對象時，實際上是創(chuàng)建了一個引用數(shù)組，一旦Java看到null。就知道這

個引用還沒有指向某個對象。在使用任何引用前，必須為其指定一個對象；如果試圖

使用一個還是null的引用，在運行時將會報錯。

2.3永遠不需要銷毀對象

2.3.1作用域：決定生命周期

作用域決定了在其內定義的變量名的可見性和生命周期。

intx=12;

intx=96;〃報錯。不同于java。

}

1

2.3.2對象的作用域〃存活于作用域之外

java對象不具備和基本類型一樣的生命周期。當用new創(chuàng)建一個Java對象時，它可以

存活于作用域之外。

Java有一個垃圾回收器，用來監(jiān)視用new創(chuàng)建的所有對象。

2.4創(chuàng)建新的數(shù)據(jù)類型：類

5.4.1字段和方法

一旦定義了一個類（在java中你所做的全部工作就是定義類，產(chǎn)生那些類的對象，以

及發(fā)送消息給這些對象），就可以在類中設置兩種類型的元素：字段（有時被稱作數(shù)

據(jù)成員）和方法（有時被稱為成員函數(shù)）

基本成員默認值

若基本數(shù)據(jù)類型作為類成員的時候，即使沒有進行初始化。java也會給定默認的初始

值。默認是如下所示：

booleanfalse

char7uoooo*(null)

byte(byte)O

short(short)O

int0

long0L

floatO.Of

doubleO.Od

當變量作為作為類成員使用時，java才確保給定其初始值，防止程序運行時錯誤。

但是這些初始值對你的程序來說是不正確的。所以必須明確指定初始值。然而以上所

訴并不適用于“局部”變量(即：非某個類的字段)。因此在某個方法中定義inti；那么變

量i可能得到的是任一值。不會被初始化為0。所以使用前先付一個適當?shù)闹?。如果?/p>

記了，java會在編譯時返回一個錯誤。告訴你此變量沒有初始化。在類中定義對象的

引用時，如果沒有給定初始化值，此引用會默認為null值。

也就是說在java中基本類型的默認值是0,引用類型會默認為nulL

注意：只認類的成員才能初始化。對局部變量那個要顯示初始化。

2.5方法、參數(shù)和返回值

intx=a.f()；〃向對象a發(fā)送f()消息。

2.5.1參數(shù)列表

2.6構建一個java程序

static關鍵字：兩種方法調用類方法和類數(shù)據(jù)。(最好是用類名直接引用，在某

些情況下它為編譯器進行優(yōu)化提供了更好的機會)當創(chuàng)建類時，就是在描述那個類的

對象的外觀與行為。當聲明一個事物是static時，就意味著這個域或方法不會與包含

它的那個類的任何對象實例關聯(lián)在一起。

2.7注釋和嵌入式文檔

javadoc便是用于提取注釋的工具。

2.7.1語法

三種類型的注釋文檔：類，域和方法。

/*Aclasscomment*/類注釋

publicclassDocumentation1

/**Afieldcomment7域注釋

publicinti;

/**Amethodcomment*/方法注釋

publicvoidf(){}

}

javadoc只能為public(公共)和protected成員進行文檔注釋。

可以通過-private進行標記，以便把private成員的注釋也包括在內。

第三章操作符

1.操作符接受一個或多個參數(shù)，并生成一個新值。Java中幾乎所有的操作符都只能操

作“基本類型"。例外的操作符是“="、和"！=”，這些操作符能操作所有

的對象。除此之外，String類支持“+”和“+=”。

2.賦值使用操作符“=”。它的意思是“取右邊的值(即右值)，把它復制給左邊(即

左值)。對一個對象進行賦值時，我們真正操作的是對對象的引用。通過Random類

的對象，傳遞給nextlnt。的參數(shù)設置了所產(chǎn)生的隨機數(shù)的上限，而其下限為0。比較內

容相等：1)對于對象，使用的是equals。。2)對于基本類型，使用==和！=。而如果

對于對象使用==和！=比較的是對象的引用。

3.==andequal?

inta=3,b=3;

Integeri=newInteger(3);

Integerm=newInteger(3);

System.out.println(i==m);//false(1)

System.out.println(a==i);//true(2)

//inta=b=3;〃在java中會編譯報錯

System.out.println(a==b);//true(3)

Stringsi="Monday";

Strings2="Monday";

System.out.println(s1==s2);//true(4)比較引用，因為是在常量區(qū)分配。

System.out.println(sl.equals(s2));//true(5)

Stringsll="Monday";

Strings22=newString("Monday");

System.out.println(sll==s22);//false(6)

System.out.println(s11.equals(s22));//true(7)

1.(1)說明new方法在線程區(qū)變量中分配內存。與(2)比較,

inta=3;

intb=3；

編譯器先處理inta=3；首先它會在棧中創(chuàng)建一個變量為a的引用，然后查找棧中是否

有3這個值，如果沒找到，就將3存放進來，然后將a指向3。接著處理intb=3；在

創(chuàng)建完b的引用變量后，因為在棧中已經(jīng)有3這個值，便將b直接指向3。這樣，就

出現(xiàn)了a與b同時均指向3的情況。這時，如果再令a=4；那么編譯器會重新搜索棧

中是否有4值，如果沒有，則將4存放進來，并令a指向4；如果已經(jīng)有了，則直接將

a指向這個地址。因此a值的改變不會影響到b的值。要注意這種數(shù)據(jù)的共享與兩個

對象的引用同時指向一個對象的這種共享是不同的，因為這種情況a的修改并不會影

響到b,它是由編譯器完成的，它有利于節(jié)省空間。而一個對象引用變量修改了這個對

象的內部狀態(tài)，會影響到另一個對象引用變量。

String是一個特殊的包裝類數(shù)據(jù)。可以用：

Stringstr=newString("abc");

Stringstr="abc";

兩種的形式來創(chuàng)建，第一種是用new()來新建對象的，它會在存放于堆中。每調用一

次就會創(chuàng)建一個新的對象。

->Stringstr=newString("abc");自己補充：應該說有會產(chǎn)生兩個對象，一個為new

String(“abc")的實體對象放到內存堆中，一個為堆棧對象str也就是類實例對象的引用對

象。

而第二種(Stringstr="abc";)是先在棧中創(chuàng)建一個對String類的對象弓|用變量str,然后查找棧

中有沒有存放"abc",如果沒有,則將"abc"存放進棧,并令str指向“abc”，如果已經(jīng)有“abc”則直

接令str指向“abc”。

比較類里面的數(shù)值是否相等時，用equals。方法；當測試兩個包裝類的引用是否指向同一個對象

時，用==,下面用例子說明上面的理論。

Stringstr1="abc";

Stringstr2="abc";

System.out.println(str1==str2);//true

可以看出str1和str2是指向同一個對象的。

Stringstr1=newString("abc");

Stringstr2=newString("abc");

System.out.println(str1==str2);//false

用new的方式是生成不同的對象。每一次生成一個。

因此用第二種方式(Stringstr="abc";)創(chuàng)建多個”abc”字符串，在內存中其實只存在一

個對象而已.這種寫法有利與節(jié)省內存空間.同時它可以在一定程度上提高程序的運行

速度，因為JVM會自動根據(jù)棧中數(shù)據(jù)的實際情況來決定是否有必要創(chuàng)建新對象。而對

于Stringstr=newString("abc")；的代碼，則一概在堆中創(chuàng)建新對象，而不管其字符串

值是否相等，是否有必要創(chuàng)建新對象，從而加重了程序的負擔。

另一方面,要注意:我們在使用諸如Stringstr="abc"；的格式定義類時，總是想當然

地認為，創(chuàng)建了String類的對象str。擔心陷阱！對象可能并沒有被創(chuàng)建！而可能只是

指向一個先前已經(jīng)創(chuàng)建的對象。只有通過new()方法才能保證每次都創(chuàng)建一個新的對

象。由于String類的immutable性質，當String變量需要經(jīng)常變換其值時，應該考慮

使用StringBuffer類(線程安全，很多方法是syncronized的，但在jdk7以上，編譯器

會自動優(yōu)化)，以提高程序效率。

4.移位操作符：“有符號'右移位（?）操作符使用"符號擴展"：若符號為正，則在

高位插入0,若符號為負，則在高位插入1。Java中增加了一種“無符號”右移位操作

符（＞＞＞）,它使用“零擴展”：無論正負，都在高位插入0。如果對char,byte或者

short進行移位，那么在移位進行之前，它們會被轉換為int類型。

5Java不會自動地將int類型轉換為bool類型，所以在編譯時會拋出一個編譯時錯

、口

第四章控制流程

4.1break和continue

break用于強行退出循環(huán)，不執(zhí)行循環(huán)中剩余的語句。而continue則停止執(zhí)行當前的

迭代，然后退回循環(huán)起始處，開始下一次迭代。

同樣的規(guī)則適合whileo

1）一般的continue會退回最內層循環(huán)的開頭（頂部），并繼續(xù)執(zhí)行。

2）帶標簽的continue會達到標簽的位置，并重新進入緊接在那個標簽后面

的循環(huán)。

3）一般的break會中斷并跳出當前循環(huán)。

4）帶標簽的break會中斷并跳出標簽所指的循環(huán)。

4.2goto

標簽是后面跟有冒號的標識符，如：label：。Java中的break和continue同goto使用

了標簽機制。

4.3其他

l.return關鍵字有兩方面的用途：一方面指定一個方法返回什么值（假設它沒有void

返回值），另一方面它會導致當前的方法退出，并返回那個值。

2.switch是一種選擇語句。根據(jù)整數(shù)（int或char類型）表達式的值，switch語句可以

從一系列代碼中選出一段去執(zhí)行。

第五章初始化與清理

初始化和清理正是涉及安全的兩個問題。C++中采用構造器和析構函數(shù)來實現(xiàn)。

Java通過構造器和“垃圾回收”來實現(xiàn)。

5」初始化順序

5.1.1對于單個類

對于靜態(tài)變量、靜態(tài)初始化塊、變量、初始化塊、構造器，它們的初始化順序依次是

（靜態(tài)變量、靜態(tài)初始化塊）＞（變量、初始化塊）〉構造器。

我們也可以通過下面的測試代碼來驗證這一點：

publicclassInitialOrderTest{

〃靜態(tài)變量

publicstaticStringstaticField="靜態(tài)變量";

//變量

publicStringfield="變量"；

//靜態(tài)初始化塊

static{

System.out.println(staticField);

System.out.println("靜態(tài)初始化塊")；

}

//初始化塊

(

System.out.println(field);

System,out.printin("初始化塊");

}

〃構造器

publicInitialOrderTest(){

System.out.println("構造器”)；

}

publicstaticvoidmain(String[]args){

newInitialOrderTest();

}

}

運行以上代碼，我們會得到如下的輸出結果：

1.靜態(tài)變量

2.靜態(tài)初始化塊

3.變量

4.初始化塊

5.構造器

5.1.2對于有繼承關系的類

classParent{

//靜態(tài)變量

publicstaticStringp_StaticField="父類一靜態(tài)變量”;

〃變量

publicStringp_Field="父類一變量"；

protectedinti=9;

protectedintj=0;

//靜態(tài)初始化塊

static{

System.out.println(p_StaticField);

System.out.println，'父類-靜態(tài)初始化塊)

)

//初始化塊

(

System.out.println(p_Field);

System.out.println("殳類--初始化塊");

)

//構造器

publicParent(){

System.out.println("父類-構造器)

System.out.println("i="+i+",j="+j);

j=20;

publicclassSubClassextendsParent{

//靜態(tài)變量

publicstaticStrings_StaticField="子類--靜態(tài)變量"；

〃變量

publicStrings_Field="子類一變量"；

//靜態(tài)初始化戰(zhàn)

static{

System.out.println(s_StaticField);

System.out.println，'字類-靜態(tài)初詔化塊")；

)

//初始化塊

(

System.out.println(s_Field);

System.out.printing子類--初始化塊")；

)

//構造器

publicSubClass(){

System.out.printin("子類一構造器")；

System.out.println("i="+i+",j="+j);

)

//程序入口

publicstaticvoidmain(String[]args){

System.out.printing子類main方法")；

newSubClass();

)

)

運行一下上面的代碼，結果馬上呈現(xiàn)在我們的眼前：

父類--靜態(tài)變量

父類--靜態(tài)初始化塊

子類--靜態(tài)變量

子類-靜態(tài)初始化塊

子類main方法

父類-變量

父類-初始化塊

父類--構造器

i=9,j=0

子類--變量

子類--初始化塊

子類-構造器

i=9,j=20

現(xiàn)在，結果已經(jīng)不言自明了。子類的靜態(tài)變量和靜態(tài)初始化塊的初始化是在父類的變量、初始化

塊和構造器初始化之前就完成了。

靜態(tài)變量、靜態(tài)初始化塊，變量、初始化塊初始化了順序取決于它們在類中出現(xiàn)的先后順序。

執(zhí)行過程分析

⑴訪問SubClass.main。,(這是一個static方法)，于是裝載器就會為你尋找已經(jīng)編譯的SubClass

類的代碼(也就是SubClass.class文件)。在裝載的過程中，裝載器注意到它有一個基類(也就

是extends所要表示的意思)，于是它再裝載基類。不管你創(chuàng)不創(chuàng)建基類對象，這個過程總會發(fā)

生。如果基類還有基類，那么第二個基類也會被裝載，依此類推。

(2)執(zhí)行根基類的static初始化，然后是下一個派生類的static初始化，依此類推。這個順序非常重

要，因為派生類的“static初始化”有可能要依賴基類成員的正確初始化。

⑶當所有必要的類都已經(jīng)裝載結束，開始執(zhí)行main()方法體，并用newSubClass()創(chuàng)建對象。

⑷類SubClass存在父類，則調用父類的構造函數(shù)，你可以使用super來指定調用哪個構造函數(shù)

(也就是Beetle()構造函數(shù)所做的第一件事)。

基類的構造過程以及構造順序，同派生類的相同。首先基類中各個變量按照字面順序進行初始

化，然后執(zhí)行基類的構造函數(shù)的其余部分。

(5)對子類成員數(shù)據(jù)按照它們聲明的順序初始化，執(zhí)行子類構造函數(shù)的其余部分。

Java初始化順序如圖：

1普通類初始化2續(xù)承外系初始化

5.2清理(垃圾回收機制)

L假設你的對象(并非使用new)獲得了一塊“特殊”的內存區(qū)域，由于垃圾回收

器只知道釋放那些經(jīng)由new分配的內存，所以它不知道該如何釋放該對象的這塊“特

殊”內存。為了應對這種情況，Java允許在類中定義一個名為finalize。的方法。

5.3構造器的初始化順序

5.4垃圾回收機制

Java從堆分配空間的速度，可以和其他語言從堆棧上分配空間的速度相媲美。

1.引用計數(shù)是一種簡單但速度很慢的垃圾回收技術。每個對象都含有一個引用計數(shù)

器，當有引用連接至對象時，引用計數(shù)加1.當引用離開作用域或被置為null時，引

用計數(shù)減1.這種方法有一個缺陷，如果對象之間存在循環(huán)引用，可能會出現(xiàn)“對象

應該被回收，但引用計數(shù)卻不為零”的情況。對于垃圾回收器而言，定位這樣的交

互自引用的對象組所需要的工作量極大。引用計數(shù)常用來說明垃圾收集的工作方

式，但似乎從未被應用于任何一種Java虛擬機實現(xiàn)中。

2.自適用的、分代的、停止-復制、標記-清掃”式垃圾回收器

在一些更快的模式中，垃圾回收器并非基于弓I用計數(shù)技術。它們依據(jù)的思想是：對

于任何“活”的對象，一定能最終追溯到其存活在堆?；蜢o態(tài)存儲區(qū)之中的引用。

這個引用鏈會穿過數(shù)個對象層。由此，如果從堆棧和靜態(tài)存儲區(qū)開始，遍歷所有的

引用，就能找到所有”活“的對象。對于發(fā)現(xiàn)的每個引用，必須追蹤它所引用的對

象，然后是此對象包含的所有引用。如此反復進行，直到”根源于堆棧和靜態(tài)存儲

區(qū)的引用“所形成的網(wǎng)絡全部被訪問為止。

“停止-復制“：先暫停程序的運行（所以它不屬于后臺回收模式），然后找到所

有存活的對象從當前堆復制到另一個堆，沒有被復制的全部都是垃圾。當對象被復

制到新堆時，它們是一個個挨著的，所以新堆保持緊湊排列，然后就可以按簡單、

直接地分配新空間了。當把對象從一處搬到另一處時，所有指向它的那些引用都必

須修正。

“標記-清掃”：所依據(jù)的思路同樣是從堆棧和靜態(tài)存儲區(qū)出發(fā)，遍歷所有的引

用，進而找出所有存活的對象。每當它找到一個存活對象，就會給對象一個標記，

這個過程中不會回收任何對象。只有全部標記工作完成的時候，清理動作才會開

始。在清理過程中，沒有標記的對象將被釋放，不會發(fā)生任何復制動作。

“自適用”：垃圾回收器將對上次回收動作之后新分配的塊進行整理。這對處理大

量短命的臨時對象很有幫助。垃圾回收器會定期進行完整的清理動作一大型對象任

然不會被復制（只是其代數(shù)會增加），內含小型對象的那些塊則被復制并整理。

Java虛擬機會進行監(jiān)視，如果所有對象都很穩(wěn)定，垃圾回收器的效率降低的話，就

切換到“標記-清掃”方式；同樣，Java虛擬機會跟蹤“標記-清掃”效果，要是堆

空間出現(xiàn)很對碎片，就會切換回“停止-復制”方式。這就是“自適應”。

5.5枚舉類的初始化

5.6本章相關概念及問題

1.this關鍵字：this關鍵字只能在方法內部使用，表示對“調用方法的那個對象”

的引用。如果在方法內部調用同一個類的另一個方法，就不必用this,直接調用即可。

第六章訪問權限控制

6.1包名及import

-包在項目開發(fā)時經(jīng)常用到，用于為了避免名稱重復而采用的一種措施。包的使用方式

是：

package包名；

如我在開發(fā)時經(jīng)常使用到包名為packageedu.zut.cs.java;

建議包名為“域名倒置+項目名"。這里我用了學校的域名。

-若某個類需要訪問，則此類必須聲明為public.

若要訪問不包package內某個public類時，我們要用到import。通過import引用其他

類；

格式：import包名.類名稱；

-JDK常用包的有以下幾個：

(1)java.lang-包含Java語言的一些核心類,如String、Math、Integer、System和

Thread;

(2)java.awt-包含構成抽象窗口工具集的多個類，用于構建和管理應用程序的圖形用

戶界面；

⑶java.applet-包含applet運行所需要的一些類；

(4)-包含執(zhí)行與網(wǎng)絡相關的操作的類；

(5)java.io-包含執(zhí)行與網(wǎng)絡相關的一些類；

(6萬ava.util-包含一些實用工具類，如定義系統(tǒng)特性、與日期日歷相關的方法.

6.2類成員的訪問控制權限

-在中有種訪問控制權限：、

Java4private,defaultprotectedspublic;

其中default控制權限為方法或變量的名字為其前沒有任何訪問權限關鍵字限制。

-各個訪問控制權限的范圍：

(1)private:如果成員方法或成員變量被private修飾，其只能被這個類的內部使用；

(2)default:默認的訪問控制成員可以被這個包中的其他類訪問，子類不能訪問在另

一個包內的父類；

(3)protected:成員方法或變量被protected修飾，這個成員被同一個包中的其他類使

用，也可以被其他包的子類訪問；

(4)public:成員方法或變量被public修飾，其可以被所有包中的類訪問；

-附加一些Java的命名習慣：

(1)包中的字母均為小寫；

(2)類名、接口名應當使用名字，每個單詞首字母大寫；

(3)方法名、變量名第一個字母小寫，其余大寫；

(4)常量名的每個字母大寫。

1-從最大權限到最小權限依次為：public,protected,包訪問權限(沒有關鍵詞)

和private。默認訪問權限沒有任何關鍵字，但通常是指包訪問權限(有時也表

示成為friendly)。這就意味著當前的包中的所有其他類對那個成員都有訪問權

限，但對于這個包之外的所有類，這個成員卻是private。對private的使用是多

么的重要，在多線程環(huán)境中更是如此。

2.Java解釋器的運行過程如下：首先，找出環(huán)境變量CLASSPATH(可以通過操作

系統(tǒng)來設置，有時也可通過安裝程序-用來在你的機器上安裝Java或者基于Java

的工具-來設置）。CLASSPATH包含一個或者多個目錄，用作查找.class文件的

根目錄。從根目錄開始，解釋器獲取包的名稱并將每個句點替換成反斜杠，以

從CLASSPATH根中產(chǎn)生一個路徑名稱（于是，packagefoo.bar.baz就變成為

foo\bar\baz或foo/bar/baz或其他，這取決于操作系統(tǒng)）。得到的路徑會與

CLASSPATH中的各個不同的項相連接，解釋器就在這些目錄中查找與你所要創(chuàng)

建的類名稱相關的.class文件。（解釋器還會去查找某些涉及Java解釋器所在

的位置的標準目錄。）

取得對某成員的訪問權的唯一途徑是：使該成員成為通過不加

3.1）publico2）

訪問權限修飾詞并將其它類放置于同一個包內的方式給成員賦予包訪問權。3）

繼承而來的類既可以訪問public成員也可以訪問protected成員（但不能訪問

private成員卻不行）。只有在兩個類都處于同一個包內時，它才可以訪問包訪

問權限的成員。但現(xiàn)在不必擔心繼承和提供訪問器

protectedo4）（accessor）

和變異器（mutator）方法（也稱get/set方法），以讀取和改變數(shù)值。

4.接口和實現(xiàn)：訪問權限的控制常被稱為是具體實現(xiàn)的隱藏。把數(shù)據(jù)和方法包裝

進類中，以及具體實現(xiàn)的隱藏，常共同被稱為是封裝。其結果是一個同時帶有

特征和行為的數(shù)據(jù)類型。

5.類的訪問權限：1）每個編譯單元（文件）都只能有一個public類。這表示，

每個編譯單元都有單一的公共接口，用public類來實現(xiàn)。public類的名稱必

須完全與含有該編譯單元的文件名相匹配，包括大小寫。3）雖然不是很常見，

但編譯單元內完全不帶public類也是可能的。在這種情況下，可以隨意對文件

命名。

第七章復用類

復用代碼有兩種方式：第一種方法非常直觀：只需在新的類中產(chǎn)生現(xiàn)有類的對象。由

于新的類是由現(xiàn)有類的對象所組成，這種方式稱為組合。第二種方式它按照現(xiàn)有類的

類型來創(chuàng)建新類。無需改變現(xiàn)有類的形式，采用現(xiàn)有類的形式并在其中添加新代碼。

這種神奇的方式稱為繼承。第三種方式是代理：這是繼承和組合之間的中庸之道。

7.1組合語法

只需將對象引用置于新類中即可。對于非基本類型的對象，必須將其引用置于新的類

中。但可以直接定義基本類型對象。類中的域為基本類型時能夠自動被初始化為零。

但是對引用會被初始化為null。如果想初始化這些引用，可以在代碼中的下列位置進

行：

1.在定義對象的地方。這意味著它們總是能夠在構造器被調用之前被初始化。

2.在類的構造器中。

3.就在正要使用這些對象之前，這種方式稱為惰性初始化。在生成對象不值得及

不必每次都生成對象的情況下，這種方式可以減少額外的負擔。

7.2繼承語法

在繼承過程中，需要先聲明“新類與舊類相似”。這種聲明是通過在類主體的左邊花

括號之前，書寫后面緊隨基類名稱的關鍵字extends而實現(xiàn)的。為了繼承，一般的規(guī)

則是將所有的數(shù)據(jù)成員都指定為private,將所有的方法指定為public。

1.初始化基類：繼承并不只是復制基類的接口。當創(chuàng)建了一個導出類的對象時，

該對象包含了一個基類的子對象。這個子對象與你用基類直接創(chuàng)建的對象是一

樣的。二者的區(qū)別在于，后者來自于外部，而基類的子對象被包含在導出類對

象內部。對基類子對象的正確初始化也是至關重要的，而且也僅有一種方法來

保證這一點：在構造器中調用基類構造器來執(zhí)行初始化。Java會自動在導出類

中的構造器中插入對基類構造器的調用。

2.JavaSE5新增加了@Override注解，當你想要復寫某個方法時，可以選擇添加這

個注解。

3.向上轉型：新類和基類之間的關系，這種關系可以用“新類是現(xiàn)有類的一種類

型”。

4.是否使用繼承：一個最清晰的判斷辦法是問一問自己是否需要從新類向基類進

行向上轉型。如果必須向上轉型，則繼承是必要的。

7.3final關鍵字

final通常指：“這是無法改變的"。可能用到final的三種情況：數(shù)據(jù)、方法和類。

1.final數(shù)據(jù)

數(shù)據(jù)恒定不變：1)一個永不改變的編譯時常量。2)一個在運行時被初始化的值，而

你不希望它被改變。它可以在編譯時執(zhí)行計算。但這類常量必須是基于基本數(shù)據(jù)類

型，并且以關鍵字final表示。一個既是static又是final的域只占據(jù)一段不能改變的存

儲空間。對于基本類型，final使數(shù)值恒定不變；而對于對象引用，final使引用恒定

不變。而對象其自身卻是可以被修改的，Java并未提供使任何對象恒定不變的途徑。

定義為public,則可以被用于包之外；定位為static,則強調只有一份；定義為

final,則說明它是一個常量。并不是某個數(shù)據(jù)是final就認為在編譯時可以知道它的

值?？瞻譮inal：所謂空白final是指被聲明為final但又未給定初值的域。必須在

域的定義處或者每個構造器中用表達式對final進行賦值，這正是final域在使用前

總是被初始化的原因所在。final參數(shù)：Java允許在參數(shù)列表中以聲明的方式將參數(shù)

指明為finalo這意味著你無法在方法中更改參數(shù)引用所指向的對象。

2.final方法

使用final方法可以防繼承修改，又可以提高效率(但在JavaSE5/6中，應該讓編譯器

去處理效率)。類中的所有private方法都隱藏地指定為final的。

3.final類

由于final類禁止繼承，所有final類中所有的方法都隱式指定為是final的，因為無法

覆蓋它們。

4.thedifferentofstaticbetweenfinal?

4.1static關鍵字

static關鍵字可以用來修飾類的變量，方法和內部類。static是靜態(tài)的意思，也是全局的意

思它定義的東西，屬于全局與類相關，不與具體實例相關。就是說它調用的時候，只是

ClassName.method。,而不是newClassName().method()0newClassName()不就是一個對象了

嗎？static的變量和方法不可以這樣調用的。它不與具體的實例有關。

4.2final關鍵字

final關鍵字有三個東西可以修飾的。修飾類，方法，變量。詳細解釋一下：

在類的聲明中使用final

使用了foial的類不能再派生子類，就是說不可以被繼承了。有些java的面試題里

面，問String可不可以被繼承。答案是不可以，因為java.lang.String是一^final

類。這可以保證String對象方法的調用確實運行的是String類的方法，而不是經(jīng)其

子類重寫后的方法。

在方法聲明中使用final

被定義為final的方法不能被重寫了，如果定義類為final的話，是所有的方法都不

能重寫。而我們只需要類中的某幾個方法，不可以被重寫，就在方法前加final

了。而且定義為final的方法執(zhí)行效率要高的啊。

在變量聲明中使用final

這樣的變量就是常量了，在程序中這樣的變量不可以被修改的。修改的話編譯器會

抱錯的。而且執(zhí)行效率也是比普通的變量要高。final的變量如果沒有賦予初值的

話，其他方法就必需給他賦值，但只能賦值一次。

注意：子類不能重寫父類的靜態(tài)方法哦，也不能把父類不是靜態(tài)的重寫成靜態(tài)的方法。想隱藏

父類的靜態(tài)方法的話，在子類中聲明和父類相同的方法就行了。

5.final、finally和finalize的區(qū)另［|?

final用于聲明屬性，方法和類，分別表示屬性不

可變，方法不可覆蓋，類不可繼承。

finally是異常處理語句結構的一部分，表示總是執(zhí)行。

finalize是Object類的一個方法，在垃圾收集器執(zhí)行的時候會調用被回收對象的此方

法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等

final—修飾符（關鍵字）如果一個類被聲明為final,意味著它不能再派生出新的子類，不

能作為父類被繼承。因此一個類不能既被聲明為abstract的，又被聲明為final的。將變量或方法

聲明為final,可以保證它們在使用中不被改變。被聲明為final的變量必須在聲明時給定初值，而

在以后的引用中只能讀取，不可修改。被聲明為final的方法也同樣只能使用，不能重載。

finally—在異常處理時提供行nally塊來執(zhí)行任何清除操作。如果拋出一個異常，那么相匹

配的catch子句就會執(zhí)行，然后控制就會進入finally塊（如果有的話）。

finalize一方法名。Java技術允許使用finalizeQ方法在垃圾收集器將對象從內存中清除出

去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調

用的。它是在Object類中定義的，因此所有的類都繼承了它。子類覆蓋finalize。方法以整理系統(tǒng)

資源或者執(zhí)行其他清理工作。finalizeQ方法是在垃圾收集器刪除對象之前對這個對象調用的。

7.4初始化及類的加載

初次使用之處也是static初始化發(fā)生之處。所有的static對象和static代碼段都會

在加載時依程序中的順序（即：定義類時的書寫順序）而依次初始化。當然，定義為

static的東西只會被初始化一次。

第八章多態(tài)

多態(tài)通過分離做什么和怎么做，從另一角度將接口和實現(xiàn)分離開來。

8.1多態(tài)

1.多態(tài)的作用：如果有這樣的一個簡單方法，它僅接收基類作為參數(shù)，而不是那些特

殊的導出類。我們不管導出類的存在，編寫的代碼只是與基類打交道。當然，在方法

里編譯器是無法識別導出類還是基類的。

2.將一個方法調用同一個方法主體關聯(lián)起來被稱為綁定。若在程序執(zhí)行之前進行綁

定，叫做前期綁定。后期綁定：就是在運行時根據(jù)對象的類型進行綁定。如果一種語

言能實現(xiàn)后期綁定，就必須具有某種機制，以便在運行時能判斷對象的類型，從而調

用恰當?shù)姆椒āＲ簿褪钦f，編譯器一直不知道對象的類型，但是方法調用機制能找到

正確的方法體，并加以調用。其實是在對象中安置某種“類型信息”。Java中除了

static方法和final方法（private方法屬于final方法）之外，其他所有的方法都是后期

綁定。

3.域和靜態(tài)方法：任何域訪問都由編譯器解析，因此不是多態(tài)的。只有非靜態(tài)方法是

多態(tài)的，域是由編譯器決定的。靜態(tài)方法是與類，而并非與單個對象相關聯(lián)。所以非

靜態(tài)方法是不具有多態(tài)性的。

8.2構造器和多態(tài)

1.構造器實際上是static方法，只不過該static聲明是隱式的，因此并不具有多態(tài)性。

構造器有一項特殊的任務：檢查對象是否被正確地構造。導出類只能訪問它自己的成

員，不能訪問基類中的成員。對象調用構造器要遵照下面的順序：

1）調用基類構造器。這個步驟會不斷地反復遞歸下去。2）按聲明順序調用成員的初

始化方法。3）調用導出構造器的主體。

2.構造器內部的多態(tài)方法的行為

在一般的方法內部，動態(tài)綁定的調用是運行時才決定的，因為對象無法知道它是屬于

方法所在的那個類，還是屬于那個類的導出類。

3.構造器初始化的過程：1）在其他任何事物發(fā)生之前，將分配給對象的存儲空間初始

化為二進制的零。2）調用基類構造器。3）按照聲明的順序調用成員的初始化方法。

4）調用導出類的構造體。

4.協(xié)變返回類型：JavaSE5中添加了協(xié)變返回類型，它表示在導出類中的被覆蓋方法可

以返回基類方法的返回類型的某種導出類型。

第九章接口

9」抽象類和抽象方法

抽象類是普通類與接口之間的一種中庸之道。包含抽象方法的類叫做抽象類。如果一

個類包含一個或多個抽象方法，該類必須被限定為抽象的。（否則，編譯器就會報

錯）。為抽象類創(chuàng)建對象是不安全的（為什么不安全，因為當你想調用該抽象方法

時，卻沒有方法體），所以我們會從編譯器那里得到一條出錯消息。這樣編譯器會確

保抽象類的純粹性。

92接口

1.接口被用來建立類與類之間的協(xié)議。如果接口不添加public關鍵字，則它只具有包

訪問權限，這樣它就只能在同一個包內可用。接口也可以包含域，但是這些域隱式地

是static和final的。只要一個方法操作的是類而非接口，那么你就只能使用這個類及

其子類。創(chuàng)建一個能夠根據(jù)所傳遞的參數(shù)對象的不同而具有不同行為的方法，被稱為

策略模式。策略設計模式：你可以用任何你想要的對象來調用為的方法，只要你的對

象遵循我的接口。類庫是被發(fā)現(xiàn)而非創(chuàng)建的，在這種情況下，可以使用適配器設計模

式。適配器中的代碼獎接受你所擁有的接口，并產(chǎn)生你所需要的接口。

2捱口可以多重繼承，也可以嵌套在類或其他接口中。

34妾口中的域：因為你放入接口中的任何域都自動是static和final的。所以接口就稱

為了一種很便捷的用來創(chuàng)建常量組的工具，但有了JavaSE5,你可以用enum代替。在

接口中定義的域不能是“空final”，但是可以被非常量表達式初始化。

4.當實現(xiàn)某個接口時，并不需要實現(xiàn)嵌套在其內部的任何接口。而且，private接口不

能定義它的類之外被實現(xiàn)。

5推口是實現(xiàn)多重繼承的途徑，而生成遵循某個接口的對象的典型方式就是工廠方法

設計模式。

9.3多重繼承

將所有的接口名都置于implements關鍵字之后，用逗號將它們一一隔開。可以繼承任

意多個接口，并可以向上轉型為每個接口。因為每一個接口都是一個獨立類型。

第十章內部類

工工.工嵌套類和內部類

可以在一個類的內部定義另一個類，這種類稱為嵌套類(nestedclasses),它有兩種

類型：靜態(tài)嵌套類和非靜態(tài)嵌套類。靜態(tài)嵌套類使用很少，最重要的是非靜態(tài)嵌套

類，也即是被稱作為內部類嵌套類從開始引入。其中類又可

(inner)oJDK1.1inner

分為三種：

其一、在一個類(外部類)中直接定義的內部類；

其二、在一個方法(外部類的方法)中定義的內部類；

其三、匿名內部類。

靜態(tài)嵌套類

publicclassStaticTest{

privatestaticStringname="javaJohn”;

privateStringid="X001";

staticclassPerson{

privateStringaddress="swjtu,chenDu,China";

publicStringmail="josserchai@”;〃內部類公有成員

publicvoiddisplayO{

〃System.out.println(id);〃不能直接訪問夕卜部類的非靜態(tài)成員

System.o〃，printlnGw%e);〃只能直接訪問夕卜部類的靜態(tài)成員

System.owZ.println("Inner"+address);//訪問本內部類成員。

publicvoidprintlnfo(){

Personperson=newPerson();

person.display();

“System.out.println(mail);〃不可訪問

〃System.out.println(address);〃不可訪問

System。"力println(person.address);//可以訪問內部類的私有成員

System.o“f.println(person.mail);//可以訪問內部類的公有成員

在靜態(tài)嵌套類內部，不能訪問外部類的非靜態(tài)成員，這是由Java語法中"靜態(tài)方

法不能直接訪問非靜態(tài)成員”所限定。若想訪問外部類的變量，必須通過其它方法解

決，由于這個原因，靜態(tài)嵌套類使用很少。注意，外部類訪問內部類的的成員有些特

別，不能直接訪問，但可以通過內部類來訪問，這是因為靜態(tài)嵌套內的所有成員和方

法默認為靜態(tài)的了。同時注意，內部靜態(tài)類Person只在類StaticTest范圍內可見，若

在其它類中引用或初始化，均是錯誤的。

11.1.2在外部類中定義內部類(非靜態(tài)嵌套類)

對于內部類，通常在定義類的class關鍵字前不加public或private等限制符，若

加了沒有任何影響，同時好像這些限定符對內部類的變量和方法也沒有影響(？)。

11.1.3內部類和匿名內部類

內部類有如下特征：

1.內部類被編譯成名為OuterClassName$lnnerClassName.class的類。

2.內部類可以引用定義在它嵌套的外部類中的數(shù)據(jù)和方法，所以不需要將外部類

對象的引用傳遞給內部類的構造方法，因此，內部類可以拿程序簡單和簡潔。

3.聲明用可見性修飾符聲明內部類，遵從應用于一般類成員的可見性規(guī)則。

4.可以將內部類聲明為static。一個static內部類可以使用外部類的名字訪問。一

個static類是不能訪問外部類的非靜態(tài)成員的。

5.內部類的對象經(jīng)常在外部類中創(chuàng)建。但是也可以從另一個類中創(chuàng)建一個內部類

的對象。如果該內部是非靜態(tài)的，就必須先創(chuàng)建一個外部類的實例，然后用下

面的語法創(chuàng)建一個內部類的對象：

1.OuterClass.InnerClassinnerObject=OutObject.newlnnerclass()

.如果內部類是靜態(tài)的，那么使用下面的語法為它創(chuàng)建一個對象：

Java代碼

2.OuterClass.InnerClassinnerObject=newOutObject.lnnerclass()

匿名內部類是一種特殊的內部類，所以有很多方面都應把它當作內部類對待。除此之

外，它還有以下特征。

1.匿名內部類必須是擴展父類或實現(xiàn)接口的。但是它不能有明確的extends或

implements語句。

2.匿名內部類必須實現(xiàn)父類或接口中所有的抽象方法。

3.匿名內部類總是使用父類的無參數(shù)構造方法來創(chuàng)建實例。如果匿名內部類實現(xiàn)

了接口，構造方法就是Object。.

4.匿名內部類編譯為名為OuterClassName$n.class的類。如,如果外部類Test有

兩個匿名類，那么它們就編譯成和

Test$l.classTest$2.classo

第十一章持有對象

Java實現(xiàn)類庫還提供了一套相當完整的容器類來解決這個問題，其中基本的類型是

List、Set、Queue和Map,這些對象也稱為集合類。Set對于每個值都只保存一個對

象，Map是允許你將某些對象與其他一些對象關聯(lián)起來的關聯(lián)數(shù)組，Java容器類都可

以自動調整自己的尺寸。

11.1基本概念

l.Java容器類類庫的用途是“保存對象”。并劃分為兩個不同的概念。

一個獨立元素的序列，這些元素都服從一條或者多條規(guī)則。

1)Collectiono

List必須按照插入的順序保存元素，而Set不能有重復元素。Queue按照排隊規(guī)

則來確定對象產(chǎn)生的順序(通常與它們插入的順序相同)。

2)Map。一組成對的“鍵值對”對象，允許你用鍵來查找值。ArrayList允

許你使用數(shù)字來查找。也被稱為“關聯(lián)數(shù)組”或者“字典”。

2.Arrays.asList()方法接受一個數(shù)組或是一個用逗號分隔維元素列表(使用可變參數(shù))，

并將其轉換為一個List對象。Collections.addAII。方法接受一個Collection對象，以及一

個數(shù)組或是一個用逗號分割的列表，將元素添加到Collection中。

3.一共有三種風格的Map：HashMap、TreeMap和LinkedHashMap。與HashSet一樣，

HashMap也提供了最快的查找技術，也沒有按照任何明顯的順序來保存其元素。

TreeMap按照比較結果的升序保存鍵，而linkedHashMap則按照插入順序保存鍵，同

時保留了HashMap的查詢速度。

11.2List及LinkedList

可使元素維持在特定的序列中，有兩種基本類型的

ListListo

1)基本的ArrayList,它長于隨機訪問元素，但是在List的中間插入和移除元素時

較慢。

2)LinkedList,它通過代價較低的在List中間進行的插入和刪除操作，提供了優(yōu)化

的順序訪問。LinkedList在隨機訪問相對較慢，但是它的特性集較ArrayList更大。

11.3迭代器

迭代器是一個對象，它的工作是遍歷并選擇序列中的對象，而客戶端程序員不必之道

或關心該序列底層的結構。Java的Iterator只能單向移動。這個Iterator只能用來：

1)使用方法iterator。要求容器返回一個Iterator。Iterator將準備好返回序列的第

一個元素。

2)使用next。獲得序列中的下一個元素。

3)使用hasNext。檢查序列中是否還有元素。

4)使用remove。將迭代器新近返回的元素刪除。

1.Listiterator

Listiterator是一個更加強大的Iterator的子類型，它只能用于各種List類的訪問。盡管

Iterator只能向前移動，但是Listiterator可以雙向移動。

2.Stack

“?！蓖ǔＪ侵?‘后進先出"的容器。LinkedList具有能夠直接實現(xiàn)棧的所有功能的方

法，因此可以直接將LinkedList作為棧使用。

3.Set

Set最常用被使用的是測試歸屬性，你可以很容易地詢問某個對象是否在某個Set中。

TreeSet將元素存儲在紅-黑樹數(shù)據(jù)結構中，而HashSet使用的是散列函數(shù)。

LinkedHashList因為查詢速度的原因也使用了散列。

4.Map是將對象映射到其他對象的能力。

5.Queue

隊列是一個典型的先進先出的容器。隊列在并發(fā)編程中特別重要。LinkedList提供了方

法以支持隊列的行為，并且它將實現(xiàn)Queue接口，因此LinkedList可用作Queue的一

種實現(xiàn)。PriotityQueue提供了典型的隊列規(guī)則。

6.Foreach與迭代器：到目前為止，foreach語法主要用于數(shù)組，但是它也可以應用于

任何Collection對象。JavaSE5引入了新的被稱為Iteratable的接口，該接口包含一個能

夠產(chǎn)生Iterator的iterator。方法，并且Itearable接口被foreach用來在序列中移動。在

JavaSE5中，大量的類都是Iterable類型，主要包含所有的Collection類（但是不包括

各種Map）。當你有一個接口并需要另一個接口時，編寫適配器就可以解決問題。

7.總結：

1）數(shù)組將數(shù)字與對象聯(lián)系起來。

2）Collection保存單一的元素，而Map保存相關聯(lián)的鍵值對。容器不能持有基本類

型，但是自動包裝機制會仔細地執(zhí)行基本類型到容器中所持有的包裝類型之間的雙向

轉換。

3）像數(shù)組一樣，List也建立數(shù)字索引與對象的關聯(lián)，因此，數(shù)組和List都是排序好的

容器。List能夠自動擴容。

4）如果要進行大量的隨機訪問，就使用ArrayList。如果要經(jīng)常從表中間插入或刪除元

素，則應該使用

LinkedListo

5）各種Queue以及棧的行為，由LinkedList提供支持。

6）Map是一種將對象（而非數(shù)字）與對象相關聯(lián)的設計。HashMap設計用來快速訪

問；而TreeMap保持“鍵"始終處于排序狀態(tài),所以沒有HashMap快。

LinkedHashMap保持元素插入的順序，但是也通過散列提供了快速訪問能力。

7）Set不接受重復元素。HashSet提供最快的查詢速度，而TreeSet保持元素處于排序

狀態(tài)。LinkedHashSet以插入順序保存元素。

新程序中不應該使用過時的、和

8）VectorHashtableStacko

:Iterator夕-------C-o-llection------

-j.jProducesProduces

ListlteratorH----------4ListijSet!iQueue

jprndiirpc1i!”HashMapTreeMap

>..K■I^9J————————?_~——————

尸

■■■■■?■■■■■???????■■■■■^|???????a?.???????■??.?

??

胃「1

LinkedHashMap