第一階段：JavaSE

1、面向對象編程(基礎)

1)面向過程和面向對象區別

一、思想理念的不同

面向對象編程（Object-Oriented Programming，OOP）注重將問題分解為一組相互關聯的對象，這些對象具有自己的屬性和行為。OOP的核心思想是通過模擬真實世界的實體，以對象為中心進行設計和開發。對象之間通過消息傳遞進行通信和交互，實現系統功能的實現。

相比之下，面向過程編程（Procedural Programming，P）則更加關注問題的步驟和流程。它將問題分解為一系列的步驟或者函數，并按照特定的順序執行。P過程性編程以算法為中心，強調問題的解決過程，將數據和功能分離，逐個處理步驟來實現程序的功能。

二、抽象程度的不同

面向對象編程通過封裝、繼承和多態等機制，可以將現實世界的復雜問題抽象成更簡單、更易于理解的模型。它強調對象的概念，將數據和操作數據的方法封裝在一起，以便更好地組織和管理代碼。通過定義類和對象，OOP可以提供更高層次的抽象，使得代碼的重用性和可維護性更強。

相反，面向過程編程的抽象程度較低。它將問題分解為一系列的步驟或函數，每個步驟都是按照特定的邏輯順序執行的。P過程性編程更加直接和實際，處理問題的方式較為細節化。雖然可以使用函數來組織代碼，但對于大型項目來說，代碼的可讀性和可維護性可能會受到挑戰。

三、代碼的復用性和可維護性不同

面向對象編程具有良好的代碼復用性和可維護性。通過類的繼承和多態等特性，可以將通用的行為和屬性封裝在父類中，子類可以繼承和擴展這些特性。這種代碼的組織方式使得代碼結構清晰，易于理解和修改，提高了開發效率。

相比之下，面向過程編程的代碼復用性和可維護性較差。由于函數和數據相分離的特點，代碼的重用性較低。當需求發生變化時，可能需要修改多個函數，這會導致代碼的可維護性下降。

四、團隊協作和開發效率不同

面向對象編程在大型項目中具有良好的團隊協作性。通過對象的封裝和信息隱藏，不同的團隊成員可以獨立開發和測試各自的模塊，減少了彼此之間的依賴。同時，OOP的抽象和封裝特性可以提高代碼的可讀性和可維護性，進而提高開發效率。

相反，面向過程編程的團隊協作性相對較差。由于函數和數據相分離的特點，不同的開發人員之間可能需要更多的溝通和協調，以確保代碼的正確性和一致性。在大型項目中，代碼的維護和擴展也相對困難，開發效率較低。

五、靈活性和可擴展性不同

面向對象編程具有較高的靈活性和可擴展性。由于對象之間的關系是通過消息傳遞實現的，可以在運行時動態地創建、銷毀和修改對象。這種動態性使得系統能夠更好地適應變化的需求，添加新功能或修改現有功能更加方便。

相對而言，面向過程編程的靈活性和可擴展性較低。由于代碼的組織方式是基于函數和步驟的順序執行，當需要添加新功能時，可能需要修改多個函數或步驟，可能會引發連鎖反應，增加了代碼的復雜性和風險。

六、封裝和信息隱藏不同

面向對象編程強調封裝和信息隱藏的概念。通過將數據和操作數據的方法封裝在對象內部，對外部提供公共接口進行訪問，實現了數據的隱藏和保護。這種封裝性可以有效地防止數據被錯誤地修改，增強了代碼的安全性和可靠性。

而面向過程編程的封裝性較差，數據和功能之間的關系比較松散。數據通常被多個函數共享，可能會導致數據被錯誤地修改或誤用，增加了代碼出錯的風險。

七、編程范式的應用領域不同

面向對象編程通常適用于大型軟件系統的開發，例如企業級應用、圖形界面程序等。OOP的思想和方法可以更好地應對復雜性和變化性，提供了更高層次的抽象和組織方式，便于團隊協作和可維護性。

面向過程編程則更適用于較小規模、簡單和直接的任務。例如編寫一些簡單的腳本、數據處理程序等。由于P過程性編程更注重問題的解決過程，適合于一步一步的邏輯操作。

