內部類優點：1.可直接訪問外部類的成員，包括私有。
之所以可以直接訪問外部類的成員，是因為內部類中持有了一個外部類的引用，格式 外部類名.this
2.外部類要訪問內部類必須要建立內部類對象

訪問格式： 當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。 可以直接建立內部類對象。
格式：外部類名.內部類名 變量名 =外部類對象.內部類對象;
Outer.Inner in =new Outer().Inner();
private 內部類
static：內部類就具備了static的特性，當內部類被static修飾後，只能直接訪問外部類中的static策劃那個元，出現了訪問局限。
new Outer.Inner().Funcation();
Outer.Inner().funcation();
註意：當內部類中定義了靜態成員，該內部類必須是static的。
當外部了中的靜態方法訪問內部類時，內部類也必須是static的。
當描述事物時，事物的內部還有十五，該事物用內部類來描述。因為內部事物在使用外部事物的內容。
內部類定義在局部時，
1.不可以被成員修飾符修飾
2.可以直接訪問外部類中的成員，因為還持有外部類中的引用。但是不可以訪問他所在的局部的變量。只能訪問被final修飾的局部變量。
匿名內部類
1.匿名內部類其實就是內部類的間歇格式。
2.定義匿名內部類的前提：
內部類必須是繼承一個類或者實現接口。
3.匿名內部類的格式： new 父類或者接口（）{定義子類的內容}
4.其實匿名內部類就是一個你名子類對象，而且對象有點胖。樂意理解為內容的對象。
new AbsDemo()
{
void show(){
System.out.print("x="+x);
}
}.show();
多態子類只能調用父類方法
5.匿名內部類中定義的方法最好不要超過3個。

Java 中被 static 修飾的成員稱為靜態成員或類成員。它屬於整個類所有，而不是某個對象所有，即被類的所有對象所共享。靜態成員可以使用類名直接訪問，也可以使用對象名進行訪問。

異常

異常：就是程序在運行時初夏不正常情況。
異常由來：問題也是生活中一個具體的事物，也可以通過java的類的形式進行描述。並封裝成對象。
其實就是java對不正常情況進行描述後的對象體現。
對於問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。
對於嚴重的，java通過Error類進行描述。
對於Error一般不編寫針對習慣的代碼對其進行處理。

對於非嚴重的，java通過Exception類進行描述。
對於Exception可以使用針對性的處理方式進行處理。

無論Error或者Exception都具有一些共性內容。
比如：不正常情況的信息，引發原因等。

Throwable
|--Error
|--Excaption

2.異常的處理

java 提供了特有的語句進行處理
try
{
需要被檢測的代碼；
}
catch（異常類 變量）
{
處理異常的代碼；（處理方式）
}
finally
{
一定會執行的語句；
}

3. .getMessage（）//異常名稱：異常信息
.toString() //異常名稱：異常信息，一擦很能夠出現的位置
.printStackTrace() //異常名稱，異常信息，異常出現的位置。
//其實jvm後人的異常處理機制，就是在調用printStackTrace方法。
打印異常的堆棧的跟蹤信息。

throws Exception//異常聲明
對多異常的處理
1.聲明異常時，建議聲明更為具體的異常。這樣處理的可以更具體。
2.對方聲明幾個異常，就對應有幾個catch塊。不要定義多余的catch塊
如果多個catch塊中的異常出現繼承關系，父類異常catch塊放在最下面。

建議在進行catch處理時，catch中一定要定義具體處理方式。不要簡單定義一句e.printStackTrace(),也不要簡單的就書寫一條輸出語句。

自定義異常
用於對特有的問題進行自定義的封裝。
必須要自定義類繼承Excaption
繼承Excaption原因：
一場體系有一個特點：因為異常類和異常地響都被拋出。
他們都具有可拋性是Throwable這個體系獨有特點
只有這個體系中的類和對象才可以被throws和throw操作。
throws Exception{
throw Exception
}
thorws使用在函數上
throw使用在函數內
throws後面跟的異常類，可以跟多個。用逗號隔開。
throw後跟的是異常對象。
Exception中有一個特殊的子類異常RuntimeException運行時異常。
如果在函數內拋出該異常，函數上可以不用聲明，編譯一樣通過。
如果在函數上聲明了異常，調用者可以不用進行處理，編譯一樣能夠通過

之所以不用在函數聲明，是因為不需要讓調用者處理。
當該異常發生，希望程序停止。因為在運行時，出現了無法繼續運算的ing狂，希望停止程序後，對代碼進行修正。

自定義異常時：如果該異常的發生，無法在繼續進行運算，就讓自定義異常繼承RuntimeException

對於異常分兩種：
1.編譯被檢測的異常
2.編譯時不被檢測的異常（運行時異常。RuntimeException以及其子類）

this：代表奔雷對象，哪個對象調用this所在函數，this就代表哪個對象。

final：
1.修飾類，變量（成員變量，靜態變量，局部變量），函數。
2.修飾的類不可以被繼承。
3.修師德函數不可以被覆蓋
4.修飾的變量是一個常量，只能賦值一次。
5.內部類只能訪問局部的final變量

