java基礎知識點整理

1.&和&&的區別？

&：邏輯與（and）,運算符兩邊的表達式均爲true時，整個結果才爲true。

&&：短路與，若是第一個表達式爲false時，第二個表達式就不會計算了。

2.在java中如何跳出當前的多重循環？

在循環語句外前面定義一個標號，而後在裏層循環體的代碼中使用帶有標號的break語句，便可跳出循環。

好比：

ok: for (int i = 0; i < 10; i++) { { for (int j = 0; j < 10; j++) { break ok; } } }

3.最有效率的方法算出2X8等於幾？

使用位運算，效率最高：2<<3,表示2向右移動了3位，就至關於2乘以2的3次方,結果：16。

4.」==」和equals方法究竟有什麼區別？

==：表示兩個變量的值是否相等，比較兩個基本數據類型的數據或者引用變量，用==。

equals:用於比較兩個獨立對象的內容是否相同。字符串的比較也用equals。

5. Int和integer的區別？

Int是Java的8中基本數據類型之一，integer是int的封裝類。Int類型的默認值爲0，integer默認值爲null，因此區別在於，integer能區分出null值和0的區別。

6.三個與取整有關的方法：

Math.ceil():表示向上取整；Math.ceil(11.3)=12;Math.ceil(-11.3)=-12。

Math.floor():表示向下取整；Math.floor(11.6)=12;Math.floor(-11.6)=-12。

Math.round():表示四捨五入；Math.round(11.5)=12;Math.round(-11.5)=-11;

  Marh.round(11.3)=11;Math.round(-11.3)=--11;

7.重載和重寫的區別？

重載（Overload）：函數名相同，參數不一樣。能夠改變返回值類型，參數的個數和類型。

重寫（Override）：和父類的的方法名稱、參數徹底相同。

8.面向對象的特徵？

封裝：將對象屬性和方法的代碼封裝到一個模塊中，也就是一個類中，保證軟件內部具備優良的模塊性的基礎，實現「高內聚，低耦合」。

抽象：找出一些事物的類似和共性之處，而後歸爲一個類，該類只考慮事物的類似和共性之處。抽象包括行爲抽象和狀態抽象。

繼承：在已經存在的類的基礎上進行，將其定義的內容做爲本身的內容，並能夠加入新的內容或者修改原來的方法適合特殊的須要。

多態：同一操做做用於不一樣的對象，能夠有不一樣的解釋，產生不一樣的執行結果，就是多態，簡單點說：就是用父類的引用指向子類的對象。目的：提升代碼複用性，解決項目中緊耦合問題，提升可擴展性。

多態的機制：靠的是父類的或者接口的引用變量能夠指向子類或者具體實現類的實例對象。

9.String和StringBuffuer、StringBuilder的區別？

String:字符串數值不可變；

StringBuffer：字符串可修改，能夠動態構造字符數據。StringBuffer類是能夠經過Append()來修改值。線程安全。

StringBuilder：線程不安全。

三者在執行速度方面的比較：StringBuilder >  StringBuffer  >  String

對於三者使用的總結：

1.若是要操做少許的數據用 = String　　

2.單線程操做字符串緩衝區下操做大量數據 = StringBuilder

3.多線程操做字符串緩衝區下操做大量數據 = StringBuffer

10.java中有幾種方法實現一個線程？用什麼關鍵字修飾同步方法？stop()和suspend()方法爲什麼不推薦使用？ 

第一種：繼承Thread類。New Thread(){}.start():表示調用子類對象的run方法。

第二種：實現Runable接口。

第三種：線程池建立多線程。

第四種：實現Callable接口，重寫call函數（

繼承Thread類實現多線程，重寫run方法時沒有返回值也不能拋出異常，使用Callable接口就能夠解決這個問題。

Callable接口和Runnable接口的不一樣之處：

1.Callable規定的方法是call，而Runnable是run

2.call方法能夠拋出異常，可是run方法不行

3.Callable對象執行後能夠有返回值，運行Callable任務能夠獲得一個Future對象，經過Future對象能夠了解任務執行狀況，能夠取消任務的執行，而Runnable不可有返回值

）

用synchronized 關鍵字修飾同步方法。

反對使用stop()，是由於它不安全。它會解除由線程獲取的全部鎖定，並且若是對象處於一種不連貫狀態，那麼其餘線程能在那種狀態下檢查和修改它們，結果很難檢查出真正的問題所在。

