2023年JAVA基礎知識點總結(jié)

CreatedbyAlwenon2023/5/14.

java是面向?qū)ο蟮某绦蛟O計語言；類可被認為是一種自定義的數(shù)據(jù)類型，可以使用類來定義變量，所有使用類定義

的變量都是引用變量，它們將會引用到類的對象。類用于描述客觀世界里某一類對象的共同特性，而對象則是類的具

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

Ajava也支持面向?qū)ο蟮娜筇匦?封裝、繼承、和多態(tài)。java提供了private、protected＞和public

三個訪問控制修飾符來實現(xiàn)良好的封裝，提供了extends關(guān)鍵字讓子類繼承父類,子類繼承父類就可以繼承到父類的

成員變量和和方法，假如訪問控制允許，子類實例可以直接調(diào)用父類里定義的方法。繼承是實現(xiàn)類復用的重要手段。

使用繼承關(guān)系來實現(xiàn)復用時，子類對象可以直接賦給父類變量，這個變量具有多態(tài)性。

面向?qū)ο蟮某绦蛟O計過程中有兩個重要的概念：類（Class）和對象（object,也被稱為實例，instance）。類可

以包含三種最常見的成員:構(gòu)造器、成員變量、和方法。A

構(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)造器定義了返回值類型，

或使用v。id聲明構(gòu)造器沒有返回值，編譯時不會犯錯,但java會把這個所謂的構(gòu)造器當成方法來解決——它就不

再是構(gòu)造器。岫事實上類的構(gòu)造器是有返回值的，當使用new關(guān)鍵字來調(diào)用構(gòu)造器時，構(gòu)造器返回該類的實例,可以把

這個類的實例當成構(gòu)造器的返回值。因此構(gòu)造器的返回值類型總是當前類，無須定義返回值類型。不要在構(gòu)造器里顯

式的使用retum來返回當前類的對象，由于構(gòu)造器的返回值是隱式的。A

java類名必須是由一個或多個故意義的單詞連綴而成的，每個單詞首字母大寫，其他字母所有小寫,單詞與單詞之

間不要使用任何分隔符。A

成員變量：A成員變量的修飾符：public、protected、private、static>fina1前三個只能出現(xiàn)一個再和

后面的修飾符組合起來修飾成員變量,也可省略。

成員變量：由一個或者多個故意義的單詞連綴而成，第一個單詞首字母小寫,后面每個單詞首字母大寫，其他字母所

有小寫,單詞與單詞之間不要使用任何分隔符。

類型：可以是java語言允許的任何數(shù)據(jù)類型,涉及基本類型和引用類型。

成員方法：

方法修飾符：pub1ic、protected,private、static^final、abstract,前三個只能出現(xiàn)一個，static

和final最多只能出現(xiàn)其中的一個，和abstract組合起來使用。也可省略。人返回值類型：可以是java語言的

允許的任何數(shù)據(jù)類型，涉及基本類型和引用類型。A方法名:和成員變量的方法命名規(guī)則相同，通常建議方法名以英文

動詞開頭。

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

行。A

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

而不屬于該類的單個實例，因此通過把static修飾的成員變量和方法被稱為類變量、類方法（靜態(tài)成員變量，靜態(tài)

成員方法）；不使用static修飾的成員變量和方法稱為實例變量和實例方法（非靜態(tài)成員變量,非靜態(tài)成員方法）。

靜態(tài)成員不能直接訪問非靜態(tài)成員。Astatic的真正作用就是用于區(qū)提成員變量、方法、內(nèi)部類、初始化塊,這四種

成員到底屬于類自身還是屬于實例。有static修飾的成員屬于類自身，沒有類修飾的成員屬于該類的實例。

java類大體有如下作用：

