Java基礎學習

阿新 • • 發佈：2020-11-21

資料型別
面向物件
多執行緒

資料型別

1、基本資料型別（4類8種）

整數型：byte、short、int、long
浮點型：float、double
字元型：char
布林型：boolean(ture or false)

其有關位元組和預設值如下圖所示：

2、引用資料型別

類
介面
陣列

3、函式

定義：函式就是定義在類中的具有特定功能的一段獨立小程式。
特點：

定義函式可以將功能程式碼進行封裝
便於對該功能進行復用
函式只有被呼叫才會被執行
函式的出現提高了程式碼的複用性
對於函式沒有具體返回值的情況，返回值型別用關鍵字void表示，
那麼該函式中的return語句如果在最後一行可以省略不寫。

函式的應用兩個明確：
明確要定義的功能最後的結果是什麼？
明確在定義該功能的過程中，是否需要未知內容參與運算？

面向物件

面向物件的程式語言主要有：C++、Java、C#等

1、面向物件思想

(1)、概述：面向物件是相對於面向過程而言的，面向過程強調的是功能，面向物件強調的是將功能封裝進物件，強調具備功能的物件；
(2)、思想特點：
A:是符合人們思考習慣的一種思想；
B:將複雜的事情簡單化了；
C:將程式設計師從執行者變成了指揮者；

例如：比如我要達到某種結果，我就尋找能幫我達到該結果的功能的物件，如我要洗衣服我就買洗衣機，至於怎麼洗我不管。

(3)、特徵：

封裝：隱藏物件的屬性和實現細節，僅對外提供公共訪問方式。
繼承：多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行為，只要繼承那個類即可。
多型：一個物件在程式不同執行時刻代表的多種狀態，父類或者介面的引用指向子類物件。

2、類和物件

類：對現實世界中某類事物的描述,是抽象的，概念上的定義。
物件：事物具體存在的個體。

3、成員變數和區域性變數的區別

(1)、作用域
成員變數：針對整個類有效。
區域性變數：只在某個範圍內有效。(一般指的就是方法,語句體內)

(2)、儲存位置
成員變數：隨著物件的建立而存在，隨著物件的消失而消失，儲存在堆內中。
區域性變數：在方法被呼叫，或者語句被執行的時候存在，儲存在棧記憶體中。當方法呼叫完，或者語句結束後，就自動釋放。

(3)、初始值
成員變數：有預設初始值。
區域性變數：沒有預設初始值，使用前必須賦值。

4、匿名物件

(1)、匿名物件就是沒有名字的物件。是物件的一種簡寫形式。

(2)、應用場景
A:只調用一次類中的方法。
B:可以作為實際引數在方法傳遞中使用

5、封裝

指隱藏物件的屬性和實現細節，僅對外提供公共訪問方式；比如電腦機箱、筆記本等
好處：將變化隔離；方便使用；提高複用性；提高安全性

6、關鍵字private

(1)、私有的意思，許可權修飾符

(2)、用來修飾成員變數和成員函式

(3)、用private修飾的成員只在本類中有效

(4)、私有是封裝的一種體現

7、構造方法

(1)特點：

方法名與類名相同
沒有返回型別
沒有返回值

(2)作用：建構函式是用於建立物件，並對其進行初始化賦值，物件一建立就自動呼叫相對應的建構函式，

(3)構造方法的注意事項:
A:如果一個自定義類沒有構造方法，系統會預設給出一個無參構造方法。
B:如果一個自定義類提供了構造方法，那麼，系統將不再給出無參構造方法。

這個時候，你可以不使用無參構造方法。如果你想使用，那麼，就必須手動給出無參構造方法。
建議：一般情況下，我們的自定義類都要手動給出無參構造方法。

(4)構造方法和成員方法的區別

格式區別
構造方法和類名相同，並且沒有返回型別，也沒有返回值。
普通成員方法可以任意起名，必須有返回型別，可以沒有返回值。
作用區別
構造方法用於建立物件，並進行初始化值。
普通成員方法是用於完成特定功能的。
呼叫區別
構造方法是在建立物件時被呼叫的，一個物件建立，只調用一次相應建構函式
普通成員方法是由建立好的物件呼叫，可以呼叫多次

8、構造程式碼塊

(1)、作用：給物件進行初始化，物件一建立就執行，而且優先於建構函式執行
(2)、構造程式碼塊和建構函式的區別：

構造程式碼塊是給所有不同物件的共性進行統一初始化
建構函式是給對應的物件進行初始化

9、this關鍵字

(1)、this關鍵字代表本類物件的一個引用，誰呼叫this所在的方法，this就代表誰
(2)、this的使用場景

用於區分同名成員變數和區域性變數；
在定義函式時，該函式內部要用到呼叫該函式的物件時，因為此時物件還沒建立，故this代表此物件
建構函式間呼叫
這個時候，this(引數)必須作為第一條語句存在。

10、Person p = new Person();在記憶體中做了哪些事情

(1)將Person.class檔案載入進記憶體中。
(2)如果p定義在主方法中，那麼，就會在棧空間開闢一個變數空間p。
(3)在堆記憶體給物件分配空間。
(4)對物件中的成員進行預設初始化。
(5)對物件中的成員進行顯示初始化。
(6)呼叫構造程式碼塊對物件進行初始化。(如果沒有就不執行)
(7)呼叫構造方法對物件進行初始化。物件初始化完畢。
(8)將物件的記憶體地址賦值給p變數，讓p變數指向該物件。

11、static關鍵字

(1)、靜態的意思，用來修飾成員變數和成員函式

(2)、靜態的特點:

隨著類的載入而載入
優先於物件存在
對所有物件共享
可以被類名直接呼叫

(3)、靜態的注意事項

靜態方法只能訪問靜態成員
為什麼：因為靜態的內容是隨著類的載入而載入，它是先進記憶體的。
靜態方法中不能使用this,super關鍵字
主方法是靜態的

public static void main(String[] args)

public:公共的意思，是最大許可權修飾符。
static:由於jvm呼叫main方法的時候，沒有建立物件。
只能通過類名呼叫。所以，main必須用static修飾。
void:由於main方法是被jvm呼叫，不需要返回值。用void修飾。
main:main是主要的意思，所以jvm採用了這個名字。是程式的入口。
String[]:字串陣列
args:陣列名
在執行的時候，通過java命令給args陣列賦值。
格式：java MainTest hello world itcast