suspend() 方法容易發生死鎖。調用 suspend() 的時候，目標線程會停下來，但卻仍然持有在這以前得到的鎖定。此時，其餘任何線程都不能訪問鎖定的資源，除非被" 掛起"的線程恢復運行。對任何線程來講，若是它們想恢復目標線程，同時又試圖使用任何一個鎖定的資源，就會形成死鎖。因此不該該使用 suspend() ，而應在本身的 Thread 類中置入一個標誌，指出線程應該活動仍是掛起。若標誌指出線程應該掛起，便用  wait() 命其進入等待狀態。若標誌指出線程應當恢復，則用一個 notify()從新啓動線程。 

 

11.sleep()和wait()有什麼區別？

sleep是線程被調用時，佔着cpu休眠，其餘線程不能佔用cpu，os認爲該線程正在工做，不會讓出系統資源，wait是進入等待池等待，讓出系統資源，其餘線程能夠佔用cpu。

 

sleep()和wait()方法的區別可從兩個角度闡述：
1.cpu的搶佔權；2.鎖旗標是否釋放
二者都會釋放cpu的搶佔權；
wait()方法執行完便可釋放鎖旗標，進入線程的等待隊列；
sleep()執行完，不會釋放，進入等待隊列；

 

12. 同步和異步的區別？同步的實現方法？

同步:發送一個請求,等待返回,而後再發送下一個請求。實現：1. Synchronized修飾；2.wait和notify。
異步:發送一個請求,不等待返回,隨時能夠再發送下一個請求。

同步能夠避免出現死鎖,讀髒數據的發生，通常共享某一資源的時候用，若是每一個人都有修改權限，同時修改一個文件，有可能使一我的讀取另外一我的已經刪除的內容，就會出錯，同步就會按順序來修改。

同步和異步最大的區別就在於，一個須要等待，一個不須要等待。

好比廣播，就是一個異步例子。發起者不關心接收者的狀態。不須要等待接收者的返回信息。

電話，就是一個同步例子。發起者須要等待接收者，接通電話後，通訊纔開始。須要等待接收者的返回信息。

13. 請對比synchronized與java.util.concurrent.locks.Lock的異同？

主要相同點：Lock能完成synchronized所實現的全部功能
主要不一樣點：Lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖，而Lock必定要求程序員手工釋放，而且必須在finally從句中釋放。

 

14.String  s =new  String (「syz」);建立了幾個String Object?

1.若是String常理池(常量緩衝區)中，已經建立"xyz"，則不會繼續建立，此時只建立了一個對象new String("xyz")；

2.若是String常理池中，沒有建立"xyz"，則會建立兩個對象，一個對象的值是"xyz"，一個對象new String("xyz")。

15.做用域public、private、protected 以及不寫時的區別？

private修飾的成員變量和函數只能在類自己和內部類中被訪問。

protected 修飾的成員變量和函數能被類自己、子類及同一個包中的類訪問。

public修飾的成員變量和函數能夠被類、子類、同一個包中的類以及任意其餘類訪問。

默認狀況（不寫）下，屬於一種包訪問，即能被類自己以及同一個包中的類訪問。

做用域	當前類	同一package	子孫類	其餘package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

 

16.forward和redirect兩種跳轉方式的區別？

1.從地址欄顯示來講

forward是服務器請求資源,服務器直接訪問目標地址的URL,把那個URL的響應內容讀取過來,而後把這些內容再發給瀏覽器.瀏覽器根本不知道服務器發送的內容從哪裏來的,因此它的地址欄仍是原來的地址.

redirect是服務端根據邏輯,發送一個狀態碼,告訴瀏覽器從新去請求那個地址.因此地址欄顯示的是新的URL.

2.從數據共享來講

forward:轉發頁面和轉發到的頁面能夠共享request裏面的數據.

redirect:不能共享數據.

3.從運用地方來講

forward:通常用於用戶登錄的時候,根據角色轉發到相應的模塊.

redirect:通常用於用戶註銷登錄時返回主頁面和跳轉到其它的網站等.

4.從效率來講

forward:高.

redirect:低.

本質上說, 轉發是服務器行爲，重定向是客戶端行爲。其工做流程以下：

