java基礎(chǔ)知識點總結(jié)

java基礎(chǔ)知識點總結(jié)

CreatedbyAlwenon2017/5/14.

java是面向?qū)ο蟮某绦蛟O(shè)計語言；類可被認為是一種自定義的數(shù)據(jù)類

型，可以使用類來定義變量，所有使用類定義的變量都是引用變量，它們

將會引用到類的對象。類用于描述客觀世界里某一類對象的共同特征，而

對象則是類的具體存在，java程序使用類的構(gòu)造器來創(chuàng)建該類的對象。

java也支持面向?qū)ο蟮娜筇卣鳎悍庋b、繼承、和多態(tài)。java提供了

private、protected＞和public三個訪問控制修飾符來實現(xiàn)良好的封裝，提

供了extends關(guān)鍵字讓子類繼承父類，子類繼承父類就可以繼承到父類的

成員變量和和方法，如果訪問控制允許，子類實例可以直接調(diào)用父類里定

義的方法。繼承是實現(xiàn)類復用的重要手段。使用繼承關(guān)系來實現(xiàn)復用時、

子類對象可以直接賦給父類變量，這個變量具有多態(tài)性。

面向?qū)ο蟮某绦蛟O(shè)計過程中有兩個重要的概念：類（Class）和對象

（也被稱為實例，）類可以包含三種最常見的成員：構(gòu)造

object,instanceo

器、成員變量、和方法。

構(gòu)造器用于構(gòu)造該類的實例,java語言通過new關(guān)鍵字類調(diào)用構(gòu)造器,

從而返回該類的實例。構(gòu)造器是一個類創(chuàng)建對象的根本途徑，如果一個類

沒有構(gòu)造器，這個類通常無法創(chuàng)建實例。因此java語言提供了一個功能:

如果程序員沒有為一個類編寫構(gòu)造器，則系統(tǒng)會為該類提供一個默認的構(gòu)

造器，這個構(gòu)造器總是沒有參數(shù)的。一旦程序員為一個類提供了構(gòu)造器,

系統(tǒng)將不再為該類提供構(gòu)造器。

構(gòu)造器用于對類實例進行初始化操作，構(gòu)造器支持重載，如果多個重

載的構(gòu)造器里包含了相同的初始化代碼，則可以把這些初始化代碼放置在

普通初始化塊里完成，初始化塊總在構(gòu)造器執(zhí)行之前被調(diào)用。靜態(tài)初始化

塊代碼用于初始化類，在類初始化階段被執(zhí)行。如果繼承樹里某一個類需

要被初始化時，系統(tǒng)將會同時初始化該類的所有父類。

構(gòu)造器修飾符：可以是public、protected、private其中之一,或者省

略構(gòu)造器名：構(gòu)造器名必須和類名相同。注意：構(gòu)造器既不能定義返回

值類型，也不能使用void聲明構(gòu)造器沒有返回值。如果為構(gòu)造器定義了返

回值類型，或使用void聲明構(gòu)造器沒有返回值，編譯時不會出錯，但java

會把這個所謂的構(gòu)造器當成方法來處理一一它就不再是構(gòu)造器。

實際上類的構(gòu)造器是有返回值的，當使用new關(guān)鍵字來調(diào)用構(gòu)造器時,

構(gòu)造器返回該類的實例，可以把這個類的實例當成構(gòu)造器的返回值。因此

構(gòu)造器的返回值類型總是當前類，無須定義返回值類型。不要在構(gòu)造器里

顯式的使用return來返回當前類的對象，因為構(gòu)造器的返回值是隱式的。

java類名必須是由一個或多個有意義的單詞連綴而成的，每個單詞首

字母大寫，其他字母全部小寫，單詞與單詞之間不要使用任何分隔符。

成員變量：

成員變量的修飾符：public^protected>private,static、final前三個只

能出現(xiàn)一個再和后面的修飾符組合起來修飾成員變量，也可省略。

成員變量：由一個或者多個有意義的單詞連綴而成，第一個單詞首字

母小寫，后面每個單詞首字母大寫，其他字母全部小寫，單詞與單詞之間

不要使用任何分隔符。

類型：可以是java語言允許的任何數(shù)據(jù)類型，包括基本類型和引用類

型。

成員方法：

方法修飾符：public、protected、privatesstatic>finalsabstract,前

三個只能出現(xiàn)一個，static和final最多只能出現(xiàn)其中的一個,和abstract

組合起來使用。也可省略。

返回值類型：可以是java語言的允許的任何數(shù)據(jù)類型，包括基本類型

和引用類型。

方法名：和成員變量的方法命名規(guī)則相同，通常建議方法名以英文動

詞開頭。

方法體里多條可執(zhí)行語句之間有嚴格的執(zhí)行順序，排在方法體前面的

語句總先執(zhí)行，排在方法體后面的語句總是后執(zhí)行。

static是一個特殊的關(guān)鍵字，它可用于修飾方法、成員變量等成員。static

修飾的成員表明它屬于這個類本身，而不

屬于該類的單個實例，因此通過把static修飾的成員變量和方法被稱

為類變量、類方法（靜態(tài)成員變量，靜態(tài)成員方法）；不使用static修飾的

成員變量和方法稱為實例變量和實例方法（非靜態(tài)成員變量，非靜態(tài)成員

方法）。靜態(tài)成員不能直接訪問非靜態(tài)成員。static的真正作用就是用于區(qū)

分成員變量、方法、內(nèi)部類、初始化塊，這四種成員到底屬于類本身還是

屬于實例。有static修飾的成員屬于類本身，沒有類修飾的成員屬于該類

的實例。

java類大致有如下作用:

定義變量

創(chuàng)建對象

調(diào)用類的類方法或訪問類的類變量。

定義一個類就是為了重復創(chuàng)建該類的實例，同一個類的多個實例具有

相同的特征，而類則是定義了多個實例的共同特征。

類里定義的方法和成員變量都可以通過類或?qū)嵗齺碚{(diào)用。Static修飾

的方法和成員變量，既可通過類來調(diào)用，也可通過實例來調(diào)用；沒有使用

static修飾的普通方法成員變量，只可通過實例來調(diào)用。

Personp=newPerson。;這行代碼創(chuàng)建了一個Person實例，也被稱為

Person對象，這個Person對象被賦給p變量。在這行代碼中實際上產(chǎn)生了

兩個東西，一個是p變量，一個是Person對象。P引用變量本身只存儲了

一個地址值，并未包含任何實際數(shù)據(jù)，但它指向?qū)嶋H的Person對象。

Person對象由多塊內(nèi)存組成，不同內(nèi)存塊分別存儲了Person對象的不

