java面向對象
*.Java中的原生數據類型共有8種：
1） 整型：使用int表示。（32位）（表示範圍 -2147483648~2147483648）
2） 字節型：使用byte表示。（表示-128～127之間的256個整數， 8位）。
3）短整型：使用short表示。（16位）（表示範圍 -32768 ~ 32768）
4）長整型：使用long表示。（64位）（表示範圍 -9233372036854477808~9233372036854477808）
5）單精度浮點型：使用float表示。（32位）（表示範圍-3.40292347E+38~3.40292347E+38 ）
6）雙精度浮點型：使用double表示。（64位）（表示範圍-1.79769313486231570E+308~1.79769313486231570E+308）
7）字符型：使用char表示（char是character的縮寫）。所謂字符，就是單個的字符表示。（16位）（表示範圍 ‘ \u0000 - u\ffff ’ ）
8）布爾類型，使用boolean表示。布爾類型只有兩種可能值，分別是true與false。（1位）
*.當有若干個變量參與運算時，結果類型取決於這些變量中表示範圍最大的那個變量類型。比如，參與運算的變量中，有整型int，有雙精度浮點型double，有短整型short，那麼最後的結果類型就是double。
*. break語句：經常用在循環語句中，用於跳出整個循環，執行循環後面的代碼。
*. continue語句：經常用在循環語句中，用於跳出當前的這個循環（或者是跳出本次循環），開始下一次循環的執行。
*.成員變量與局部變量的聯繫與區別：
a) 無論是成員變量還是局部變量，使用前都需要聲明（定義）。
b) 對於局部變量來說，使用前必須要初始化；對於成員變量來說，使用前可以不初始化。如果沒有初始化成員變量就開始使用，那麼每個類型的成員變量都有一個默認的初始值
i. byte、short、int、long類型的初始值爲0
ii. float、double類型的初始值爲0.0
iii. char類型的初始值‘\u0000’
iv. boolean類型的初始值爲false
1.訪問修飾符（access modifier）
1） public（公共的）：被public所修飾的屬性和方法可以被所有類訪問。
2） protected（受保護的）：被protected所修飾的屬性和方法可以在類內部、相同包以及該類的子類所訪問。
3） private（私有的）：被private所修飾的屬性和方法只能在該類內部使用
4） 默認的（不加任何訪問修飾符）：在類內部以及相同包下面的類所使用。
2. instanceof： 判斷某個對象是否是某個類的實例。語法形式：引用名 instanceof 類名（接口名），返回一個boolean值。
3. 相等性的比較（==）
1） 對於原生數據類型來說，比較的是左右兩邊的值是否相等。
2） 對於引用類型來說，比較左右兩邊的引用是否指向同一個對象，或者說左右兩邊的引用地址是否相同。
4. equals()方法，該方法定義在Object類當中，因此Java中的每個類都具有該方法，對於Object類的equals()方法來說，它是判斷調用equals()方法的引用與傳進來的引用是否一致，即這兩個引用是否指向的是同一個對象。對於Object類的equals()方法來說，它等價於==。
5. 對於String類的equals()方法來說，它是判斷當前字符串與傳進來的字符串的內容是否一致。
6. 對於String對象的相等性判斷來說，請使用equals()方法，而不要使用==。
7. String是常量，其對象一旦創建完畢就無法改變。當使用+拼接字符串時，會生成新的String對象，而不是向原有的String對象追加內容。
8. String Pool（字符串池）
9. String s = “aaa”;（採用字面值方式賦值）
1) 查找String Pool中是否存在“aaa”這個對象，如果不存在，則在String Pool中創建一個“aaa”對象，然後將String Pool中的這個“aaa”對象的地址返回來，賦給引用變量s，這樣s會指向String Pool中的這個“aaa”字符串對象
2) 如果存在，則不創建任何對象，直接將String Pool中的這個“aaa”對象地址返回來，賦給s引用。
10. String s = new String(“aaa”);
1) 首先在String Pool中查找有沒有“aaa”這個字符串對象，如果有，則不在String Pool中再去創建“aaa”這個對象了，直接在堆中（heap）中創建一個“aaa”字符串對象，然後將堆中的這個“aaa”對象的地址返回來，賦給s引用，導致s指向了堆中創建的這個“aaa”字符串對象。
2) 如果沒有，則首先在String Pool中創建一個“aaa“對象，然後再在堆中（heap）創建一個”aaa“對象，然後將堆中的這個”aaa“對象的地址返回來，賦給s引用，導致s指向了堆中所創建的這個”aaa“對象。
11.當final修飾一個原生數據類型時，表示該原生數據類型的值不能發生變化（比如說不能從10變爲20）；如果final修飾一個引用類型時，表示該引用類型不能再指向其他對象了，但該引用所指向的對象的內容是可以發生變化的。
12. static代碼塊：靜態代碼塊。靜態代碼塊的作用也是完成一些初始化工作。首先執行靜態代碼塊，然後執行構造方法。靜態代碼塊在類被加載的時候執行，而構造方法是在生成對象的時候執行；要想調用某個類來生成對象，首先需要將類加載到Java虛擬機上（JVM），然後由JVM加載這個類來生成對象。
13. 類的靜態代碼塊只會執行一次，是在類被加載的時候執行的，因爲每個類只會被加載一次，所以靜態代碼塊也只會被執行一次；而構造方法則不然，每次生成一個對象的時候都會調用類的構造方法，所以new一次就會調用構造方法一次。
14. 如果繼承體系中既有構造方法，又有靜態代碼塊，那麼首先執行最頂層的類的靜態代碼塊，一直執行到最底層類的靜態代碼塊，然後再去執行最頂層類的構造方法，一直執行到最底層類的構造方法。注意：靜態代碼塊只會執行一次。
15.靜態的只能訪問靜態的；非靜態的可以訪問一切。不能在靜態方法中使用this關鍵字。
16. 關於繼承的注意事項
a) 構造方法不能被繼承
b) 方法和屬性可以被繼承
c) 子類的構造方法隱式地調用父類的不帶參數的構造方法
d) 當父類沒有不帶參數的構造方法時，子類需要使用super來顯
式地調用父類的構造方法，super指的是對父類的引用
e) super關鍵字必須是構造方法中的第一行語句。
17.new關鍵字在生成對象時完成了三件事情：
a) 爲對象開闢內存空間。
b) 調用類的構造方法。
c) 將生成的對象的地址返回。
18.關於方法參數傳遞的總結：對於Java中的方法參數傳遞，無論傳遞的是原生數據類型還是引用類型，統一是傳值（pass by value）。
java集合
1.集合中存放的依然是對象的引用而不是對象本身。
2. ArrayList底層採用數組實現，當使用不帶參數的構造方法生成ArrayList對象時，實際上會在底層生成一個長度爲10的Object類型數組
3.如果增加的元素個數超過了10個，那麼ArrayList底層會新生成一個數組，長度爲原數組的1.5倍+1，然後將原數組的內容複製到新數組當中，並且後續增加的內容都會放到新數組當中。當新數組無法容納增加的元素時，重複該過程。
4. 對於ArrayList元素的刪除操作，需要將被刪除元素的後續元素向前移動，代價比較高。
5. 集合當中只能放置對象的引用，無法放置原生數據類型，我們需要使用原生數據類型的包裝類才能加入到集合當中。
6. 集合當中放置的都是Object類型，因此取出來的也是Object類型，那麼必須要使用強制類型轉換將其轉換爲真正的類型（放置進去的類型）。
7. 關於ArrayList與LinkedList的比較分析
a) ArrayList底層採用數組實現，LinkedList底層採用雙向鏈表實現。
b) 當執行插入或者刪除操作時，採用LinkedList比較好。
c) 當執行查找操作時，採用ArrayList比較好。
8. 當向ArrayList添加一個對象時，實際上就是將該對象放置到了ArrayList底層所維護的數組當中；當向LinkedList中添加一個對象時，實際上LinkedList內部會生成一個Entry對象，該Entry對象的結構爲：
Entry
{
Entry previous;
Object element;
Entry next;
}
其中的Object類型的元素element就是我們向LinkedList中所添加的元素，然後Entry又構造好了向前與向後的引用previous、next，最後將生成的這個Entry對象加入到了鏈表當中。換句話說，LinkedList中所維護的是一個個的Entry對象。
9. 關於Object類的equals方法的特點
a) 自反性：x.equals(x)應該返回true
b) 對稱性：x.equals(y)爲true，那麼y.equals(x)也爲true。
c) 傳遞性：x.equals(y)爲 true並且y.equals(z)爲true，那麼x.equals(z)也應該爲true。
d) 一致性：x.equals(y)的第一次調用爲true，那麼x.equals(y)的第二次、第三次、第n次調用也應該爲true，前提條件是在比較之間沒有修改x也沒有修改y。
e) 對於非空引用x，x.equals(null)返回false。
10. 關於Object類的hashCode()方法的特點：
a) 在Java應用的一次執行過程當中，對於同一個對象的hashCode方法的多次調用，他們應該返回同樣的值（前提是該對象的信息沒有發生變化）。
b) 對於兩個對象來說，如果使用equals方法比較返回true，那麼這兩個對象的hashCode值一定是相同的。
c) 對於兩個對象來說，如果使用equals方法比較返回false，那麼這兩個對象的hashCode值不要求一定不同（可以相同，可以不同），但是如果不同則可以提高應用的性能。
d) 對於Object類來說，不同的Object對象的hashCode值是不同的（Object類的hashCode值表示的是對象的地址）。
11.關於Object類的toString()方法的特點：
a)當一個Object實例被轉化成String時，Java就會自動調用toString()方法返回一個String。
b)toString()方法是Object類提供的一個特殊的自述方法，調用該方法將返回對象實現類的類名+@+hashCode的組合字符串。其內容如：return getClass().getName() + "@" + Integer.toHexString(hashCode());
12. 當使用HashSet時，hashCode()方法就會得到調用，判斷已經存儲在集合中的對象的hash code值是否與增加的對象的hash code值一致；如果不一致，直接加進去；如果一致，再進行equals方法的比較，equals方法如果返回true，表示對象已經加進去了，就不會再增加新的對象，否則加進去。
13. 如果我們重寫equals方法，那麼也要重寫hashCode方法，反之亦然。
14. Map（映射）：Map的keySet()方法會返回key的集合，因爲Map的鍵是不能重複的，因此keySet()方法的返回類型是Set；而Map的值是可以重複的，因此values()方法的返回類型是Collection，可以容納重複的元素。
15. HashSet底層是使用HashMap實現的。當使用add方法將對象添加到Set當中時，實際上是將該對象作爲底層所維護的Map對象的key，而value則都是同一個Object對象（該對象我們用不上）；
16. HashMap底層維護一個數組，我們向HashMap中所放置的對象實際上是存儲在該數組當中；
17. 當向HashMap中put一對鍵值時，它會根據key的hashCode值計算出一個位置，該位置就是此對象準備往數組中存放的位置。
18. 如果該位置沒有對象存在，就將此對象直接放進數組當中；如果該位置已經有對象存在了，則順着此存在的對象的鏈開始尋找（Entry類有一個Entry類型的next成員變量，指向了該對象的下一個對象），如果此鏈上有對象的話，再去使用equals方法進行比較，如果對此鏈上的某個對象的equals方法比較爲false，則將該對象放到數組當中，然後將數組中該位置以前存在的那個對象鏈接到此對象的後面。
java反射
1. Java中，無論生成某個類的多少個對象，這些對象都會對應於同一個Class對象，要想使用反射，首先需要獲得待處理類或對象所對應的Class對象。
2. 獲取某個類或某個對象所對應的Class對象的常用的3種方式：
a) 使用Class類的靜態方法forName：Class.forName(“java.lang.String”);
b) 使用類的.class語法：String.class;
c) 使用對象的getClass()方法：String s = “aaa”; Class<?> clazz = s.getClass();
3. 若想通過類的不帶參數的構造方法來生成對象，我們有兩種方式：
a) 先獲得Class對象，然後通過該Class對象的newInstance()方法直接生成即可：
Class<?> classType = String.class;
Object obj = classType.newInstance();
b) 先獲得Class對象，然後通過該對象獲得對應的Constructor對象，再通過該Constructor對象的newInstance()方法生成：
Class<?> classType = Student.class;
Constructor cons = classType.getConstructor(new Class[]{});
Object obj = cons.newInstance(new Object[]{});
4. 若想通過類的帶參數的構造方法生成對象，只能使用下面這一種方式：
Class<?> classType = Student.class;
Constructor cons = classType.getConstructor(new Class[]{String.class, int.class});
Object obj = cons.newInstance(new Object[]{“nihao”, 5});
5. Integer.TYPE返回的是int，而Integer.class返回的是Integer類所對應的Class對象。
java異常
1. Java中的異常分爲兩大類：
a) Checked exception （非 Runtime Exception）
b) Unchecked exception（Runtime Exception）
2. Java中所有的異常類都會直接或間接地繼承自Exception。
3. RuntimeException類也是直接繼承自Exception類，它叫做運行時異常，Java中所有的運行時異常都會直接或間接地繼承自RuntimeException。
4. Java中凡是繼承自Exception而不是繼承自RuntimeException的類都是非運行時異常。
5. 所謂自定義異常，通常就是定義了一個繼承自Exception類的子類，那麼這個類就是一個自定義異常類。通常情況下，我們都會直接繼承自Exception類，一般不會繼承某個運行時的異常類。
6. 我們可以使用多個catch塊來捕獲異常，這時需要將父類型的catch塊放到子類型的catch塊之後，這樣才能保證後續的catch可能被執行，否則子類型的catch將永遠無法到達，Java編譯器會報編譯錯誤；如果多個catch塊的異常類型是獨立的(MyException, MyException2)， 那麼誰前誰後都是可以的。
7. 如果try塊中存在return語句，那麼首先也需要將finally塊中的代碼執行完畢，然後方法再返回。
8. 如果try塊中存在System.exit(0)語句，那麼就不會執行finally塊中的代碼，因爲System.exit(0)會終止當前運行的Java虛擬機，程序會在虛擬機終止前結束執行。
java內部類
1. 內部類（Inner Class），內部類共分爲4種。
2. 靜態內部類（static inner class）：只能訪問外部類的靜態成員變量與靜態方法，生成靜態內部類對象的方式爲：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
3. 成員內部類（member inner class）：可以訪問外部類的靜態與非靜態的方法與成員變量。生成成員內部類對象的方式爲：
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
4. 若想在局部內部類中訪問外部類的成員變量，語法爲：OuterClass.this.a;
5. 局部內部類（Local Inner Class）：定義在方法當中，只能訪問方法中聲明的final類型的變量。
6. 匿名內部類（Anonymous Inner Class）：匿名內部類會隱式地繼承一個父類或實現一個接口。
java線程
1.進程：執行中的程序（程序是靜態的概念，進程是動態的概念）。
2.線程的實現有三種方式
(1)繼承Thread類，重寫run函數創建：class xx extends Thread{ public void run(){Thread.sleep(1000) //線程休眠1000毫秒，sleep使線程進入Block狀態，並釋放資源}}開啓線程：對象.start() //啓動線程，run函數運行。
(2)實現Runnable接口，重寫run函數開啓線程：Thread t = new Thread(對象) //創建線程對象t.start()
(3)實現Callable接口，重寫call函數Callable是類似於Runnable的接口，實現Callable接口的類和實現Runnable的類都是可被其它線程執行的任務。 Callable和Runnable有幾點不同:①Callable規定的方法是call()，而Runnable規定的方法是run(). ②Callable的任務執行後可返回值，而Runnable的任務是不能返回值的③call()方法可拋出異常，而run()方法是不能拋出異常的。 ④運行Callable任務可拿到一個Future對象，Future表示異步計算的結果。它提供了檢查計算是否完成的方法,以等待計算的完成,並檢索計算的結果.通過Future對象可瞭解任務執行情況,可取消任務的執行,還可獲取任務執行的。
3.Thread類和Runnable接口
1) Thread類也實現了Runnable接口，因此實現了Runnable接口中的run方法；
2) 當生成一個線程對象時，如果沒有爲其設定名字，那麼線程對象的名字將使用如下形式：Thread-number,該number將是自動增加的，並被所有的Thread對象所共享（因爲它是static的成員變量）。
3) 當使用第一種方式來生成線程對象時，我們需要重寫run方法，因爲Thread類的run方法此時什麼事情也不做。
4) 當使用第二種方式來生成線程對象時，我們需要實現Runnable接口的run方法，然後使用new Thread(new MyThread())（假如MyThread已經實現了Runnable接口）來生成線程對象，這時的線程對象的run方法就會調用MyThread類的run方法，這樣我們自己編寫的run方法就執行了。
4. 關於成員變量與局部變量：如果一個變量是成員變量，那麼多個線程對同一個對象的成員變量進行操作時，他們對該成員變量是彼此影響的（也就是說一個線程對成員變量的改變會影響到另一個線程）。
5. 如果一個變量是局部變量，那麼每個線程都會有一個該局部變量的拷貝，一個線程對該局部變量的改變不會影響到其他的線程。
6. 停止線程的方式：不能使用Thread類的stop方法來終止線程的執行。一般要設定一個變量，在run方法中是一個循環，循環每次檢查該變量，如果滿足條件則繼續執行，否則跳出循環，線程結束。
7. 不能依靠線程的優先級來決定線程的執行順序。
8. synchronized關鍵字：當synchronized關鍵字修飾一個方法的時候，該方法叫做同步方法。
9. Java中的每個對象都有一個鎖（lock）或者叫做監視器（monitor），當訪問某個對象的synchronized方法時，表示將該對象上鎖，此時其他任何線程都無法再去訪問該synchronized方法了，直到之前的那個線程執行方法完畢後（或者是拋出了異常），那麼將該對象的鎖釋放掉，其他線程纔有可能再去訪問該synchronized方法。
10. 如果某個synchronized方法是static的，那麼當線程訪問該方法時，它鎖的並不是synchronized方法所在的對象，而是synchronized方法所在的對象所對應的Class對象，因爲Java中無論一個類有多少個對象，這些對象會對應唯一一個Class對象，因此當線程分別訪問同一個類的兩個對象的兩個static，synchronized方法時，他們的執行順序也是順序的，也就是說一個線程先去執行方法，執行完畢後另一個線程纔開始執行。
11.如果一個對象有多個synchronized方法，某一時刻某個線程已經進入到了某個synchronized方法，那麼在該方法沒有執行完畢前，其他線程是無法訪問該對象的任何synchronized方法的。
12. synchronized塊，寫法：
synchronized(object)
{
}
表示線程在執行的時候會對object對象上鎖。
13. synchronized方法是一種粗粒度的併發控制，某一時刻，只能有一個線程執行該synchronized方法;synchronized塊則是一種細粒度的併發控制，只會將塊中的代碼同步，位於方法內、synchronized塊之外的代碼是可以被多個線程同時訪問到的。
14. 死鎖（deadlock）
15 wait與notify方法都是定義在Object類中，而且是final的，因此會被所有的Java類所繼承並且無法重寫。這兩個方法要求在調用時線程應該已經獲得了對象的鎖，因此對這兩個方法的調用需要放在synchronized方法或塊當中。當線程執行了wait方法時，它會釋放掉對象的鎖。
16. 另一個會導致線程暫停的方法就是Thread類的sleep方法，它會導致線程睡眠指定的毫秒數，但線程在睡眠的過程中是不會釋放掉對象的鎖的。
java 文件
1. 一個類若想被序列化，則需要實現java.io.Serializable接口，該接口中沒有定義任何方法，是一個標識性接口（Marker Interface），當一個類實現了該接口，就表示這個類的對象是可以序列化的。
2. 在序列化時，static變量是無法序列化的；如果A包含了對B的引用，那麼在序列化A的時候也會將B一併地序列化；如果此時A可以序列化，B無法序列化，那麼當序列化A的時候就會發生異常，這時就需要將對B的引用設爲transient，該關鍵字表示變量不會被序列化。
3. 當我們在一個待序列化/反序列化的類中實現了以上兩個private方法（方法聲明要與上面的保持完全的一致），那麼就允許我們以更加底層、更加細粒度的方式控制序列化/反序列化的過程。
4.java紅的淺克隆與深克隆
淺複製（淺克隆）：被複制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之，淺複製僅僅複製所考慮的對象，而不復制它所引用的對象。
深複製（深克隆）：被複制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被複制過的新對象，而不再是原有的那些被引用的對象。換言之，深複製把要複製的對象所引用的對象都複製了一遍。
Java的clone()方法【定義在Object類中】
–clone方法將對象複製了一份並返回給調用者。一般而言，clone（）方法滿足：
–①對任何的對象x，都有x.clone() !=x
.克隆對象與原對象不是同一個對象
–②對任何的對象x，都有x.clone().getClass()= =x.getClass()
.克隆對象與原對象的類型一樣
–③如果對象x的equals()方法定義恰當，那麼x.clone().equals(x)應該成立。
Java中對象的克隆
–①爲了獲取對象的一份拷貝，我們可以利用Object類的clone()方法。
–②在派生類中覆蓋基類的clone()方法，並聲明爲public【Object類中的clone()方法爲protected的】。
–③在派生類的clone()方法中，調用super.clone()。
–④在派生類中實現Cloneable接口。
說明：
–①爲什麼我們在派生類中覆蓋Object的clone()方法時，一定要調用super.clone()呢？
.在運行時刻，Object中的clone()識別出你要複製的是哪一個對象，然後爲此對象分配空間，並進行對象的複製，將原始對象的內容一一複製到新對象的存儲空間中。
–②繼承自java.lang.Object類的clone()方法是淺複製。