轉發過程：客戶瀏覽器發送http請求----》web服務器接受此請求--》調用內部的一個方法在容器內部完成請求處理和轉發動做----》將目標資源發送給客戶；在這裏，轉發的路徑必須是同一個web容器下的url，其不能轉向到其餘的web路徑上去，中間傳遞的是本身的容器內的request。在客戶瀏覽器路徑欄顯示的仍然是其第一次訪問的路徑，也就是說客戶是感受不到服務器作了轉發的。轉發行爲是瀏覽器只作了一次訪問請求。

重定向過程：客戶瀏覽器發送http請求----》web服務器接受後發送302狀態碼響應及對應新的location給客戶瀏覽器--》客戶瀏覽器發現是302響應，則自動再發送一個新的http請求，請求url是新的location地址----》服務器根據此請求尋找資源併發送給客戶。在這裏 location能夠重定向到任意URL，既然是瀏覽器從新發出了請求，則就沒有什麼request傳遞的概念了。在客戶瀏覽器路徑欄顯示的是其重定向的路徑，客戶能夠觀察到地址的變化的。重定向行爲是瀏覽器作了至少兩次的訪問請求的。

18.編程單例模式：寫一個singleton出來

Singleton分爲：飽漢模式、飢漢模式、雙重鎖模式

//飽漢模式:類加載時完成初始化，建立出實例對象（無論用不用，先建立）。 public class SingleTon { //實例化對象放到靜態代碼塊中，可提升執行效率，可是可能更佔用空間 private final static SingleTon instence=new SingleTon(); private SingleTon(){};//私有的構造函數 //獲取方法 public static SingleTon getinstance(){ return instence; }; }

//飢漢模式:延遲加載，在第一次用的時候才建立出對象，存在線程安全問題。 public class SingleTon { private  static SingleTon instence=null; private SingleTon(){};//私有的構造函數 //獲取方法 public static synchronized SingleTon getinstance(){ if(instence==null){ //第一次使用的時候建立對象 instence=new SingleTon(); } return instence; }; }

 

19.編程冒泡排序：用java實現冒泡排序？快速排序的方法。

冒泡排序：