同成員變量。類是一種引用數(shù)據(jù)類型，因此程序中定義的Person類型的變

量實際上是一個引用，它被存放在棧內(nèi)存里，指向?qū)嶋H的Person對象；而

真正的Person對象則存放在堆內(nèi)存中。

當一個對象被創(chuàng)建成功以后，這個對象將保存在堆內(nèi)存中，java程序

不允許直接訪問堆內(nèi)存中的對象，只能通過該對象的引用操作該對象。堆

內(nèi)存里的對象可以有多個引用，即多個引用變量指向同一個對象。

如果堆內(nèi)存里的對象沒有任何變量指向該對象，那么程序?qū)o法再訪

問該對象，這個對象也就變成了垃圾，java垃圾回收機制將回收該對象，

釋放該對象所占的內(nèi)存區(qū)。

對象的this引用

Java提供了一個this關(guān)鍵字,this關(guān)鍵字總是指向調(diào)用該方法的對象。

This作為對象的默認引用有兩種情形：構(gòu)造器中引用該構(gòu)造器正在初始化

的對象；在方法中引用調(diào)用該方法的對象。

This關(guān)鍵字最大的作用就是讓類中一個方法，訪問該類里的另一個方

法或者實例變量。

Java允許對象的一個成員直接調(diào)用另一個成員，可以省略this前綴。

如果在static修飾的方法中使用this關(guān)鍵字，則這個關(guān)鍵字就無法指

向合適的對象，所以，static修飾的方法中不能使用this引用。

Java編程時不要使用對象去調(diào)用static修飾的成員變量、方法、而是

應(yīng)該使用類去調(diào)用static修飾的成員變量、方法。

如果確實需要在靜態(tài)方法中訪問另一個普通方法，則只能重新創(chuàng)建一

個對象。

大部分的時候，普通方法訪問其他方法、成員變量時無須使用this前

綴，但如果方法里有個局部變量和成員變量同名，但程序又需要在該方法

里訪問這個被覆蓋的成員變量，則必須使用this前綴。

This引用也可以用于構(gòu)造器中作為默認引用，由于構(gòu)造器時直接使用

new關(guān)鍵字來調(diào)用，而不是使用對象來調(diào)用的，所以this在構(gòu)造器中代表

該構(gòu)造器正在初始化對象。

方法：

Java里的方法不能獨立存在，所有的方法都必須定義在類里。如果這

個方法是用來static修飾，則這個方法屬于這個類，否則這個方法屬于這

個類的實例。執(zhí)行方法時，必須使用類或者對象作為調(diào)用者。同一個類的

一個方法調(diào)用另外一個方法時.，如果被調(diào)方法是普通方法，則默認使用this

作為調(diào)用者，如果被調(diào)用方法是靜態(tài)方法，則默認使用類

作為調(diào)用者。也就是說java中看起來某些方法可以被獨立執(zhí)行，但實

際上還是使用this或者類來作為調(diào)用者。Java里方法參數(shù)傳遞方式只有

一種：值傳遞。所謂值傳遞，就是講實際參數(shù)值的副本（復制品）傳入方

法內(nèi)，而參數(shù)本身不會受到任何影響。

從JDK1.5之后，java允許定義形參個數(shù)可變的參數(shù)，從而允許為方法

指定數(shù)量不確定的形參。如果在定義方法時，在最后一個形參的類型后增

加三點（？），則表明該形參可以接受多個參數(shù)值，多個參數(shù)值被當成數(shù)組

傳入。

長度可變的形參。

方法重載：

Java允許同一個類里定義多個同名方法，只要形參列表不同就行。如

果同一個類中包含了兩個或兩個以上方法的方法名相同，但形參列表不同,

則被稱為方法的重載。

Java程序確定一個方法需要三個要素：調(diào)用者；方法名；形參列表。

Java中變量分為：成員變量和局部變量。成員變量被分為類變量和實

例變量兩種，定義成員變量時沒有static修飾的就是實例變量，有static

修飾的就是類變量。

?變量的命名：從程序的可讀性角度來看，應(yīng)該是多個有意義的單詞

連綴而成，其中第一個單詞首字母小寫，后面

每個單詞首字母大寫。

?如果通過一個實例修改了類變量的值，由于這個類變量并不屬于它,

而是屬于它對應(yīng)的類。因此，修改的依然是

類變量，與通過該類來修改類變量的結(jié)果完全相同，這會導致該類的

其他實例來訪問這個類變量時也將獲得這個被修改過的值。

?成員變量無須顯式初始化，只要為一個類定義了類變量或?qū)嵗兞?

系統(tǒng)就會在這個類的初始化階段或創(chuàng)建該類

的實例時，進行默認初始化。

?實例變量隨實例的存在而存在，而類變量則隨類的存在而存在。實

例也可訪問類變量，同一個類的所有實例訪問

類變量時，實際上訪問的是該類本身的同一個變量，也就是說，訪問

了同一片內(nèi)存區(qū)。

?局部變量根據(jù)定義形式的不同，又可分為三種形式：形參，方法局

部變量，代碼塊局部變量；局部變量除了形參

之外，都必須顯示初始化。

?在同一個類里，成員變量的作用范圍是整個類內(nèi)有效，一個類里不

能定義兩個同名的成員變量，即使一個是類變

量，一個是實例變量也不行；一個方法里不能定義兩個同名的方法局

部變量，方法局部變量與形參也不能同名；同一個方法中不同代碼塊內(nèi)局

部變量可以同名；如果先定義代碼塊局部變量，后定義方法局部變量，前

面定義的代碼塊局部變量與后面定義的方法局部變量也可同名.

?Java允許局部變量和成員變量同名，如果方法里的局部變量和成員

變量同名，局部變量會覆蓋成員變量，如果需

要在這個方法里引用被覆蓋的成員變量，則可使用this(對于實例變量)

或類名(對于類變量)作為調(diào)用者來限定訪問成員變量。

publicclassVariableOverrideTest{

〃定義一個name實例變量

privateStringname="李剛";

〃定義一個price類變量

privatestaticdoubleprice=78.0;

publicstaticvoidmain(String[]args){

〃方法里局部變量覆蓋成員變量，將輸出price的局部變量65

intprice=65;

System.out.println(price);

〃使用類名作為price變量的限定，將輸出price類變量的值

System.out.println(VariableOverrideTest.price);

newVariableOverrideTest().info();

)

publicvoidinfo(){

〃方法里的局部變量，局部變量覆蓋成員變量，輸出name局部變量

的值：孫悟空

Stringname="孫悟空"；

System.out.println(name);

〃將輸出name實例的值：李剛

System.out.println(this.name);

)

)

