java 基礎篇知識資料

java基礎篇

1.數據類型

整型：intshortlongbyte

浮點型：floatdouble

char類型：表示單個字符，用單引號括起來

Boolean類型:判定邏輯條件，false/true

2.變量與常量

變量：變化的值在java9中不能當做變量名

首先變量聲明:每一個變量都有一個類型

變量初始化:用賦值語句對變量進行顯示初始化

常量：固定不變的用關鍵字final指示常量。

Final：表示只能被賦值一次

Staticfinal：設置一個類常量（位于main方法的外部）

3.static與final的區(qū)別：

Static作用：方便在沒有創(chuàng)建對象的條件下調用變量或方法?？梢孕?/p>

飾成員方法，成員變量，編寫static代碼優(yōu)化程序性能（形成靜態(tài)代碼

塊優(yōu)化程序性能，并且只會在類加載的時候執(zhí)行一次），

Final:final類（最終類）不可以繼承，沒有子類。

final方法不能被子類的方法覆蓋，但可以繼承。

Final不能修飾構造方法。

4.靜態(tài)常量：類中可以共享數據。

5.檢測字符串是否相等：s.equals⑴檢測s和t是否相等

第1頁共130頁

equalsIgnoreCase不用區(qū)分大小寫來檢測字符串是否相等。

6.==與equals的區(qū)別：

，==，對于基本類型和引用類型是不相同的

基本類型：==表示的是值是否相同

引用類型：==表示的是引用是否相同

Equals:本質上是==但是通過string和Integer對equals方法的重寫，

變成了值的比較。

7.數組

聲明數組：類型□名字

數組的拷貝：int[]copiedLucky=Arrays.copyof（Lucky,Lucky.lengyh）

8.JDK與JRE的區(qū)別：

JDK：java開發(fā)工具包，提供java的開發(fā)環(huán)境和運行環(huán)境

JRE：java運行環(huán)境，為java運行提供環(huán)境

具體的來說JDK包含JRE,還包括編譯java編碼的編譯器javac,以

及java的調試和分析工具。

9.類class類名｛

類體（變量聲明）

（方法定義）｝

10.Java里面向對象的三大特征是什么？

封裝：將數據和行為組合到一個包中，并對對象的使用者隱藏具體

的實現方式。封裝的思想類內部數據結構的完整性，讓用戶無法輕

易直接的操作內部數據，這樣降低對內部數據的影響，提高了程序

第2頁共130頁

的安全性和可維護性。

類的封裝實現：將成員變量聲明為private,再通過public的方法對

這個變量進行訪問。對于一個變量我們有讀取和賦值的操作，

getXxx（讀取變量），setXxx（對成員變量進行賦值處理）。

封裝的優(yōu)點：隱藏類的實現細節(jié)。

便于修改，增加代碼的可維護性。

讓使用者使用事先制定好的方法來訪問數據，方便加入

控制邏輯，限制對屬性的不合理操作。

繼承：當兩個類具有相同的屬性和方法時，可以將相同的部分提取

出

出來作為父類，其他的類繼承這個類的方法和屬性。

關鍵字：extends

繼承和權限：

Hna

Publiic無修飾PrivateProtectabstractstatic

1

不能

只有同一包不能修飾不能修飾不能修飾

類繼承可繼承濠生一段可繼承

中的可繼承類突

拔

可重戢（修蜂

不可重

方法重載不能重蚣司■羲r可?能王函數就不能

H了）

必須鼻個實例

成員變量子類不能直父集虐性

幺英聶性使除墓攵金原性陵隨我不能脩飾

（屬做（使用sup"R（使用我接訪問父類（使用ZP衣技付初共享這個

廣一*辛

取父笑廈性）取父劃■性）的私有變量取父類JBa）值類變量

多態(tài)：同一個行為用不同的表現形式或形態(tài)的能力。說具體點就是

同一接口，使用不同的實例而執(zhí)行的結果。

多態(tài)的優(yōu)點:消除類型之間的耦合關系可替換性可擴充性接口性

第3頁共130頁

靈活性簡化性

實現多態(tài)的必要條件：要有繼承

要有方法分的重寫

父類引用指向子類對象

例子：父類：publicclassHttpServlet{

publicvoidservice(){

System.out.println("HttpServlet-service");

doGet();

)

publicvoiddoGet(){

System.out.print("HttpServlet-doGet");

)

)

子類：publicclassMyServletextendsHttpServlet{

publicvoiddoGet(){

System.out.println("MyServlet-doGet");

)

)

主類：publicclassTest{

publicstaticvoidmain(String[]args){

HttpServlets=newMyServlet();

s.service();

第4頁共130頁

)

)

結果：HttpServlet-service

MyServlet-doGet

代碼分析：HttpServlets=newMyServlet();//s雖然是父類變量

的引用，但是指向的是子類對象。s.serviceO;//子類中沒有定

service,因此調用的是繼承父類的service方法，然后service方法

