1、PO, Persistence Object, 持久層對象，對象的屬性和資料庫表的字段一一對應；
2、BO, Business Object, 業務層對象，對象的屬性和目前業務邏輯所需的資料的名稱一一對應；
3、VO, View Object, 表現層對象,對象的屬性和頁面展示的資料的名稱一一對應；
4、POJO, Plain Ordinary Java Object, 普通Java對象，隻有屬性及其set/get方法。
JDK的更新，無非是達到下面幾個目的：
1、簡化代碼書寫 2、提高效率 3、提高安全性
一、記憶體的劃分：
1，寄存器。
2，本地方法區。
3，方法區。
4，棧記憶體。
存儲的都是局部變量。
而且變量所屬的作用域一旦結束，該變量就自動釋放。
5，堆記憶體。
存儲是數組和對象(其實數組就是對象) 凡是new建立在堆中。
特點：
1，每一個實體都有首位址值。
2，堆記憶體中的每一個變量都有預設初始化值，根據類型的不同而不同。整數是0，小數0.0或者0.0f，boolean false char '\u0000'
3，垃圾回收機制。
二、定義類其實就是在定義類中的成員。
成員：成員變量<-->屬性，成員函數<-->行為。
成員變量和局部變量的差別：
1，
成員變量定義在類中，整個類中都可以通路。
局部變量定義在函數，語句，局部代碼塊中，隻在所屬的區域有效。
2，
成員變量存在于堆記憶體的對象中。
局部變量存在于棧記憶體的方法中。
3，
成員變量随着對象的建立而存在，随着對象的消失而消失。
局部變量随着所屬區域的執行而存在，随着所屬區域的結束而釋放。
4，
成員變量都有預設初始化值。
局部變量沒有預設初始化值。
三、面向對象概念了解
舉例：
大象裝進冰箱。
面向過程。
打開冰箱。
存儲大象。
關上冰箱。
對于面向過程思想，強調的是過程(動作).
C語言.
面向對象。
對于面向對象思想，強調的是對象(實體)。
冰箱打開。
冰箱存儲。
冰箱關閉。
C++ Java C#
特點：
1，面向對象就是一種常見的思想。符合人們的思考習慣。
2，面向對象的出現，将複雜的問題簡單化。
3，面向對象的出現，讓曾經在過程中的執行者，變成了對象中的指揮者。
四、構造函數
構造函數：建構創造對象時調用的函數。作用：可以給對象進行初始化。
建立對象都必須要通過構造函數初始化。
一個類中如果沒有定義過構造函數，那麼該類中會有一個預設的空參數構造函數。
如果在類中定義了指定的構造函數，那麼類中的預設構造函數就沒有了。
一般函數和構造函數什麼差別呢？
構造函數：對象建立時，就會調用與之對應的構造函數，對對象進行初始化。
一般函數：對象建立後，需要函數功能時才調用。
構造函數：對象建立時，會調用隻調用一次。
一般函數：對象建立後，可以被調用多次。
什麼時候定義構造函數呢？
在描述事物時，該事物一存在就具備的一些内容，這些内容都定義在構造函數中。
構造函數可以有多個，用于對不同的對象進行針對性的初始化.
多個構造函數在類中是以重載的形式來展現的。
細節：
1，構造函數如果完成了set功能。set方法是否需要。
2，一般函數不能直接調用構造函數。
3，構造函數如果前面加了void就變成了一般函數。
4，構造函數中是有return語句的。
五、主函數
public static void main(String[] args)
主函數特殊之處：
1，格式是固定的。
2，被jvm所識别和調用。
public:因為權限必須是最大的。
static:不需要對象的,直接用主函數所屬類名調用即可。
void：主函數沒有具體的傳回值。
main:函數名，不是關鍵字，隻是一個jvm識别的固定的名字。
String[] args:這是主函數的參數清單，是一個數組類型的參數，而且元素都是字元串類型。
六、代碼塊
靜态代碼塊。
随着類的加載而執行。而且隻執行一次。
作用：
用于給類進行初始化。
class Person
{
private String name;
{//構造代碼塊。可以給所有對象進行初始化的。
System.out.println("constructor code ");
cry();
}
static
{
System.out.println("static code");
}
Person()//是給對應的對象進行針對性的初始化。
{
name = "baby";
cry();
}
Person(String name)
{
this.name = name;
cry();
}
七、static修飾
static的特點：
1，static是一個修飾符，用于修飾成員。
2，static修飾的成員被所有的對象所共享。
3，static優先于對象存在，因為static的成員随着類的加載就已經存在了。
4，static修飾的成員多了一種調用方式，就可以直接被類名所調用 。 類名.靜态成員 。
5，static修飾的資料是共享資料，對象中的存儲的是特有資料。
成員變量和靜态變量的差別？
1，兩個變量的生命周期不同。
成員變量随着對象的建立而存在，随着對象的被回收而釋放。
靜态變量随着類的加載而存在，随着類的消失而消失。
2，調用方式不同。
成員變量隻能被對象調用。
靜态變量可以被對象調用，還可以被類名調用。
3，别名不同。
成員變量也稱為執行個體變量。
靜态變量稱為類變量。
4，資料存儲位置不同。
成員變量資料存儲在堆記憶體的對象中，是以也叫對象的特有資料.
靜态變量資料存儲在方法區(共享資料區)的靜态區，是以也叫對象的共享資料.
靜态使用的注意事項：
1，靜态方法隻能通路靜态成員。(非靜态既可以通路靜态，又可以通路非靜态)
2，靜态方法中不可以使用this或者super關鍵字。
3，主函數是靜态的。
靜态什麼時候用？
1，靜态變量。
當分析對象中所具備的成員變量的值都是相同的 。
這時這個成員就可以被靜态修飾。
隻要資料在對象中都是不同的，就是對象的特有資料，必須存儲在對象中，是非靜态的。
如果是相同的資料，對象不需要做修改，隻需要使用即可，不需要存儲在對象中，定義成靜态的。
2，靜态函數。
函數是否用靜态修飾，就參考一點，就是該函數功能是否有通路到對象中的特有資料。
簡單點說，從源代碼看，該功能是否需要通路非靜态的成員變量，如果需要，該功能就是非靜态的。
如果不需要，就可以将該功能定義成靜态的。當然，也可以定義成非靜态，
但是非靜态需要被對象調用，而僅建立對象調用非靜态的
沒有通路特有資料的方法，該對象的建立是沒有意義。
八、this關鍵字
當成員變量和局部變量重名，可以用關鍵字this來區分。
this : 代表對象。代表哪個對象呢？目前對象。
this就是所在函數所屬對象的引用。
簡單說：哪個對象調用了this所在的函數，this就代表哪個對象。
this也可以用于在構造函數中調用其他構造函數。
注意：隻能定義在構造函數的第一行。因為初始化動作要先執行。
九、繼承
繼承的好處：
1，提高了代碼的複用性。
2，讓類與類之間産生了關系，給第三個特征多态提供了前提.
java中支援單繼承。不直接支援多繼承，但對C++中的多繼承機制進行改良。
單繼承：一個子類隻能有一個直接父類。
多繼承：一個子類可以有多個直接父類(java中不允許,進行改良)
不直接支援，因為多個父類中有相同成員，會産生調用不确定性。
在java中是通過"多實作"的方式來展現。
java支援多層(多重)繼承。
C繼承B，B繼承A。
就會出現繼承體系。
當要使用一個繼承體系時，
1，檢視該體系中的頂層類，了解該體系的基本功能。
2，建立體系中的最子類對象，完成功能的使用。
什麼時候定義繼承呢？
當類與類之間存在着所屬關系的時候，就定義繼承。xxx是yyy中的一種。 xxx extends yyy
所屬關系： is a 關系。
當本類的成員和局部變量同名用this區分。
當子父類中的成員變量同名用super區分父類。
this和super的用法很相似。
this:代表一個本類對象的引用。
super：代表一個父類空間。
當子父類中出現成員函數一模一樣的情況，會運作子類的函數。
這種現象，稱為覆寫操作。這時函數在子父類中的特性。
函數兩個特性：
1，重載。同一個類中。overload
2，覆寫。子類中。覆寫也稱為重寫，覆寫。override
覆寫注意事項：
1，子類方法覆寫父類方法時，子類權限必須要大于等于父類的權限。
2，靜态隻能覆寫靜态，或被靜态覆寫。
什麼時候使用覆寫操作?
當對一個類進行子類的擴充時，子類需要保留父類的功能聲明，
但是要定義子類中該功能的特有内容時，就使用覆寫操作完成.
十、抽象abstract
抽象類：
抽象：籠統，模糊，看不懂！不具體。
特點：
1，方法隻有聲明沒有實作時，該方法就是抽象方法，需要被abstract修飾。
抽象方法必須定義在抽象類中。該類必須也被abstract修飾。
2，抽象類不可以被執行個體化。為什麼？因為調用抽象方法沒意義。
3，抽象類必須有其子類覆寫了所有的抽象方法後，該子類才可以執行個體化。
否則，這個子類還是抽象類。
1，抽象類中有構造函數嗎？
有，用于給子類對象進行初始化。
2，抽象類可以不定義抽象方法嗎？
可以的。 但是很少見，目的就是不讓該類建立對象。AWT的擴充卡對象就是這種類。
通常這個類中的方法有方法體，但是卻沒有内容。
abstract class Demo
{
void show1()
{}
void show2()
{}
}
3，抽象關鍵字不可以和那些關鍵字共存?
private 不行
static 不行
final 不行
4，抽象類和一般類的異同點。
相同點：
抽象類和一般類都是用來描述事物的，都在内部定了成員。
不同：
1，一般類有足夠的資訊描述事物。
抽象類描述事物的資訊有可能不足。
2，一般類中不能定義抽象方法，隻能定非抽象方法。
抽象類中可定義抽象方法，同時也可以定義非抽象方法。
3，一般類可以被執行個體化。
抽象類不可以被執行個體化。
5，抽象類一定是個父類嗎？
是的。因為需要子類覆寫其方法後才可以對子類執行個體化。
十一、子父類中的構造函數的特點
在子類構造對象時，發現，通路子類構造函數時，父類也運作了。
為什麼呢？
原因是：在子類的構造函數中第一行有一個預設的隐式語句。 super();
子類的執行個體化過程：子類中所有的構造函數預設都會通路父類中的空參數的構造函數。
為什麼子類執行個體化的時候要通路父類中的構造函數呢？
那是因為子類繼承了父類，擷取到了父類中内容(屬性)，是以在使用父類内容之前，
要先看父類是如何對自己的内容進行初始化的。
是以子類在構造對象時，必須通路父類中的構造函數。
為什麼完成這個必須的動作，就在子類的構造函數中加入了super()語句。
如果父類中沒有定義空參數構造函數，那麼子類的構造函數必須用super明确要調用
父類中哪個構造函數。同時子類構造函數中如果使用this調用了本類構造函數時，
那麼super就沒有了，因為super和this都隻能定義第一行。是以隻能有一個。
但是可以保證的是，子類中肯定會有其他的構造函數通路父類的構造函數。
注意：supre語句必須要定義在子類構造函數的第一行。因為父類的初始化動作要先完成。
十二、一個對象執行個體化過程
Person p = new Person();
1，JVM會讀取指定的路徑下的Person.class檔案，并加載進記憶體，
并會先加載Person的父類(如果有直接的父類的情況下).
2，在堆記憶體中的開辟空間，配置設定位址。
3，并在對象空間中，對對象中的屬性進行預設初始化。
4，調用對應的構造函數進行初始化。
5，在構造函數中，第一行會先到調用父類中構造函數進行初始化。
6，父類初始化完畢後，在對子類的屬性進行顯示初始化。
7，在進行子類構造函數的特定初始化。
8，初始化完畢後，将位址值指派給引用變量.
十三、final關鍵字
1，final是一個修飾符，可以修飾類，方法，變量。
2，final修飾的類不可以被繼承。
3，final修飾的方法不可以被覆寫。
4，final修飾的變量是一個常量，隻能指派一次。
為什麼要用final修飾變量。其實在程式如果一個資料是固定的，
那麼直接使用這個資料就可以了，但是這樣閱讀性差，是以它該資料起個名稱。
而且這個變量名稱的值不能變化，是以加上final固定。
寫法規範：常量所有字母都大寫，多個單詞，中間用_連接配接。
十四、接口interface
abstract class AbsDemo
{
abstract void show1();
abstract void show2();
}
當一個抽象類中的方法都是抽象的時候，這時可以将該抽象類用
另一種形式定義和表示，就是 接口 interface。
*/
//定義接口使用的關鍵字不是class，是interface.
method(new Dog());
}
public static void method(Animal a)//Animal a = new Dog();
{
a.eat();
if(a instanceof Cat)//instanceof：用于判斷對象的具體類型。隻能用于引用資料類型判斷
// //通常在向下轉型前用于健壯性的判斷。
{
Cat c = (Cat)a;
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d = (Dog)a;
d.lookHome();
}
else
{
}
}
十七、多态時，成員的特點
1，成員變量。
編譯時：參考引用型變量所屬的類中的是否有調用的成員變量，有，編譯通過，沒有，編譯失敗。
運作時：參考引用型變量所屬的類中的是否有調用的成員變量，并運作該所屬類中的成員變量。
簡單說：編譯和運作都參考等号的左邊。哦了。
作為了解。
2，成員函數(非靜态)。
編譯時：參考引用型變量所屬的類中的是否有調用的函數。有，編譯通過，沒有，編譯失敗。
運作時：參考的是對象所屬的類中是否有調用的函數。
簡單說：編譯看左邊，運作看右邊。
因為成員函數存在覆寫特性。
3，靜态函數。
編譯時：參考引用型變量所屬的類中的是否有調用的靜态方法。
運作時：參考引用型變量所屬的類中的是否有調用的靜态方法。
簡單說，編譯和運作都看左邊。
其實對于靜态方法，是不需要對象的。直接用類名調用即可。
十八、内部類通路特點
1，内部類可以直接通路外部類中的成員。
2，外部類要通路内部類，必須建立内部類的對象。
一把用于類的設計。
分析事物時，發現該事物描述中還有事物，而且這個事物還在通路被描述事物的内容。
這時就是還有的事物定義成内部類來描述。
class Outer
{
private static int num = 31;
class Inner// 内部類。
{
void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner in = new Inner();
in.show();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
// Outer out = new Outer();
// out.method();
//直接通路外部類中的内部類中的成員。
// Outer.Inner in = new Outer().new Inner();
// in.show();
//如果内部類是靜态的。 相當于一個外部類
// Outer.Inner in = new Outer.Inner();
// in.show();
//如果内部類是靜态的，成員是靜态的。
// Outer.Inner.function();
}
}
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(Outer.this.num);
}
}
void method()
{
new Inner().show();
}
}
class InnerClassDemo2
{
public static void main(String[] args)
{
new Outer().method();
}
}
十九、匿名内部類
就是内部類的簡寫格式。
必須有前提：
内部類必須繼承或者實作一個外部類或者接口。
匿名内部類：其實就是一個匿名子類對象。
格式：new 父類or接口(){子類内容}
abstract class Demo
{
abstract void show();
}
class Outer
{
int num = 4;
public void method()
{
//new Inner().show();
new Demo()//匿名内部類。
{
void show()
{
System.out.println("show ........"+num);
}
}.show();
}
}
class InnerClassDemo4
{
public static void main(String[] args)
{
new Outer().method();
}
}
二十、異常：是在運作時期發生的不正常情況
在java中用類的形式對不正常情況進行了描述和封裝對象。
描述不正常的情況的類，就稱為異常類。
以前正常流程代碼和問題處理代碼相結合，
現在将正常流程代碼和問題處理代碼分離。提高閱讀性.
其實異常就是java通過面向對象的思想将問題封裝成了對象.
用異常類對其進行描述。
不同的問題用不同的類進行具體的描述。 比如角标越界。空指針等等。
問題很多，意味着描述的類也很多，
将其共性進行向上抽取，形成了異常體系。
最終問題（不正常情況）就分成了兩大類。
Throwable:無論是error，還是異常，問題，問題發生就應該可以抛出，讓調用者知道并處理。
//該體系的特點就在于Throwable及其所有的子類都具有可抛性。
可抛性到底指的是什麼呢？怎麼展現可抛性呢？
其實是通過兩個關鍵字來展現的。
throws throw ,凡是可以被這兩個關鍵字所操作的類和對象都具備可抛性.
|--1，一般不可處理的。Error
特點：是由jvm抛出的嚴重性的問題。
這種問題發生一般不針對性處理。直接修改程式
|--2，可以處理的。Exception
該體系的特點：
子類的字尾名都是用其父類名作為字尾，閱讀性很想。
對于角标是整數不存在，可以用角标越界表示，
對于負數為角标的情況，準備用負數角标異常來表示。
負數角标這種異常在java中并沒有定義過。
那就按照java異常的建立思想，面向對象，将負數角标進行自定義描述。并封裝成對象。
這種自定義的問題描述成為自定義異常。
注意：如果讓一個類稱為異常類，必須要繼承異常體系，因為隻有稱為異常體系的子類才有資格具備可抛性。
才可以被兩個關鍵字所操作，throws throw
異常的分類：
1，編譯時被檢測異常:隻要是Exception和其子類都是，除了特殊子類RuntimeException體系。
這種問題一旦出現，希望在編譯時就進行檢測，讓這種問題有對應的處理方式。
這樣的問題都可以針對性的處理。
2，編譯時不檢測異常(運作時異常):就是Exception中的RuntimeException和其子類。
這種問題的發生，無法讓功能繼續，運算無法進行，更多是因為調用者的原因導緻的而或者引發了内部狀态的改變導緻的。
那麼這種問題一般不處理，直接編譯通過，在運作時，讓調用者調用時的程式強制停止,讓調用者對代碼進行修正。
是以自定義異常時，要麼繼承Exception。要麼繼承RuntimeException。
throws 和throw的差別。
1，throws使用在函數上。
throw使用在函數内。
2，throws抛出的是異常類，可以抛出多個，用逗号隔開。
throw抛出的是異常對象。
異常處理的原則：
1，函數内容如果抛出需要檢測的異常，那麼函數上必須要聲明。
否則必須在函數内用trycatch捕捉，否則編譯失敗。
2，如果調用到了聲明異常的函數，要麼trycatch要麼throws，否則編譯失敗。
3，什麼時候catch，什麼時候throws 呢？
功能内容可以解決，用catch。
解決不了，用throws告訴調用者，由調用者解決 。
4，一個功能如果抛出了多個異常，那麼調用時，必須有對應多個catch進行針對性的處理。
内部又幾個需要檢測的異常，就抛幾個異常，抛出幾個，就catch幾個。
異常的注意事項：
1，子類在覆寫父類方法時，父類的方法如果抛出了異常，
那麼子類的方法隻能抛出父類的異常或者該異常的子類。
2，如果父類抛出多個異常，那麼子類隻能抛出父類異常的子集。
簡單說：子類覆寫父類隻能抛出父類的異常或者子類或者子集。
注意：如果父類的方法沒有抛出異常，那麼子類覆寫時絕對不能抛，就隻能try
StringBuffer 與 StringBuilder：
1、StringBuffer 與 StringBuilder 功能一樣
2、StringBuffer線程同步，是以速度會慢些，線程安全；StringBuilder 線程非同步，通常用于單線程，速度會快些
3、StringBuffer jdk 1.0 出現；StringBuilder jdk 1.5出現
基本資料類型對象包裝類：
注意：
小于等于一個位元組，八位，不會重新開辟空間，是以 == 為true
泛型：泛型類、泛型方法、泛型接口
泛型定義在方法上，方法輸入的參數類型根據方法定義泛型來決定；若泛型直接修飾在方法參數上，則類型是根據泛型類的類型來判斷的。
注：
泛型接口：
實作接口的時候已經知道類型
實作接口的時候還沒知道類型
注：jdk 1.5 新特性之ForEach、可變參數、靜态導入