當系統(tǒng)加載類或創(chuàng)建該類的實例時.，系統(tǒng)自動為成員變量分配內(nèi)存空

間，并在分配內(nèi)存空間后，自動為成員變量指定初始值。

Personpl=newPerson。;時，如果這行代碼是第一次使用Person類，則

系統(tǒng)通常會在第一次使用Person類時加載這個類，并初始化這個類。局

部變量定以后，必須經(jīng)過顯式初始化后才能使用，系統(tǒng)不會為局部變量執(zhí)

行初始化。局部變量不屬于任何類或者實例，因此它總是保存在其所在方

法的棧內(nèi)存中。如果局部變量時基本類型的變量，則直接把這個變量的值

保存在該變量對應(yīng)的內(nèi)存中；如果局部變量是一個引用類型的變量，則這

個變量里存放的是地址，通過該地址引用到該變量實際引用的對象或者數(shù)

組。

棧內(nèi)存中的變量無須系統(tǒng)垃圾回收，往往隨是方法或代碼塊的運行結(jié)

束而結(jié)束。

如果定義的某個變量是用于描述某個類或某個對象的固有信息的，這

種變量應(yīng)該定義成成員變量。如果這種信息對這個類的所有實例完全相同,

或者說它是類相關(guān)的，則該定義成類變量；如果這個信息是實例相關(guān)的，

則應(yīng)該定義成實例變量。

用于保存某個類或某個實例狀態(tài)信息的變量通常應(yīng)該使用成員變量。

如果某個信息需要在某個類的多個方法之間進行共享，則這個信息應(yīng)該使

用成員變量來保存。

隱藏和封裝

訪問控制符用于控制一個類的成員是否可以被其他類訪問。Java提

供了3個訪問控制修飾符:private,protected,和public,還有一個默認訪

問控制修飾符default

Private(當前類訪問權(quán)限)；default(包訪問權(quán)限)；protected(子類訪

問權(quán)限)：如果一個成員使用protected訪問修飾符修飾，那么這個成員既

可以被同一個包中的其他類訪問，也可以被不同包中子類訪問。通常情況

下，使用protected修飾的方法，通常希望其子類來重寫這個方法。Public

(公共訪問權(quán)限)

對于局部變量而言，其作用域就是它所在的方法，不可能被其他類訪

問，因此不能使用訪問控制符來修飾。外部類只能有兩種訪問控制級別：