綜合考慮以上幾個方面的區別，選擇適合具體需求的編程范式是開發人員需要權衡的因素。面向對象編程強調代碼的組織和抽象能力，適合大型項目和復雜系統的開發；而面向過程編程則更簡單直接，適用于小規模任務和簡單應用的開發。

延伸閱讀1：面向對象程序設計的基本特征

面向對象程序設計（Object-Oriented Programming，OOP）具有以下基本特征：

一、封裝（Encapsulation）

封裝是指將數據和對數據的操作封裝在一個單元內部，形成一個對象。對象對外部提供公共接口，隱藏了內部實現細節，通過接口訪問對象的屬性和方法。封裝提供了信息隱藏和保護數據的能力，同時也提高了代碼的可讀性和可維護性。

二、繼承（Inheritance）

繼承是一種機制，允許一個對象（子類）繼承另一個對象（父類）的屬性和方法。通過繼承，子類可以復用父類的代碼，擴展或修改父類的功能。繼承實現了代碼的重用性和層次性，提供了面向對象編程的靈活性和可擴展性。

三、多態（Polymorphism）

多態是指同一個方法可以在不同的對象上產生不同的行為。通過多態，可以在父類引用的變量中存儲子類對象，然后根據實際的對象類型來調用相應的方法。多態提供了代碼的靈活性和可擴展性，能夠處理不同類型的對象，提高了代碼的可讀性和可維護性。

四、抽象（Abstraction）

抽象是指從具體的事物中抽取出共同的特征和行為，形成一個抽象的類或接口。抽象類定義了一組相關的對象的通用特征，接口定義了一組操作的規范。抽象提供了問題領域的概念模型，使得程序設計更加高層次化和模塊化。

這些基本特征共同構成了面向對象程序設計的基礎。通過封裝、繼承、多態和抽象，面向對象編程可以提供更高層次的抽象和封裝能力，實現代碼的重用性、可維護性、可擴展性和靈活性。這種編程范式適用于大型軟件系統的開發，能夠提高開發效率和代碼質量。

2)類和對象的概述

3)類的屬性和方法

4)創建對象內存分析

5)構造方法(Construtor)及其重載

6)對象類型的參數傳遞

7)this關鍵字詳解

8)static關鍵字詳解

1、深度總結

引用一位網友的話，說的非常好，如果別人問你static的作用；如果你說靜態修飾 類的屬性 和 類的方法 別人認為你是合格的；如果是說 可以構成 靜態代碼塊，那別人認為你還可以； 如果你說可以構成 靜態內部類， 那別人認為你不錯；如果你說了靜態導包，那別人認為你很OK；

那我們就先在這幾方面一一對static進行總結；然后說一些模糊的地方，以及一些面試中容易問道的地方；

1）static方法

static方法一般稱作靜態方法，由于靜態方法不依賴于任何對象就可以進行訪問，因此對于靜態方法來說，是沒有this的，因為它不依附于任何對象，既然都沒有對象，就談不上this了。并且由于這個特性，在靜態方法中不能訪問類的非靜態成員變量和非靜態成員方法，因為非靜態成員方法/變量都是必須依賴具體的對象才能夠被調用。

但是要注意的是，雖然在靜態方法中不能訪問非靜態成員方法和非靜態成員變量，但是在非靜態成員方法中是可以訪問靜態成員方法/變量的。舉個簡單的例子：
　　
在上面的代碼中，由于print2方法是獨立于對象存在的，可以直接用過類名調用。假如說可以在靜態方法中訪問非靜態方法/變量的話，那么如果在main方法中有下面一條語句：

MyObject.print2();

此時對象都沒有，str2根本就不存在，所以就會產生矛盾了。同樣對于方法也是一樣，由于你無法預知在print1方法中是否訪問了非靜態成員變量，所以也禁止在靜態成員方法中訪問非靜態成員方法。

而對于非靜態成員方法，它訪問靜態成員方法/變量顯然是毫無限制的。