定義變量始U建對象A調(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對象;而真正的P

erson對象則存放在堆內(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修飾的成員變量、方法、而是應當使用類去調(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ù)組傳入。

publicclassVarargs{

〃定義形參可變的方法,publicstaticvoidtest(inta,String...books){

//books被當成數(shù)組解決

for(Stringtmp:books){

System.out.printIn(tmp);A}ASystera.out.println(a)；

}Apublicstaticvoidmain(String[]args){

〃調(diào)用test方法」力est(5,"he1lo","world","aa")；A}A}

數(shù)組形式的形參可以處在形參列表的任意位置，但個數(shù)可變的形參只能處在形參表的最后。也就是說最多只能有一個

長度可變的形參。

形參可變和傳入數(shù)組的區(qū)別:

publiestaticvoidtest(inta,String...books);^)ublicstaticvoidtest(inta,Str

ing[]books);Mtest(5,"aa","bb","cc");Atest(5,newString[]{"aa","bb","cc'});

方法重載：

Java允許同一個類里定義多個同名方法，只要形參列表不同就行。假如同一個類中包含了兩個或兩個以上方法的方

法名相同，但形參列表不同，則被稱為方法的重載。

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

方法的重載規(guī)定就是兩同一不同：同一個類中方法名相同，參數(shù)列表不同。至于方法的其他部分，如方法返回值類

型、修飾符等,與方法重載沒有任何關(guān)系。

pub1icclassOverloadVarargs{

publievoidtest(Stringmsg){ASystem.。ut.printin("只有一個參數(shù)的test");

)

//由于前面已有了一個字符串參數(shù)的方法,則長度可變形參里不包含一個字符串參數(shù)的形式

publicvoidtest(String...books){

System.out.println("形參可變的test方法”)；

)

publicstaticvoidmain(String[]args){

0verloadVarargso1v=newOverloadVarargs();A//下面兩次調(diào)用將執(zhí)行第二個te

st方法

olv.test()；

olv.test("aa","bb")；

//將調(diào)用第一個test方法二o1v.test("aa");A〃將調(diào)用第二個test方法二

olv.test(newString[]{"aa'})；

Java中變量分為：成員變量和局部變量。成員變量被分為類變量和實例變量兩種，定義成員變量時沒有static修

飾的就是實例變量，有static修飾的就是類變量。

?變量的命名：從程序的可讀性角度來看，應當是多個故意義的單詞連綴而成，其中第一個單詞首字母小寫，后面

每個單詞首字母大寫。

?假如通過一個實例修改了類變量的值，由于這個類變量并不屬于它，而是屬于它相應的類。因此,修改的仍然是

類變量,與通過該類來修改類變量的結(jié)果完全相同，這會導致該類的其他實例來訪問這個類變量時也將獲得這個

被修改過的值。

?成員變量無須顯式初始化,只要為一個類定義了類變量或?qū)嵗兞浚到y(tǒng)就會在這個類的初始化階段或創(chuàng)建該類

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

?實例變量隨實例的存在而存在，而類變量則隨類的存在而存在。實例也可訪問類變量，同一個類的所有實例訪問類

變量時，事實上訪問的是該類自身的同一個變量，也就是說，訪問了同一片內(nèi)存區(qū)。

?局部變量根據(jù)定義形式的不同,又可分為三種形式：形參，方法局部變量，代碼塊局部變量;局部變量除了形參之

外,都必須顯示初始化。

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

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

一個方法中不同代碼塊內(nèi)局部變量可以同名；假如先定義代碼塊局部變量，后定義方法局部變量,前面定義的代碼

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

?Java允許局部變量和成員變量同名，假如方法里的局部變量和成員變量同名，局部變量會覆蓋成員變量，假如

需要在這個方法里引用被覆蓋的成員變量，則可使用this（對于實例變量）或類名（對于類變量）作為調(diào)用者來限

定訪問成員變量。

publicclassVariable0verrideTest{

//定義一個name實例變量privateStringname="李剛"；

//定義一個Price類變量

privatestatiedoubleprice=78.0;ApUbliCstaticvoidmain(String[]arg

s){

//方法里局部變量覆蓋成員變量,將輸出price的局部變量65口intprice=65;

System,out.print1n(price);

//使用類名作為Price變量的限定,將輸出price類變量的值

System,out.printin(VariableOverrideTest.price);

newVariableOverrideTest().info();

}

publicvoidinfo(){A〃方法里的局部變量,局部變量覆蓋成員變量,輸出name局部變量

的值:孫悟空[Stringname="孫悟空";ASystem,out.printin(name)；

//將輸出name實例的值:李剛二System.out.print1n(this.name);

}A}

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

初始值。

Personpl=newPerson();時，假如這行代碼是第一次使用Person類,則系統(tǒng)通常會在第一次使用Person類時

加載這個類，并初始化這個類。

局部變量定以后,必須通過顯式初始化后才干使用，系統(tǒng)不會為局部變量執(zhí)行初始化。局部變量不屬于任何類或者實例,

因此它總是保存在其所在方法的棧內(nèi)存中。假如局部變量時基本類型的變量，則直接把這個變量的值保存在該變量相

應的內(nèi)存中；假如局部變量是一個引用類型的變量，則這個變量里存放的是地址，通過該地址引用到該變量實際引用

的對象或者數(shù)組。

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

假如定義的某個變量是用于描述某個類或某個對象的固有信息的，這種變量應當定義成成員變量。假如這種信息對這

個類的所有實例完全相同，或者說它是類相關(guān)的,則該定義成類變量；假如這個信息是實例相關(guān)的，則應當定義成實例

變量。

用于保存某個類或某個實例狀態(tài)信息的變量通常應當使用成員變量。假如某個信息需要在某個類的多個方法之間進行

共享,則這個信息應當使用成員變量來保存。

隱藏和封裝

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

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

Private(當前類訪問權(quán)限)；defauIt(包訪問權(quán)限)；protected(子類訪問權(quán)限)：假如一個成員使用protected

訪問修飾符修飾，那么這個成員既可以被同一個包中的其他類訪問，也可以被不同包中子類訪問。通常情況下，使用P

rotected修飾的方法,通常希望其子類來重寫這個方法。Public(公共訪問權(quán)限)

對于局部變量而言，其作用域就是它所在的方法，不也許被其他類訪問，因此不能使用訪問控制符來修飾。

外部類只能有兩種訪問控制級別：pub1ic和默認,不能使用Private和protected

pub1icclassPerson{

privateStringname;Aprivateintage;

publicvoidsetName(Stringname){Aif(name,length()>6||name.1ength

()<2){

System.out.println("error")；

return；A}Aelse{Athis.name=name；

)

}

publicStringgetName(){

returnthis,name;A}

pub1icvoidsetAge(intage){Aif(age>100||age<0){

System.out.prin11n("error");A}else{Athis,a

ge=age;A}A}

publieintgetAge(){Areturnthis.age；A}

}

pub1icclassPersonTest{

pub1icstaticvoidmain(String[]args){APersonp=newPerson();A

//下面的變量不會運營錯誤,但是會提醒錯誤

p.setAge(1000);

//由于上面沒有成功設立p的age成員,故輸出0

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

〃成功設立P的age成員p.setAge(30)；

System,out.printin(p.getAge());

//成功設立p的name成員

p.setName("李剛”)；

System,ouf.println(p.getName());

)

}

構(gòu)造器：

構(gòu)造器最大的用途是創(chuàng)建對象時執(zhí)行初始化。當創(chuàng)建一個對象時,系統(tǒng)為這個對象的實例變量進行默認初始化，這種

默認的初始化把所有基本類型的實例變量設為0(對數(shù)值型實例變量)或false(對布爾型實例變量)，把所有引用類

型的實例變量設為null.假如想改變這種默認的初始化，想讓系統(tǒng)創(chuàng)建對象時就位該對象的實例變量顯式指定初始

值，就可以通過構(gòu)造器來實現(xiàn)。

由于構(gòu)造器重要用于被其他方法調(diào)用，用以返回該類的實例，因而通常把構(gòu)造器設立成pub1ic訪問權(quán)限，從而允

許系統(tǒng)中任何位置的類來創(chuàng)建該類的對象。假如設立成protected,重要用于被子類調(diào)用；設立為private,阻止

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

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

調(diào)用構(gòu)造器A中的初始化代碼,又不會重新創(chuàng)建一個java對象，可以使用this關(guān)鍵字來調(diào)用相應的構(gòu)造器。

publicclassApple{ApublicStringname;

publicStringcolor;Apublicdoubleweight；//兩個參數(shù)的構(gòu)造器.publicApp1

e(Stringname,Stringco1or){

this,name=name;Athis.COlor=color;

}

〃三個參數(shù)的構(gòu)造器publicApple(Stringname,Stringcolor,doubleweight){

//通過this調(diào)用另一個重載的構(gòu)造器的初始化代碼

this(name,color)//通過this引用該構(gòu)造器正在初始化的Java對象

this.weight=weight；

)

}

使用this調(diào)用另一個重載的構(gòu)造器只能在構(gòu)造器中使用，并且必須作為構(gòu)造器執(zhí)行體的第一條語句。使用this

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

類的繼承:

Java繼承通過extends關(guān)鍵字來實現(xiàn)實現(xiàn)繼承的類被稱為子類,被繼承的類被稱為父類,有的也稱為基類、超類。

由于子類是一種特殊的父類，因此父類包含的范圍總比子類包含的范圍要大。

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

publicclassFruit{

publiedoubleweight;Apub1icvoidinfo(){ASystem.out.print1n(wei

ght);

)

)

publieclassAppleextendsFruit{//Appie類繼承了Fruit類,所以Apple對象也就有了w

eight成員變量和info()方法口、publicstaticvoidmain(String[]args)(.*A

pp1ea=newApple();

//Apple對象自身沒有weight成員變量,但是,Appie父類有weight成員變量,所以,也可以訪問

App1e對象的weight成員變量

a.weight=56;

//調(diào)用App1e對象的info6方法.a.info();

)

)

Java類只能有一個直接父類,事實上,Java類可以有無限多個間接父類。

重寫父類方法：

子類擴展了父類，子類是一個特殊的父類。大部分時候，子類總是以父類為基礎，額外增長新的成員變量和方法。但

有一種情況例外:子類需要重寫父類方法。

publicclassBird{

〃Bird類的f1y。方法

publicvoidfly(){

System,out.print1n("我在天空中飛")；4)

publicc1assOstrichextendsBird{?*//重寫B(tài)ird類的fly()方法

pub1icvoidfly(){

System,out.rintIn("我在陸地上飛")：A}Apub1iCstaticvoidmain(String[]

args){A//創(chuàng)建0strich對象，Ostrichor=newOstrich();

//執(zhí)行Ostrich對象的fly()方法，將輸出“我在陸地上飛”口or.flyO;

網(wǎng)

這種子類包含與父類同名方法的現(xiàn)象被稱為方法重寫(Override)，也被稱為方法覆蓋。可以說子類重寫了父類的

方法，也可以說子類覆蓋了父類的方法。

方法的重寫要遵循“兩同兩小一大”規(guī)則，“兩同”即方法名相同、形參列表相同；“兩小”指的是子類方法的返回

值類型應比父類方法返回值類型更小或相等，子類方法聲明拋出的異常類應比父類聲明拋出的異常類更小或相等；

“一大”指的是子類方法的訪問權(quán)限應比父類方法的訪問權(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)用者也許是一個類，而不是對象，因而sup

er限定就失去了意義。

假如在構(gòu)造器中使用super,則super用于限定該構(gòu)造器初始化的是該對象從父類繼承得到的實例變量，而不是該

類自己定義的實例變量。

假如子類定義了和父類同名的實例變量，則會發(fā)生子類實例變量隱藏父類實例變量的情形。在正常情況下，子類里定

義的方法直接訪問該實例變量,默認會訪問到子類中定義的實例變量,無法訪問到父類中被隱藏的實例變量。在子類定

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

pub1icc1assBaseClass{Apublieinta=5;

)

publicclassSubClassextendsBaseC1ass{

publicinta=7;

publicvoidaccessOwner(){ASystem.out.printin(a)；A}Apublicv

oidaccessBase(){

//通過super來限定訪問從父類繼承得到的a實例變量

Syst&m.out.printin(super.a);

)

publicstaticvoidmain(String[]args){ASubClasssb=newSubClass();

sb.accessBase();〃輸出5

sb.accessOwner();//輸出7

網(wǎng)

假如在某個方法中訪問名為a的成員變量,但沒有顯式指定調(diào)用者，則系統(tǒng)查找a的順序為:

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

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

3.查找a的直接父類中是否包含名為a的成員變量，一次上溯a的所有父類，直到java.lang.Object類,假如最

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

假如被覆蓋的是類變量,在子類的方法中則可以通過父類名作為調(diào)用者來訪問被覆蓋的類變量

當程序創(chuàng)建一個子類對象時,系統(tǒng)不僅會為該類中定義的實例變量分派內(nèi)存，也會為它從父類繼承得到的所有實例變

量分派內(nèi)存，即使子類定義了與父類中同名的實例變量。

假如在子類里定義了與父類中已有變量同名的變量,那么子類中定義的變量會隱藏父類中定義的變量。注意不是完全

覆蓋,因此系統(tǒng)在創(chuàng)建子類對象時，仍然會為父類中定義的、被隱藏的變量分派內(nèi)存空間。

publicc1assParent{ApublicStringtag="helloworld

}

publicclassDerivedextendsParent{A//定義一"個私有的tag實例變量來隱藏父類的tag實例變量

privateStringtag="abc

publicclassHideTest仙publiestaticvoidmain(String[]args){ADerived

d=newDerived()?//程序不可訪問d的私有變量ta&所以會出現(xiàn)編譯錯誤

//System.out.println(d.tag);

//將d變量顯式的向上轉(zhuǎn)型為Parent后，即可訪問tag實例變量System.out.prin

tIn(((Parent)d),tag);?A}

調(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)用來完畢。

publieclassBase{Apublicdoublesize;

publieStringname;ApublicBase(doublesize,Stringname){

this.size=size;

this.name=name;A}A}

publicclassSubextendsBase{ApublicStringcolorspublicSub(doublesiz

e,Stringname,Stringcolor){A//通過super調(diào)用父類構(gòu)造器的初始化過程supe

r(size,name)；

this,color=color；

}Apublicstaticvoidmain(String[]args){ASubs=newSub(5.6,

"測試"，"red");

System.out.print1n(s.size+”,"+s,name+”,"+s,co1or);A}

}

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)

造器。

publieclassCreature{ApUbliCCreature(){ASystem,ou/,.println(M無參”)；

)

)

publicclassAnimalextendsCreature{Apub1icAnimal(Stringname),S

ystem.out.print1n("Animal帶一個參數(shù)的構(gòu)造器“+name)}ApublicAnimal(String

name,intage){

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

System,oz/f.print1n("Anima1帶兩個參數(shù)的構(gòu)造器"+age)；

)

)

publicc1assWolfextendsAnimal{

publicWolf(){Asuper("灰太狼"，4);ASystem.out.println("wolf無參構(gòu)

造器”)；

}

publiestaticvoidmain(String[]args){

Wolfwf=newWolf();

//雖然main方法只創(chuàng)建了一個Wolf對象,但系統(tǒng)在底層完畢了復雜的操作,運營將會得到

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

//Anima1帶兩個參數(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)。

publicclassBaseC1ass{Apublicintbook=6publicvoidbase(){A

System.out.println("父類的普通方法”);

}Apub1icvoidtest(){

System.out.println("父類被覆蓋的方法”)；

)

)

publicclassSubC1assextendsBaseClass{

//重寫定義一個book實例變量隱藏父類的book實例變量

publicStringbook="abc";Apublicvoidtest(){ASystem.out.println(“子

類的覆蓋父類的方法〃)；

)

publicvoidsub(){

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

pub1icstaticvoidmain(String[]args){

//編譯時類型和運營時類型完全同樣，因此不存在多態(tài)口BaseC1assbc=newBaseC1a

ss();A//輸出父類bc對象的成員變量值:6QSystem.t.println(bc.book)；

be.test();

be.base()；

//編譯時類型和運營時類型完全同樣,因此不存在多態(tài)

SubClasssbc=newSubClass()；A//輸出子類對象sbc的成員變量值:abg

System,out.print1n(sbe.book);ASbe.test()；

sbc.sub();A//下面調(diào)用將執(zhí)行從父類繼承到的base。方法

sbc.base()；

//編譯時類型和運營時類型不同樣,發(fā)生多態(tài)發(fā)生二BaseC1assployBc=new

SubClass()；

//訪問的是父類對象的實例變量System.out.println(p1oyBc.book);A

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

p1oyBc.base();

//調(diào)用將執(zhí)行當前類的test()方法二ployBc.test();

//ployBe.sub()；由于編譯時類型是BaseClass,沒有提供sub()方法,所以編譯會出現(xiàn)錯誤

網(wǎng)

由于子類是一種特殊的父類,因此java允許把一個子類對象直接賦給一個父類引用變量,無須任何類型轉(zhuǎn)換,或者被

稱為向上轉(zhuǎn)型，向上轉(zhuǎn)型由系統(tǒng)自動完全。A對象的實例變量不具有多態(tài)性。

注：

引用變量在編譯階段只能調(diào)用其編譯時類型所具有的方法，但運營時則執(zhí)行它運營時類型所具有的方法。因此在編寫

Java代碼時，引用變量只能調(diào)用聲明該變量時所用類里包含的方法。例如：0bjectp=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)換之前應先通過instanceof運算符來判斷是否可以成功轉(zhuǎn)

換。

注意：

當把子類對象賦給父類引用變量時,被稱為向上轉(zhuǎn)型，這種轉(zhuǎn)型總是可以成功的,這也從另一個側(cè)面證實了子類是一種

特殊的父類。這種轉(zhuǎn)型只是表白這個引用變量的編譯時類型是父類，但實際執(zhí)行它的方法時，仍然表現(xiàn)出子類對象行

為方式。但把一個父類對象賦給子類引用變量時，就需要進行強制類型轉(zhuǎn)換，并且還也許在運營時產(chǎn)生ClassCas

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

Instanceof運算符:

Instanceof運算符前一個操作數(shù)通常是一個引用類型變量，后一個操作數(shù)通常是一個類（也可以是接口），它用于判

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

在使用instanceof運算符時需要注意：instanceof運算符前面操作數(shù)的編譯時類型要么與后面的類相同,要么與

后面的類具有父子繼承關(guān)系,否則會引起編譯錯誤。

publicclassinstanceofTest{

publicstaticvoidmain(String[]args){

//聲明hello時使用Object類,則hel1o的編譯類型是Objec(0//Object是所有類的

父類,{Shello變量的實際類型是String匚Objecthello="he1lo”;

System,out.print1n((helloinstanceofObject));

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

System,out.print1n((helloinstanceofString));

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

System.out.print1n((hel1oinstanceofMath));

//String實現(xiàn)了Comparabel接口，所以返回true口System.out.print

In((he11oinstanceofComparable));

Stringa="hello"；

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

//System.out.printIn((ainstanceofMath))；0}

)

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)會一直上溯到java.1

ang.Object類,先執(zhí)行java.1ang.Object類的初始化塊,再開始執(zhí)行java.1ang.Object的構(gòu)造器,依次向

下執(zhí)行其子類的初始化塊，再開始執(zhí)行其子類的構(gòu)造器…最后才執(zhí)行該類的初始化塊和構(gòu)造器,返回該類的對象。

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

假如定義初始化塊時使用了static修飾符，則這個初始化塊就變成了靜態(tài)初始化塊,也被稱為類初始化塊（普通初

始化塊負責對對象執(zhí)行初始化,類初始化塊則負責對類進行初始化）o靜態(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)初始化塊，并且還會一直上

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

publicclassTest{Apub1icstaticvoidmain(String[]args){

newLeaf();■4newLeaf();

)

}MlassRoot,static,System.。u&println("Root的靜態(tài)初始化塊”)；

}A(

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

}ApublieRoot(){ASystem.ouf.println(*Root的無參構(gòu)造器”)；

}A}AC1assMidextendsRoot{

static{ASystem.out.printIn("Mid的靜態(tài)初始化塊”);

)

(

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

}

publicMid(){

System.ouprintln("Mid的無參構(gòu)造器”);

}ApublicMid(Stringmsg){

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

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

}

}

classLeafextendsMid{

static{ASystem.ouf.print1n(*Leaf的靜態(tài)初始化塊");

)

(

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

}

pub1icLeaf(){

super("abe");

System.out.print1n("執(zhí)行Leaf的構(gòu)造器”)；④}

)

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

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

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

Root的初始化塊

Root的無參構(gòu)造器

Mid的初始化塊

Mid的無參構(gòu)造器

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

Leaf的初始化塊

執(zhí)行Leaf的構(gòu)造器

Root的初始化塊

Root的無參構(gòu)造器

Mid的初始化塊

Mid的無參構(gòu)造器

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

Leaf的初始化塊

執(zhí)行Leaf的構(gòu)造器

類初始化階段，先執(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ù)類型相應的包裝類都是將其首字母大寫即可。

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

publicclassAutoBoxingUnboxing{

publicstaticvoidmain(String[]args){AiT.接把一個底本類暨變位賦給hiteger對象

IntegerinObj=5；

//江接把-一個b()ohn類型變量賦給Objeci類型變0bjectboolObj=true；

//直接把一個Integer對象賦給int類型變量

intit=inObj;

if(boolObjinstanceofBoolean){

//先把Object對象強制類型轉(zhuǎn)換為Boolean類型,再賦給b。olean變量

booleanb=(Boolean)boolObj;^System.out.prin

tln(b)；A}

}

}

包裝類還可實現(xiàn)基本類型變量和字符串之間的轉(zhuǎn)換。把字符串類型的值轉(zhuǎn)換為基本類型的值有兩種方式：

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

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

String類提供了多個重載的value。f()方法，用于將基本類型變量轉(zhuǎn)換成字符串。

publicclassPrimitive2String{*pub1icstaticvoidmain(String[]args){A

StringintStr="123”；

//把一個特定的字符串轉(zhuǎn)換成/nt變量inti11=Integer.parseZ/?f(intS

tr)；intit2=newInteger(intStr)System,out.print1n(it2)；A

StringfloatStr="4.56"；A//把一個特定的字符出整換成紛，"

floatftl=Flo