(4)、靜態變數和成員變數的區別

呼叫方式
靜態變數也稱為類變數，可以直接通過類名呼叫。也可以通過物件名呼叫。這個變數屬於類。成員變數也稱為例項變數，只能通過物件名呼叫。這個變數屬於物件。
儲存位置
靜態變數儲存在方法區長中的靜態區。
成員變數儲存在堆記憶體。
生命週期
靜態變數隨著類的載入而存在，隨著類的消失而消失。生命週期長。
成員變數隨著物件的建立而存在，隨著物件的消失而消失。
與物件的相關性
靜態變數是所有物件共享的資料。
成員變數是每個物件所特有的資料。

(5)、靜態的優點和弊端

優點：對物件的共享資料進行單獨空間的儲存，節省記憶體，沒有必要每個物件都儲存一份，可直接被類名呼叫。

弊端：生命週期過長，隨著類的消失而消失訪問出現許可權，即靜態雖好但只能訪問靜態

(6)、什麼使用使用靜態呢？

當所有物件共享某個資料的時候，就把這個成員變數定義為靜態修飾的。
當某個方法沒有訪問該類中的非靜態成員，就可以把這個方法定義為靜態修飾。

靜態的生命週期比較長，所以一般不推薦使用。

(7)、靜態程式碼塊

它只執行一次，它比main還先執行。
執行順序

靜態程式碼塊--構造程式碼塊--構造方法

12、製作API

API(全拼):Application Program Interface 應用程式程式設計介面。

(1)、類中的內容需要用文件註釋。
(2)、使用JDK\bin目錄下的javadoc工具。

格式:javadoc -d 目錄 -author -version ArrayTool.java

13、單例設計模式

(1)、設計模式

解決某類問題行之有效的方法，是一種思想，是規律的總結 
用來保證某個類在記憶體中只有一個物件 
保證唯一性的思想及步驟:
為了避免其他程式建立該類物件，先禁止其他程式建立該類物件，即將建構函式私有化  
為了其他程式訪問到該類物件，須在本類中建立一個該類私有物件 
為了方便其他程式訪問到該類物件，可對外提供一個公共訪問方式

比如API中的Runtime類就是單例設計模式。

(2)、單例設計模式的兩種方式

A:餓漢式 當類載入的時候，就建立物件。	
class Student
{
   private Student(){}
			
   private static final Student s = new Student();
			
   public static Student getInstance()
 {
    return s;
 }
}

B:懶漢式 當使用的使用，才去建立物件。
class Student
{
	private Student(){}
	
   private static final Student s = null;
   	
   public static Student getInstance()
  {
		if(s==null) 
		{
			//執行緒1就進來了，執行緒2就進來了。
			s = new Student();
		}
			return s;
  }
}

餓漢式和懶漢式的區別：

餓漢式是類一載入進記憶體就建立好了物件；
懶漢式則是類才載入進記憶體的時候，物件還沒有存在，只有呼叫了getInstance()方法時，物件才開始建立。
懶漢式是延遲載入，如果多個執行緒同時操作懶漢式時就有可能出現執行緒安全問題，解決執行緒安全問題
可以加同步來解決。但是加了同步之後，每一次都要比較鎖，效率就變慢了，所以可以加雙重判斷來提高程式效率。
注：開發常用餓漢式，因為餓漢式簡單安全。懶漢式多執行緒的時候容易發生問題

14、繼承

(1)、把很多類的相同特徵和行為進行抽取，用一個類來描述。讓多個類和這個類產生一個關係。這樣的話，多個類就可以省略很多程式碼。這個關係就是繼承。java中用extends關鍵字表示。
(2)、繼承的體系結構
A:多個具體的物件，不斷的向上抽取共享的內容，最終形成了一個體系。這個體系叫做繼承體系。
B:繼承體系的學習和使用原則學習頂層的內容。因為他是整個體系的共性內容。建立子類使用。也就是使用底層的具體物件。
(3)、繼承的特點:
A:java中只能單繼承，沒有多繼承。
B:java可以有多重(層)繼承。
(4)、繼承的好處：
繼承的出現提高了程式碼的複用性。
繼承的出現讓類與類之間產生了關係，提供了多型的前提。
(5)、子父類中的成員關係
A:成員變數
在子類方法中使用一個變數時：
首先，在方法的區域性變數中找這個變數，有則使用。
否則，在本類中找成員變數，有則使用。
否則，在父類中找成員變數，有則使用。
否則，報錯。
B:成員方法
用子類物件使用一個方法時。
首先，在子類中找這個方法，有則使用。
否則，在父類中找這個方法，有則使用。
否則，報錯。

重寫和過載的區別？
過載：在同一類中。方法名相同，引數列表不同。過載可以改變返回型別。
重寫：在不同類中(子父類中)。
方法宣告相同(返回型別，方法名，引數列表均相同)。
重寫需要注意：子類方法的訪問許可權要大於等於父類方法的訪問許可權。
靜態只能重寫靜態。但是這種情況一般不會出現。

構造方法
子類的例項化過程子類建立物件時，會先去建立父類的物件。預設是去呼叫父類的無參構造方法。
子類構造方法中，第一行預設是super() 為什麼子類中第一行會預設有super() 因為他繼承父類的成員使用，使用前這些成員必須初始化，
而他們是父類的成員，所以，必須通過父類進行初始化。所以，會先建立一個父類的物件。當父類沒有無參構造方法時
必須使用this或者super呼叫其他的構造方法。

this和super的區別 this:代表本類物件的引用。 super:代表父類的儲存空間。

15、final關鍵字

最終的意思，可以用於修飾類，方法，變數。
final修飾的類不能被繼承。
final修飾的方法不能被重寫。
final修飾的變數是一個常量。
只能被賦值一次。內部類只能訪問被final修飾的區域性變數。

16、抽象類