多態 成員變量不覆蓋 方法覆蓋
throw單獨存在，下面不要定義語句，因為執行不到
多個catch時，父類的catch要放在下面
靜態調用靜態
catch塊中有return仍然執行final語句

包（package)
1.對類文件進行分類管理
2.給類提供多層命名空間
3.寫在程序文件的第一行
4.類名的全程的是 包名.類名。
5.包也是一種封裝形式。

jar包
java的壓縮包
方便項目的攜帶
方便與使用，只要在classpath設置jar路徑即可
數據可驅動，SSH框架等都是以jar包體現

進程：是一個正在執行中的程序
每一個進程執行都有執行一個執行順序。該順序是一個執行路徑，或者叫一個控制單元。
線程：就是進程總的一個獨立的控制單元。
線程在控制者進程的執行。

一個進程中至少有一個線程。

java VM 啟動的時候會有一個進程java.exe

該進程中至少一個線程負責java程序的執行。
而且這個線程運行的代碼存在於main方法中
該線程稱之為主線程。

擴展：其實更細節說明jvm，jvm啟動不知一個線程，還有負責垃圾回收機制的線程。

1.如何自定義的代碼中，自定義一個線程呢？

通過先側滑蓋的第一種方式，繼承Thread類
步驟：
1.定義類繼承Thread。
2.復寫Thread類中的run方法
目的：講自定義代碼存儲在run方法。讓線程運行。
3.調用線程的start方法
該方法兩個作用，啟動線程，調用run方法。

發現運行結果每一次都不同。
因為多個線程都獲取cpu的執行權。cpu執行到誰，誰就運行。
明確I點，在某一時刻，只能有一個承訓在運行。（多核除外）
cpu在做著快速的切換，以達到看上去是同時運行的效果。
我們可以形象的吧多線程的運行行為在互相搶奪cpu的執行權。

這就是多線程的一個特性：隨機性，誰搶到誰執行，至於執行多長，cpu說了算。

為什麽要覆蓋run方法？

Thread類用於描述線程。
該類就定義一個功能，用於存儲線程要運行的代碼，該存儲功能就是run方法。

也就是說Tread類中的run方法，用於存儲先策劃概念要運行的代碼。

執行狀態：被創建 運行 阻塞 凍結 臨時 消亡

原來線程都有自己默認的名稱（. getname（））
Tread-編號 該編號從0開始
Tread.currentTread()==this 前一種調用方式是通用的

static Thread crrentThread():獲取當前線程對象。
getName()：獲取線程名稱

設置線程名稱：setName或者構造函數。

創建線程的第二種方式：實現Runnable接口

步驟：
1.定義類實現Runnable接口
2.覆蓋Runnable接口中的run方法
講線程要運行的代碼存放在該run方法中。

3.通過Thread類建立線程對象。
4.講Runnable接口的子類對象作為實際參數傳遞給Thread類的構造函數。
為什麽要將Runnable接口的子類對象傳遞給Thread的構造函數。
因為，自定義的潤方法所屬的對象是Runnable接口的子類對象。
所以要讓線程去指定對象的run方法，就鼻息明確該run方法所屬對象。

5.調用Thread類start方法發開啟線程並調用Runnable接口子類的run方法。

實現方式和繼承方式有什麽區別？

實現方式好處：避免了單繼承的局限性。
在定義線程時，建議使用實現方式。

兩種方式區別：
繼承Thread：線程代碼存放Thread子類run方法中。
實現Runnable，線程代碼存在接口的子類的run方法。

問題的原因：
當多條語句在操作同一個線程共享數據時，一個下城對多條語句只執行了一部分，還沒有執行完，
解決方法：
對多條操作共享數據的語句，只能讓一個線程讀執行完。在執行過程中，其他線程不可以參與執行。

java對於多線程的安全問題提供了

就是同步代碼塊

synchronized（對象）
{
需要被同步的代碼
}

對象如同鎖，持有鎖的線程可以在同步中執行。
沒有持有鎖的線程即時獲取cpu的執行權，也進不去，因為沒有獲取鎖。

同步的前提：
1,必須要有兩個或者兩個以上的線程。
2，必須是多個線程使用同一個鎖。

必須保證同步中只能有一個線程在運行

好處：解決了多線程的安全問題。

弊端：多個線程需要判斷鎖，較為浪費資源。

如何找問題：
1，明確哪些代碼是多線程運行代碼。
2, 明確共享數據
3，明確多線程運行代碼中哪些語句是操作共享數據的。

同步函數：用synchronized 修飾即可

同步函數用的是哪一個鎖呢？
函數需要被對象調用，那麽函數都有一個所屬對象引用。就是this
所以同步函數使用的鎖是this

如果同步函數被靜態修飾後，使用的鎖是什麽呢？

通過驗證，發現不在是this，因為就能夠臺方法中也不可以定義this。

靜態進內存時，內存中沒有奔雷對象，但是一定有該類對應的字節碼文件對象。
類名.class 該對象的類型是Class

靜態的同步方法，使用的鎖是該方法所在類的字節碼文件對象。 類名.class

懶漢式：延遲加載

懶漢式：

class Single
{
private static Single s=null;
private Single(){}

public static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null){
s=new Single();
}

}

}
return s;
}
}

死鎖
同步中嵌套同步，而鎖不同

note（java）