因此，如果說想在不創建對象的情況下調用某個方法，就可以將這個方法設置為static。我們最常見的static方法就是main方法，至于為什么main方法必須是static的，現在就很清楚了。因為程序在執行main方法的時候沒有創建任何對象，因此只有通過類名來訪問。

2）static變量

static變量也稱作靜態變量，靜態變量和非靜態變量的區別是：靜態變量被所有的對象所共享，在內存中只有一個副本【存放在方法區】，它當且僅當在類初次加載時會被初始化【加final和不加final的static變量初始化的位置不一樣】。而非靜態變量是對象所擁有的，在創建對象的時候被初始化，存在多個副本，各個對象擁有的副本互不影響。

static成員變量的初始化順序按照定義的順序進行初始化。

3）static代碼塊

static關鍵字還有一個比較關鍵的作用就是 用來形成靜態代碼塊以優化程序性能。static塊可以置于類中的任何地方，類中可以有多個static塊。在類初次被加載的時候，會按照static塊的順序來執行每個static塊，并且只會執行一次【根據class加載原理 每個類加載一次 使用雙親委托加載】。

初始化的順序 靜態代碼塊 > 構造代碼塊 > 構造函數
　　
　　為什么說static塊可以用來優化程序性能，是因為它的特性:只會在類加載的時候執行一次。下面看個例子:

isBornBoomer是用來這個人是否是1946-1964年出生的，而每次isBornBoomer被調用的時候，都會生成startDate和birthDate兩個對象，造成了空間浪費，如果改成這樣效率會更好，其實就是利用了靜態代碼塊在內存中值加載一次的機制：

因此，很多時候會將一些只需要進行一次的初始化操作都放在static代碼塊中進行。

4）靜態內部類

這個地方不單獨寫靜態內部類，通過和普通的內部類對比來加深對靜態內部類的理解：

為何要用內部類？

1. 內部類一般只為其外部類使用；【供外部類使用說的很好 舉例 hashmap集合中 有一個內部類 Entry 就是 轉為為 hashmap 存儲來使用】

2. 內部類提供了某種進入外部類的窗戶，內部類存在外部類的引用，所以內部類可以直接訪問外部類的屬性；

3. 也是最吸引人的原因，每個內部類都能獨立地繼承一個接口，而無論外部類是否已經繼承了某個接口。因此，內部類使多重繼承的解決方案變得更加完整。

定義在一個類內部的類叫內部類，包含內部類的類稱為外部類。內部類可以聲明public、protected、private等訪問限制，可以聲明 為abstract的供其他內部類或外部類繼承與擴展，或者聲明為static、final的，也可以實現特定的接口。

外部類按常規的類訪問方式（以對象的方式）使用內部 類，唯一的差別是外部類可以訪問內部類的所有方法與屬性，包括私有方法與屬性，外部類訪問內部類，需要創建對象訪問；有一點需要注意，內部類不能訪問外部類所在的局部變量，只能訪問final修飾的局部變量。

舉例: 在方法中 定義內部類 然后內部類 調用方法的的入參 則 入參必須是 final 修飾

在方法內定義內部類時，如果內部類調用了方法中的變量，那么該變量必須申明為final類型，百思不得其解，后來想到應該是生命周期的原因，因為方法內定義的變量是局部變量，離開該方法，變量就失去了作用，也就會自動被消除，而內部類卻不會離開它所在方法就失去作用，它有更廣的生命周期，下面通過一個實例加以說明：

(1)創建實例

OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部類實例.new，內部類
AAA.StaticInner in = new AAA.StaticInner();//注意是外部類本身，靜態內部類

(2)內部類中的this

內部類中的this與其他類一樣是指的本身。創建內部類對象時，它會與創造它的外圍對象有了某種聯系，于是能訪問外圍類的所有成員，不需任何特殊條件，可理解為內部類鏈接到外部類。 用外部類創建內部類對象時，此內部類對象會秘密的捕獲一個指向外部類的引用，于是，可以通過這個引用來訪問外圍類的成員。

(3)外部類訪問內部類

內部類類似外部類的屬性，因此訪問內部類對象時總是需要一個創建好的外部類對象。外部類對象通過‘外部類名.this.xxx'的形式訪問內部類的屬性與方法。如：