(1)、多個類有相同的方法宣告，但是方法體現不一樣。這個時候，我們考慮把方法宣告進行抽取。
讓子類繼承後，自己去實現方法體。沒有方法體的方法，我們需要用抽象標誌下。
抽象的關鍵字是：abstract。
(2)、抽象類：
該方法稱為抽象方法，包含抽象方法的類就是抽象類。
(3)、抽象類的特點：
A:抽象類和抽象方法都要用abstract進行修飾
B:抽象類不能被例項化
C:抽象類中不一定有抽象方法，但是，有抽象方法的類一定是抽象類。
(4)、抽象類中資料的特點
A:成員變數
抽象類中可以有變數，也可以有常量。
B:成員方法
抽象類中可以有抽象方法，也可以有非抽象方法。
C:構造方法
抽象類是一個類，所以，它有構造方法。
雖然本身不能例項化。但是可以給子類例項化使用。
(5)、抽象類中的問題

A、抽象類中是否有構造方法？能不能被例項化？如果不能，為什麼有構造方法？
抽象類有構造方法。抽象類不能被例項化。
抽象類中的構造方法供子類例項化呼叫。
B、抽象關鍵字abstract不可以和哪些關鍵字共存？ private:
私有內容子類繼承不到，所以，不能重寫。但是abstract修飾的方法，要求被重寫。兩者衝突。
final
final修飾的方法不能被重寫。
而abstract修飾的方法，要求被重寫。兩者衝突。
static
假如一個抽象方法能通過static修飾，那麼這個方法，就可以直接通過類名呼叫。
而抽象方法是沒有方法體的，這樣的呼叫無意義。所以，不能用static修飾。
C、抽象類中可不可以沒有抽象方法？如果可以，這樣的類有什麼用嗎？
抽象類可以沒有抽象方法。
抽象類中沒有抽象方法的作用，只是為了不讓別的類建立該抽象類物件。這個在awt中有體現。

17、介面interface

(1)、當一個類中的方法都是抽象的時候，java提供了另一種表示方式，叫介面。 
用interface關鍵字表示。類與介面關係用implements表示。  
(2)、介面的成員特點  
A、成員變數 是常量，預設修飾 public static final	 
B、成員方法 都是抽象的，預設修飾 public abstract	 
(3)、關係 
A、類與類的關係 是繼承關係。類與類只能單繼承，可以多重繼承。 
B、類和介面的關係 是實現關係。類可以多實現介面。 類在繼承一個類的同時，可以實現多個介面。 
C、介面和介面的關係 是繼承關係。介面可以多繼承介面。 
(4)、介面的特點 
A、是對外暴露的規則 
B、是功能的擴充套件 
C、介面的出現降低耦合性。 耦合(類與類之間的關係) 內聚(類完成功能的能力) 程式設計規範：低耦合，高內聚。 
D:介面可以多實現。如：CPU和主機板、筆記本的USB插口、插座 
(5)、介面和抽象類的區別 
A、抽象類只能被單繼承 介面可以多實現,介面的出現避免了多繼承的侷限性。 
B、抽象類中的資料特點： 
成員變數：可以是變數，也可以是常量 
成員方法：可以是抽象方法，也可以是非抽象方法 
構造方法：有構造方法 
介面中的資料特點： 
成員變數：是常量。預設修飾 public static final 
成員方法：都是抽象方法。都有預設修飾 public abstract 
構造方法：沒有構造方法 
C：抽象類中定義的是繼承體系中的共性功能。 介面中定義的是繼承體系中的擴充套件功能。 
D：抽象類被繼承是"is a"關係:xx是yy的一種 介面被實現是"like a"關係:xx像yy的一種

18、多型：

(1)、同一個物件，在程式不同時刻的多種執行狀態。舉例：動物，狗是狗，狗是動物。水(氣態，液態，固態)
(2)、多型前提
A:存在著繼承或者實現關係
B:有方法的重寫
C:父類(介面)引用指向子類(實現)物件
(3)、多型的好處和弊端：
好處：多型的存在提高了程式的擴充套件性和後期可維護性
弊端：雖然可以預先使用，但是隻能訪問父類中已有的功能，執行的是後期子類的功能內容。
不能預先使用子類中定義的特有功能。
(4)、多型中物件呼叫成員的特點
Fu f = new Zi();
A:成員變數編譯看左邊，執行看左邊
B:成員方法編譯看左邊，執行看右邊
C:靜態方法編譯看左邊，執行看左邊
(5)、多型的思想指揮同一批物件做事情。舉例：帶兵打仗，下課等。

19、內部類

(1)、把一個類定義在某個類中的，這個類就被稱為內部類，內建類，巢狀類。
(2)、訪問特點：
A:內部類可以直接訪問外部類中的成員，因為內部類持有外部類的引用，格式為：外部類名.this
B:外部類要想訪問內部類的成員，必須建立物件訪問。
(3)、內部類的訪問格式：
A:當內部類定義在外部類的成員位置，而且非私有，則可以在其他外部類中直接建立內部類物件
格式：外部類名.內部類名變數名 = new
外部類物件.內部類物件如：Outer.Inner in = new Outer().new Inner()
B:當內部類在外部類成員位置，且被static修飾時外部其他類可直接訪問靜態內部類的非靜態成員
格式：new 外部類名.內部類名().內部類成員如：new Outer.Inner().function(); 外部其他類可直接訪問靜態內部類的靜態成員
格式：new 外部類名.內部類名.內部類成員如：new Outer.Inner.function();
(4)、什麼使用時候內部類呢？
假如有A類和B類，A類想直接訪問B類的成員，B類訪問A類成員的時候，需要建立A類物件進行訪問，這個時候，就可以把A類定義為B類的內部類。
(5)、內部類的位置
A:成員位置可以被private修飾(Body，Heart)，可以被static修飾。(它訪問的外部類的成員必須是靜態的)
B:區域性位置可以直接訪問外部類中的成員，因為還持有外部類的持用
也可以直接訪問區域性成員，但是區域性成員要用final修飾。
注意：區域性內部類不能用private和static修飾
(6)、通過class檔案我們就可以區分是否帶有內部類，以及內部類的位置
Outer$Inner:成員內部類
Outer$1Inner:區域性內部類

20、匿名內部類(區域性內部類的簡寫)

(1)前提：繼承一個類或者實現一個介面(注意不要弄混匿名內部類的前提和多型的前提)
(2)格式：
		new 父類名或者介面名()
		{
			重寫父類方法或者實現介面中的方法。
			也可以自定義其他方法。
		};