public和默認，不能使用private和protectedpublicclassPerson{

privateStringname;

privateintage;

publicvoidsetName(Stringname){

if(name.length()>61|name.length()<2){

System.out.println("error");

return;

)

else{

=name;

)

)

publicStringgetName(){

return;

}

publicvoidsetAge(intage){

if(age>100||age<0){

System.out.println("error");

}else{

this.age=age;

)

)

publicintgetAge(){

returnthis.age;

)

構(gòu)造器：

構(gòu)造器最大的用途是創(chuàng)建對象時執(zhí)行初始化。當創(chuàng)建一個對象時，系

統(tǒng)為這個對象的實例變量進行默認初始化，這種默認的初始化把所有基本

類型的實例變量設(shè)為0(對數(shù)值型實例變量)或false(對布爾型實例變量)，

把所有引用類型的實例變量設(shè)為null。如果想改變這種默認的初始化，想

讓系統(tǒng)創(chuàng)建對象時就位該對象的實例變量顯式指定初始值，就可以通過構(gòu)

造器來實現(xiàn)。

因為構(gòu)造器主要用于被其他方法調(diào)用，用以返回該類的實例，因而通

常把構(gòu)造器設(shè)置成public訪問權(quán)限，從而允許系統(tǒng)中任何位置的類來創(chuàng)建

該類的對象。如果設(shè)置成protected,主要用于被子類調(diào)用；設(shè)置為private,

阻止其他類創(chuàng)建該類的實例。

如果系統(tǒng)中包含了多個構(gòu)造器，其中一個構(gòu)造器B的執(zhí)行體里完全包

含另一個構(gòu)造器A的執(zhí)行體。為了這構(gòu)造器

B中重載的構(gòu)造器時，系統(tǒng)會根據(jù)this后括號里的實參來調(diào)用形參列

表與之對應(yīng)的構(gòu)造器

類的繼承：

Java繼承通過extends關(guān)鍵字來實現(xiàn)實現(xiàn)繼承的類被稱為子類，被繼

承的類被稱為父類，有的也稱為基類、超類。

因為子類是一種特殊的父類，因此父類包含的范圍總比子類包含的范

圍要大。

Java子類不能獲得父類的構(gòu)造器

重寫父類方法：

子類擴展了父類，子類是一個特殊的父類。大部分時候，子類總是以

父類為基礎(chǔ)，額外增加新的成員變量和方法。但有一種情況例外：子類需

要重寫父類方法。publicclassBird{

//Bird類的fly()方法

publicvoidfly(){

System.out.printing我在天空中飛")；

)

)

publicclassOstrichextendsBird{

〃重寫B(tài)ird類的fly()方法

publicvoidfly(){

System.out.printing我在陸地上飛")；

)

publicstaticvoidmain(String[]args){

〃創(chuàng)建Ostrich對象

Ostrichor=newOstrich();

〃執(zhí)行Ostrich對象的fly()方法，將輸出“我在陸地上飛”

or.fly();

)

}

這種子類包含與父類同名方法的現(xiàn)象被稱為方法重寫(Override),也

被稱為方法覆蓋?？梢哉f子類重寫了父類的方法，也可以說子類覆蓋了父

類的方法。

方法的重寫要遵循“兩同兩小一大”規(guī)則，“兩同”即方法名相同、

形參列表相同；“兩小”指的是子類方法的返回值類型應(yīng)比父類方法返回

值類型更小或相等，子類方法聲明拋出的異常類應(yīng)比父類聲明拋出的異常

類更小或相等；“一大”

指的是子類方法的訪問權(quán)限應(yīng)比父類方法的訪問權(quán)限更大或相等。

覆蓋方法和被覆蓋方法要么都是類方法，要么都是實例方法。

當子類覆蓋了父類方法后，子類的對象將無法訪問父類中被覆蓋的方

法，但可以在子類方法中調(diào)用被覆蓋的方法。如果需要在子類方法中調(diào)用

父類中被覆蓋的方法，則可以使用super（被覆蓋的是實例方法）或者父

類類名（被覆蓋的是類方法）作為調(diào)用者來調(diào)用父類中被覆蓋的方法。

如果父類方法具有private訪問權(quán)限，則該方法對其子類是隱藏的，因

此其子類無法訪問該方法，也就是無法重寫該方法。

重載只要發(fā)生在同個類多個同名方法之間，而重寫發(fā)生在子類和父類

同名方法之間。父類方法和子類方法之間也可能發(fā)生重載。

Super限定：

Super是Java提供的一個關(guān)鍵字，super用于限定該對象調(diào)用它從父類

繼承得到的實例變量或方法。Super不能出現(xiàn)在static修飾的方法中。Static

修飾的方法是屬于類的，該方法的調(diào)用者可能是一個類，而不是對象，因

而super限定就失去了意義。

如果在構(gòu)造器中使用super,則super用于限定該構(gòu)造器初始化的是該

對象從父類繼承得到的實例變量，而不是該類自己定義的實例變量。

如果子類定義了和父類同名的實例變量，則會發(fā)生子類實例變量隱藏

父類實例變量的情形。在正常情況下，子類里定義的方法直接訪問該實例

變量，默認會訪問到子類中定義的實例變量，無法訪問到父類中被隱藏的

實例變量。在子類定義的實例方法中可以通過super來訪問父類中被隱藏

的實例變量。

如果在某個方法中訪問名為a的成員變量，但沒有顯式指定調(diào)用者，

則系統(tǒng)查找a的順序為：

1.查找該方法中是否有名為a的局部變量

2.查找當前類中是否包含名為a的成員變量

3.查找a的直接父類中是否包含名為a的成員變量，一次上溯a的所

有父類，直到j(luò)ava.Iang.Object類，如果最終

不能找到名為a的成員變量，則系統(tǒng)出現(xiàn)編譯錯誤。

如果被覆蓋的是類變量，在子類的方法中則可以通過父類名作為調(diào)用

者來訪問被覆蓋的類變量

當程序創(chuàng)建一個子類對象時，系統(tǒng)不僅會為該類中定義的實例變量分

配內(nèi)存，也會為它從父類繼承得到的所有實例變量分配內(nèi)存，即使子類定

義了與父類中同名的實例變量。

如果在子類里定義了與父類中已有變量同名的變量，那么子類中定義

的變量會隱藏父類中定義的變量。注意不是完全覆蓋，因此系統(tǒng)在創(chuàng)建子

類對象時，依然會為父類中定義的、被隱藏的變量分配內(nèi)存空間。

調(diào)用父類構(gòu)造器：

子類不會獲得父類的構(gòu)造器，但子類構(gòu)造器里可以調(diào)用父類構(gòu)造器的

初始化代碼。在一個構(gòu)造器里調(diào)用另一個重載的構(gòu)造器使用this調(diào)用來完

成，在子類構(gòu)造器中調(diào)用父類構(gòu)造器使用super調(diào)用來完成。

publicclassBase{

publicdoublesize;

publicStringname;

publicBase(doublesize,Stringname){

this.size=size;

=name;

)

)

publicclassSubextendsBase{

publicStringcolor;

publicSub(doublesize,Stringname,Stringcolor){

〃通過super調(diào)用父類構(gòu)造器的初始化過程

super(size,name);

this.color=color;

)

publicstaticvoidmain(String[]args){

Subs=newSub(5.6,“測試，"red");

System.out.println(s.size+","++",l'+s.color);

)

)

Super調(diào)用的是其父類的構(gòu)造器，而this調(diào)用的是同一個類中重載的

構(gòu)造器；因此，使用super調(diào)用父類的構(gòu)造器也必須出現(xiàn)在子類構(gòu)造器執(zhí)

行體的第一行，所以this調(diào)用和super調(diào)用不會同時出現(xiàn)。

當調(diào)用子類構(gòu)造器來初始化子類對象時，父類構(gòu)造器總會在子類構(gòu)造

器之前執(zhí)行；不僅如此，執(zhí)行父類構(gòu)造器時，系

統(tǒng)會再次上溯執(zhí)行其父類的構(gòu)造器??依次類推，創(chuàng)建任何java對象,

最先執(zhí)行的總是java.lang.Object類的構(gòu)造器。

publicclassCreature{

publicCreature(){

System.out.printing'無參)}

)

publicclassAnimalextendsCreature{

publicAnimal(Stringname){

System.out.println("Animal帶一個參數(shù)的構(gòu)造器"+name);

)

publicAnimal(Stringnamejntage){

〃this調(diào)用同一個重載構(gòu)造器

this(name);

System.out.println("Animal帶兩個參數(shù)的構(gòu)造器"+age);

}

)

publicclassWolfextendsAnimal{

publicWolf(){

super("灰太狼",4);

System.out.println("wolf無參構(gòu)造器")；

)

publicstaticvoidmain(String[]args){

Wolfwf=newWolf();

〃雖然main方法只創(chuàng)建了一個Wolf對象，但系統(tǒng)在底層完成了復雜

的操作，運行將會得到

//無參

〃Animal帶一個參數(shù)的構(gòu)造器灰太狼

//Animal帶兩個參數(shù)的構(gòu)造器4

//wolf無參構(gòu)造器

)

)

創(chuàng)建任何對象總是從該類所在繼承樹最頂層類的構(gòu)造器開始執(zhí)行，然

后依次向下執(zhí)行，最后才執(zhí)行本類的構(gòu)造器。如果某個父類通過this調(diào)用

了同類中重載的構(gòu)造器，就會依次執(zhí)行此父類的多個構(gòu)造器。

4.7多態(tài)：

Java引用變量有兩個類型：一個是編譯時類型，一個是運行時類型。

編譯時類型由聲明該變量時使用的類型決定，運行時類型由實際賦給該變

量的對象決定。如果編譯時類型和運行時類型不一致，就可能出現(xiàn)所謂的

多態(tài)。

publicStringbook="abc";

publicvoidtest(){

System.out.printing子類的覆蓋父類的方法)}

publicvoidsub(){

System.out.printin("子類的普通方法")；

}

publicstaticvoidmain(String[]args){

〃編譯時類型和運行時類型完全一樣，因此不存在多態(tài)

BaseClassbc=newBaseClass();

〃輸出父類be對象的成員變量值：6

System.out.println(bc.book);

bc.test();

bc.base();

〃編譯時類型和運行時類型完全一樣，因此不存在多態(tài)SubClass

sbc=newSubClass();

〃輸出子類對象sbe的成員變量值：abc

System.out.println(sbc.book);

sbc.test();

sbc.sub();

〃下面調(diào)用將執(zhí)行從父類繼承到的base。方法

sbc.base();

〃編譯時類型和運行時類型不一樣，發(fā)生多態(tài)發(fā)生

BaseClassployBc=newSubClass();

〃訪問的是父類對象的實例變量

System.out.println(ployBc.book);

〃執(zhí)行從父類繼承到的base。方法

ployBc.base();

〃調(diào)用將執(zhí)行當前類的test。方法

ployBc.test();

//ployBc.sub();因為編譯時類型是BaseClass,沒有提供sub()

方法，所以編譯會出現(xiàn)錯誤

)

)

因為子類是一種特殊的父類，因此java允許把一個子類對象直接賦給

一個父類引用變量，無須任何類型轉(zhuǎn)換，或者被稱為向上轉(zhuǎn)型，向上轉(zhuǎn)型

由系統(tǒng)自動完全。

對象的實例變量不具備多態(tài)性。

注：

引用變量在編譯階段只能調(diào)用其編譯時類型所具有的方法，但運行時

則執(zhí)行它運行時類型所具有的方法。因此在編寫Java代碼時，引用變量只

能調(diào)用聲明該變量時所用類里包含的方法。例如：Objectp=newPerson。

代碼定義了一個變量P,則這個P只能調(diào)用Object類的方法，而不能調(diào)用

Person類里的方法。

如果需要讓這個引用變量調(diào)用它運行時類型的方法，則必須把它強制

類型轉(zhuǎn)化成運行時的類型，強制類型轉(zhuǎn)換符需要借助于類型轉(zhuǎn)換運算符,

用法是(type)variable

強制類型轉(zhuǎn)換需要注意：

基本類型之間的轉(zhuǎn)換只能在數(shù)值類型之間進行，這里所說的數(shù)值類型

包括，整數(shù)型、字符型和浮點型；但數(shù)值類型和布爾類型之間不能進行類

型轉(zhuǎn)換。

引用類型之間的轉(zhuǎn)換只能在具有繼承關(guān)系的兩個類型之間進行，如果

是兩個沒有任何繼承關(guān)系的類型，則無法進行類型轉(zhuǎn)換。

考慮到強制類型轉(zhuǎn)換時可能出現(xiàn)異常，因此進行類型轉(zhuǎn)換之前應(yīng)先通

過instanceof運算符來判斷是否可以成功轉(zhuǎn)換。

注意：

當把子類對象賦給父類引用變量時，被稱為向上轉(zhuǎn)型，這種轉(zhuǎn)型總是

可以成功的，這也從另一個側(cè)面證實了子類是一種特殊的父類。這種轉(zhuǎn)型

只是表明這個引用變量的編譯時類型是父類，但實際執(zhí)行它的方法時，依

然表現(xiàn)出子類對象行為方式。但把一個父類對象賦給子類引用變量時，就

需要進行強制類型轉(zhuǎn)換，而且還可能在運行時產(chǎn)生ClassCastException異常,

使用instanceof運算符可以讓強制類型轉(zhuǎn)換更安全。

Instanceof運算符：Instanceof運算符前一個操作數(shù)通常是一個引用

類型變量，后一個操作數(shù)通常是一個類(也可以是接口)，它用于判斷前

面的對象是否是后面的類，或者其子類、實現(xiàn)的實例。如果是，則返回ture,

否則返回false.

在使用instanceof運算符時需要注意：instanceof運算符前面操作數(shù)的

編譯時類型要么與后面的類相同，要么與后面的類具有父子繼承關(guān)系，否

則會引起編譯錯誤。

publicclassinstanceofTest{publicstaticvoidmain(String[]args){

〃聲明hello時使用Object類，則hello的編譯類型是Object

//Object是所有類的父類，但hello變量的實際類型是String

Objecthello="hello";

System.out.println((helloinstanceofObject));

//String和Object類存在繼承關(guān)系，可以進行instanceof運算，返回true

System.out.println((helloinstanceofString));

//Math和Object類存在繼承關(guān)系，可以進行instanceof運算，返回false

System.out.println((helloinstanceofMath));

//String實現(xiàn)了Comparabel接口,所以返回true

System.out.println((helloinstanceofComparable));

Stringa="hello";

//String類和Math類沒有繼承關(guān)系，所以下面的代碼編譯無法通過

//System.out.println((ainstanceofMath));

)

)

4.8初始化塊：

初始化塊是一段固定執(zhí)行的代碼，它不能接受任何參數(shù)。因此初始化

塊對同一個類的所有對象所進行的的初始化處理完全相同。如果兩個構(gòu)造

器中有相容的初始化代碼，且這些初始化代碼無須接收參數(shù)，就可以把它

們放在初始化塊中定義。

當創(chuàng)建java對象時，系統(tǒng)總是先調(diào)用該類里定義的初始化塊，相同類

型的初始化塊之間按順序執(zhí)行。初始化塊在執(zhí)行構(gòu)造器之前執(zhí)行。

與構(gòu)造器類型，創(chuàng)建一個java對象時，不僅會執(zhí)行該類的普通初始化

塊和構(gòu)造器，而且系統(tǒng)會一直上溯到j(luò)ava.Iang.Object類，先執(zhí)行

java.lang.Object類的初始化塊，再開始執(zhí)行java.Iang.Object的構(gòu)造器，依

次向下執(zhí)行其子類的初始化塊，再開始執(zhí)行其子類的構(gòu)造器?最后才執(zhí)行

該類的初始化塊和構(gòu)造器，返回該類的對象。

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

如果定義初始化塊時使用了static修飾符，則這個初始化塊就變成了

靜態(tài)初始化塊，也被稱為類初始化塊(普通初始化塊負責對對象執(zhí)行初始

化，類初始化塊則負責對類進行初始化)。靜態(tài)初始化塊總是類相關(guān)的，

系統(tǒng)將在類初始化階段執(zhí)行靜態(tài)初始化塊，而不是在創(chuàng)建對象時才執(zhí)行。

因此靜態(tài)初始化塊總是比普通初始化塊先執(zhí)行。

通常靜態(tài)初始化塊用于對類變量執(zhí)行初始化處理。

與普通初始化塊類型，系統(tǒng)在類初始化階段執(zhí)行靜態(tài)初始化塊時，不

僅會執(zhí)行本類的靜態(tài)初始化塊，而且還會一直上溯到j(luò)ava.lang.Object類,

從最高父類開始一直到本類結(jié)束，依次執(zhí)行每個類中的靜態(tài)初始化塊。

publicclassTest{

publicstaticvoidmain(String[]args){

newLeaf();

newLeaf();

)

)

classRoot{

static{

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

}

System.out.println（"Root的初始化塊）

)

publicRoot(){

System.out.println("Root的無參構(gòu)造器")；

}

)