System.out.println("Print in inner Outer.index=" + pouter.this.index);
System.out.println("Print in inner Inner.index=" + this.index);

(4)內部類向上轉型

內部類也可以和普通類一樣擁有向上轉型的特性。將內部類向上轉型為基類型，尤其是接口時，內部類就有了用武之地。如果內部類是private的，只可以被它的外部類問，從而完全隱藏實現的細節。

(5)方法內的類

方法內創建的類（注意方法中也能定義類），不能加訪問修飾符。另外，方法內部的類也不是在調用方法時才會創建的，它們一樣也被事先編譯了。

(6)靜態內部類

定義靜態內部類：在定義內部類的時候，可以在其前面加上一個權限修飾符static。此時這個內部類就變為了靜態內部類。

通常稱為嵌套類，當內部類是static時，意味著：

[1]要創建嵌套類的對象，并不需要其外圍類的對象；

[2]不能從嵌套類的對象中訪問非靜態的外圍類對象（不能夠從靜態內部類的對象中訪問外部類的非靜態成員）；

嵌 套類與普通的內部類還有一個區別：普通內部類的字段與方法，只能放在類的外部層次上，所以普通的內部類不能有static數據和static字段， 也不能包含嵌套類。但是在嵌套類里可以包含所有這些東西。也就是說，在非靜態內部類中不可以聲明靜態成員，只有將某個內部類修飾為靜態類，然后才能夠在這 個類中定義靜態的成員變量與成員方法。

另外，在創建靜態內部類時不需要將靜態內部類的實例綁定在外部類的實例上。普通非靜態內部類的 對象是依附在外部類對象之中的，要在一個外部類中定義一個靜態的內部類，不需要利用關鍵字new來創建內部類的實例。靜態類和方法只屬于類本身，并不屬于 該類的對象，更不屬于其他外部類的對象。

(7)內部類標識符

每個類會產生一個.class文件，文件名即為類名。同樣，內部類也會產生這么一個.class文件，但是它的名稱卻不是內部類的類名，而是有著嚴格的限制：外圍類的名字，加上$,再加上內部類名字。

代碼具體：

