java核心技術基礎知識整理

一、.java源文件：

一個以」.java「爲後綴的源文件：只能有一個與文件名相同的類，能夠包含其餘類。

二、類方法：

類方法：類中用static修飾的方法（非static爲實例方法）	在類方法中調用本類的類方法時，能夠直接調用。
在類方法中不能有this關鍵字，直接調用類方法便可。	類方法中能夠經過建立實例對象調用類的實例方法。

三、super和this關鍵字

在子類構造器中使用super()顯示調用父類的構造方法，super()必須寫在子類構造方法的第一行，不然編譯不經過；

this：

屬性：this屬性表示找到本類的屬性，若是本類沒有找到則繼續查找父類；

方法：this方法表示找到本類的方法，若是本類沒有找到則繼續查找父類；

構造：必須放在構造方法的首行，不能與super關鍵字同時出現；

特殊：表示當前對象；

super：

屬性：super屬性直接在子類之中查找父類中的指定屬性，再也不查找子類自己屬性；

方法：super方法直接在子類之中查找父類中的指定方法，再也不查找子類自己方法；

構造：必須放在構造方法首行，不能與this關鍵字同時出現。

super和this關鍵字

1）調用super()必須寫在子類構造方法的第一行，不然編譯不經過。每一個子類構造方法的第一條語句，都是隱含地調用super()，若是父類沒有這種形式的構造函數，那麼在編譯的時候就會報錯。 2）super從子類中調用父類的構造方法，this()在同一類內調用其它方法。 3）super()和this()均需放在構造方法內第一行。 4）儘管能夠用this調用一個構造器，但卻不能調用兩個。 5）this和super不能同時出如今一個構造函數裏面，由於this必然會調用其它的構造函數，其它的構造函數必然也會有super語句的存在，因此在同一個構造函數裏面有相同的語句，就失去了語句的意義，編譯器也不會經過。 6）this()和super()都指的是對象，因此，均不能夠在static環境中使用。包括：static變量,static方法，static語句塊。 7）從本質上講，this是一個指向本對象的指針, 然而super是一個Java關鍵字。

四、抽象類

 一、抽象類不能被實例化，實例化的工做應該交由它的子類來完成，它只須要有一個引用便可。

 二、抽象方法必須由子類來進行重寫。

 三、只要包含一個抽象方法的類，該類必需要定義成抽象類，無論是否還包含有其餘方法。

 四、抽象類中能夠包含具體的方法，固然也能夠不包含抽象方法。

 五、子類中的抽象方法不能與父類的抽象方法同名。

 六、abstract不能與final並列修飾同一個類。（abstract須要子類去實現，而final表示不能被繼承，矛盾。）

 七、abstract 不能與private、static、final或native並列修飾同一個方法。

A、final修飾的類爲終態類，不能被繼承，而抽象類是必須被繼承的纔有其意義的，所以，final是不能用來修飾抽象類的。

B、 final修飾的方法爲終態方法，不能被重寫。而繼承抽象類，必須重寫其方法。

C、抽象方法是僅聲明，並不作實現的方法。

五、訪問權限：

（1）訪問權限修飾詞：

1）public（公共的）：代表該成員變量或方法對全部類或對象都是可見的，全部類或對象均可以直接訪問；

2）protected（受保護的）：代表成員變量或方法對該類自己&與它在同一個包中的其它類&在其它包中的該類的子類均可見；

3）default（默認的，不加任何訪問修飾符）：代表成員變量或方法只有本身&其位於同一個包內的類可見；

4）private（私有的）：代表該成員變量或方法是私有的，只有當前類對其具備訪問權限。

由大到小：public（接口訪問權限）、protected（繼承訪問權限）、包訪問權限（沒有使用任何訪問權限修飾詞）、private（私有沒法訪問）

protected表示就類用戶而言，這是private的，但對於任何繼承於此類的導出類或其餘任何位於同一個包內的類來講，倒是能夠訪問的。（protected也提供了包內訪問權限）

private和protected通常不用來修飾外部類，而public、abstract或final能夠用來修飾外部類（若是用private和protected修飾外部類，會使得該類變得訪問性受限）。

（2）訪問權限注意點：

一、類的訪問權限，只能是包訪問權限（默認無訪問修飾符便可）或者public。若把一個類中的構造器指定爲private，則不能訪問該類，若要建立該類的對象，則須要再該類的static成員內部建立，如單例模式。

二、若是沒能爲類訪問權限指定一個訪問修飾符，默認獲得包訪問權限，則該類的對象能夠由包內任何其餘類建立，可是包外不能夠。

三、訪問權限的控制，也稱爲具體實現的隱藏。制定規則（如使用訪問權限，設定成員所遵照的界限），是防止客戶端程序員對類爲所欲爲而爲。

（3）控制對成員的訪問權限的兩個緣由：

·       使用戶不要碰觸那些不應碰觸的部分，對類內部的操做是必要的，不屬於客戶端程序員所需接口的一部分；