classMidextendsRoot{

static{

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

)

(

System.out.println("Mid的初始化塊")；

)

publicMid(){

System.out.println("Mid的無參構(gòu)造器")；

)

publicMid(Stringmsg){

〃通過this調(diào)用同一類中重載的構(gòu)造器

this();

System.out.println("Mid的帶有參數(shù)的構(gòu)造器");

}

}

classLeafextendsMid{

static{

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

)

(

System.out.println("Leaf的初始化塊")；

)

publicLeaf(){

super("abc");

System.out.printing執(zhí)行Leaf的構(gòu)造器")；

)

)

Root的靜態(tài)初始化塊

Mid的靜態(tài)初始化塊

類初始化階段，先執(zhí)行最頂層父類的靜態(tài)初始化塊，然后依次向下，

直到執(zhí)行當前類的初始化塊。

對象初始化階段，先執(zhí)行最頂層父類的初始化塊、最頂層父類的構(gòu)造

器，然后依次向下，直到執(zhí)行當前類的初始化塊、當前類的構(gòu)造器

Java系統(tǒng)加載并初始化某個類時，總是保證該類的所有父類(包括直

接父類和間接父類)全部加載并進行初始化。

靜態(tài)初始化塊和靜態(tài)成員變量的執(zhí)行順序與在源程序中排列順序相