public class OutClassTest {static int a;int b;public static void test() {System.out.println("outer class static function");}public static void main(String[] args) {// new一個外部類OutClassTest oc1 = new OutClassTest();// 通過外部類的對象new一個非靜態的內部類OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();// 調用非靜態內部類的方法System.out.println(no_static_inner.getKey());// 調用靜態內部類的靜態變量System.out.println(OutClassTest.InnerStaticClass.static_value);// 不依賴于外部類實例,直接實例化內部靜態類OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();// 調用靜態內部類的非靜態方法System.out.println(inner.getValue());// 調用內部靜態類的靜態方法System.out.println(OutClassTest.InnerStaticClass.getMessage());}private class InnerClass {// 只有在靜態內部類中才能夠聲明或定義靜態成員// private static String tt = "0";private int flag = 0;public InnerClass() {// 三.非靜態內部類的非靜態成員可以訪問外部類的非靜態變量和靜態變量System.out.println("InnerClass create a:" + a);System.out.println("InnerClass create b:" + b);System.out.println("InnerClass create flag:" + flag);//System.out.println("InnerClass call outer static function");// 調用外部類的靜態方法test();}public String getKey() {return "no-static-inner";}}private static class InnerStaticClass {// 靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。private static String static_value = "0";private int flag = 0;public InnerStaticClass() {System.out.println("InnerClass create a:" + a);// 靜態內部類不能夠訪問外部類的非靜態成員// System.out.println("InnerClass create b:" + b);System.out.println("InnerStaticClass flag is " + flag);System.out.println("InnerStaticClass tt is " + static_value);}public int getValue() {// 靜態內部類訪問外部類的靜態方法test();return 1;}public static String getMessage() {return "static-inner";}}public OutClassTest() {// new一個非靜態的內部類InnerClass ic = new InnerClass();System.out.println("OuterClass create");}}

4）靜態導包

靜態導包就是java包的靜態導入，用import static代替import靜態導入包是JDK1.5中的新特性。

一般我們導入一個類都用 import com……ClassName;而靜態導入是這樣：import static com……ClassName.;這里的多了個static，還有就是類名ClassName后面多了個. ，意思是導入這個類里的靜態方法。當然，也可以只導入某個靜態方法，只要把 .* 換成靜態方法名就行了。然后在這個類中，就可以直接用方法名調用靜態方法，而不必用ClassName.方法名 的方式來調用。

好處：這種方法的好處就是可以簡化一些操作，例如打印操作System.out.println(…);就可以將其寫入一個靜態方法print(…)，在使用時直接print(…)就可以了。但是這種方法建議在有很多重復調用的時候使用，如果僅有一到兩次調用，不如直接寫來的方便

example:

在Java 5中，import語句得到了增強，以便提供甚至更加強大的減少擊鍵次數功能，雖然一些人爭議說這是以可讀性為代價的。這種新的特性成為靜態導入。當你想使用static成員時，可以使用靜態導入（在API中的類和你自己的類上，都可以使用該特性）。下面是靜態導入前后的代碼實例：

在靜態導入之前：

public class TestStatic {public static void main(String[] args) {System.out.println(Integer.MAX_VALUE);System.out.println(Integer.toHexString(42));}}

在靜態導入之后：

import static java.lang.System.out;import static java.lang.Integer.*;public class TestStaticImport {public static void main(String[] args) {out.println(MAX_VALUE);out.println(toHexString(42));}}

讓我們看一下使用靜態導入特性的代碼中將發生什么：

1、雖然該特性通常稱為“靜態導入”，但語法必須是import static，后面跟你想導入的static成員的完全限定名稱，或者通配符。在本例中，我們在System類的out對象上進行靜態導入。

2、在本例中，我們可能想使用java.lang.Integer類的幾個static成員。該靜態導入語句使用通配符來表達“我想在此類中的所有靜態成員上進行靜態導入”。

3、現在我們終于看到靜態導入特性的好處！我們不必在System.out.println中鍵入System。太好了！另外，我們不必在Integer.MAX_VALUE中鍵入Integer。因此，在這行代碼中，我們能夠將快捷方式用于靜態方法和一個常量。

4、最后，我們進行更多的快捷操作，這次針對Integer類的方法。

關于該特性，我們已經有點兒諷刺意味兒了，但不僅我們是這樣的。我們不認為節省少量的擊鍵次數會讓代碼

難于閱讀一點，但許多開發人員要求將它添加到語言中。

下面是使用靜態導入的幾條原則：

你必須說import static， 不能說static import。

提防含糊不清的命名static成員。例如，如果你對Integer類和Long類執行了靜態導入，引用MAX_VALUE將導致一個編譯器錯誤，因為Integer和Long都有一個MAX_VALUE常量，并且Java不會知道你在引用哪個MAX_VALUE。

你可以在static對象引用、常量（記住，它們是static 或final）和static方法上進行靜態導入。

二.static關鍵字的誤區

1.static關鍵字會改變類中成員的訪問權限嗎？

有些初學的朋友會將java中的static與C/C++中的static關鍵字的功能混淆了。在這里只需要記住一點：與C/C++中的static不同，Java中的static關鍵字不會影響到變量或者方法的作用域。在Java中能夠影響到訪問權限的只有private、public、protected（包括包訪問權限）這幾個關鍵字。看下面的例子就明白了：
　　
2.能通過this訪問靜態成員變量嗎？

雖然對于靜態方法來說沒有this，那么在非靜態方法中能夠通過this訪問靜態成員變量嗎？先看下面的一個例子，這段代碼輸出的結果是什么？

public class Main {　　static int value = 33;public static void main(String[] args) throws Exception{new Main().printValue();}private void printValue(){int value = 3;System.out.println(this.value);}

輸出

這里面主要考察隊this和static的理解。this代表什么？this代表當前對象，那么通過new Main()來調用printValue的話，當前對象就是通過new Main()生成的對象。而static變量是被對象所享有的，因此在printValue中的this.value的值毫無疑問是33。在printValue方法內部的value是局部變量，根本不可能與this關聯，所以輸出結果是33。在這里永遠要記住一點：靜態成員變量雖然獨立于對象，但是不代表不可以通過對象去訪問，所有的靜態方法和靜態變量都可以通過對象訪問（只要訪問權限足夠）。

3.static能作用于局部變量么？

在C/C++中static是可以作用域局部變量的，但是在Java中切記：static是不允許用來修飾局部變量。不要問為什么，這是Java語法的規定。

三.常見的筆試面試題

下面列舉一些面試筆試中經常遇到的關于static關鍵字的題目，僅供參考，如有補充歡迎下方留言。

1.下面這段代碼的輸出結果是什么？

public class Test extends Base{static{System.out.println("test static");}public Test(){System.out.println("test constructor");}public static void main(String[] args) {new Test();}
}class Base{static{System.out.println("base static");}public Base(){System.out.println("base constructor");}
}

至于為什么是這個結果，我們先不討論，先來想一下這段代碼具體的執行過程，在執行開始，先要尋找到main方法，因為main方法是程序的入口，但是在執行main方法之前，必須先加載Test類，而在加載Test類的時候發現Test類繼承自Base類，因此會轉去先加載Base類，在加載Base類的時候，發現有static塊，便執行了static塊。在Base類加載完成之后，便繼續加載Test類，然后發現Test類中也有static塊，便執行static塊。在加載完所需的類之后，便開始執行main方法。在main方法中執行new Test()的時候會先調用父類的構造器，然后再調用自身的構造器。因此，便出現了上面的輸出結果。

2.這段代碼的輸出結果是什么？

public class Test {Person person = new Person("Test");static{System.out.println("test static");}public Test() {System.out.println("test constructor");}public static void main(String[] args) {new MyClass();}
}class Person{static{System.out.println("person static");}public Person(String str) {System.out.println("person "+str);}
}class MyClass extends Test {Person person = new Person("MyClass");static{System.out.println("myclass static");}public MyClass() {System.out.println("myclass constructor");}
}

類似地，我們還是來想一下這段代碼的具體執行過程。首先加載Test類，因此會執行Test類中的static塊。接著執行new MyClass()，而MyClass類還沒有被加載，因此需要加載MyClass類。在加載MyClass類的時候，發現MyClass類繼承自Test類，但是由于Test類已經被加載了，所以只需要加載MyClass類，那么就會執行MyClass類的中的static塊。在加載完之后，就通過構造器來生成對象。而在生成對象的時候，必須先初始化父類的成員變量，因此會執行Test中的Person person = new Person()，而Person類還沒有被加載過，因此會先加載Person類并執行Person類中的static塊，接著執行父類的構造器，完成了父類的初始化，然后就來初始化自身了，因此會接著執行MyClass中的Person person = new Person()，最后執行MyClass的構造器。

3.這段代碼的輸出結果是什么？

public class Test {static{System.out.println("test static 1");}public static void main(String[] args) {}static{System.out.println("test static 2");}
}

9)局部代碼塊、構造代碼塊和靜態代碼塊

10)package和import詳解

11)JavaDoc生成API文檔

12)遞歸

第五階段：高級框架

1、mybatis

1)MyBatis概述

2)MyBatis入門配置

3)基本的CRUD操作

4)核心配置文件詳解

5)Mapper.xml基礎詳解

6)模糊查詢

7)分頁的實現及插件PageHelper的使用

8)動態sql+sql片段的使用

9)一對多、多對一的關系處理

10)注解的使用

11)一級緩存和二級緩存說明及使用

12）Mybatis Log4j的使用

13）Mybatis slf4j的使用

14）Mybatis動態代理的使用

15)MyBatis Generator介紹

16)generatorConfig.xml講解

17)MyBatis Generator序列化配置

18)MyBatis Generator生成toString()

19)MyBatis Generator的數據庫設置

20)MyBatis Generator包設置

21)MyBatis Generator的表設置

22)基于MyBatis Generator的數據查詢

23)基于MyBatis Generator的數據添加

24)基于MyBatis Generator的數據更新

25)基于MyBatis Generator的數據刪除