·       讓類庫設計者能夠更改類的內部工做方式，而不會對客戶端程序員產生重大影響；訪問權限控制能夠確保不會有任何客戶端程序員依賴於類的底層實現的任何部分。

（4）對某成員的訪問權的惟一途徑：

·       1.該成員爲public；

·       2.經過不加訪問權限修飾詞並將其餘類放置在同一個包內的方式給成員賦予包訪問權。

·       3.繼承技術，訪問protected成員

·       4.提供訪問器和變異器（get/set方法），以讀取和改變數值。

六、值傳遞與引用傳遞

值傳遞：Java中原始數據類型都是值傳遞，傳遞的是值的副本，形參的改變不會影響實際參數的值；

引用傳遞： 傳遞的是引用類型數據，包括String,數組，列表，map，類對象等類型，形參與實參指向的是同一內存地址，所以形參改變會影響實參的值。

七、封裝：

把數據和方法包裝進類中，以及實現的隱藏，共同稱做封裝。結果是一個同時帶有特徵和行爲的數據類型。

八、組合、繼承：

（1）組合：

定義：只需在新的類中產生現有類的對象，因爲新的類是由現有類的對象所組成， 稱爲組合。組合技術知識將對象引用置於新類中便可。

缺點：將一個成員對象置於所要構造的類中（組合），在新類中暴露這個成員對象的全部方法（繼承），須要折中（代理），能夠選擇只提供在成員對象中的方法的某個子集。

特色：

·       1.has-a關係用組合；

·       2.組合技術一般用於想在新類中使用現有類的功能而非它的接口這種情形。在新類中嵌入某個對象，讓其實現所須要的功能，但新類的用戶看到的只是爲新類所定義的接口，而非所嵌入對象的接口。

（2）繼承：

定義：按照現有類的類型來建立新類 ，無需改變現有類的形式，採用現有類的形式並在其增長新代碼，稱爲繼承。經過關鍵字extends實現。

特色：

·       1.當建立一個類時，總在繼承。（除非明確指明繼承類，不然都是隱式第繼承根類Object）

·       2.爲了繼承，通常將全部的數據成員都指定爲private，將全部的方法指定爲public。

·       3.能夠將繼承視做是對類的複用；

·       4.is-a關係用繼承；

·       5.繼承容許對象視爲自身的類型或其基類型加以處理；

·       6.若是向上轉型，不能調用那些新的方法（如Animal an = new Cat()，an是不能調用Cat中有的而Animal中沒有的方法，會返回一條編譯時出錯消息），因此向上轉型會丟失具體的類型信息；

注意：

1.構造方法不能被繼承；方法和屬性能夠被繼承；

2.子類的構造方法隱式地調用父類的不帶參數的構造方法；

3.當父類沒有不帶參數的構造方法時，子類須要使用super來顯示調用父類的構造方法，super指的是對父類的引用

4.super關鍵字必須是構造方法中的第一行語句。特例以下