同。

第五章面向?qū)ο笙?/p>

5.1java增強的包裝類

為了解決8種基本類型的變量不能當成Object類型變量使用的問題,

java提供了包裝類的概念。

除了int和char有點例外，其他的基本數(shù)據(jù)類型對應(yīng)的包裝類都是將

其首字母大寫即可。

自動裝箱和自動拆箱用法：

1)利用包裝類提供的parseXxx(Strings)靜態(tài)方法

2)利用包裝類提供的Xxx(Strings)構(gòu)造器

String類提供了多個重載的valueOf()方法，用于將基本類型變量轉(zhuǎn)換

成字符串。

publicclassPrimitive2String{

publicstaticvoidmain(String[]args){

StringintStr="123";

〃把一個特定的字符串轉(zhuǎn)換成int變量

intitl=lnteger.parselnt(intStr);

intit2=newInteger(intStr);

System.out.println(it2);

StringfloatStr="4.56";

〃把一個特定的字符串轉(zhuǎn)換成float變量

float代l=Float.parseFloat(floatStr);

floatft2=newFloat(floatStr);

〃把一個float變量轉(zhuǎn)換成String變量

StringftStr=String.valueOf(2.345f);

System.out.println(ftStr);

〃把一個double變量轉(zhuǎn)換成String變量

StringdbStr=String.valueOf(3.344);

System.out.println(dbStr);

〃把一個boolean變量轉(zhuǎn)換成String變量

StringboolStr=String.valueOf(true);

System.out.println(boolStr.tollpperCase());

)

)

如果希望把基本類型變量轉(zhuǎn)換成字符串，還有一種更簡單的方法：將

基本類型變量和””進行連接運算，系統(tǒng)會自動把基本類型變量轉(zhuǎn)換成字

符串。

雖然包裝類型的變量時引用數(shù)據(jù)類型，但包裝類的實例可以與數(shù)值類

型的值進行比較，這種比較是直接取出包裝類實

系統(tǒng)把一個-128-127之間的證書自動裝箱成Integer實例，并放入了一

個名為cache的數(shù)組中緩存起來。如果以后把一個-128-127之間的整數(shù)自

動裝箱成一個Integer實例時，實際上是直接指向?qū)?yīng)的數(shù)組元素，因此

-128-127之間的同一個整數(shù)自動裝箱成Integer實例時,永遠都是引用cache

數(shù)組的同一個數(shù)組元素，所以它們都相等。但如果整數(shù)不在這個范圍內(nèi)，

則會重新創(chuàng)建一個Integer實例。

5.2處理對象

對象打印的誤區(qū)：

重寫toString()方法，通過重寫,就可以讓系統(tǒng)在打印Apple對象時

打印該對象的"自我描述"內(nèi)容publicclassToStringTest{

publicstaticvoidmain(String[]args){

Applea=newApple("red",100);

〃打印Apple對象

System.out.println(a);

)

)