int temp = 0; int[] sortNum = {12,33,28,86,15,62,9,38}; for (int i = 0; i < sortNum.length-1; i++) {  //第一個for循環控制排序要走多少趟，最多作n-1趟排序       for (int j = 0; j < sortNum.length-1-i; j++) { //第2個for循環控制每趟比較多少次                   if(sortNum[j+1]<sortNum[j]){  //大的 日後面排                       temp = sortNum[j];                       sortNum[j] = sortNum[j+1];                       sortNum[j+1] = temp;                   }       } } System.out.println(Arrays.toString(sortNum));

 

1.對基本數據類型數組的排序

1>數字排序：

int[] intArray = new int[]{1,56,-5,33}; Arrays.sort(intArray); System.out.println(Arrays.toString(intArray));

 

2>字符串排序(先大寫後小寫)：

String[] strArray = new String[]{"Z", "a", "D"}; Arrays.sort(strArray); System.out.println(Arrays.toString(strArray));

 

20.HashMap和Hashtable的區別？

HashMap：實現了Map接口，容許空(null)鍵值(key),因爲非線程安全，在只有一個線程訪問的狀況下，效率高於Hashtable。

Hashtable：不能將null做爲key或者value。方法是同步的，線程安全。

 

21.List、Set和Map的區別？

List:是存儲單列數據的集合，存儲有順序，容許重複。繼承Collection接口。

Set: 是存儲單列數據的集合。繼承Collection接口。不容許重複。

Map:存儲鍵和值這樣的雙列數據的集合，存儲數據無順序，鍵(key)不能重複，值(value)。能夠重複。

22.何時用assert？

在調試程序時使用，對一個boolean表達式進行檢查。爲true，則程序正確，若是爲false，系統則給出警告或者退出。

 

23.使用java.lang.Math,生成100個0到99之間的隨機整數，找出最大和最小，並統計大於50的整數個數？

import java.util.Random; public class RandomTest { public static void main(String args[]) { int max = 0; int min = 0; String sum=""; int num=0; for (int i = 0; i <= 100; i++) { Random rand = new Random(); int r = rand.nextInt(99); if (r >= max) { max = r; } else if (r < min) { min = r; } String s= ""+r; if (r > 50) { sum=sum+s+","; ++num; } } System.out.println("最大數max=" + max + "\n" + "最小數min=" + min); System.out.println("大於50的個數："+num); } }

備註：Random rand = new Random();   int r = rand.nextInt(99); 表示產生的隨機數爲0-99的整數,不包括99。

24.java建立對象的方式有哪些？

1.使用new關鍵字

2.使用反射機制建立對象：

(1)使用Class類的newInstance方法

(2)java.lang.reflect.Constructor類裏也有一個newInstance方法能夠建立對象。

3.使用clone方法：先實現Cloneable接口並實現其定義的clone方法

4.使用反序列化

25.java垃圾回收機制

GC是垃圾回收機制，是用來釋放內存中的資源的。

垃圾回收能夠有效的防止內存泄露，有效的使用空閒的內存。

26.error和exception有什麼區別?

Error（錯誤）表示系統級的錯誤和程序沒必要處理的異常，是java運行環境中的內部錯誤或者硬件問題。好比：內存資源不足等。對於這種錯誤，程序基本無能爲力，除了退出運行外別無選擇，它是由Java虛擬機拋出的。

Exception（違例）表示須要捕捉或者須要程序進行處理的異搜索常，它處理的是由於程序設計的瑕疵而引發的問題或者在外的輸入等引發的通常性問題，是程序必須處理的。

Exception又分爲運行時異常，受檢查異常。

       運行時異常，表示沒法讓程序恢復的異常，致使的緣由一般是由於執行了錯誤的操做，建議終止程序，所以，編譯器不檢查這些異常。

       受檢查異常，是表示程序能夠處理的異常，也即表示程序能夠修復（由程序本身接受異常而且作出處理）， 因此稱之爲受檢查異常。

 

27.Int如何去重複？

1.For循環

2.Set集合

28.JDBC使用步驟過程？

1、加載JDBC驅動程序：  

2、提供JDBC鏈接的URL

3、建立數據庫的鏈接    

4、建立一個Statement    

5、執行SQL語句   

6、處理結果

7、關閉JDBC對象    

29.運行時異常與通常異常有何異同？

Java提供了兩類主要的異常:運行時異常runtime exception和通常異常checked exception。對於後者這種通常異常，JAVA要求程序員對其進行catch處理。因此，面對這種異常無論咱們是否願意，只能本身去寫一大堆catch塊去處理可能的異常。

運行時異常咱們能夠不處理。這樣的異常由虛擬機接管。出現運行時異常後，系統會把異常一直往上層拋，一直遇處處理代碼。若是不對運行時異常進行處理，那麼出現運行時異常以後，要麼是線程停止，要麼是主程序終止。

30.抽象類和接口區別?

抽象類：用abstract修飾，抽象類不能建立實例對象。抽象方法必須在子類中實現，不能有抽象構造方法或者抽象靜態方法。

接口：抽象類的一種特例，接口中的方法必須是抽象的。

二者的區別：

1. 抽象類能夠有構造方法，接口沒有構造方法
2. 抽象類能夠有普通成員變量，接口沒有普通成員變量。
3. 抽象類能夠有非抽象的普通方法，接口中的方法必須是抽象的。
4. 抽象類中的抽象方法訪問類型能夠是public，protected，接口中抽閒方法必須是public類型的。
5. 抽象類能夠包含靜態方法，接口中不能包含靜態方法。
6. 一個類能夠實現多個接口，可是隻能繼承一個抽象類。

7.接口中基本數據類型的數據成員，都默認爲static和final，抽象類則不是。

31.如何獲取map集合中的數據？

// 方法一： for each  +  map.keySet();    Set<Integer> set = map.keySet();   for (Integer key : set) {       System.out.println("key:" + key + ", value:" + map.get(key));   }

// 方法二：while循環(Iterator  +  map.keySet();)   Set<Integer> set = map.keySet();   Iterator<Integer> it = set.iterator();   while(it.hasNext()){       Integer key = it.next();       System.out.println("key:" + key + ", value:" + map.get(key));   }

// 方法三：while循環(Iterator +Map.Entry<Key, Value>)   Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();   while (it.hasNext()) {       Map.Entry<Integer, String> entry = it.next();       System.out.println("key:"+entry.getKey() + ", value:"+entry.getValue());   }

// 方法四：for循環(Iterator + Map.Entry<Key, Value>)   for(Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator(); it.hasNext();){       Map.Entry<Integer, String> entry = it.next();       System.out.println("key:" + entry.getKey() + ", value:" +entry.getValue());   }

// 方法五：for each  +  Map.Entry<Key, Value>   for(Map.Entry<Integer, String> entry : map.entrySet()){       System.out.println("key:" + entry.getKey() + ", value:" +entry.getValue());   }

32.hashCode與equals的區別與聯繫？

1、equals方法的做用

   1、默認狀況（沒有覆蓋equals方法）下equals方法都是調用Object類的equals方法，而Object的equals方法主要用於判斷對象的內存地址引用是否是同一個地址（是否是同一個對象）。

2 、要是類中覆蓋了equals方法，那麼就要根據具體的代碼來肯定equals方法的做用了，覆蓋後通常都是經過對象的內容是否相等來判斷對象是否相等。

2、Hashcode（）方法：

1、咱們並無覆蓋equals方法只覆蓋了hashCode方法，兩個對象雖然hashCode同樣，但在將stu1和stu2放入set集合時因爲equals方法比較的兩個對象是false，因此就沒有在比較兩個對象的hashcode值。

2、覆蓋一下equals方法和hashCode方法，stu1和stu2經過equals方法比較相等，並且返回的hashCode值同樣，因此放入set集合中時只放入了一個對象。

3、咱們讓兩個對象equals方法比較相等，但hashCode值不相等試試，雖然stu1和stu2經過equals方法比較相等，但兩個對象的hashcode的值並不相等，因此在將stu1和stu2放入set集合中時認爲是兩個不一樣的對象。

總結：

1、equals方法用於比較對象的內容是否相等（覆蓋之後）

2、hashcode方法只有在集合中用到

3、當覆蓋了equals方法時，比較對象是否相等將經過覆蓋後的equals方法進行比較（判斷對象的內容是否相等）。

4、將對象放入到集合中時，首先判斷要放入對象的hashcode值與集合中的任意一個元素的hashcode值是否相等，若是不相等直接將該對象放入集合中。若是hashcode值相等，而後再經過equals方法判斷要放入對象與集合中的任意一個對象是否相等，若是equals判斷不相等，直接將該元素放入到集合中，不然不放入。

33.Java中什麼是競態條件?

當兩個線程競爭同一資源時，若是對資源的訪問順序敏感，就稱存在競態條件。致使競態條件發生的代碼區稱做臨界區。在臨界區中使用適當的同步就能夠避免競態條件。 界區實現方法有兩種，一種是用synchronized，一種是用Lock顯式鎖實現。

 

 

 

34.線程死鎖及解決辦法

1)、讓全部的線程按照一樣的順序得到一組鎖。這種方法消除了 X 和 Y 的擁有者分別等待對方的資源的問題。
　　2)、將多個鎖組成一組並放到同一個鎖下。前面Java線程死鎖的例子中，能夠建立一個銀器對象的鎖。因而在得到刀或叉以前都必須得到這個銀器的鎖。
　　3)、將那些不會阻塞的可得到資源用變量標誌出來。當某個線程得到銀器對象的鎖時，就能夠經過檢查變量來判斷是否整個銀器集合中的對象鎖均可得到。若是是，它就能夠得到相關的鎖，不然，就要釋放掉銀器這個鎖並稍後再嘗試。

