本篇博客寫的都是自己複習Java的時候所記錄的一些筆記(還是比較篇概念的內容)，所以可能內容不是很全面、或許也很雜，內容都是從基礎一點點往後增加的。
1.數據類型：由低級到高級轉型
(byte,char,short)-->int-->float-->long-->double-->boolean
/**
* 類型轉換 1.強制類型轉換:我就是要這麼幹 2.自動類型轉換:只能從小到大進行，無法逆
* 向,並且具有前後兼容性
*/2.數據類型所佔字節
byte 1字節 8位
char 2字節 16位
short 2字節 16位
int 4字節 32位
float 4字節 32位
long 8字節 64位
double 8字節 64位
boolean 1位3.二進制:計算機機器計算規則
好處:1.計算方便
2.運算規則簡單
3.適合邏輯運算
4.易於進行轉換
1.基本數據類型:
byte,char,short,int,float,long,double,boolean
2.引用數據類型: 對象類型
3.數組
堆內存,棧內存的區別:
1.棧內存運行速度快
2.堆內存體積大
3.棧內存主要存放基本數據類型,堆內存主要存放引用數據類型4. 變量
/**
* 局部變量：
* 定義在方法體內部的屬於局部變量,
* 這個變量只能在自身方法體內使用 一旦方法執行完成，
* 局部變量自動銷燬(如果方法是靜態方法，該局部變量不會銷燬) (存放於棧內存中)
* 成員變量: 作用於整個類 (存放於堆內存中)
* 靜態變量：作用於整個包
*/5.運算符
/**
* 加法是把左右兩邊的數據轉換成二進制進行運算
*
* 字符串連接符，不需要進行二進制轉換
*
* 字符串和任何數據類型進行連接操作（+），結果都是字符串類型
*/
/**
* j=i++; 先給j賦值。然後在自加1
* j=++i; 先i自加1，然後在給j賦值
*/
/**
* & : 一假爲假
* | : 一真爲真
* ^ : 相同爲假，不同爲真
* && : 前面的爲真時，後面的不執行
* || : 前面的爲真時，後面的不執行
* << : 左移位 運算速率快，但是隻能乘以2的n次方 （6<<n）---->n代表2的幾次方
* >> : 右移位 運算速率快，但是隻能除以2的n次方（這是整形之間的運算，需要取整）
*/6.選擇結構
/**
* switch語句
* 當判斷條件滿足時，沒有break的話會繼續執行下一條語句，並且不在進行判斷，
* 直到遇到break爲止
* 代碼先走case 語句 最後走default
*/
###7.while循環 /**
* while 循環
* 先判斷在執行
* do while
* 不論如何 do while 至少執行一次
*/
###8.for循環//初始表達式只執行一次，執行語句是在條件表達式之後執行。
for(初始表達式 ; 條件表達式 ; 循環後的表達式){
System.out.println("執行語句");
}
###9.面向對象 /**
* 使用匿名對象的時候。只有在掉了對象的行爲時纔有實際意義
* 調用屬性沒任何意義，並且都會在執行完畢之後被回收
*/
###10. 封裝 /** 封裝：是指隱藏對象的屬性實現細節，僅對外提供公共的訪問方式
* 特點：
* 1.安全性高
* 2.複用性強
* 3.便於使用
* 4.隔離變化
* 封裝的原則：將不需要對外提供的內容隱藏起來，把屬性隱藏，提供公共方法讓其訪問
*/
###11.構造函數 /**
* 靜態成員變量與非靜態成員變量之間的區別：
* 1.存放的位置不同
* 2.生命週期長短不同
* 3.靜態成員變量生命週期比非靜態成員變量長
* 什麼時候使用靜態：
* 1.當幾個對象之間具體共享的成員的時候
* 2.當幾個對像在初始化已經具備某些相同的屬性或行爲
* 靜態的好處：節省內存（單獨開闢一個空間，存靜態成員），方便使用：類名.靜態成員
* 壞處:訪問侷限性(靜態區域只能訪問靜態成員)
* ｛
* 構造代碼塊
* ｝
*/
//構造代碼塊：對對象進行初始化，運行在構造函數之前，對象一建立，立即運行，而且只能運行一次。靜態代碼塊優先於構造代碼塊
###12. 繼承子類繼承父類，就獲得了父類的屬性和行爲(private除外)
爲什麼要使用繼承： 1.提高代碼複用性 2.爲了多態的順利進行
繼承的關係是一種特殊的關係 子類 is a 父類
先有父類，再有子類，但是代碼中，父類是由多個子類進行抽取得到的。
###13.成員變量super：代表父類的對象
this ：代表本類對象
特殊情況：父類和子類沒有同名成員時，使用super和this都是指父類對象
加載子類的.class文件之前會優先加載父類的.class文件
###14.成員方法當子類和父類存在同名方法的時候：重寫（覆蓋）
這種覆蓋不是嚴格意義上的覆蓋，父類的方法在內存中還是存在的，
只不過這時候實例化的是子類對象，只能調用自身方法
重寫是爲了解決：當子類對象具備和父類相同的功能，
但是功能的內容不同時，我們可以用方法的重寫來重新定義子類的功能內容，並且保留了父類的方法定義。
重寫：提高了代碼的可擴展性
//重寫與重載的區別：1.方法的重載只看參數列表 2.重寫子類和父類的方法格式必須一模一樣
###15.構造方法在子類構造方法中會默認添加一個隱式語句,super();回調父類的構造函數
子類中每個構造函數都調用了一次父類的構造函數super();
爲什麼Java要這麼幹：在子類創建對象之前，必須明確父類初始化的內容，防止安全隱患
用了this()，super就不會默認被添加，因爲代碼最終還是會走super()。
super()必須出現在構造函數的第一行。
this()回調本類空參構造;
###16.抽象(abstract)這個功能不能含有方法體，因爲這裏面的功能存在很多模糊不清的東西。
特點：abstract能夠修飾類和方法，不能夠修飾變量
爲啥出現抽象：我們抽取的過程中發現很多子類的方法名字相同，但是實現的功能不一樣，我們父類無法對其進行描述，因爲它是模糊不清的，這個時候我們只抽取方法的名字，沒有方法體
特徵：1.抽象類不能被實例化，不能用new來創建對象
2.子類繼承抽象類，子類必須重寫抽象類中所有方法，不重寫也行，只不過這時候子類也成了抽象類
3.要想實例化抽象類，必須實例化重寫了其所有抽象方法的子類
4.子類要想真實存在，必須重寫所有抽象方法，因爲抽象類含有強制性
5.抽象類其實和一般類一樣，都是從子類向上抽取得到的。
//不同之處在於：1.抽象類一般情況下比一般類要多幾個抽象方法（HttpServlet它是一個抽象類，但是它沒有抽象方法，這麼做唯一的目的就是不讓其進行實例化操作）。2.抽象類不能被實例化
###17.接口(interface)方法都是抽象方法
成員格式固定： 成員變量：public static final
成員方法：public abstract
(修飾符可以不寫，系統會默認添加)
接口和抽象類一樣，不能被實例化，要想實例化接口，必須實例化一個類（實現了該接口）
在JVM中，接口的編譯生成的還是.class文件。
不支持多繼承的原因：父類可能含有同名方法，會出現安全隱患。但是在多實現過程中，不存這種說法，接口的方法本身就是不具備方法體，是模糊不清的，所以說實現多個接口的類不管到底實現了哪個接口的方法。
Java中可以同時進行實現接口和繼承，extends XXX implements XX
接口和接口的關係：繼承，可以多繼承
特點：
1. 是一種對外暴露的規則
2. 接口是程序功能的擴展
3. 接口可以多繼承
4. 接口與接口有繼承關係：多繼承
###18.多態：多種形態 有兩種：函數的多態，對象的多態對象的多態：一種事物的多種表現形態
父類的引用指向了子類的對象
1. 多態提高了代碼的擴展性
2. 使用的侷限性：不能使用子類特有的方法
###19.程序運行會有兩個過程：編譯過程和運行過程。（動態綁定，靜態綁定）(編譯看左邊，運行看右邊)
非靜態方法 編譯過程中：查看引用類型變量是否含有該方法
運行過程中：查看引用類型變量指向的對象方法
靜態方法 編譯過程和運行過程中：查看引用類型變量是否含有該方法
成員變量 編譯過程和運行過程中：查看引用類型變量是否含有該變量
20.內部類：一個類定義在另一個類的內部類
訪問內部類分兩種情況：
1.內部類所在外部類訪問
2.外部其他類訪問內部類
外部類.內部類 變量名 = 外部類對象.內部類對象
(Outer.Inner in = new Outer().new Inner())
內部類可以訪問外部類的所有成員，包括私有成員
不論內部類是否被封裝，外部類都能進行訪問
內部類的意義：1.爲了讓內部類對外部類所有成員具有訪問權限，
2.可以對內部類進行更好的封裝，要想訪問內部類對象，必須經過外部類的同意（外部類可以提供一個方法供其它類進行訪問）
當被static修飾的時候，可以直接使用外部類.內部類來創建對象。(Outer.Inner in = new Outer.new Inner()) 如果內部類中有靜態內容，那麼該類也必須是靜態的
內部類中調用外部類的成員，省略了：外部類.this
作爲局部變量存在，只能在當前所在區域內進行調用。不能靜態化
匿名內部類其實就是一種簡寫格式
定義匿名內部類的前提：內部類必須繼承一個類或者實現一個接口
###21. 進程和線程進程：是由系統創建的一個活動單元
線程：進程運行的最小單元，是由系統創建
CPU運行線程
線程的狀態：
1. 被創建
2. 運行
3. 睡眠
4. 等待
5. 阻塞
6. 銷燬
###22.實現Runnable的好處，打破了單繼承的侷限性，強烈使用實現而不使用繼承使用前提：
1. 必須是多個線程
2. 必須使用同一個鎖
線程鎖（synchronized）
synchronized (obj){ //obj—>鎖旗標
共享數據代碼塊
}
###23.確定一個線程是否安全？找出使用多線程運行代碼
- 是否操作了共享數據
操作共享是否會出現安全問題
同步方法：
因爲非靜態方法是被對象調用的，所以這個鎖就是自己對象本身this
靜態方法：JVM首先將.java編譯成.class，這時候.class是作爲對象存在，所以使用的鎖：類名.class
死鎖
解決單例模式–>懶漢式線程不安全的方法。
public class Single{
private Single(){}private static Single lhs = null; public static Single getInstance(){ if(lhs == null){ synchronized (Single.class){ if(lhs == null){ lhs = new Single(); } } } return lhs; }}
###24. 線程等待換醒機制wait(),notify()。必須持有鎖
必須同一個鎖
線程池：1.存放等待的線程
notify()：一般情況下跑到線程池去喚醒第一個等待的線程
wait(),notify()，notifyAll().這三個方法封裝在Object類中的原因：
這三個方法必須持有鎖，這個鎖是任意對象，在調用過程中，只有Object可以作爲任意對象的父類。所以封裝在Object類中，可以被任意鎖調用
###25.線程中的Interrupt()方法wait()、wait(long) 或 wait(long, int) 方法，或者該類的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法過程中受阻。
調用Interrupt()方法則其中斷狀態將被清除，它還將收到一個 InterruptedException。
//join();加入，優先執行，A線程加入B線程，優先執行A線程，A線程執行完畢，執行B線程，與除AB外其他線程無關。
###26.String解析(類類型)String str = "abc";//這樣寫是在常量池中開闢一個空間
String對象有一個特性：不可變(指的是對象)，賦值操作是針對該對象的引用進行的，讓該對象的引用指向其他內存地址
String str1 = "abc";
String str2 = new String("abc");
//區別：第一句：創建了一個對象
第二句：創建了兩個對象
equals()在String中對Object的方法進行了重寫，比較的是字符序列
###27.集合1. 集合可以存儲不同類型的數據
2. 集合長度可變
3. 集合用來存儲對象，對象是用來存儲數據
4. 集合裏面存放的都是對象的地址
List:它是有序的，可重複的，因爲他有索引
ArrayList：底層是數組結構，查詢快，增刪慢，它是線程不同步的
LinkedList：底層是鏈表結構，查詢慢，增刪快
Vector：底層是數組結構，它是被淘汰的
TreeSet:底層是樹狀結構
數據是按字典順序排列的
###28.集合泛型/**
* 泛型:廣泛的類型
* 在編寫代碼的過程中，使用集合強轉的時候可能會出現ClassCastException(類型轉換異常)
* 因爲在集合中存放的對象是任意的，使用對象的時候會有安全隱患
* JDK1.5之後出現了泛型
* 1.泛型好處在於:將程序運行時的異常轉換成編譯時的異常
* 方便程序員編寫代碼，提高代碼的安全性
* 2.避免了強轉操作
* 泛型的格式:<類型>
* 泛型的使用:在集合中使用的比較多,其實泛型的定義就是指定接收某一類型
*
* 泛型出現之前與出現之後的對比:
* 早期:定義Object去接收未知類型
* 現在:當需要使用的引用數據類型不確定的時候,使用泛型去作爲一個規則去接收數據(提高代碼的擴展性)
* 一旦這麼定義,該類中所有使用到了該泛型的方法都必須遵守這個規則
* 現在我想打破這個規則:
* 1.之前都是泛型類
* 2.可以使用泛型方法打破這個規則
* 當方法需要使用未知類型的引用數據的時候，如果在類上定義泛型，會造成使用的侷限性，爲了打破這個侷限性，
* 我們在方法中單獨定義泛型，讓該方法使用的泛型脫離類的控制
* 格式:修飾符 <泛型> 返回值 方法名(){}
* 靜態方法使用泛型:必須使用自己定義的泛型
*
* 泛型的高級應用:
* 佔位符: ?
* 泛型限定: ? extends Person 定義上限,向下擴展
* : ? super Person 定義下限，向上延伸
*
*/
```
29.Map集合
/**
* Map<K,V>:映射,鍵值對
* 一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值
* k--->key
* v--->value
* 1.containsKey(Object key) 查詢是否含有該鍵
* 2.containsValue(Object value) 查詢是否含有該值
* 3.get(Object key) 通過鍵查詢值
* 4.put(K key, V value) 添加
* 5.putAll(Map<? extends K,? extends V> m) 添加
* 6.V remove(Object key) 刪除映射的同時會拿到該映射的Value值
* 7.Collection<V> values() 拿到由該map中的值所組成的集合
* 8.replace(K key, V value) 修改該映射
*
* 需求，對map的映射進行修改，假設map存在一個映射關係 abc-->學生
* 將該映射修改爲 abc--->老師
*
* Map
* |--HashMap:底層是哈希表，null可以作爲鍵或者值,是線程不同步的(運行效率高)
* |--TreeMap:底層是二叉樹結構,會進行一個排序,是線程不同步的(運行效率高)
* |--HashTable:底層是哈希表，null不能作爲鍵或者值,是線程同步的(運行效率低)
*
* 需求:遍歷一個HashMap
* 特殊方法:
* 1. Set<K> keySet() 將map中所有的鍵取出並存入一個set集合中
* 2. Set<Map.Entry<K,V>> entrySet() 將map中的映射關係取出並存入一個set集合中
* Map.Entry<K,V>指的是一組鍵值對
*
* map是如何保證唯一性的:通過hashCode()和equals()兩個方法同時決定
*
* 需求:有5個學生，將學生的姓名(String name)
* 和地址(String add)存放進map中，形成映射
* 學生有姓名和年齡屬性,當姓名和年齡同時相等時，這是同一個學生，不存
*
* 當自己創建的類生成的作爲key存放進map的時候，需要重寫hashCode()和equals()方法
* 指定規則:什麼時候鍵重複
*/30. I/O流
/**
* I/O 流:I->Input O->Output
* I/O流：用於不同設備之間進行數據傳輸
* 用java書寫代碼進行的I/O傳輸
* I/O在java中的體現:存在一個體系:封裝在了IO包裏面
* 數據傳輸分爲:
* 字節流(數據以字節的形式進行傳輸):
*
* 字符流(數據以字節的形式進行傳輸):
* 都是操作文件,文本以字符爲主,創造出了字符流
*
* ascII(老美) A - 65 a - 97
*
* 漢字:GB2312編碼表(存放了幾千個漢字)
* 漢字:GBK編碼表(收納了幾萬個漢字)
* 漢字:18030編碼表(56個名族)
*
* 國際碼錶:utf-8(unicode)
*
* 字符流是基於字節流:只所以要使用字符流:方便
*
* IO包:有四個基類
* 字節流基類:InputStream,OutputStream
* 字符流基類:Reader,Writer
*
* 會有很多子類:FileInputStream
* (以當前基類名字爲後綴,前面的名字代碼的是具體的操作對象)
* FileReader
* (以當前基類名字爲後綴,前面的名字代碼的是具體的操作對象)
*/
/**
* IO流: new FileWriter(fileName);這個構造方法:
* 假如該文件存在於當前目錄下，則新建一個該名字的文件，
* 並且把之前那個文件覆蓋掉 不論如何，都會新建一個文件
* 在調用該構造方法的時候:如果指定路徑不存在，則會產生FileNotFoundExeception
*/