classApple{

privateStringcolor;

privatedoubleweight;

〃提供有參數(shù)的構(gòu)造器

publicApple(Stringcolor,doubleweight){

this.color=color;

this.weight=weight;

)

publicStringgetColor(){

returncolor;

}

publicvoidsetColor(Stringcolor){

this.color=color;

)

publicdoublegetWeight(){

returnweight;

}

publicvoidsetWeigth(doubleweigth){

this.weight=weight;

)

〃重寫toString。方法

publicStringtoString(){

returncolor+",''+weight;

5.2.2==和equals方法

Java中測試兩個變量是否相等有兩種方式，一種是利用==運算符，一

種是利用equals。方法。當使用==來判斷兩個變量是否相等時，如果兩個

變量是基本類型變量，且都是數(shù)值類型(不一定要求數(shù)據(jù)類型嚴格相同)，

則只要兩個變量的值相等，就將返回true.

對于兩個引用類型變量，只有他們指向同一個對象時，==判斷才會返

回true。==不可用于比較類型上沒有父子關(guān)系的兩個對象。

當Java程序直接使用形如"hello”的字符串直接量(包括可以在編譯

時就計算出來的字符串值)時，JVM將會使用常量池來管理這些字符串；

當使用newString("hello")時,JVM會先使用常量池來管理“hello”直

接量,再調(diào)用String類的構(gòu)造器來創(chuàng)建一個新的String對象，新創(chuàng)建的String

對象被保存在堆內(nèi)存中。換句話說，newString("hello")一共產(chǎn)生了兩個

字符串對象。

JVM常量池保證相同的字符串直接量只有一個，不會產(chǎn)生多個副本。

String已經(jīng)重寫了Object的equals。方法,String的equals。方法判斷兩

個字符串相等的標準是：只要兩個字符串所包含的字符序列相同，通過

equals。比較將返回true,否則返回false

類成員不能訪問實例成員

如果一個類始終只能創(chuàng)建一個實例，則這個類被稱為單例類public

classSingletonTest{

publicstaticvoidmain(String[]args){

〃創(chuàng)建Singleton對象不能通過構(gòu)造器，只能通過getInstance方法得到

實例

Singletonsl=Singleton.getlnstance();

Singletons2=Singleton.getlnstance();

System.out.println(sl==s2);

)

)

classSingleton{

〃使用一個類變量來緩存曾經(jīng)創(chuàng)建的實例

privatestaticSingletoninstance;

〃對構(gòu)造器使用private修飾，隱藏該構(gòu)造器

privateSingleton(){}

〃提供一個靜態(tài)方法，用于返回Singleton實例

〃該方法可以加入自定義控制，保證只產(chǎn)生一個Singleton對象

publicstaticSingletongetlnstance(){

〃如果Instance為Null,,則表明還不曾創(chuàng)建singleton對象

〃如果intstance不為null,則表明已經(jīng)創(chuàng)建了Singleton對象,將不會

重新創(chuàng)建新的實例

if(instance==null){

instance=newSingleton();

)

returninstance;

)

5.4final修飾符

Final修飾的變量不可被改變，一旦獲得了初始值，該final變量的值就

不能被重新賦值。因此java語法規(guī)定：final修飾的成員變量必須由程序員

顯式的指定初始值。

Final修飾的類變量、實例變量能指定初始值的地方如下：

類變量：必須在靜態(tài)初始化塊中指定初始值或聲明該類型變量時指定

初始值，而且只能在兩個地方的其中之一指定實例變量：必須在非靜態(tài)

初始化塊、聲明該實例變量或構(gòu)造器中指定初始值，而且只能在三個地方

的其中之一指定。實例變量不能在靜態(tài)初始化塊中指定初始值，因為靜

態(tài)初始化塊時靜態(tài)成員，不可訪問實例變量一一非靜態(tài)成員；類變量不能

在普通初始化塊中指定初始值，因為類變量在類初始化階段已經(jīng)被初始化

了，普通初始化塊不能對其重新賦

finalintc;

finalstaticdoubled;

//ch既沒有指定默認值，有沒有在初始化塊、構(gòu)造器中指定初始值

//finalcharch;

〃初始化塊，對沒有指定默認值的實例變量指定初始值

(

〃在初始化塊中為實例變量指定初始值，合法

str="hello";

〃定義a實例變量時，已經(jīng)指定了默認值，不能重新為a賦值

//a=9;

)

static{

〃在靜態(tài)初始化塊中為類變量指定初始值，合法

d=5.6;

)

publicFinalVariableTest(){

//str在初始化塊中已定義初始值，不可重新賦值

//str="java";

〃構(gòu)造器，可對既沒有指定默認值，又沒有在初始化塊中指定初始值

的實例變量指定初始值

c=5;

)

publicvoidchangeFinal(){

〃普通方法不能為final修飾的成員變量賦值

//d=1.2;

〃不能在普通方法中為final成員變量指定初始值

//ch='a';

)

publicstaticvoidmain(String[]args){

FinalVariableTestft=newFinalVariableTest();

System.out.println(ft.a);

System.out.println(ft.c);

System.out.println(ft.d);

}

)

Final局部變量

系統(tǒng)不會對局部變量進行初始化，局部變量必須由程序員顯式初始化。

因此final修飾局部變量時，既可以在定義時指定默認值，也可以不指定默

認值。如果final修飾的局部變量在定義時沒有指定默認值，則可以在后面

代碼中對該final變量賦初始值，但只能一次，不能重復賦值。

當使用final修飾基本類型變量時，不能對基本類型變量重新賦值，因

此基本列表變量不能改變。但對于引用類型變量而言，它保存的僅僅是一

個引用，final只保證這個引用類型變量所引用的地址不會改變，即一直引

用同一個對象,

〃對數(shù)組元素排序，合法

Arrays.sort(iArr);

System.out.println(Arrays.toString(iArr));

〃對數(shù)組元素賦值，合法

iArr[2]=-8;

System.out.println(Arrays.toString(iArr));

〃對iArr重新賦值，非法

//iArr=null;

〃final修飾Person變量，p是一個引用變量

finalPersonp=newPerson(45);

〃改變p對象的age實例變量，合法

p.setAge(23);

System.out.println(p.getAge());

〃對p重新賦值，非法

//P=null;

)

)

classPerson{

privateintage;

publicPerson(){}

〃有參數(shù)的構(gòu)造器

publicPerson(intage){

this.age

=age;

)

publicvoidsetAge(intage){

this.age=age;

)

publicintgetAge(){

returnage;

)

)

可執(zhí)行“宏替換”的final變量

對于一個final變量來說，不管它是類變量、實例變量,還是局部變量，

只要該變量滿足三個條件，這個final變量就不再是一個變量，而是相當于

一個直接量

1)使用final修飾符修飾

2)在定義該final變量時指定了初始值

3)該初始值可以在編譯時就被確定下來

如果被賦的表達式只是基本的算術(shù)表達式或字符串連接運算，沒有訪

問普通變量，調(diào)用方法,java編譯器同樣會將這種final變量當成''宏變量”

處理。

Java會使用常量池來管理曾經(jīng)用過的字符串直接量，例如執(zhí)行String

a="java”，語句之后，常量池中就會緩存一個字符串“Java”；如果程序再

執(zhí)行Stringb="java"，系統(tǒng)將會讓b直接指向常量池中的"java”字符串,

因此a==b

Final修飾的方法不可被重寫，但是可以重載

Final類

Final修飾的類不可以有子類。因而為了保證某個類不可被繼承，則可

以使用final修飾這個類。

5.5抽象類

抽象方法和抽象類必須使用abstract修飾符來定義，有抽象方法的類

只能被定義成抽象類，抽象類里可以沒有抽象方法。

抽象方法和抽象類的規(guī)則如下：

1）抽象類必須使用abstract修飾符來修飾，抽象方法也必須使用

abstract修飾符來修飾，抽象方法不能有方法體。

2）抽象類不能被實例化，無法使用new關(guān)鍵字來調(diào)用抽象類的構(gòu)造

器創(chuàng)建抽象類的實例。即使抽象類里不包含抽象方

法，這個抽象類也不能創(chuàng)建實例。

3）抽象類可以包含成員變量、方法（普通方法和抽象方法都可以）、

構(gòu)造器、初始化塊、內(nèi)部類（接口、枚舉）5種

成分。抽象類的構(gòu)造器不能用于創(chuàng)建實例，主要是用于被其他子類調(diào)

用。

4）含有抽象方法的類（包括直接定義了一個抽象方法；或繼承了一

個抽象父類，但沒有完全實現(xiàn)父類包含的抽象方法；

或?qū)崿F(xiàn)了一個接口，但沒有完全實現(xiàn)接口包含的抽象方法三種情況）

只能被定義成抽象類。

抽象類：多了一個能力，抽象類可以包含抽象方法；失去了一個能力，

抽象類不能用于創(chuàng)建實例。

定義抽象方法只需在普通方法上增加abstract修飾符，并把普通方法

的方法體(也就是方法后花括號括起來的部分)全部去掉，并在方法后增

加分號即可。