35.ArrayList和LinkList的區別

1.ArrayList是實現了基於動態數組的數據結構，LinkedList基於鏈表的數據結構。

    2.對於隨機訪問get和set，ArrayList以爲優於LinkedList，由於LinkedList要移動指針。

3.對於新增和刪除操做add和remove，LinedList比較佔優點，由於ArrayList要移動數據，而查詢和修改ArrayList佔優點。

36.Socket和HTTP區別？

socket則是對TCP/IP協議的封裝和應用(程序員層面上)， Socket自己並非協議，而是一個調用接口(API)。也能夠說，TPC/IP協議是傳輸層協議，主要解決數據如何在網絡中傳輸，而HTTP是應用層協議，主要解決如何包裝數據。

37.BS與CS的聯繫與區別？

C/S 與 B/S 區別：

（bs 面向龐大、不一樣羣體、不一樣平臺的客戶;cs 面向比較單一的客戶）

1．硬件環境不一樣:

  C/S 通常創建在專用的網絡上, 小範圍裏的網絡環境, 局域網之間再經過專門服務器提供鏈接和數據交換服務.

  B/S 創建在廣域網之上的, 沒必要是專門的網絡硬件環境,例與電話上網, 租用設備. 信息本身管理. 有比C/S更強的適應範圍, 通常只要有操做系統和瀏覽器就行