中調doGet,這時候也是以子類中優(yōu)先查找重寫的doGet方法。

11.多態(tài)的向上轉型和向下轉型分別指的是什么？

向上轉型：簡單的說就是子類對象賦值給父類引用(減少代碼重復)

格式：父類類型變量名=new子類類型()Fatherf=new

son()

Personp=newStudent。；

向下轉型：已經向上轉型的子類可以使用強制類型轉換格式，將父

類對象賦值給子類引用

格式：子類類型變量名=(子類類型)父類類型變量名

sons=(son)f

Personp=newStudent。；

Studentstu=(Student)p

12.重寫和重載的區(qū)別？

重寫(override)：子類定義一個方法，這個方法的類型和父類的方

法類型一致，并且方法名字，參數個數,參數類型和父類是完全相同

的。

重寫的規(guī)則：參數列表與被重寫方法的參數列表必須完全相同。

第5頁共130頁

返回類型與被重寫方法的返回類型可以不相同，但是必須是父類返

回值的派生類（java5及更早版本返回類型要一樣，java7及更高版

本可以不同）。

訪問權限不能比父類中被重寫的方法的訪問權限更低。例如：如果

父類的一個方法被聲明為public,那么在子類中重寫該方法就不能

聲明為protectedo

父類的成員方法只能被它的子類重寫。

聲明為final的方法不能被重寫。

聲明為static的方法不能被重寫，但是能夠被再次聲明。

子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了

聲明為private和final的方法。

子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為

public和protected的非final方法。

重寫的方法能夠拋出任何非強制異常，無論被重寫的方法是否拋出

異常。但是，重寫的方法不能拋出新的強制性異常，或者比被重寫

方法聲明的更廣泛的強制性異常，反之則可以。

構造方法不能被重寫。

如果不能繼承一個方法，則不能重寫這個方法。

重載（overload）：一個類中可以有多個方法具有相同的名字，但這

些方法的參數必須不同（參數個數不同。參數個數相同但參數表對

應某個參數的類型不同。）

二者的區(qū)別：重寫和重載都是java多態(tài)性的不同表現。重寫是子類

第6頁共130頁

與父類之間多態(tài)性的一種表現，重載是一個類中多態(tài)性的表現。

13.super關鍵字怎么使用？

可以用super操作被隱藏的成員變量和方法。

publicclassAverageextendsSum{//子類繼承父類

intn;//成員變量

floatf(){//方法

floatc;

super.n=n;//sup一r關鍵字調用子類繼承所隱藏的成員變量

c=super.f();//用對象名調用父類的f方法

returnc/n;

)

floatg(){

floatc;//局部變量聲明

c=super，()；//也是調用父類的f方法但是此時沒有用到n

returnc/2;

)

}

publicclassSum{

intn;

floatf(){

floatsum=0;

for(inti=1;i〈=n;i++)//for循環(huán)先進行判斷滿足執(zhí)行循環(huán)代碼，然后才是加一

n=100執(zhí)行了100次

sum=sum+i;//循環(huán)代碼1+2+3+++99=n(al+an)/2

returnsum;

}

}

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Averageaver=newAv一rag一()；//倉U建對象執(zhí)行的時候先跳至!JAverag一類中

aver.n=100;//賦值n=100

floatresultOne=av一r,f();//調用方法

floatresultTwe=aver.g();

System.out.printin(nresultOne=n+resultOne);//輸出