(3)什麼時候定義匿名內部類？
匿名內部類只是為了簡化書寫，匿名內部類有侷限，通常定義匿名內部類時，該類方法不超過3個
(4)匿名內部類的好處和弊端：
好處：簡化程式碼書寫
弊端：
不能直接呼叫自己的特有方法
不能執行強轉換動作
如果該類裡面方法較多，不允許使用匿名內部類

21、異常

(1)、程式執行過程中的不正常現象就叫異常。
(2)、導致程式執行不正常的現象有很多，所以，就有很多的異常物件。
而這些異常物件存在著共性的內容，所以，可以不斷的進行抽取。最終形成了異常的體系結構。
異常體系的根類是:Throwable
Throwable：
		|--Error:重大的問題，我們處理不了。也不需要編寫程式碼處理。比如說記憶體溢位。
		|--Exception:一般性的錯誤，是需要我們編寫程式碼進行處理的。
		|--RuntimeException:執行時異常，這個我們也不需要處理。
		其實就是為了讓他在執行時出問題，然後我們回來修改程式碼。
(3)、異常的分類		
異常有兩種：
編譯時被檢測異常：
該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。
該異常被標識，代表這可以被處理。
執行時異常(編譯時不檢測)
在編譯時，不需要處理，編譯器不檢查。
該異常的發生，建議不處理，讓程式停止。需要對程式碼進行修正。
(4)、異常體系的特點：
異常體系中的所有類及其子類物件都具備可拋性。也就是說可以被throw和throws關鍵字所操作。
(5)、main方法是如何處理異常的。
A:在main裡面編寫程式碼進行處理
B:交給jvm自己進行處理。採用的是jvm的預設處理方式。
其實就是相當於呼叫了異常物件的printStackTrace()方法。

(6)、Throwable類的學習
getMessage():獲取異常資訊，返回字串。
toString():獲取異常類名和異常資訊，返回字串。
printStackTrace():獲取異常類名和異常資訊，以及異常出現在程式中的位置。返回值void。
(7)、異常的處理·
A:try...catch...finally
	基本格式：
		try
		{
			可能出現異常的程式碼
		}
		catch(異常物件)
		{	
			異常處理程式碼
		}
		finally
		{
			釋放資源
		}
		
變形格式：
try...catch
try...catch...catch...
try...catch...catch...finally
多個異常同時被捕獲的時候，記住一個原則：先逮小的，再逮大的。
finally:永遠被執行，除非退出jvm。System.exit(0);
面試題2個。
final,finally,finalize區別。
final是最終的意思。它可以用於修飾類，成員變數，成員方法。
它修飾的類不能被繼承，它修飾的變數時常量，它修飾的方法不能被重寫。
finally:是異常處理裡面的關鍵字。它其中的程式碼永遠被執行。
特殊情況：在執行它之前jvm退出。System.exit(0);
finalize:是Object類中的一個方法。
它是於垃圾回收器呼叫的方式。
假如catch中有return語句， finally裡中的程式碼會執行嗎？是在return前，還是在return後呢？
會，在return前執行finally裡面的程式碼。
(8)、Exception和RuntimeException的區別
A:Exception:一般性的錯誤，是需要我們編寫程式碼進行處理的。	
B:RuntimeException:執行時異常，這個我們也不需要處理。
其實就是為了讓他在執行時出問題，然後我們回來修改程式碼。
在用throws丟擲一個的時候，如果這個異常是屬於RuntimeException的體系的時候，
我們在呼叫的地方可以不用處理。(RuntimeException和RuntimeException的子類)
在用throws丟擲一個的時候，如果這個異常是屬於Exception的體系的時候，
我們在呼叫的地方必須進行處理或者繼續丟擲。
(9)、自定義異常
定義類繼承Exception或者RuntimeException
1,為了讓該自定義類具備可拋性。
2，讓該類具備操作異常的共性方法。
class MyExcepiton extends Exception
{
	MyExcepiton(){}
	MyExcepiton(String message)
	{
		super(message);
	}
}
class MyException extends RuntimeException
{
	MyExcepiton(){}
	MyExcepiton(String message)
	{
		super(message);
	}
}

(10)、throws和throw的區別
A：有throws的時候可以沒有throw。
有throw的時候，如果throw拋的異常是Exception體系，那麼必須有throws在方法上宣告。
B：throws用於方法的宣告上，其後跟的是異常類名，後面可以跟多個異常類，之間用逗號隔開
throw用於方法體中，其後跟的是一個異常物件名

22、反射

反射是Java中一個非常重要同時也是一個高階特性，基本上Spring等一系列框架都是基於反射的思想寫成的。我們來認識一下反射。
Java反射機制是在程式的執行過程中，對於任何一個類，都能夠知道它的所有屬性和方法；對於任意一個物件，都能夠知道呼叫它的任意屬性和方法，這種動態獲取資訊以及動態呼叫物件方法的功能稱為 java語言的反射機制。（來源於百度百科）

Java反射機制主要提供了以下這幾個功能：

在執行時判斷任意一個物件所屬的類
在執行時構造任意一個類的物件
在執行時判斷任意一個類所有的成員變數和方法
在執行時呼叫任意一個物件的方法

下面是一個簡單的反射類

public class Person {
    public String name;// 姓名
    public int age;// 年齡

    public Person() {
        super();
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String showInfo() {
        return "name=" + name + ", age=" + age;
    }
}

public class Student extends Person implements Study {
    public String className;// 班級
    private String address;// 住址
    public Student;

    {
        super();
    }

    public Student(String name, int age, String className, String address) {
        super(name, age);
        this.className = className;
        this.address = address;
    }

    public Student(String className) {
        this.className = className;
    }