2．對安全要求不一樣

  C/S 通常面向相對固定的用戶羣, 對信息安全的控制能力很強. 通常高度機密的信息系統採用C/S 結構適宜. 能夠經過B/S發佈部分可公開信息.

  B/S 創建在廣域網之上, 對安全的控制能力相對弱, 可能面向不可知的用戶。

3．對程序架構不一樣

  C/S 程序能夠更加註重流程, 能夠對權限多層次校驗, 對系統運行速度能夠較少考慮.

  B/S 對安全以及訪問速度的多重的考慮, 創建在須要更加優化的基礎之上. 比C/S有更高的要求 B/S結構的程序架構是發展的趨勢, 從MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持網絡的構件搭建的系統. SUN 和IBM推的JavaBean 構件技術等,使 B/S更加成熟.

4．軟件重用不一樣

  C/S 程序能夠不可避免的總體性考慮, 構件的重用性不如在B/S要求下的構件的重用性好.

  B/S 對的多重結構,要求構件相對獨立的功能. 可以相對較好的重用.就入買來的餐桌能夠再利用,而不是作在牆上的石頭桌子

5．系統維護不一樣

  C/S 程序因爲總體性, 必須總體考察, 處理出現的問題以及系統升級. 升級難. 多是再作一個全新的系統

  B/S 構件組成,方面構件個別的更換,實現系統的無縫升級. 系統維護開銷減到最小.用戶從網上本身下載安裝就能夠實現升級.

6．處理問題不一樣

  C/S 程序能夠處理用戶面固定, 而且在相同區域, 安全要求高需求, 與操做系統相關. 應該都是相同的系統

  B/S 創建在廣域網上, 面向不一樣的用戶羣, 分散地域, 這是C/S沒法做到的. 與操做系統平臺關係最小.

7．用戶接口不一樣

  C/S 可能是創建的Window平臺上,表現方法有限,對程序員廣泛要求較高

  B/S 創建在瀏覽器上, 有更加豐富和生動的表現方式與用戶交流. 而且大部分難度減低,減低開發成本.

8．信息流不一樣

  C/S 程序通常是典型的中央集權的機械式處理, 交互性相對低

  B/S 信息流向可變化, B-B B-C B-G等信息、流向的變化, 更像交易中心。

38.多線程中thread的start（）和run()的區別？

　1） start：

　用start方法來啓動線程，真正實現了多線程運行，這時無需等待run方法體代碼執行完畢而直接繼續執行下面的代碼。經過調用Thread類的start()方法來啓動一個線程，這時此線程處於就緒（可運行）狀態，並無運行，一旦獲得cpu時間片，就開始執行run()方法，這裏方法 run()稱爲線程體，它包含了要執行的這個線程的內容，Run方法運行結束，此線程隨即終止。

　2） run：

　　run()方法只是類的一個普通方法而已，若是直接調用Run方法，程序中依然只有主線程這一個線程，其程序執行路徑仍是隻有一條，仍是要順序執行，仍是要等待run方法體執行完畢後纔可繼續執行下面的代碼，這樣就沒有達到寫線程的目的。總結：調用start方法方可啓動線程，而run方法只是thread的一個普通方法調用，仍是在主線程裏執行。這兩個方法應該都比較熟悉，把須要並行處理的代碼放在run()方法中，start()方法啓動線程將自動調用 run()方法，這是由jvm的內存機制規定的。而且run()方法必須是public訪問權限，返回值類型爲void。

 

39.final關鍵字的用法

1、final修飾類：

被final修飾的類，是不能夠被繼承的，這樣作的目的能夠保證該類不被修改，Java的一些核心的API都是final類，例如String、Integer、Math等。

2、final修飾方法：

子類不能夠重寫父類中被final修飾的方法。

3、final修飾實例變量(類的屬性，定義在類內，可是在類內的方法以外)

final修飾實例變量時必須初始化，且不可再修改。//

4、final修飾局部變量(方法體內的變量)

final修飾局部變量時只能初始化(賦值)一次，但也能夠不初始化。

5、final修飾方法參數

final修飾方法參數時，是在調用方法傳遞參數時候初始化的。