System.out.printin(nresultTwe="+resultTwe);

第7頁共130頁

使用super調用父類的構造方法。

classAnimal{

publicvoidmove(){

System.out.printIn("動物可以移動*;

}

)

classDogextendsAnimal{

publicvoidmove(){

super.move();//應用super類的方法

System.out.printIn("狗可以跑和走；

}

}

publicclassTestDog{

publicstaticvoidmain(Stringargs[]){

Animalb=newDog();//Dog對象

b.move();〃執(zhí)行Dog類的方法

}

}

14.構造器可以重寫嗎？

構造器(Constructor):就是和類名相同但無返回類型的方法。它

的作用是創(chuàng)建對象時進行初始化。

構造器是不能被繼承的，所以不可以進行。verride的，但可以進行

重載(overload)

如果父類自定義了有參構造函數，則子類無論定義構造函數與否，

定義有參構造函數與否，都會報錯，正確的做法是在子類的構造方

法中添上super(參數)，以表明子類構造之前先構造父類，而這

句話必須放在第一句，否則報"Constructorcallmustbethe

firststatementinaconstructor”的錯誤。

類的加載順序:

第8頁共130頁

首先執(zhí)行父類的靜態(tài)代碼塊/初始化靜態(tài)變量（兩者優(yōu)先級相

同），然后執(zhí)行子類的靜態(tài)代碼/初始化靜態(tài)變量（兩者優(yōu)先級相

同，誰寫在前面誰先執(zhí)行），然后初始化父類成員變量/執(zhí)行代碼塊

{}（兩者優(yōu)先級相同），接著父類的構造器，然后子類的成員變量/

代碼塊，最后子類的構造器。

15.什么是正則表達式以及它有什么用途？

在編寫處理字符串的程序時，經常會有查找符合某些復雜規(guī)則的字

符串的需要。正則表達式就是用于描述這些規(guī)則的工具。換句話

說，正則表達式就是記錄文本規(guī)則的代碼。計算機處理的信息更多

的時候不是數值而是字符串，正則表達式就是在進行字符串匹配和

處理的時候最為強大的工具，絕大多數語言都提供了對正則表達式

的支持。

16.int和integer的區(qū)別是什么？

Java是一個近乎純潔的面向對象編程語言，但是為了編程的方便還

是引入了基本數據類型，但是為了能夠將這些基本數據類型當成對

象操作，Java為每一個基本數據類型都引入了對應的包裝類型

（wrapperclass）,int的包裝類就是Integer,從Java5開始引

入了自動裝箱/拆箱機制，使得二者可以相互轉換。

Java為每個原始類型提供了包裝類型：

一原始類型：boolean,char,byte,short,int,long,float,

double

-包裝類型：Boolean,Character,Byte,Short,Integer,

第9頁共130頁

Long,Float,Double

包裝類的作用：方便對一些基本類型進行操作，解決基本類解決不

了的問題。

集合不允許存放基本數據類型，只能存放應用數據類型。

add(Objecto)

基本類型可以和包裝類型直接相互轉換，自動裝箱拆箱，(自動裝

箱：將基本類型轉換為包裝器類型，自動拆箱：將包裝器類型轉換

為基本類型)1〃自動裝箱

2Integertotal=99;

3

4//自動拆箱

5inttotalprim=total;

通過包裝類型的parse方法可以實現基本數據類型+String類型之間

的相互轉換。

函數需要傳遞進去的參數為Object類型，傳入基本數據類型就不可

行。

17.抽象類和接口的區(qū)別？

抽象類：在面向對象里，所有的對象是通過類來描繪的，但反過來

并不是所有的類都是用來描繪對象的，通俗一點講，如果一個類中

沒有包含足夠的信息來描繪一個對象，那么這個類就是抽象類。通

常使用關鍵字abstract來修飾。

abstract類的特點：不能實例化對象，必須被繼承才能實現。

abstract類不能使用new運算符創(chuàng)建對象。

第10頁共130頁

abstract類中可以有abstract方法。

一旦一個類里面有abstract方法，那么這個

類必須用abstract修飾。

接口：java編程語言中的一個抽象類型，，是抽象方法的集合，通

常用關鍵字interface聲明。(隱式抽象不需要關鍵字abstract

所有方法都是公用的)

interface接口名稱[extends其他的接口名]{

//聲明變量常量聲明所有的常量一定都是公共的public而且是static常量

//抽象方法訪問權限一定是public

)

接口的實現：當接口要實現時，類要實現接口中所以有的方法。類

使用關鍵字implements聲明該類實現一個或多個接口(多個時用逗

號隔開)。

publicclassMammalintimplementsAnimal{

publicvoideat(){

System.out.println("Mammaleats");

)

publicvoidtravel(){

System.out.printin("Mammaltravels");

)

publicintnoOfLegs(){

return0;

)

publicstaticvoidmain(Stringargs[]){

Mammalintm=newMammalint();

m.eat();

();

)

)

抽象類與接口的區(qū)別：

第11頁共130頁

抽象類中的方法可以有方法體，就可以實現方法的具體功能，但接

口就不行。

抽象類中的成員變量可以是各種類型，但接口中的成員變量只能是

publicstaticfinal類型的。

接口里只有常量，不能有變量；但抽象類中既有常量也有變量。

接口中不能含有靜態(tài)代碼塊和靜態(tài)方法（static修飾），但是抽象

類中就可以有。一個類只能繼承一個抽象類，但一個類可以實現一

個或多個接口。abstract類中可以有非abstract方法，但是接口

不行（abstract是可以省略的）。

18.java里什么是構造函數？構造函數重載？復制構造函數？

構造函數：是函數的一種特殊形式，它不需要定義返回類型，而且

構造函數的名稱和所在類的名稱相同，其余的與函數的特性相同，

可以帶有參數列表，可以存在函數重載。

作用：創(chuàng)建函數對象對象初始化

Java中構造函數重載和方法重載很相似。可以為一個類創(chuàng)建多個構

造函數。每一個構造函數必須有它自己唯一的參數列表。

Java不支持像C++中那樣的復制構造函數，這個不同點是因為如果

你不自己寫構造函數的情況下，Java不會創(chuàng)建默認的復制構造函

數。

19.面向對象的“六原則一法則”目的分別是什么？

1）一職責原則：一個類只做它該做的事情（單一職責原則表達的是

“高內聚”的思想，寫代碼最終原則“高內聚，低耦合”。高內聚

第12頁共130頁

通俗的講就是一個代碼能完成一項功能，在面向對象中，如果只讓

一個類完成該做的事，而不涉及到其它無關的類就是高內聚。）

2）開閉原則：設計的系統(tǒng)對擴展開放，對修改關閉。怎么理解呢，

開閉原則在做新功能開發(fā)的時候經常用到，我的理解是當我們需要

給一個類添加一個新的功能時，最好的辦法不是直接修改這個類的

代碼，有可能牽一發(fā)動全身，應該考慮如何用一個新的類實現一個

新的功能，最終的效果是一系列相關的功能都有自己的類，當然它

們都繼承于父類。

3）依賴倒轉原則：高層模塊不應該依賴于底層模塊，二者都應該依

賴于抽象。抽象不應該依賴于具體實現，具體實現應該依賴于抽

象。其核心思想是面向接口編程。怎么理解吶，就比如說我們要把

生產一輛汽車當做一條程序，首先是不是先要建立接口比如車輪，

車身，汽車。每一個接口都有各自固定的方法，比如車輪這個接口

里面就有大小尺寸的方法。比如我們現在要生產一輛轎車，我們就

要寫一個實現這個接口的實現類，類名是轎車輪。要是生產卡車呢

就寫一個實現這個接口的實現類。這樣一來既節(jié)省了時間，也便于

我們更好的維護。

4）里氏替換原則：所有引用父類的地方必須能透明的使用其子類的

對象。比如有兩個類一個A類，一個B類，并且A是B的父類。現

在有一個方法可以接受A類對象a時，那么這個方法也能接受B類

對象b。

5）接口隔離原則：接口應該小而專，不應該大而全。

第13頁共130頁

6）合成聚合復用原則：優(yōu)先使用聚合或合成關系復合代碼。

7）迪米特法則：最少知識原則，一個對象應當對其他對象有盡可能

少的了解。

20.java語言如何處理異常，關鍵字throw,throws,try,finally

分別代表什么？在宜y塊可以拋出異常嗎？

異常：程序運行時出現的錯誤，比如試圖打開一個根本不存在的文

件夾等。異常大致分為：Error和Exception兩類，Error是程序無

法處理的錯誤，此類錯誤一般表示代碼運行時JVM出現的錯誤。比

如虛擬機運行錯誤或者類定義錯誤。而Exception代表的是程序本

身能夠捕獲且可以處理的異常?？梢苑譃閮深愐环N是運行時異常

（不受檢異常）一種是非運行時異常（受檢異常）。前者屬于不可

查異常，一般是由邏輯性錯誤引起的，在程序中可以選擇捕獲異

常，也可以不處理。而一旦出現后者這種異常，必須對異常進行處

理。比如lOException,要么使用try-catch捕獲，要么使用

throws拋出異常，否則編譯不過。

Java處理異常機制：通過面向對象的方法進行異常處理，把不同的

異常進行分類，并提供良好的接口。當一個方法出現異常時就會拋

出一個異常對象，這個對象包含異常信息，然后調用這個對象的方

法就會捕獲到異常并進行處理。

throw拋出異常對象thrownew異常類名（參數）；

publicclassDemoThrow{

publicstaticvoidmain（String[]args）{

inta=DemoThrow.div（4,0）;

第14頁共130頁

System.out.println(a);

)

publicstaticintdiv(inta,intb){

if(b==0)

thrownewArithmeticException("異常信息：除數不能為0");

//拋出具體問題,編譯時不檢測

returna/b;

)

)

throws聲明拋出異常

修飾符返回值類型方法名(參數)throws異常類名工，異常類名2...{}

importjava.io.Fileinputstream;

importjava.io.FileNotFoundException;

importjava.io.Inputstream;

publicclassDemoThrows{

publicstaticvoidmain(String[]args)throws

FileNotFoundException{

readFile();

)

publicstaticvoidreadFile()throwsFileNotFoundException{

Inputstreamis=newFileInputStream("E:/iodemo/ch01.txt");

)

)

try：在這個成員函數內部寫另一個try語句保護其他代碼。每當遇到一

個try語句，”異常"的框架就放到堆棧上面，直到所有的try語句都

完成。如果下一級的宜y語句沒有對某種“異常”進行處理，堆棧就會

展開，直到遇到有處理這種“異常”的try語句。

Finally為確保一段代碼不管發(fā)生什么“異?！倍急粓?zhí)行一段代碼。

importjava.io.Fileinputstream;

importjava.io.FileNotFoundException;

importjava.io.Inputstream;

publicclassDemoTryCatch{

publicstaticvoidmain(String[]args){

//捕獲異常

try(

//可能產生異常的代碼

第15頁共130頁

readFile();

}catch(FileNotFoundExceptione){

//異常的處理邏輯,將異常記錄日志,異常封裝后顯示

System.out.printin("系統(tǒng)找不到指定的路徑”);

}

System.out.printIn(“后續(xù)代碼”)；

}

publicstaticvoidreadFile()throwsFileNotFoundException{

Inputstreamis=newFileInputStream("E:/iodemo/ch01.txt");

)

)

21.說明一下finalfinallyfinalize的區(qū)別？

final聲明屬性、方法、類，分別表示屬性不可變、方法不可覆蓋、

類不可繼承。

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

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

被回收的對象的此方法，可以覆蓋此方法提供垃圾回收的其他資源。

22.面向對象的特征？

抽象：：抽象是將一類對象的共同特征總結出來構造類的過程，包括

數據抽象和行為抽象兩方面，抽象只關注對象的哪些屬性和行為，并

不關注這此行為的細節(jié)是什么

封裝：將數據和行為組合到一個包中，并對對象的使用者隱藏具體的

實現方式。

繼承：當兩個類具有相同的屬性和方法時，可以將相同的部分提取

出

出來作為父類，其他的類繼承這個類的方法和屬性。

多態(tài)：同一個行為用不同的表現形式或形態(tài)的能力。說具體點就是

同一接口，使用不同的實例而執(zhí)行的結果。

第16頁共130頁

23.java是否具支持多繼承？

Java中類是不支持多繼承的。(一個類只能有一個父類)但java中

接口是支持多繼承的，即一個接口可以有多個父接口。

24.如何通過反射創(chuàng)建對象？反射：java反射機制是在運行過程中，

對任何一個類，都可以知道這個類的所有方法和屬性；對于任何一個

對象，都可以知道這個對象的所有方法和屬性。

第一種通過class的newlntance()方法來創(chuàng)建對象。

第二種通過Constructor的newlntance()方法來創(chuàng)建對象。

25.string、stringBuffer、stringBulide的區(qū)別？String不可變有

什么好處？

string：是字符串常量string類是final的所以string不可以繼

承沒有子類。

stringBuffer：是字符變量，是線程安全的，也就是多線程修改同一

個StringBuffer對象的時候，過程是同步的，當然這就導致了

StringBuffer的效率降低。

不可變對象是指一個對象的狀態(tài)在對象被創(chuàng)建之后就不再變化。不可

改變的意思就是說：不能改變對象內的成員變量，包括基本數據類型

的值不能改變，引用類型的變量不能指向其他的對象，引用類型指向

的對象的狀態(tài)也不能改變。

String不可變是因為在JDK中String類被聲明為一個final類,

且類內部的value字節(jié)數組也是final的，只有當字符串是不可

變時字符串池才有可能實現，字符串池的實現可以在運行時節(jié)約很多

第17頁共130頁

heap空間，因為不同的字符串變量都指向池中的同一個字符串；如

果字符串是可變的則會引起很嚴重的安全問題，譬如數據庫的用戶名

密碼都是以字符串的形式傳入來獲得數據庫的連接，或者在socket

編程中主機名和端口都是以字符串的形式傳入，因為字符串是不可變

的，所以它的值是不可改變的，否則黑客們可以鉆到空子改變字符串

指向的對象的值造成安全漏洞；因為字符串是不可變的，所以是多線

程安全的，同一個字符串實例可以被多個線程共享，這樣便不用因為

線程安全問題而使用同步，字符串自己便是線程安全的；因為字符串

是不可變的所以在它創(chuàng)建的時候hashcode就被緩存了，不變性也保

證了hash碼的唯一性，不需要重新計算，這就使得字符串很適合作

為Map的鍵，字符串的處理速度要快過其它的鍵對象，這就是

HashMap中的鍵往往都使用字符串的原因。

26.String類的常用方法？

publicintlength()獲取string對象的字符序列長度。

Stringchina="1998年出生”;

intnlrn2￡

nl=chian.lenght();

n2="小鳥fly”.lenght();

nl的值是7,n2的值是5

publicintcompareTo(Strings)按字典序與參數指定的string對

象s的字符序列比較大小.如果String對象的字符序列與s相同，該

方法返回0,大于返回正值。

publicintindexOf(Strings)從當前string對象的字符序列的0

索引位置開始檢索首次出現S的位置并返回該位置

Stringtom="Iamagoodcat";

第18頁共130頁

//0123456789從零開始的并且空格也算一個數如果沒有返回-1

tom.indexOf("a");//值是2

tom.indexOf("good"A2);//值是7從當前字符串的第二位開始數

tom.indexOf("wn,2);//-I

publicintindexOf(Strings,intstartpoint)

從當前字符串的startpoint位置開始檢索字符串s,并返回首次出現s的位置。

沒有找到的時候，返回T.

publicintlastlndexOf(Strings)從當前String對象的字符序列

的0索引位置開始檢索最后一次出現S的位置并返回該位置

publicbooleanequals(Strings)比較當前string對象的字符

序列是否和參數相等

Stringtom=newString("天道酬勤”)；

Stringboy=newString(“知心朋友”)；

Stringjerry=newString(“天道酬勤”)；

tom.equlas(boy);//false比較對象tom和參數boy是否相等如果相等返回

true否貝!Jfalse

tom.equals(jerry);//true

publicbooleanstartsWith(Strings)string字符前綴是否相等

publicbooleanendWith(Strings)string字符后綴是否相等

publicbooleancontains(Strings)判斷當前String對象的

字符序列是否包含參數S的字符序列。

publicStringsubstring(intstartpoint)字符串對象調用該方法

獲得一個新的String對象

27.說明Comparator和Comparable接口的區(qū)別以及它們的作用？

Comparator接口里面有兩種方法一種是compare另一種是equals。

compareO方法用來給輸入兩個輸入的參數排序，返回值負、0、

正分別代表第一個參數小于、等于、大于第二個參數。equalsO

方法需要一個對象作為參數，然后才能決定對象是否和comparator

相等，如果相等返回true,不相等返回false。

第19頁共130頁

comparable接口里面只有一個compareTo()方法，這個方法用來

給兩個對象排序。它返回負數、0、正數表示輸入對象小于、等于、

大于已經存在的對象。

28.解釋一下類加載機制，什么是雙親委派模型？好處是什么？

類加載機制：將類的.class文件中的二進制數據讀入到內存中，將

其放在運行時數據區(qū)的方法區(qū)內，然后在堆內創(chuàng)建一個

java.lang.Class對象，用來封裝類在方法區(qū)的數據結構。類加載的最

終結果是堆內的class對象，class對象封裝了方法區(qū)的數據結

構，并向程序員提供訪問方法區(qū)數據結構的接口。

雙親委派機制：當一個類加載器收到類加載請求時，它首先不會自

己加載這個類，而是把加載這個類的請求委派給自己的父類加載

器，每一層加載器都是這樣，這樣一來加載請求就會傳送到頂層的

啟動加載器中，只有父類加載器無法完成加載請求時(搜索范圍沒

有要加載的類)，子類加載器才會嘗試去完成類的加載。

好處：避免重復加載，提高效率。父類已經加載了，子類就不需要

加載了。

很好的解決了各個類加載器之間基礎類的的同一問題，如果不使用

該種方式，那么用戶隨意定義類加載器來加載核心API,會帶來相

關的隱患。

29.請說明static關鍵字是什么意思?Java中是否可以覆蓋

(override)——個private或static的方法？

static:static關鍵字表示一個成員變量或者成員方法可以在沒有

第20頁共130頁

所屬類的實例變量的情況下被訪問。

修飾變量：static變量類型變量名

目的：作為共享變量使用減少創(chuàng)建對象保留唯一副本

修飾方法：【訪問權限修飾符】static方法返回值方法名(參

數列表)

Java中static方法不能被覆蓋，因為方法覆蓋是基于運行時動態(tài)

綁定的，而static方法是編譯時靜態(tài)綁定的。static方法跟類的

任何實例都不相關，所以概念上不適用。

30.列舉object類的方法并簡要說明。

object類：所以類的超類(父類)

equals方法：確定兩個對象的引用是否相等。

hashCode方法：返回對象的哈希碼值。publicinthashCode()

getClass方法：返回object運行時的類。

publicfinalclassgetClass()

toString方法：返回對象值的一個字符串。

publicStringtoString()

StringtoString(){

getClass().getName()+n@n+Integer.toHexString(hashCode())；

getClass().getName()++Integer.toHexString(hashCode())這返

回的是：類的全路徑名稱+它的哈希碼值。

31.類和對象的區(qū)別？

定義上的不同：類是現實世界或思維世界在計算機的反映，它將數

據和數據上的操作封裝起來。

第21頁共130頁

對象是具有類類型的變量，兩者是面向對象編程最基本的概念。

范疇不同：類是一個抽象概念，它不存在現實世界的時間、空間

里。類知識為所有對象定義了抽象的屬性和行為。

對象則是類的一個具體。

狀態(tài)不同：類是一個靜態(tài)的概念，類本身不攜帶任何數據。當沒有

為類創(chuàng)建任何數據時，類本身不存在于內存空間。

對象是動態(tài)的概念，每一個對象都存在著有別于其他對象的屬性和

行為。

二者的聯(lián)系：類是對象的抽象，對象是類的具體。二者的關系猶如

模板和鑄件一樣，類的實例化就是對象。

32.類的加載過程？如何保證我的類被指定加載器加載？相同的類被

不同的加載器加載，這兩個類相同嗎？

類加載機制：

加載一驗證—準備—,解析一,初始化

加載：在內存中生成java.long.class對象，作為方法區(qū)這個類的

各種數據入口。（注意這個過程并不是一定要去class類中獲取，

還可以從zip包或者運行時計算生成）

驗證：這個過程主要確保class文件中的字節(jié)流中包含的信息是否

滿足當前虛擬機的要求。

準備：準備階段是正式為類變量分配內存，設置變量初始值的階

段。在方法區(qū)中分配這些變量所使用的空間。

解析:虛擬機將常量池中的符號引用替換為直接引用的過程。符號引

第22頁共130頁

用就是class文件中:

CONSTANT_Class_info

CONSTANT_Field_info

CONSTANT_Method_info

等類型的常量。

初始化：類加載的最后一個階段，前面的加載階段可以自定義加載

器以外，其他階段都是有jvm主導的。這個階段是執(zhí)行類構造器

〈client》方法的過程。

一個類，由不同的類加載器實例加載的話，就會在方法區(qū)產生兩個

不同的類，彼此不可見，并且在堆中生成不同的class實例。

33.什么是集合？它的作用是什么？集合與數組的區(qū)別？Java集合

框架體系結構？

集合：是一種java工具類，像是一種容器，用來存儲任意數量的具

有相同屬性的對象。

作用：在類的內部，對數據進行組織。

簡單快速的搜索大量的條目。

有的集合接口，提供一系列排列有序的元素，并且可以在有

序列中快速的插入刪除有關元素。

還有一些集合接口，提供映射關系，可通過關鍵字（key）去

快速查找唯一對應的對象，且這個關鍵字的類型是任意的。

區(qū)別：數組長度固定不變，集合長度改變。

數組只能通過下標去訪問元素，類型固定（整型），有的集

第23頁共130頁

合可以通過任意類型查找所映射的具體對象。

Java集合框架體系結構：

lis廂Queue是有序，可以重復科既U的

list（序列）子接口0實現類ArrayList數組序列

一~一~Queue（隊列）子?接口?實現類LinkedList鏈表

Collectionm接口>-----------------------------------------------

1\set（集）子接口0實現類Headset哈希集

java集合框架體系結構無序，不可重復科既

<key,Value〉Entry（鍵對值）內音湊

~?實現類HeadMap哈希表

------------------------------------------

34.什么是迭代器（Iterator）?迭代器的fail-fast機制？主要解

決什么問題？

迭代器：是一種設計模式，是一個對象，它的工作是遍歷并選擇序

列中的對象。（遍歷就是把每一個元素訪問一邊）（java的迭代器

只能單向移動）

迭代器方法：next。獲取序列的下一個元素。

HasNextO檢查序列中是否還有元素（如果有返回

true）o

Remove。刪除上次調用next（）方法返回的元素。

迭代器的作用：為各種容器提供公共的操作接口，使用java的迭代

器iterator可以使對容器的遍歷操作完全與其底層隔離可以很好地

達到解耦效果。（解耦：較為具體的說明就是有的時候程序需要修

改，我只需要改正一部分，單是如果程序的耦合性很強的話就需要

從頭再寫一遍很不劃算，而正常的開發(fā)中都是改那部分，重寫那部

分，把配置文件一改就成了，java中通過接口（interface）,

第24頁共130頁

spring技術中的ioc等實現的解耦合，重寫覆蓋父類的方法也是一

種解耦行為)

迭代器源代碼：

importjava.util.*;

publicclassT一st工t一rator{

publicstaticvoidmain(Stringargs[]){

//創(chuàng)建一個list它是一個序列化的數據

List1ist=newArrayList();

//創(chuàng)建一個map,它是一個非序列化的數據

Mapmap=newHashMap();

for(inti=0;i<10;i++){

//向容器中添加數據

list?add(newString();

map.put(i,newString(”map"+i));

}

//序列化了的數據創(chuàng)建迭代器。

IteratoriterList=list?it一rator();//List接口實現了工t一rabl一接口

//進行遍歷如果容器中有下一個數據，就獲取下一個數據并打印出來

while(iterList.hasNext()){

StringstrList=(String)iterList.next();

System.out.printIn(strList.toString());

}

//創(chuàng)建非序列化數據的迭代器，要先將其序列化

IteratoriterMap=map.entrySet().iterator();

//進行遍歷如果容器中有下一個數據，就獲取下一個數據并打印出來

while(iterMap.hasNext()){

Map.EntrystrMap=(Map.Entry)iterMap.next();

System.out.printin(strMap.getValue());

}

)

}

迭代器的fail-fast機制：

Fail-fast是java集合中的一種錯誤機制，當多個線程對同一

集合的內容同時操作時，就可能會產生fail-fast事件。比如說

35.set、Map、List接口存取元素時，各有什么特點？以及

collection^set>map、list之間的聯(lián)系和區(qū)另U?

第25頁共130頁

Set(集)接口存取元素時不允許增加重復的元素(用對象的

equals()方法來區(qū)分元素是否重復)。

publicstaticvoidmain(String[]args){

HashSet<String>hashSet=newHashSet<>();

LinkedHashSet<String>linkedHashSet=newLinkedHashSet<>();

TreeSet<String>treeSet=newTreeSet<>();

for(Stringdata:Arrays.asListC'afaE","afaE","asfweD",

"hfasfae","aefaeA")){

hashSet.add(data);

linkedHashSet.add(data);

treeSet.add(data);

}

//HashSet:無序,隨機輸出。底層數據結構是哈希表,依賴hashCode()和

equals()兩個方法來保證唯一性。

System.out.printIn("OrderinginHashSet:"+hashSet);

“LinkedHashSet:FIFO插入有序,先進先出。底層結構是鏈表和哈希表,

由鏈表保證元素有序,哈希表保證元素唯一。

System.out.println("OrderofelementinLinkedHashSet:"+

linkedHashSet);

//TreeSet：有序,唯一。底層結構是紅黑樹,排序采用自然排序和比較容器

排序,根據比較的返回值是否為。來判斷元素唯一。

System.out.printIn("OrderofobjectsinTreeSet:"+

treeSet);

)

*>rubhr->；??,OCXXKOW

*terminated?【JavaApp?c?tior]ew(2019^3^195上午

OrdvringinHji>ehS*t：[af?B.MXVMD,hfaufa?,awfawAj

OrderofelenentinLinkedHashSet:[afaE.asfweDhfasf&e,aefaeA]

Ordercfobj?ctsinTr?eS?t：(??fiwA,af?BrasfweD.hfasf40]

Map(映射)接口存取元素時采用鍵對值(key-value)的方式來存

取。key唯一的，value不唯一可以重復，一個value有一個

key對映。

publicstaticvoidmain(String[]args){

第26頁共130頁

//HashMap采用鍵值對存儲數據,采用put。方法存放數據

Map<IntegerJString>map=newHashMap<Integer,String)。；

map.put(l?“中國“)；

map.put(2?“小日本”)；

map.put(3,“美國佬”)；

//foreach遍歷方法》普遍使用,通過對hey唯一的特性,進行huy遍歷

for(Integerkey:map.keySet()){

System.out.println(key+"+map.get(key));

}

System.out.printin("----------------------------------------------------------------");

//因為hey唯一,key重復時會自動覆蓋value之前存儲的數據

map.put(3?”英國佬”)；

for(Integerkeyl:map.keySet()){

System.out.println(keyl+"+map.get(keyl));

}

System.out.printin("----------------------------------------------------------------");

//Map.Entry遍歷hey和value,同樣是foreach方法,推薦容量大的時候

使用

for(Map.Entry<IntegerJString>entry:map.entrySet()){

System.out.printin(entry.getKey()++

entry.getValue());

}

)

.*;，??J>L.OComoU漢

*terminated>Trw&?t1(JwaAppfic?t>on)(2019^3Qi99下*2:16901)

List(列表)接口用特定的索引來存取，可以有重復元素。

publicstaticvoidmain(String[]args){

List<Integer>arraylist=newArrayList<>();

arraylist.add(3);

arraylist.add(22);

arraylist.add(31);

arraylist.add(345);

arraylist.add(63);

arraylist.add(3);

第27頁共130頁

//ArrayLtst底層是一個數組,輸出時需要于oreach遍歷,查詢快,增刪慢,線層安全)

效率高

System.out.print("arraylist:

for(Integertest:arraylist){

System.out.print(test+"");

System.out.printin();//換行

//Vector底層是一個實現自動增長的對象數組,元素會自動添加到數組中,查詢快,增

刪慢,線層安全,效率低

Vector<Integer>vector=newVector<>();

vector.add(3);

vector.add(5);

vector.add(25);

vector.add(51);

vector.add(5);

System.out.printin("vector:"+vector);

//LtnhedLtst底層是一個鏈表,查詢慢,增刪快,線層不安全,效率高

LinkedList<Integer>linkedList=newLinkedList<>();

linkedList.add(30);

linkedList.add(30);

linkedList.add(34);

linkedList.add(55);

System.out.printIn("linkedlist"+linkedList);

?：QComote

?t?rrntna<?d?IrwSHl(JavaApplicalicn]^0^201\bir(2019*3月19m上學11:11:19)

&rraylifii:32231345633

vector：[X5,25,51,5]

linkedlifit[30.30,34,55]

Set、list者B是collection接口的子接口，map接口和

collection接口是同等級的。

36.詳細介紹java集合框架結構？

list接口的實現類：

ArrayList:基于數組實現，非線性安全、效率高、增刪慢、查找

快。

Vector:基于數組實現，線性安全、效率低、增刪慢、查找慢。

LinkedList:基于鏈表實現，鏈表內存是散列的、增刪快、查找慢。

Map接口的實現類：

第28頁共130頁

HashMap:基于hash表的map接口實現，非線性安全、高效、支持

null值和null健。

HashTable:線程安全、低效、不支持null值和null健。

sortedMap接口：TreeMap能夠把它保留德記錄根據健排序，默認升

序排序。

Set接口的實現類：

HashSet：底層是由HashMap實現，不允許集合中有重復的值，使

用該方式時需要重寫equals。和hashCode。方法。

第29頁共130頁

排列有序,可重復

底層使用數坦

ArrayList速磨快，塔珊侵，getter便Gseneq）方法快

送程不安叁倒

當零星不婚時,ArrayList是當前容量*15*1

排列有序，可里晝

底層使用數阻

Vector速，章快.塔珊奧

線朝全融低

當容量慢氏