當兩個方法造成重寫關係時，可在子類方法中經過super.run(）形式調用父類的run()方法，其中super.run()沒必要放在第一行語句，所以此時父類對象已經構造完畢，先調用父類的run()方法仍是先調用子類的run()方法是根據程序的邏輯決定的。

總結：

代理使用時，能夠擁有更多的控制力，能夠選擇只提供在成員對象中的方法的某個子集；

組合和繼承都容許在新的類中放置子對象，組合是顯式地放置，繼承是隱式的作；

組合和繼承都能從現有類型中生成新類，組合通常是將現有類型做爲新類型底層實現的一部分加以複用，而繼承複用的是接口。優先使用組合。

九、final關鍵字

1）使用範圍：數據、方法和類

2）final關鍵字：final能夠修飾屬性、方法、類。

3）final修飾類：當一個類被final所修飾時，表示該類是一個終態類，即不能被繼承。

4）final修飾方法：當一個方法被final所修飾時，表示該方法是一個終態方法，即不能被重寫（Override）。

5）final修飾屬性：當一個屬性被final所修飾時，表示該屬性不能被改寫。

（1）final數據：

·       1.編譯時常量：是使用static和 final修飾的常量，全用大寫字母命名，且字與字之間用下劃線隔開。（不能由於數據是final的就認爲在編譯時就知道值，在運行時也能夠用某數值來初始化某一常量）

·       2.final修飾基本數據類型和對象引用：對於基本類型，final修飾的數值是恆定不變；而final修飾對象引用，則引用恆定不變（一旦引用被初始化指向一個對象，就不能改成指向另外一個對象），可是對象自己的內容能夠修改。

·       3.空白final：空白final是指被聲明爲final但又未給定初值的域，不管什麼狀況，編譯器都保證空白final在使用被初始化。必須在域的定義處或每一個構造器中用表達式對final進行賦值。

·       4.final參數：final修飾參數後，在方法體中不容許對參數進行更改，只能夠讀final參數。主要用於向匿名類傳遞數據。

（2）final方法：

·       1.使用final修飾方法緣由：將方法鎖定以及效率問題。將方法鎖定：防止任何繼承類修改final方法的含義，確保該方法行爲保持不變，且不會被覆蓋；效率：早期Java實現中贊成編譯器將針對該方法的全部調用轉爲內嵌調用。

·       2.類中全部的private方法都隱式地指定爲final的。

（3）final類：

·       1.將某個類總體定義爲final時，則不繼承該類，不能有子類。

十、初始化及類的加載

 

 

 

1.加載的含義：一般，加載發生在建立類的第一個對象時，但訪問static域或static方法時，也會發生加載。static的東西只會初始化一次。

2.加載過程：加載一個類的時候，首先去加載父類的靜態域，而後再加載自身的靜態域，以後去初始化父類的成員變量，後加載父類的構造方法，最後初始化自身的成員變量，後加載自身的構造方法。（先初始化成員變量，後加載構造函數的緣由是，構造函數中可能要用到這些成員變量）

父類靜態塊——子類靜態塊——父類塊——父類構造器——子類塊——子類構造器

最終版本：父類靜態域——父類靜態塊——子類靜態域——子類靜態塊——父類成員變量及代碼塊——父類構造器——子類成員變量及代碼塊——子類構造器。

3.加載次數：加載的動做只會加載一次，該類的靜態域或第一個實體的建立都會引發加載。

4.變量的初始化：變量的初始化老是在當前類構造器主體執行以前進行的，且static的成員比普通的成員變量先初始化。

十一、多態

1.多態只發生在普通方法中，對於域和static方法，不發生多態。子類對象轉化爲父類型引用時，對於任何域的訪問都是由編譯器解析。靜態方法是與類相關聯，而不與單個對象相關聯；

2.在繼承時，若被覆寫的方法不是private，則父類調用方法時，會調用子類的方法，經常使用的多態性就是當父類引用指向子類對象時。

3.多態就是指程序中定義的引用變量所指向的具體類型和經過該引用變量發出的方法調用在編程時並不肯定，而是在程序運行期間才肯定，即一個引用變量到底指向哪一個類的實例對象，該引用變量發出的方法調用究竟是哪一個類中實現的方法，必須在由程序運行期間才能決定。

4.多態是同一個行爲具備多個不一樣表現形式或形態的能力。

5.多態就是同一個接口，使用不一樣的實例而執行不一樣操做，多態性是對象多種表現形式的體現。

十二、構造器

1.爲何強制每一個導出類部分都必須調用構造器的緣由？（基類的構造器老是在導出類的構造過程當中被調用）

只有基類的構造器才具備恰當的知識和權限對本身的元素進行初始化，所以必須令全部的構造器都獲得調用。導出類只能訪問本身的成員，不能訪問基類中的成員（一般是private類型）。

2.編寫構造器原則：用盡量的簡單的方法使對象進入正常狀態；若是能夠的話，避免調用其餘方法，由於調用這些方法，有可能會致使初始化未進行，調用的是0值，在構造器內惟一可以安全調用的方法是基類中的final方法（調用不能被覆蓋的方法）。

1三、基本數據類型與包裝類

全部的包裝類（8個）都位於java.lang包下，分別是Byte，Short，Integer，Long，Float，Double，Character，Boolean

基本數據類型：byte：8位；short：16位；int：32位；long：64位；float：32位；double：64位；char：16位；boolean：8位。

 

1四、==與equals方法的區別：

（1）基本數據類型與引用數據類型

1.基本數據類型的比較：只能用==；

2.引用數據類型的比較：==是比較棧內存中存放的對象在堆內存地址，equals是比較對象的內容是否相同；

（2）特殊：String做爲一個對象

例子一：經過構造函數建立對象時。對象不一樣，內容相同，"=="返回false，equals返回true

String s1 = newString("java");
String s2 = new String("java");

System.out.println(s1==s2);            //false
System.out.println(s1.equals(s2));   //true

例子二：同一對象，"=="和equals結果相同

String s1 = newString("java");
String s2 = s1;  //兩個不一樣的引用變量指向同一個對象

System.out.println(s1==s2);            //true
System.out.println(s1.equals(s2));   //true

若是值不相同，對象就不相同，因此"=="和equals結果同樣

String s1 = "java";
String s2 = "java";   //此時String常量池中有java對象，直接返回引用給s2；

System.out.println(s1==s2);            //true

System.out.println(s1.equals(s2));    //true

字面量形式建立對象時：

若是String緩衝池內不存在與其指定值相同的String對象，那麼此時虛擬機將爲此建立新的String對象，並存放在String緩衝池內。

若是String緩衝池內存在與其指定值相同的String對象，那麼此時虛擬機將不爲此建立新的String對象，而直接返回已存在的String對象的引用。

（3）String的字面量形式和構造函數建立對象

1）String s = "aaa";採用字面值方式賦值

1.查找StringPool中是否存再「aaa」這個對象，若是不存在，則在StringPool中建立一個「aaa」對象，而後將String Pool中的這個「aaa」對象的地址返回來，賦給引用變量s，這樣s會指向String Pool中的這個「aaa」字符串對象；

2.若是存在，則不建立任何對象，直接將String Pool中的這個「aaa」對象地址返回來，賦給s引用。

2）String s = new String("aaa");

1.首先在StringPool中查找有沒有"aaa"這個字符串對象，若是有，則不在String Pool中再去建立"aaa"這個對象，直接在堆中建立一個"aaa"字符串對象，而後將堆中的這個"aaa"對象的地址返回來，賦給s引用，致使s指向了堆中建立的這個"aaa"字符串對象；

2.若是沒有，則首先在String Pool中建立一個"aaa"對象，而後再去堆中建立一個"aaa"對象，而後將堆中的這個"aaa"對象的地址返回來，賦給s引用，致使s指向了堆中所建立的這個"aaa"對象。

1五、Object類的公有方法

clone()（protected的）、toString()、equals(Object obj)、hashCode()、getClass()、finialize()（protected的）、notify()/notifyAll()、wait()/wait(long timeout)、wait(long timeout,intnaos)

 

1六、try catchfinally

·       1.finally裏面的代碼必定會執行的；

·       2.當try和catch中有return時，先執行return中的運算結果可是先不返回，而後保存下來計算結果，接着執行finally，最後再返回return的值。

·       3.finally中最好不要有return，不然，直接返回，而先前的return中計算後保存的值得不到返回。

1七、面向對象的三大基本特徵

封裝、繼承和多態

（1）封裝

隱藏一切能夠隱藏的消息，只向外界提供最簡單的編程接口；類就是對數據和方法的封裝；方法就是對具體實現細節的封裝；

（2）繼承

從已有的類繼承獲得繼承信息，建立新類的過程，並沒有需從新編寫與原來的類相同的方法或成員變量狀況下就能夠對這些功能進行擴展。

（3）多態

容許父類型的引用指向子類型的對象。

實現方式：方法重載（編譯器綁定，前綁定）和方法重寫（運行期綁定，後綁定）

1八、靜態類和非靜態類

（1）靜態類

靜態類中的字段與方法都必須是static的，靜態類不須要實例化就可使用；

（2）非靜態類

非靜態類中能夠有static的字段與方法，也能夠由非static的字段與方法，訪問static的字段與方法不須要實例化，可是訪問非static的字段與方法時須要實例化。

1九、for和foreach循環效率：

 

 

 

for能夠不逐個遍歷，如每隔一個遍歷；也能夠從前向後遍歷，從後向前遍歷；有條件判斷，使用已知次數的循環遍歷；

foreach只能逐個遍歷；只能從前向後遍歷；沒有執行條件限制，不能向迭代變量賦值；適合集合的遍歷；

若是遍歷集合或數組時，若是須要訪問集合或數組的下標，則最好使用舊式的方式來實現循環或遍歷，而不要使用加強的for循環，由於它丟失了下標信息。

20、JNIjava native interface

設計做用：主要實現和其餘語言的通訊，c和c++。標準的Java類庫中可能不支持程序所需的特性，或已經有了一個用其餘語言編寫的庫或程序，可是如今但願用到Java程序中，則須要使用JNI。

使用場景：JDBC實現鏈接數據庫，Thread.sleep()方法。

2一、pach和classpath的區別

path是windows的環境屬性，用於指定可執行命令的路徑；classpath是指在Java程序執行的時候，用於指定類的加載路徑。

2二、final、finally、finalize的區別

final是Java的一個關鍵字，用於定義不能被繼承的類，不能被覆寫的方法，不能修改的常量。

finally是Java的一個關鍵字，是異常處理操做的統一出口。

finalize是Object類中所提供的一個方法，用於在對象回收以前進行收尾操做。

final

修飾符（關鍵字）若是一個類被聲明爲final，意味着它不能再派生出新的子類，不能做爲父類被繼承。所以一個類不能既被聲明爲 abstract的，又被聲明爲final的。將變量或方法聲明爲final，能夠保證它們在使用中不被改變。被聲明爲final的變量必須在聲明時給定初值，而在之後的引用中只能讀取，不可修改。被聲明爲final的方法不能夠重寫（父子類繼承關係），可是能夠重載（同一個類中）。

finally

異常處理時提供 finally 塊來執行任何清除操做。若是拋出一個異常，那麼相匹配的 catch 子句就會執行，而後控制就會進入 finally 塊（若是有的話）。通常異常處理塊須要。

finalize

·       方法名，Java技術容許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去以前作必要的清理工做。這個方法是由垃圾收集器在肯定這個對象沒有被引用時對這個對象調用的。它是在 Object 類中定義的，所以全部的類都繼承了它。子類覆蓋 finalize() 方法以整理系統資源或者執行其餘清理工做。finalize() 方法是在垃圾收集器刪除對象以前對這個對象調用的。 

·       Java中全部類都從Object類中繼承finalize()方法。

·       當垃圾回收器(garbage colector)決定回收某對象時，就會運行該對象的finalize()方法。值得C++程序員注意的是，finalize()方法並不能等同與析構函數。Java中是沒有析構函數的。C++的析構函數是在對象消亡時運行的。因爲C++沒有垃圾回收，對象空間手動回收，因此一旦對象用不到時，程序員就應當把它delete()掉。因此析構函數中常常作一些文件保存之類的收尾工做。可是在Java中很不幸，若是內存老是充足的，那麼垃圾回收可能永遠不會進行，也就是說filalize()可能永遠不被執行，顯然期望它作收尾工做是靠不住的。

·       那麼finalize()到底是作什麼的呢？它最主要的用途是回收特殊渠道申請的內存。Java程序有垃圾回收器，因此通常狀況下內存問題不用程序員操心。但有一種JNI(JavaNative Interface)調用non-Java程序（C或C++），finalize()的工做就是回收這部分的內存。

2三、Java實現可移植性的原理

Java程序最終經過字節碼文件運行，運行的時候字節碼須要JVM支持，可是在不一樣的操做系統中有不一樣的JVM，程序不用關心操做系統，只關心JVM，只要JVM不改變，程序能夠在操做系統間任意移植。

2四、Java的數據類型劃分

1）當若干個變量參與運算時，結果類型取決於這些變量中表示範圍最大的那個變量類型，若有整型int，有雙精度浮點型double，有短整型short，則最後的結果類型爲double。

 

2）取模

 

數據類型	默認值
基本數據類型
數值型：整型：byte、short、int、long 浮點型：float、double	0
字符型：char	'\u0000'
布爾型：boolean	false
引用數據類型
數組、類、接口	null

2五、&和&&、|和||的區別

·       &（普通與）和|（普通或）是指全部條件都須要判斷；

·       &&稱爲邏輯與（短路與）是若是前面的條件不知足false，則後面的再也不進行判斷；||稱爲邏輯或（短路或）若是前面的條件知足true則後面的再也不判斷；

·       在開發之中爲了性能的提升，不須要全部條件進行判斷，因此使用短路與和短路或操做；

·       &和|除了用於邏輯運算之外，還進行位運算的操做。

·       

2六、String對象的兩種實例化方式的區別

1.首先String對象的實例化有兩種：直接賦值和構造方法完成。

2.直接賦值：在常量池中建立該字符串；

3.構造方法：先判斷在字符串常量池中是否包含該字符串，若包含該字符串，則在堆中直接建立這個字符串對象並返回該對象引用；若不包含，則先在堆上建立，而後在字符串常量池中也建立，最後把返回堆上對象引用。

2七、throw和throws區別

1.throw是語句拋出一個異常。

語法：throw (異常對象);

          throw e;

throws是方法可能拋出異常的聲明。(用在聲明方法時，表示該方法可能要拋出異常)

語法：[(修飾符)](返回值類型)(方法名)([參數列表])[throws(異常類)]{......}

           public void doA(int a) throws Exception1,Exception3{......}

2.throw語句用在方法體內，表示拋出異常，由方法體內的語句處理；throws語句用在方法聲明後面，表示再拋出異常，由該方法的調用者來處理。

3.throw是具體向外拋異常的動做，已經發生異常，被捕獲到，要拋出該異常，因此它是拋出一個異常實例；throws主要是聲明這個方法會拋出這種類型的異常，使它的調用者知道要捕獲這個異常，傾向於發生，但不必定發生。

2八、枚舉（Enums）

1.當使用「enum」定義枚舉類型時，實質上是繼承java.lang.Enum類型；

2.每一個枚舉的成員其實就是定義的枚舉類型的一個實例，他們都被預設爲final，因此沒法改變他們，也是static成員，因此能夠經過類型名稱直接使用它們，且他們是公開的public的。

3.特性：final static public的。

4.在編譯時期就肯定該枚舉類型具備幾個實例，分別是什麼。在運行期間咱們沒法再使用該枚舉類型建立新的實例，這些實例在編譯期間就已經徹底肯定下來。

2九、遞歸

　　Recursion，就是方法調用自身，對於遞歸來講，必定有一個出口，讓遞歸結束，只有這樣才能保證不出現死循環。

30、可變參數

1.可變參數本質上就是一個數組，對於某個聲明瞭可變參數的方法來講，既能夠傳遞離散的值，也能夠傳遞數組對象。

2.若是將方法中的參數定義爲數組，則只能傳遞數組對象而不能傳遞離散的值。

3.可變參數必需要做爲方法參數的最後一個參數，即一個方法不可能具備兩個或以上的可變參數。

3一、靜態導入

1.使用靜態導入import static時，要一直導入到類中的靜態成員變量或靜態方法。

如：

import static com.ljy.exercise.Person.age;

import staticcom.ljy.exercise.Person.printlnPersonName；

3二、集合的元素

集合中存放的依然是對象的引用，而不是對象自己。

集合沒法放置原生數據類型，因此須要使用原生數據類型的包裝類將其轉換爲真正的類型。

3三、一個類不能既是final的，又是abstract的

由於abstract的主要目的是定義一種約束：讓子類去實現這種約定，而final表示該類不能被繼承，這樣abstract但願該類能夠被繼承與之矛盾。

3四、靜態方法

1.static修飾方法，能夠經過類名.靜態方法名的方式訪問，靜態方法只能繼承，不能重寫（Override）。

2.不能在靜態方法中使用this關鍵字；

3.靜態的只能訪問靜態的（由於靜態的代碼塊在構造方法以前就已經開始初始化，而此時非靜態的還未開始初始化，若是靜態能訪問非靜態的就會出現發生錯誤），非靜態的能夠訪問一切。

3五、局部變量和成員變量

局部變量使用前必須聲明並賦初值；成員變量使用前必需要聲明，但能夠不賦初值。

 

3六、引用類型

reference type，引用類型用在對象上，一個對象能夠被多個引用所指向，但同一時刻，每一個引用只能指向惟一的對象，若是一個對象被多個引用所指向，那麼不管哪一個引用對對象的屬性進行修改，都會反映到其餘的引用中去。

3七、方法和類的定義

（1）類的定義

修飾符 class 類的名字{

//類的內容（包含了屬性與方法）

}

（2）方法的定義

修飾符　返回類型　方法名稱([參數1，參數2，參數3...]){

//方法體

}

1）方法定義不能嵌套，一個方法中不能定義另外一個方法，方法只能定義在類中。

2）形式參數：方法定義時的參數。

3）實際參數：方法調用時所賦予的具體值。

3八、break和continue

1）break語句：常常用在循環語句中，用於跳出整個循環，執行循環後面的代碼。（若是雙重循環，在內循環中使用break，跳出內循環）

2）continue語句：常常用在循環語句中，用於跳出本次循環，開始下一次循環的執行。

3）break與continue能夠搭配標籤使用。

3九、switch語句

 

40、變量的自增與自減運算

1）關於int b = a++，做用：先將a賦給b，而後再讓a自增1。

2）關於int b = ++a，做用：先將a的值自增1，而後再將自增後的a賦給b。

總結：哪一個在前，就先作哪一步。

4一、Arrays.sort底層實現

基本類型：採用調優的快速排序：當待排序元素小於7個的時候，採用插入排序。

對象類型：採用改進的歸併排序；

4二、什麼是跨平臺性？原理是什麼？

 

1）跨平臺性：經過Java語言編寫的應用程序在不一樣的系統平臺上均可以運行。

2）原理：只要在須要運行Java應用程序的操做系統上，先安裝一個Java虛擬機（JVM Java Virtual Machine）便可，由JVM來負責Java程序在該系統中的運行。由於有了JVM，因此同一個Java程序在三個不一樣的操做系統中均可以執行，這樣實現Java程序的跨平臺性，也稱爲Java具備良好的可移植性。

4三、JRE與JDK

1）JRE：Java Runtime Environment，Java運行環境，包括JVM和Java程序所需的核心類庫等。

2）JDK：Java Development Kit，Java開發工具包，JDK是提供給Java開發人員使用的，其中包含了Java的開發工具（編譯工具javac.exe和打包工具jar.exe等），也包括了JRE。因此安裝JDK，就不用單獨安裝JRE。

3）若是是命令行模式：編譯器javac進行編譯：javac 源文件名.java——編譯經過後，對class字節碼文件運行：java 類名

4）運行與工做原理

 

5）path環境變量配置的做用：程序開發過程當中，不能將源代碼寫入JDK的安裝目錄，所以須要將源程序保存到任意位置的指定目錄（英文目錄），因此須要使javac指令在任意目錄下能夠運行。經過配置path環境變量，將javac指令所在目錄及JDK安裝目錄下的bin目錄配置到path變量下，便可使javac指令在任意目錄下運行。

6）使classpath目錄中的.class文件能夠在任意目錄運行。

7）path和classpath的區別：path環境變量裏面記錄的是可執行性文件，如.exe文件，對可執行文件先在當前路徑去找，若是沒找到就去path環境變量中配置的路徑去找。而classpath環境變量裏記錄的是java類的運行文件所在的目錄。

4四、反射

（1）反射機制

1）定義：JAVA反射機制是在運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；對於任意一個對象，都可以調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制。要想解剖一個類,必須先要獲取到該類的字節碼文件對象。而解剖使用的就是Class類中的方法.因此先要獲取到每個字節碼文件對應的Class類型的對象.

2）獲取Class對象的三種方式

第一種方式：

Person p = new Person();

Class c = p.getClass();

第二種方式：任意類都具有一個class靜態屬性

Class c2 = Person.class;

第三種方式：將類名做爲字符串傳遞給Class類的靜態方法forName

Class c3 =Class.forName("Person");

（2）動態代理

1）在Java中java.lang.reflect包下提供了一個Proxy類和一個InvocationHandler接口，經過使用這個類和接口就能夠生成動態代理對象。JDK提供的代理只能針對接口作代理。咱們有更強大的代理cglib

2）Proxy類中的方法建立動態代理類對象

public static Object newProxyInstance(ClassLoaderloader,Class<?>[] interfaces,InvocationHandler h)

最終會調用InvocationHandler的方法

Proxy類中建立動態代理對象的方法的三個參數；

·       ClassLoader對象，定義了由哪一個ClassLoader對象來對生成的代理對象進行加載；

·       Interface對象的數組，表示的是我將要給我須要代理的對象提供一組什麼接口，若是我提供了一組接口給它，那麼這個代理對象就宣稱實現了該接口(多態)，這樣我就能調用這組接口中的方法了；

·       InvocationHandler對象，表示的是當我這個動態代理對象在調用方法的時候，會關聯到哪個InvocationHandler對象上。

3）InvocationHandler

Object invoke(Object proxy,Method method,Object[] args)

每個動態代理類都必需要實現InvocationHandler這個接口，而且每一個代理類的實例都關聯到了一個handler，當咱們經過代理對象調用一個方法的時候，這個方法的調用就會被轉發爲由InvocationHandler這個接口的invoke 方法來進行調用。

InvocationHandler接口中invoke方法的三個參數：

·       proxy:表明動態代理對象

·       method:表明正在執行的方法

·       args:表明調用目標方法時傳入的實參

4）Proxy.newProxyInstance

建立的代理對象是在jvm運行時動態生成的一個對象，它並非咱們的InvocationHandler類型，也不是咱們定義的那組接口的類型，而是在運行是動態生成的一個對象，而且命名方式都是這樣的形式，以$開頭，proxy爲中，最後一個數字表示對象的標號。System.out.println(u.getClass().getName());

4五、異常

（1）異常介紹

1）編譯時異常

除了RuntimeException及其子類,Exception中全部的子類都是,這種異常必需要處理,要不編譯通不過

2）運行時異常

RuntimeException及其子類都是,這種異常不用處理,編譯會經過,不過這樣的程序會有安全隱患,遇到這種異常是須要改代碼的

3）嚴重錯誤問題

用Error進行描述,這個問題發生後,通常不編寫針對代碼進行處理,而是要對程序進行修正.一般都是由虛擬機拋出的問題

（2）Throwable中方法

getMessage()

獲取異常信息，返回字符串。

toString()

獲取異常類名和異常信息，返回字符串。

printStackTrace()

獲取異常類名和異常信息，以及異常出如今程序中的位置。返回值void。

printStackTrace(PrintStream s)

一般用該方法將異常內容保存在日誌文件中，以便查閱。

（3）throws和throw的區別

1）throws

·       用在方法聲明後面，跟的是異常類名；

·       能夠跟多個異常類名，用逗號隔開；

·       表示拋出異常，由該方法的調用者來處理；

·       throws表示出現異常的一種可能性，並不必定會發生這些異常。

2）throw

·       用在方法體內，跟的是異常對象名；

·       只能拋出一個異常對象名；

·       表示拋出異常，由方法體內的語句處理；

·       throw則是拋出了異常，執行throw則必定拋出了某種異常 。

（4）try和throws區別

若是該功能內部能夠將問題處理，用try，若是處理不了，則交由調用者處理，用throws進行拋出異常。

區別：後序程序須要運行，則用try；後序程序不須要繼續運行，則用throws；

4六、面向對象：

1）思想：是站在現實世界的角度去抽象和解決問題，把數據和行爲都看做是對象的一部分，可讓程序員以符合現實世界的思惟方式來編寫和組織程序。

2）原則：

單一職責：一個類只作它該作的事（高內聚）；

開放封閉：對擴展開放，對修改關閉；

里氏替換：任什麼時候候均可用子類型替換父類型；

依賴倒置：面向接口編程（抽象類型可被任何一個子類所替代）；

合成聚和複用：優先使用聚合或合成關係複用代碼；

接口隔離：一個接口只應描述一種能力，接口應該是高內聚的（小而專注）；

迪米特法則：最少知識原則，一個對象應對其餘對象儘量少的瞭解。

4七、數組和容器的區別

1）效率：數組是一種效率最高的存儲和隨機訪問對象引用序列的方式，數組就是一個簡單的線性序列，這使得元素訪問很是快速，能夠經過整型索引值訪問元素；

2）大小：數組對象的大小被固定，而且在其生命週期中不可改變；容器如ArrayList能夠動態擴容，經過建立一個新實例，而後把舊實例中全部的引用移到新實例中，從而實現更多空間的自動分配；

3）數據類型：數組能夠持有基本類型，數組持有某種具體類型，經過編譯器檢查，防止插入錯誤類型和抽取不當類型；容器經過泛型，指定並檢查它們所持有對象的類型，而且有了自動包裝機制，好像是可以持有基本數據類型。

注意：數組的比較是是經過equals()方法，用來比較整個數組，一樣，此方法針對全部基類類型與Object都作了重載，數組相等的條件是元素個數必須相等，而且對應位置的元素也相等，這能夠經過對每個元素使用equals()做比較判斷。

4八、Arrays的方法

java.util類庫中的Arrays類，有一套用於數組的static實用方法。有6個基本方法+1個asList()方法。

1）Arrays.asList()：接收任意的序列或數組做爲其參數，並將其轉變爲List容器；

2）equals()：用於比較兩個數組是否相等（deepEquals()用於多維數組）；

3）fill()：是用同一個數值進行填充數組的各個位置，針對對象而言，就是複製同一個引用進行填充；

4）sort()：用於對數組排序；（對於數值排序，小於8的使用插入排序，大於等於8個元素使用快速排序；對於對象排序，使用合併排序）；

5）binarySearch()：用於在已經排序的數組中查找元素；

6）toString()：差生數組的String表示；

7）hashCode()：產生數組的散列碼；

50、equals()方法的5個條件

1）自反性。對任意x，x.equals(x)必定返回true；

2）對稱性。對任意x和y，若是y.equals(x)返回true，則x.equals(y)也返回true；

3）傳遞性。對任意x、y、z，若是有x.equals(y)返回true，y.equals(z)返回true，則x.equals(z)必定返回true；

4）一致性。對任意x和y，若是對象中用於等價比較的信息沒有改變，那麼不管調用x.equals(y)多少次，返回的結果應該保持一致，要麼一直是true，要麼一直是false；

5）對任何不是null的x，x.equals(null)必定返回false。

默認的Object.equals()只是比較對象的地址。

5一、public staticvoid main(String[] args)方法的必要性

1）是Java程序的入口方法，JVM在運行程序時，會首先查找main()方法；

2）public是權限修飾符，代表任何類或對象均可以訪問這個方法；

3）static代表main()方法是一個靜態方法，即方法中的代碼是存儲在靜態存儲區的，只要類加載後，就可使用該方法而不須要經過實例化對象來訪問，能夠直接經過類名。

4）main()不能用abstract修飾，但能夠用final和synchronized修飾，且public與static的順序能夠顛倒。

5二、Java程序初始化的順序

（1）遵循3個原則：

1）靜態對象（變量）優先於非靜態對象（變量）初始化；

2）父類優先於子類進行初始化；

3）按照成員變量的定義順序進行初始化，

（2）初始化順序

父類靜態變量、父類靜態代碼塊、子類靜態變量、子類靜態代碼塊、父類非靜態變量、父類非靜態代碼塊、父類構造函數、子類非靜態變量、子類非靜態代碼塊、子類構造函數

5三、Java變量類型

（1）變量類型

靜態變量、成員變量、局部變量

（2）變量類型的範圍

1）靜態變量：被static修飾的成員變量稱爲靜態變量，靜態變量不依賴於特定的實例，而是被全部實例所共享，只要一個類被加載，JVM就會給類的靜態變量分配存儲空間，能夠經過類名和實例變量名訪問靜態變量。

2）成員變量：做用範圍與類的實例化對象的做用範圍相同，當類被實例化時，成員變量就會在內存中分配空間並初始化，直到這個被實例化對象的生命週期結束時，成員變量的聲明週期才結束。

3）局部變量：做用域與可見性爲它所在的花括號內。

5四、ArrayList和LinkedList

1）實現接口：都實現了List接口；

2）底層：ArrayList底層是由數組支持；LinkedList底層是由雙向鏈表實現；

3）內存：ArrayList比LinkedList申請少的內存，由於LinkedList中的每一個對象包含數據的同時還包含指向鏈表中前一個與後一個元素的引用；

4）操做：ArrayList不適合插入或刪除，須要移動後面的元素，但適合快速訪問；而LinkedList適合插入和刪除，由於開銷是固定的；

5五、快速報錯機制

1）出現緣由：在迭代遍歷某個容器的過程當中，另外一個進程介入其中，而且插入、刪除或修改此容器內的某個對象，則會出現問題：也許迭代過程已經處理過容器中獲得該元素了，也許還沒處理，也許在調用size()以後容器的尺寸收縮了。

2）快速報錯（fail-fast）機制：探查容器上除了你的進程所進行的操做之外的全部變化，一旦發現其餘進程修改容器，當即拋出ConcurrentModificationException異常，即不是使用複雜的算法在過後來檢查問題。