定義抽象類只需在普通類上增加abstract修飾符即可。

/**

*CreatedbyAlwenon2017/5/19.

*/

publicabstractclassShape{

(

System.out.printing執(zhí)行shape的初始化塊...")；

)

privateStringcolor;

〃定義一個計算周長的抽象方法

publicabstractdoublecalPerimeter();

〃定義一個返回形狀的抽象方法

publicabstractStringgetType();

〃定義Shape的構(gòu)造器，該構(gòu)造器并不是用于創(chuàng)建Shape對象，而是

用于被子類調(diào)用publicSh叩e(){}

publicShape(Stringcolor){

System.out.printing'執(zhí)行Shape構(gòu)造器")；

this.color=color;

)

publicvoidsetColor(Stringcolor){

this.color=color;

)

publicStringgetColor(){

returncolor;

)

)

publicclassTriangleextendsShape{

privatedoublea;

privatedoubleb;

privatedoublec;

publicTriangle(Stringcolor,doublea,doubleb,doublec){

super(color);

this.setSides(a,b,c);

)

publicvoidsetSides(doublea,doubleb,doublec){

if(a>=b+c||b>=a+c||c>=a+b){

System.out.printing三角形兩邊之和必須大于第三邊");

return;

)

this.a=a;

this.b=b;

this.c=c;

)

publicdoublecalPerimeter(){

returna+b+c;

)

publicStringgetType(){

return"三角形"；

)

}

publicclassCircleextendsShape{

privatedoubleradius;

publicCircle(Stringcolor,doubleradius){

super(color);

this.radius=radius;

)

publicvoidsetRadius(doubleradius){

this.radius=radius;

)

publicdoublecalPerimeter(){

return2*Math,PI*radius;

)

publicStringgetType(){

returngetColor()+"圓形";

)

publicstaticvoidmain(String[]args){

Shapesl=newTriangle("黑色”,3,4,5);

Shapes2=newCircled黃色”,3);

System.out.println(sl.getType());

System.

out.printin(si.calPerimeter());

System.out.println(s2.getType());

System.out.println(s2.calPerimeter());

)

)

當使用abstract修飾類時，表明這個類只能被繼承；當使用abstract

修飾方法時，表明這個方法必須由子類提供實現(xiàn)(即重寫)。而final修飾

的類不能被繼承，final修飾的方法不能被重寫。因此final和abstract永遠

不能同時使用。

Abstract不能修飾變量，也不能用于修飾構(gòu)造器。

Static和abstract不能同時修飾某個方法，但它們可以同時修飾內(nèi)部

類。

Private和abstract不能同時修飾方法

抽象類不能創(chuàng)建實例，只能當成父類來被繼承。抽象類體現(xiàn)的就是一

種模板模式的設(shè)計。如果編寫一個抽象父類，父類提供了多個子類的通用

方法，并把一個或多個方法留給其子類實現(xiàn)，這就是一種模板模式，模板

模式也是十分常見且簡單的設(shè)計模式之一。

5.6java8改進的接口

接口里不能包含普通方法，接口里的所有方法都是抽象方法。Java8

對接口進行了改進，允許在接口中定義默認方法，默認方法可以提供方法

實現(xiàn)。

接口定義了某一批類所需要遵守的規(guī)范，接口不關(guān)心這些類的內(nèi)部狀

態(tài)數(shù)據(jù)，也不關(guān)心這些類里方法的實現(xiàn)細節(jié)，它只規(guī)定這批類里必須提供

某些方法，提供這些方法的類就可滿足實際需要。

接口是從多個相似類中抽象出來的規(guī)范，接口不提供任何實現(xiàn)。

定義接口使用interface關(guān)鍵字

1）修飾符可以是public或者省略，如果省略了public訪問控制符，

則默認采用包訪問控制符，即只有在相同包結(jié)構(gòu)

下才可以訪問該接口。

2）接口名應(yīng)與類名采用相同的命名規(guī)則，接口名通常能夠使用形容

3）一個接口可以有多個直接父接口，但接口只能繼承接口，不能繼

承類。

由于接口定義的是一種規(guī)范，因此接口里不能包含構(gòu)造器和初始化塊

定義。接口里可以包含成員變量（只能是靜態(tài)常量）、方法（只能是抽象

實例方法、類方法或默認方法）、內(nèi)部類（包括內(nèi)部接口、枚舉）定義。

接口里定義的是多個類共同的公共行為規(guī)范，因此接口里的所有成員,

包括常量、方法、內(nèi)部類和內(nèi)部枚舉都是public訪問權(quán)限。定義接口成員

時，可以省略訪問控制修飾符，如果指定訪問控制修飾符，則只能使用

public訪問控制修飾符。

對于接口里的定義的靜態(tài)常量而言，它們是接口相關(guān)的，因此系統(tǒng)會

自動為這些成員變量增加static和final兩個修飾符。也就是說，在接口中

定義成員變量時，不管是否使用publicstaticfinal修飾符，接口里的成員變

量總是使用這三個修飾符來修飾。而且接口里沒有構(gòu)造器和初始化塊，因

此接口里定義的成員變量只能在定義時指定默認值。

接口里定義的方法只能是抽象方法、類方法或默認方法，因此如果不

是定義默認方法，系統(tǒng)將自動為普通方法增加abstract修飾符；定義接口

里的普通方法時不管是否使用publicabstract修飾符，接口里的普通方法

總是使用publicabstract來修飾。接口里的普通方法不能有方法實現(xiàn)（方

法體）；但類方法、默認方法都必須由方法實現(xiàn)（方法體）.接口里定義的

內(nèi)部類、內(nèi)部接口、內(nèi)部枚舉默認都采用publicstatic兩個修飾符

Java8允許在接口中定義默認方法，默認方法必須使用default修飾，

該方法不能使用static修飾，無論程序是否指定，默認方法總是使用public

修飾。由于默認方法不能使用static修飾，因此不能直接使用接口來調(diào)用

默認方法，需要使用接口的實現(xiàn)類的實例來調(diào)用這些默認方法

Java8允許在接口中定義類方法，類方法必須使用static修飾，該方法

不能使用default修飾。無論程序是否指定，類方法總是使用public修飾。

類方法可以直接使用接口來調(diào)用。

接口中的成員變量默認是使用publicstaticfinal修飾，因此即使另一個

類處于不同包下，也可以通過接口來訪問接口里的成員變量。

從某個角度來看，接口可被當成一個特殊的類，因此一個java源文件

里最多只能有一個Public接口，如果一個java源文件里定義了一個public

接口，則該源文件的主文件名必須與該接口名相同。

接口的繼承：

接口的繼承和類繼承不一樣