    public String toString() {
        return "姓名："+ name + ",年齡："+ age + ",班級："+ className + ",住址:" + address;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

public class TestRelect {
    public static void main(String[] args) {
        Class student = null;
        try {
            student = Class.forName("com.up.pojo.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
       //獲取物件的所有公有屬性。
        Field[] fields = student.getFields();
        for (Field f : fields) {
            System.out.println(f);
        }
        System.out.printlnn("---------------------")	
        //獲取物件所有屬性，但不包含繼承的。
        Field[]declaredFields = student.getDeclaredFields();
        for (Field df : declaredFields) {
            System.out.println(df);
        }
        //獲取物件的所有公共方法
        Method]]methods = student.getMethods();
        for (Method m : methods) {
            System.out.println(m);
        }
        System.out.println("---------------------");
        //獲取物件所有方法，但不包含繼承的
        Method]]declaredMethods = student.getDeclaredMethods();
        for (Method dm : declaredMethods) {
            System.out.println(dm);
        }
        //獲取物件所有的公共構造方法
        Constructor]]constructors = student.getConstructors();
        for (Constructor c : constructors) {
            System.out.println(c);
        }
        System.out.printlnn("---------------------");
        //獲取物件所有的構造方法
        Constructor]]declaredConstructors = student.getDeclaredConstructors();
        for (Constructor dc : declaredConstructors) {
            System.out.println(dc);
        }
        Class c = Class.forName("com.cxuan.reflection.Student");
        Student stul = (Student) c.newInstance();
        //第一種方法，例項化預設構造方法，呼叫set賦值
        stul.setAddress("河北石家莊");
        System.out.println(stul);
        //第二種方法 取得全部的建構函式 使用建構函式賦值
        Constructor<Student> constructor = c.getConstructor(String.class, int.class,
                String.class, String.class);
        Student student2 = (Student) constructor.newInstance("cxuan", 24,”六 班”，"石家莊");
        System.out.println(student2);
        /**
        *獲取方法並執行方法
        */
        Method show = c.getMethod("showinfo"); //獲取 showinfo ()方法
        Object object = show.invoke(stu2);//呼叫 s howinfo ()方法
    }
}

有一些是比較常用的，有一些是我至今都沒見過怎麼用的，下面進行一個歸類。
與Java反射有關的類主要有

Class 類

在Java中，你每定義一個java class實體都會產生一個Class物件。也就是說，當我們編寫一個類，編譯完成後，在生成的-class檔案中，就會產生一個Class物件，這個Class物件用於表示這個類的型別資訊。Class中沒有公共的構造器，也就是說Class物件不能被例項化。下面來簡單看一下 Class類都包括了哪些方法。
toString()

public String toString(){
return (islnterface() ? "interface " : (isPrimitive() ? "" : "class "))
getName();
}

toStringO方法能夠將物件轉換為字串，toStringO首先會判斷Class型別是否是介面型別，也就是說，普通類和介面都能夠用Class物件來表示，然後再判斷是否是基本資料型別，這裡判斷的都是基本資料型別和包裝類，還有void型別。
所有的型別如下

java.lang.Boolean :代表boolean資料型別的包裝類
java.lang.Character:代表char資料型別的包裝類
java.lang.Byte:代表byte資料型別的包裝類
java.Iang.Short:代表short資料型別的包裝類
java.lang.Integer:代表int資料型別的包裝類
java.lang.Long:代表long資料型別的包裝類
java.lang.Float:代表float資料型別的包裝類
java.lang.Double:代表double資料型別的包裝類
java.lang.Void:代表void資料型別的包裝類

然後是getNameC)方法，這個方法返回類的全限定名稱。

如果是引用型別，比如 String.class.getNameQ -> java. lang. String
如果是基本資料型別，byte.class.getNameO -> byte
如果是陣列型別，new Object[3]).getClassQ.getNameQ -> [L java. lang.Object

toGenericString()

這個方法會返回類的全限定名稱，而且包括類的修飾符和型別引數資訊。

forName()

根據類名獲得一個Class物件的引用，這個方法會使類物件進行初始化。
例如 Class t = Class. forName(" java. lang.Thread")就能夠初始化一個 Thread 執行緒物件
在Java中，一共有三種獲取類例項的方式

Class.forName(java.lang.Thread)
Thread.class
thread.getClass()

newInstance()

建立一個類的例項，代表著這個類的物件。上面forNameQ方法對類進行初始化，newlnstance方法對類進行例項化。

getClassLoader()

獲取類載入器物件。

getTypeParameters()

按照宣告的順序獲取物件的引數型別資訊。

getPackage()

返回類的包

getlnterfaces()

獲得當前類實現的類或是介面，可能是有多個，所以返回的是Class陣列。

Cast

把物件轉換成代表類或是介面的物件

asSubclass(Class clazz)
把傳遞的類的物件轉換成代表其子類的物件

getClasses()

返回一個數組，陣列中包含該類中所有公共類和介面類的物件

getDeclaredClasses()

返回一個數組，陣列中包含該類中所有類和介面類的物件

getSimpleName()

獲得類的名字

getFields()

獲得所有公有的屬性物件

getField(String name)

獲得某個公有的屬性物件

getDeclaredField(String name)

獲得某個屬性物件 getDeclaredFieldsQ 獲得所有屬性物件

getAnnotation(Class annotationClass)

返回該類中與引數型別匹配的公有註解物件

getAnnotations()

返回該類所有的公有註解物件

getDeclaredAnnotation(Class annotationClass)

返回該類中與引數型別匹配的所有註解物件

getDeclaredAnnotations()

返回該類所有的註解物件

getConstructor(Class...<?> parameterTypes)

獲得該類中與引數型別匹配的公有構造方法

getConstructors()

獲得該類的所有公有構造方法

getDeclaredConstructor(Class...<?> parameterTypes)

獲得該類中與引數型別匹配的構造方法

getDeclaredConstructors()

獲得該類所有構造方法

getMethod(String name, Class...<?> parameterTypes)

獲得該類某個公有的方法

getMethods()

獲得該類所有公有的方法

getDeclaredMethod(String name, Class...<?> parameterTypes)

獲得該類某個方法

getDeclaredMethods()

獲得該類所有方法

Field 類

Field類提供類或介面中單獨欄位的資訊，以及對單獨欄位的動態訪問。這裡就不再對具體的方法進行介紹了，讀者有興趣可以參考官方API 這裡只介紹幾個常用的方法

equals(Object obj) 屬性與ob j相等則返回true
get(Object obj) 獲得obj中對應的屬性值
set(Object obj, Object value) 設定obj中對應屬性值

Method 類

invoke(Object obj, Object... args)

傳遞object物件及引數呼叫該物件對應的方法

ClassLoader 類

反射中，還有一個非常重要的類就是ClassLoader類，類裝載器是用來把類(class)裝載進JVM 的。ClassLoader使用的是雙親委託模型來搜尋載入類的，這個模型也就是雙親委派模型。
ClassLoader的類繼承圖如下：

23、列舉

列舉可能是我們使用次數比較少的特性，在Java中，列舉使用enum關鍵字來表示，列舉其實是一項非常有用的特性，你可以把它理解為具有特定性質的類。enum不僅僅Java有，C和C++也有列舉的概念。下面是一個列舉的例子。

public enum Family {

 FATHER,
 MOTHER,
 SON,
 Daughter;

}

列舉特性

enum列舉這個類比較有意思，當你建立完enum後，編譯器會自動為你的enum新增toString() 方法，能夠讓你方便的顯示enum例項的具體名字是什麼。除了 toString。方法外，編譯器還會新增 ordinal。方法，這個方法用來表示enum常量的宣告順序，以及values。方法顯示順序的值。

public static void main(String[] args) {

 for(Family family : Family.values()){
 System.out.println(family + ", ordinal" + family.ordinal());
 }
}

多執行緒

1、程序和執行緒

程序：正在進行的程式。每一個程序執行都有一個執行順序，該順序是一個執行路徑，或者叫一個控制單元。
執行緒：程序內部的一條執行路徑或者一個控制單元。

兩者的區別：一個程序至少有一個執行緒。程序在執行過程中擁有獨立的記憶體單元，而多個執行緒共享記憶體；

2、jvm多執行緒的啟動是多執行緒嗎？

java的虛擬機器jvm啟動的是單執行緒，就有發生記憶體洩露的可能，而我們使用java程式沒出現這樣的問題，也就是jvm啟動至少有兩個執行緒，一個執行java程式，一個執行垃圾回收。所以是多執行緒。

3、多執行緒的優勢

解決了多部分同時執行的問題，提高效率

4、執行緒的弊端

執行緒太多會導致效率的降低，因為執行緒的執行依靠的是CPU的來回切換。

5、什麼叫多執行緒

一個程序中有多個執行緒，稱為多執行緒。

6、實現多執行緒的方法

實現多執行緒可以通過繼承Thread類和實現Runnable介面。

(1)、繼承Thread
定義一個類繼承Thread類 複寫Thread類中的public void run()方法，將執行緒的任務程式碼封裝到run方法中 
直接建立Thread的子類物件，建立執行緒 呼叫start()方法，開啟執行緒(呼叫執行緒的任務run方法) //另外可以通過Thread的getName()獲取執行緒的名稱。

(2)、實現Runnable介面；
定義一個類，實現Runnable介面； 
覆蓋介面的public void run()的方法，將執行緒的任務程式碼封裝到run方法中； 
建立Runnable介面的子類物件，將Runnabl介面的子類物件作為引數傳遞給Thread類的建構函式，建立Thread類物件（原因：執行緒的任務都封裝在Runnable介面子類物件的run方法中。所以要線上程物件建立時就必須明確要執行的任務）。 
呼叫start()方法，啟動執行緒。

兩種方法區別：
(1)實現Runnable介面避免了單繼承的侷限性
(2)繼承Thread類執行緒程式碼存放在Thread子類的run方法中
實現Runnable介面執行緒程式碼存放在介面的子類的run方法中；
在定義執行緒時，建議使用實現Runnable介面，因為幾乎所有多執行緒都可以使用這種方式實現

6、建立執行緒是為什麼要複寫run方法？

Thread類用於描述執行緒。Thread類定義了一個功能，用於儲存執行緒要執行的程式碼，該儲存功能就是run方法。

7、start()和run方法有什麼區別？

呼叫start方法方可啟動執行緒，而run方法只是thread的一個普通方法，呼叫run方法不能實現多執行緒；
Start()方法:
start方法用來啟動執行緒,實現了多執行緒執行,這時無需等待run方法體程式碼執行完畢而直接繼續執行下面的
程式碼。通過呼叫Thread類的start()方法來啟動一個執行緒,這時此執行緒處於就緒(可執行)狀態，並沒有執行，
一旦得到cpu時間片(執行權),就開始執行run()方法,這裡方法run()稱為執行緒體，
它包含了要執行的這個執行緒的內容，Run方法執行結束,此執行緒隨即終止。
Run()方法:
run()方法只是Thread類的一個普通方法,如果直接呼叫Run方法,程式中依然只有主執行緒這一個執行緒,
其程式執行路徑還是隻有一條，還是要等待run方法體執行完畢後才可繼續執行下面的程式碼，
這樣就沒有達到多執行緒的目的。

8、執行緒的幾種狀態

新建：new一個Thread物件或者其子類物件就是建立一個執行緒，當一個執行緒物件被建立，但是沒有開啟，這個時候，
只是物件執行緒物件開闢了記憶體空間和初始化資料。
就緒：新建的物件呼叫start方法，就開啟了執行緒，執行緒就到了就緒狀態。
在這個狀態的執行緒物件，具有執行資格，沒有執行權。
執行：當執行緒物件獲取到了CPU的資源。
在這個狀態的執行緒物件，既有執行資格，也有執行權。
凍結：執行過程中的執行緒由於某些原因(比如wait,sleep)，釋放了執行資格和執行權。
當然，他們可以回到執行狀態。只不過，不是直接回到。
而是先回到就緒狀態。
死亡：當執行緒物件呼叫的run方法結束，或者直接呼叫stop方法，就讓執行緒物件死亡，在記憶體中變成了垃圾。

9、sleep()和wait()的區別

(1)這兩個方法來自不同的類，sleep()來自Thread類，和wait()來自Object類。
(2)sleep是Thread的靜態類方法，誰呼叫的誰去睡覺，即使在a執行緒裡呼叫了b的sleep方法，實際上還是a去睡覺，要讓b執行緒睡覺要在b的程式碼中呼叫sleep。而wait()是Object類的非靜態方法
(3)sleep()釋放資源不釋放鎖，而wait()釋放資源釋放鎖；
(4)使用範圍：wait,notify和notifyAll只能在同步控制方法或者同步控制塊裡面使用,而sleep可以在任何地方使用

10、多執行緒安全問題

(1)原因:當程式的多條語句在操作執行緒共享資料時(如買票例子中的票就是共享資源)，由於執行緒的隨機性導致一個執行緒對多條語句，執行了一部分還沒執行完，另一個執行緒搶奪到cpu執行權參與進來執行，此時就導致共享資料發生錯誤。比如買票例子中列印重票和錯票的情況。
(2)解決方法:對多條操作共享資料的語句進行同步，一個執行緒在執行過程中其他執行緒不可以參與進來

11、Java中多執行緒同步是什麼？

同步是用來解決多執行緒的安全問題的，在多執行緒中，同步能控制對共享資料的訪問。如果沒有同步，當一個執行緒在
修改一個共享資料時，而另外一個執行緒正在使用或者更新同一個共享資料，這樣容易導致程式出現錯誤的結果。

12、什麼是鎖?鎖的作用是什麼?

鎖就是物件
鎖的作用是保證執行緒同步，解決執行緒安全問題。
持有鎖的執行緒可以在同步中執行，沒有鎖的執行緒即使獲得cpu執行權，也進不去。

13、同步的前提

(1)必須保證有兩個以上執行緒
(2)必須是多個執行緒使用同一個鎖，即多條語句在操作執行緒共享資料
(3)必須保證同步中只有一個執行緒在執行

14、同步的好處和弊端

好處：同步解決了多執行緒的安全問題
弊端：多執行緒都需要判斷鎖，比較消耗資源

15、同步的兩種表現形式

(1)、同步程式碼塊:
可以指定需要獲取哪個物件的同步鎖,使用synchronized的程式碼塊同樣需要鎖,但他的鎖可以是任意物件
考慮到安全問題，一般還是使用同一個物件，相對來說效率較高。
注意：
雖然同步程式碼快的鎖可以使任何物件，但是在進行多執行緒通訊使用同步程式碼快時，必須保證同步程式碼快的鎖的物件和，否則會報錯。同步函式的鎖是this，也要保證同步函式的鎖的物件和呼叫wait、notify和notifyAll的物件是同一個物件，也就是都是this鎖代表的物件。

格式：
synchronized(物件)
{
	需同步的程式碼;
}

(2)、同步函式
同步方法是指進入該方法時需要獲取this物件的同步鎖，在方法上使用synchronized關鍵字，
使用this物件作為鎖，也就是使用了當前物件，因為鎖住了方法，所以相對於程式碼塊來說效率相對較低。
注:靜態同步函式的鎖是該方法所在的類的位元組碼檔案物件，即類名.class檔案

格式：
修飾詞 synchronized 返回值型別 函式名(引數列表)
{
	需同步的程式碼;
}

在jdk1.5後，用lock鎖取代了synchronized，個人理解也就是對同步程式碼塊做了修改，並沒有提供對同步方法的修改，主要還是效率問題吧。

16、多執行緒的單例設計模式：保證某個類中記憶體中只有一個物件

(1)、餓漢式:

class Singleton {
	//1,私有構造方法,其他類不能訪問該構造方法了
	private Singleton(){}
	//2,建立本類物件
	private static Singleton s = new Singleton();
	//3,對外提供公共的訪問方法
	public static Singleton getInstance() {				//獲取例項
		return s;
	}
}

(2)、懶漢式：

class Singleton {
	//1,私有構造方法,其他類不能訪問該構造方法了
	private Singleton(){}
	//2,宣告一個引用
	private static Singleton s ;
	//3,對外提供公共的訪問方法
	public static Singleton getInstance() {				//獲取例項
		if(s == null) {
			//執行緒1等待,執行緒2等待
			s = new Singleton();
		}

		return s;
	}
}

餓漢式和懶漢式的區別：
1、餓漢式是空間換時間,懶漢式是時間換空間
2、在多執行緒訪問時,餓漢式不會建立多個物件,而懶漢式有可能會建立多個物件

17、死鎖

兩個執行緒對兩個同步物件具有迴圈依賴時，就會發生死鎖。即同步巢狀同步，而鎖卻不同。

18、wait()、sleep()、notify()、notifyAll()

wait():使一個執行緒處於等待狀態，並且釋放所持有的物件的lock。
sleep():使一個正在執行的執行緒處於睡眠狀態，是一個靜態方法，呼叫此方法要捕捉InterruptedException異常。
notify():喚醒一個處於等待狀態的執行緒，注意的是在呼叫此方法的時候，並不能確切的喚醒某一個等待狀態的執行緒，
而是由JVM確定喚醒哪個執行緒(一般是最先開始等待的執行緒)，而且不是按優先順序。
Allnotity():喚醒所有處入等待狀態的執行緒，注意並不是給所有喚醒執行緒一個物件的鎖，而是讓它們競爭。

19、為什麼wait()、notify()、notifyAll()這些用來操作執行緒的方法定義在Object類中？

(1)、這些方法只存在於同步中；
(2)、使用這些方法時必須要指定所屬的鎖，即被哪個鎖呼叫這些方法；
(3)、而鎖可以是任意物件，所以任意物件呼叫的方法就定義在Object中。

20、多執行緒間通訊

多執行緒間通訊就是多個執行緒在操作同一資源,但是操作的動作不同.
(1)、為什麼要通訊
多執行緒併發執行的時候, 如果需要指定執行緒等待或者喚醒指定執行緒, 那麼就需要通訊.比如生產者消費者的問題，
生產一個消費一個,生產的時候需要負責消費的程序等待,生產一個後完成後需要喚醒負責消費的執行緒,
同時讓自己處於等待，消費的時候負責消費的執行緒被喚醒，消費完生產的產品後又將等待的生產執行緒喚醒，
然後使自己執行緒處於等待。這樣來回通訊，以達到生產一個消費一個的目的。
(2)、怎麼通訊
在同步程式碼塊中, 使用鎖物件的wait()方法可以讓當前執行緒等待, 直到有其他執行緒喚醒為止.
使用鎖物件的notify()方法可以喚醒一個等待的執行緒，或者notifyAll喚醒所有等待的執行緒.
多執行緒間通訊用sleep很難實現，睡眠時間很難把握。

21、Lock和Condition

實現提供比synchronized方法和語句可獲得的更廣泛的鎖的操作，可支援多個相關的Condition物件
Lock是個介面
鎖是控制多個執行緒對共享資料進行訪問的工具。
JDK1.5中提供了多執行緒升級的解決方案：
將同步synchonized替換成了顯示的Lock操作，將Object中的wait、notify、notifyAll替換成了Condition物件。
該物件可以Lock鎖進行獲取。

Lock的方法摘要：
void lock() 獲取鎖。
Condition newCondition() 返回繫結到此 Lock 例項的新 Condition 例項。
void unlock() 釋放鎖。
Condition方法摘要：
void await() 造成當前執行緒在接到訊號或被中斷之前一直處於等待狀態。
void signal() 喚醒一個等待執行緒。
void signalAll() 喚醒所有等待執行緒。

22、停止執行緒

stop方法已經過時，如何停止執行緒？
停止執行緒的方法只有一種，就是run方法結束。如何讓run方法結束呢？
開啟多執行緒執行，執行程式碼通常是迴圈體，只要控制住迴圈，就可以讓run方法結束，也就是結束執行緒。

特殊情況：當執行緒屬於凍結狀態，就不會讀取迴圈控制標記，則執行緒就不會結束。
為解決該特殊情況，可引入Thread類中的Interrupt方法結束執行緒的凍結狀態；
當沒有指定的方式讓凍結執行緒恢復到執行狀態時，需要對凍結進行清除，強制讓執行緒恢復到執行狀態。

23、interrupt

void interrupt() 中斷執行緒:
中斷狀態將被清除，它還將收到一個 InterruptedException

24、守護執行緒(後臺執行緒)

setDaemon(boolean on):將該執行緒標記為守護執行緒或者使用者執行緒。
當主執行緒結束，守護執行緒自動結束，比如聖鬥士星矢裡面的守護雅典娜，
在多執行緒裡面主執行緒就是雅典娜，守護執行緒就是聖鬥士，主執行緒結束了，
守護執行緒則自動結束。
當正在執行的執行緒都是守護執行緒時，java虛擬機器jvm退出；所以該方法必須在啟動執行緒前呼叫；

守護執行緒的特點：
守護執行緒開啟後和前臺執行緒共同搶奪cpu的執行權，開啟、執行兩者都沒區別，
但結束時有區別，當所有前臺執行緒都結束後，守護執行緒會自動結束。

25、多執行緒join方法

void join() 等待該執行緒終止。
void join(long millis) 等待該執行緒終止的時間最長為 millis 毫秒。
throws InterruptedException
特點：當A執行緒執行到B執行緒的join方法時，A就會等待B執行緒都執行完，A才會執行
作用: join可以用來臨時加入執行緒執行；

26、多執行緒優先順序：yield()方法

yield():暫停當前正在執行的執行緒物件，並執行其他執行緒
setPriority(int newPriority):更改執行緒優先順序
int getPriority() 返回執行緒的優先順序。
String toString() 返回該執行緒的字串表示形式，包括執行緒名稱、優先順序和執行緒組

(1)MAX_PRIORITY:最高優先順序(10級)
(1)Min_PRIORITY:最低優先順序(1級)
(1)Morm_PRIORITY:預設優先順序(5級)

27、什麼是ThreadLocal類,怎麼使用它？

ThreadLocal類提供了執行緒區域性 (thread-local) 變數。是一個執行緒級別的區域性變數，並非“本地執行緒”。
ThreadLocal 為每個使用該變數的執行緒,提供了一個獨立的變數副本，每個執行緒修改副本時不影響其它執行緒物件的副本

下面是執行緒區域性變數(ThreadLocal variables)的關鍵點：
一個執行緒區域性變數(ThreadLocal variables)為每個執行緒方便地提供了一個單獨的變數。
ThreadLocal 例項通常作為靜態的私有的(private static)欄位出現在一個類中，這個類用來關聯一個執行緒。
當多個執行緒訪問 ThreadLocal 例項時，每個執行緒維護 ThreadLocal 提供的獨立的變數副本。
常用的使用可在 DAO 模式中見到，當 DAO 類作為一個單例類時，
資料庫連結(connection)被每一個執行緒獨立的維護，互不影響。(基於執行緒的單例)

28、什麼時候丟擲InvalidMonitorStateException異常?為什麼？

呼叫 wait ()/notify ()/notifyAll ()中的任何一個方法時，如果當前執行緒沒有獲得該物件的鎖，
那麼就會丟擲 IllegalMonitorStateException 的異常
也就是說程式在沒有執行物件的任何同步塊或者同步方法時，
仍然嘗試呼叫 wait ()/notify ()/notifyAll ()時。由於該異常是 RuntimeExcpetion 的子類，
所以該異常不一定要捕獲(儘管你可以捕獲只要你願意
作為 RuntimeException，此類異常不會在 wait (),notify (),notifyAll ()的方法簽名提及。

29、在靜態方法上使用同步時會發生什麼事？

同步靜態方法時會獲取該類的“Class”物件，所以當一個執行緒進入同步的靜態方法中時，
執行緒監視器獲取類本身的物件鎖，其它執行緒不能進入這個類的任何靜態同步方法。
它不像例項方法，因為多個執行緒可以同時訪問不同例項同步例項方法。

30、當一個同步方法已經執行，執行緒能夠呼叫物件上的非同步例項方法嗎？

可以，一個非同步方法總是可以被呼叫而不會有任何問題。
實際上，Java 沒有為非同步方法做任何檢查，鎖物件僅僅在同步方法或者同步程式碼塊中檢查。
如果一個方法沒有宣告為同步，即使你在使用共享資料Java照樣會呼叫，而不會做檢查是否安全，
所以在這種情況下要特別小心。一個方法是否宣告為同步取決於臨界區訪問(critial section access)，
如果方法不訪問臨界區(共享資源或者資料結構)就沒必要宣告為同步的。

31、在一個物件上兩個執行緒可以呼叫兩個不同的同步例項方法嗎？

不能，因為一個物件已經同步了例項方法，執行緒獲取了物件的物件鎖。所以只有執行完該方法釋放物件鎖後才能執行其它同步方法。

32、什麼是執行緒餓死，什麼是活鎖？

執行緒餓死和活鎖雖然不像死鎖一樣是常見的問題，但是對於併發程式設計的設計者來說就像一次邂逅一樣。
當所有執行緒阻塞，或者由於需要的資源無效而不能處理，不存在非阻塞執行緒使資源可用。
JavaAPI 中執行緒活鎖可能發生在以下情形：
當所有執行緒在程式中執行 Object.wait (0)，引數為 0 的 wait 方法。
程式將發生活鎖直到在相應的物件上有執行緒呼叫 Object.notify ()或者 Object.notifyAll ()。
當所有執行緒卡在無限迴圈中。