學習java的雜亂筆記

1.局部變量：定義在方法中的變量，定義在方法中的參數的變量，定義在for循環中變量，都是局部變量，
在棧內存中開闢一個空間，數據使用完畢，自動釋放。

2.何定義一個函數？（不須要死記，只需瞭解）
1.既然函數是一個獨立的功能，那麼該功能的運算結果是什麼要先明確。
是在明確函數的返回值類型
2.在明肯定義該功能的過程當中是否須要未知的內容參與運算。
明確函數的參數列表（參數的類型和參數的個數）

3.break:只可做用於選擇結構與循環結構。
continue：只可做用於循環(loop)結構,結束本次循環，繼續下次循環。
continue與break若是沒有該有的做用域而單獨存在，則沒有意義，語句編譯失敗

4.能夠以字母爲標號，給for循環標號，也只能給for循環標號！！便於區分

5.累加思想：
經過變量記錄住每次變化的結果，經過循環的形式，進行累加操做。
計數器思想
經過一個變量記錄住數據的狀態變化，也須要經過循環來實現

6.何時動用重載？重載與返回值類型無關
當定義的功能相同時，但其中參與運算的未知內容不一樣時，
那麼就定義一個函數名稱以表示其功能，方便閱讀，而經過參數列表的不一樣來區分多個同名函數
注意：參數列表中參數是有順序的！！！！！！！！

7.函數定義思想：每一個函數只須要完成他所須要的功能就能夠，不須要多餘的動做，列如求和語句
只須要完成求和並返回就能夠，而不要進行多餘的打印輸出語句，每一個函數都是獨立的
只需完成應完成的定義，不須要多餘的的定義，若是須要，那也是調用者所幹的事，每一個函數
則只要返回就可。

8.一：變量都有本身的做用域，對於for循環來說，若是將控制循環的增量定義在for語句中，變量只在該循環內有效，
當for語句執行完畢，該變量就會在內存中被釋放
二：for循環能夠與while語句互換，若是須要定義循環變量，則for循環更爲合理

9.轉義字符：經過\來轉變-後面-字母或符號的含義。
\n:換行；
\b:退格，至關於BackSpace;
\r:按下回車鍵，在windows系統，回車鍵是由兩個字符來表示\r,\n
在Linux系統，回車鍵只由一個字符表示
\t:製表符，至關於tab鍵

10. 堆內存中每個實體都有一個內存地址值，或有或無的被棧內存中的定義變量所含的地址值所引用，而不是直接表明

11.數組角標從零開始，並且數組一被定義就都有值且默認值爲0.

12.堆內存中的實體都是封裝數據的，且都有默認初始化值

13.面向對象的三個特徵：1，封裝；2，繼承；3，多態；

14.對象與類的區別：
類是對現實生活中事物的描述。
對象是這類事物實實在在存在的個體。

15,其實定義類就是在描述事物，就是在定義屬性與行爲；屬性與行爲共同稱爲類中的成員（成員變量和成員方法）；

16，類類型變量指向對象

17，成員變量與局部變量的區別：
做用範圍：
成員變量做用於整個類中，
局部變量做用於函數中或語句中；
在內存中的位置：
成員變量在堆內存中，由於對象的存在，纔在內存中存在；
局部變量存在在棧內存中。

18,private:私有，權限修飾符，用於修飾類中的成員(成員變量，成員函數)。私有隻在本類中有效
將成員變量私有化，對外提供set get方法對其進行訪問，提升對數據訪問的安全性
注意：私有僅僅只是封裝的一種形式，私有是封裝，但封裝不是私有

19，構造函數的定義：
1.函數名要與類名一致
2.不用定義返回值類型
3.不用寫return語句
對象一創建就會調用與之對應的構造函數
構造函數能夠用於對象進行初始化
細節：當一個類中沒有定義構造函數時，那麼系統會默認會給該類加入一個空參數的構造函數
方便於該類進行初始化，當在類中自定義了構造函數後，默認的構造函數就沒了
構造函數與通常函數的區別：
1.在寫法上不一樣
2.在運行上不一樣
構造函數就是在對象一創建就運行，給對象初始化
通常函數是在對象調用才執行，給對象添加對象具有的功能
一個對象創建，構造函數只運行一次
通常函數能夠被對象調用不少次
何時定義構造函數：
當分析事物時，該事物存在即具有一些特性或者行爲，那麼將那些內容定義在構造函數中
一個類中默認會有一個空參數的構造函數，這個默認的構造函數的權限與所屬類一致
若是類被public修飾，那麼默認的構造函數也帶public修飾符
若是類沒被public修飾，那麼默認的構造函數也沒有public修飾

默認的構造函數的權限是隨着類的變化而變化的

20.構造代碼塊：做用：給對象進行初始化
對象一創建就運行，並且優先於構造函數執行
與構造函數的區別：
構造代碼塊是給全部對象進行統一初始化
而構造函數時給對應的對象初始化。
構造代碼塊中定義的是不一樣對象共性的初始化內容

new xxx(); 其中先默認初始化，null或者0等，顯示初始化，再構造代碼塊初始化，再構造函數初始化，有前後順序

21.this關鍵字：
表明它所在函數所屬對象的引用
簡單說：那個對象在調用this所在函數，this就表明那個對象
this的應用：當定義類中功能時，該函數內部都要用到調用該函數的對象時，這時用this來表示這個對象
但凡本類功能內部使用了本類對象，都要用this表示
this的功能：1.用以區分局部變量和成員變量的同名狀況。
2.用於構造函數之間進行互相調用。
注意：this語句只能定義在構造函數的第一行，由於初始化要先執行，不然會報錯
對this的調用必須是構造器中的第一個語句。

22.java中有堆內存，棧內存，以及方法區（共享區，數據區）；

23.static關鍵字：
用法：是一個修飾符，用於修飾成員（成員變量，成員函數）；
當成員被靜態修飾後，就多了一種調用方式，除了能夠被對象調用外，
還能夠直接被類名調用，方式：類名.靜態成員

定義的靜態的成員變量又稱類變量，類被調用就執行

成員變量又稱實例變量

static特色：
1.隨着類的加載而加載。
也就是說，靜態會隨着類的消失而消失，說明它的生命週期最長。

2.優先於對象存在
明確一點，靜態是先存在，對象是後存在

3.被全部對象所共享

4.能夠直接被類名調用

實例對象和類變量的區別：
1.存放位置：
類變量隨着類的加載而存在於方法區中
實例對象隨着對象的創建而存在於對堆內存中
2.生命週期：
類變量生命週期最長，隨着類的消失而消失
實例變量聲明週期隨着對象的消失而消失

靜態的使用注意事項：
1.靜態方法只能訪問靜態成員。
非靜態方法既能夠訪問靜態，也能夠訪問非靜態
2.靜態方法中不能夠定義this,super關鍵字
由於靜態優先於對象存在，因此靜態方法中不能夠出項this
3.主函數是靜態的

靜態有利有弊：
利處：對對象的共享數據進行單獨空間的存儲，節省空間，沒有必要每個對象都存儲一份，
能夠直接被類名調用
弊處：生命週期過長。
訪問出現侷限性（靜態只能訪問靜態、。；

24.何時使用靜態？
要從兩方面下手：
由於靜態修飾的內容有成員變量和成員函數。
何時定義靜態變量（類變量）？
當對象中出現共享數據時，該數據被靜態所修飾
對象中的特有數據要定義成非靜態存在於堆內存中。

何時定義靜態函數？
當功能內部沒有訪問到非靜態數據（對象的特有數據）
那麼該功能能夠定義成靜態的。

25.文檔註釋的特殊字符：
@auther 做者
@version 版本號
@param 參數
@return 返回值

26.Person p =new Person("張三"，20)；

該句話都作了什麼事？
1.由於new用到了Person.class.因此會先找到Person.class文件並加載到內存中。
2.執行該類中的static代碼塊，若是有的話，給Person.class類進行初始化。
3.在堆內存中開闢空間，分配內存地址。
4.在堆內存中創建對象的特有屬性，並進行默認初始化。
5.對屬性進行顯示初始化。
6.對對象進行構造代碼塊初始化
7.對對象進行對應的構造函數初始化。
8將內存地址賦給棧內存中的p變量。

27.事物不只僅只有繼承關係，還有彙集：聚合和組合。

28.子類的實例化過程：（逐級向上找）

子類中的全部構造函數默認都會訪問父類中的空參數構造函數，由於子類構造函數
中的第一行都有一句隱式的super語句。

當父類中沒有空參數的構造函數時，子類必須手動經過super語句形式來指定要訪問的父類中的構造函數，

固然，子類中的構造函數第一行也能夠手動指定this語句來訪問本類中的構造函數，子類中至少會有一個構造函數會訪問
父類中的構造函數。

注意：this和super語句不能在一個函數中，由於兩個函數都必須在第一行，
而爲何this和super語句爲何在第一行，由於兩個語句要進行初始化，若是不在第一行，
初始化沒有意義。

29.什麼是模板方法
在定義功能時，有一部分功能是肯定的，而有另外一部分功能是不肯定的，並且肯定的功能在使用不肯定的功能時，
能夠將不肯定的功能暴露出去，由子類進行覆寫。
30.public，protected，private是Java裏用來定義成員的訪問權限的，另外還有一種是「default」，也就是在成員前不加任何權限修飾符。如：
public class A{
void method(){};
}
method就屬於default權限。

這四個修飾符的訪問權限以下表:
-----------------------------------------------
類內部 package內 子類 其餘
public 容許 容許 容許 容許
protected 容許 容許 容許 不容許
default 容許 容許 不容許 不容許
private 容許 不容許 不容許 不容許
-----------------------------------------------

好比：用protected修飾的成員（變量或方法），在類內部能夠調用，同一個package下的其餘類也能夠調用，子類裏也能夠調用，其餘地方則不能夠調用，
也就是說在其餘

Java語言定義了public、protected、private、abstract、static和final這6經常使用修飾
詞外還定義了5個不太經常使用的修飾詞，下面是對這11個Java修飾詞的介紹：
1.public
使用對象：類、接口、成員
介紹：不管它所處在的包定義在哪，該類（接口、成員）都是可訪問的
2.private
使用對象：成員
介紹：成員只能夠在定義它的類中被訪問
3.static
使用對象：類、方法、字段、初始化函數
介紹：成名爲static的內部類是一個頂級類，它和包含類的成員是不相關的。靜態方法
是類方法，
是被指向到所屬的類而不是類的實例。靜態字段是類字段，不管該字段所在的類建立了
多少實例，該字
段只存在一個實例被指向到所屬的類而不是類的實例。初始化函數是在裝載類時執行
的，而不是在建立
實例時執行的。
4.final
使用對象：類、方法、字段、變量
介紹：被定義成final的類不容許出現子類，不能被覆蓋（不該用於動態查詢），字段值
不容許被
修改。
5.abstract
使用對象：類、接口、方法
介紹：類中包括沒有實現的方法，不能被實例化。若是是一個abstract方法，則方法體
爲空，該方
法的實如今子類中被定義，而且包含一個abstract方法的類必須是一個abstract類
6.protected
使用對象：成員
介紹：成員只能在定義它的包中被訪問，若是在其餘包中被訪問，則實現這個方法的類
必須是該成
員所屬類的子類。
7.native
使用對象：成員
介紹：與操做平臺相關，定義時並不定義其方法，方法的實現被一個外部的庫實現。
8.strictfp
使用對象：類、方法
介紹：strictfp修飾的類中全部的方法都隱藏了strictfp修飾詞，方法執行的全部浮點
計算遵照
IEEE 754標準，全部取值包括中間的結果都必須表示爲float或double類型，而不能利用
由本地平臺浮
點格式或硬件提供的額外精度或表示範圍。
9.synchronized
使用對象：方法
介紹：對於一個靜態的方法，在執行以前jvm把它所在的類鎖定；對於一個非靜態類的方
法，執行
前把某個特定對象實例鎖定。
10.volatile
使用對象：字段
介紹：由於異步線程能夠訪問字段，因此有些優化操做是必定不能做用在字段上的。
volatile有時
能夠代替synchronized。
11.transient
使用對象：字段
介紹：字段不是對象持久狀態的一部分，不該該把字段和對象一塊兒串起。

31.接口與繼承的區別：
接口是對象和事物的拓展屬性，屬於單獨的，屬於每一個實現接口的類。
而繼承則是子類對父類的所有傳遞，並增長一些子類所特有的屬性，

列如高三學生是學生的一種，高三學生繼承了學生的一切屬性和方法，如學習和思考。
而有部分高三學生還會抽菸，喝酒等，若是用繼承，則表明全部學生都會抽菸，喝酒。然而只是
部分高三學生會。因此用接口來表示拓展屬性。

32.多態：事物存在的多種體現形態。
多態的體現：父類的引用指向了子類的對象，
父類的引用也能夠接受子類的對象。
Person m = new Man();
多態的前提：必須類與類有關係，要麼繼承，要麼實現，且子類對父類存在覆蓋。
多態的好處：多態的出現大大提升了程序的拓展性。
多態的弊端：雖然提升了代碼的拓展性，但只能使用父類的引用來訪問父類中的成員。
多態自始自終都是子類對象在作着變化，能夠轉換的是父類應用指向了本身的子類對象時，能夠向上轉換，也能夠強制轉換。

在多態中成員函數的特色：
在編譯時期，參閱引用型變量所屬的類中是否有調用的方法，若是有，編譯經過，不然失敗。
在運行時期，參閱對象所屬的類中是否有調用的方法
即，成員函數在多態調用時，編譯看左邊，運行看右邊。

在多態中，成員變量的特色；
不管編譯仍是運行，都參考左邊（引用型變量所屬的類）

在多態中，靜態成員函數的特色：
不管編譯仍是運行，都參考左邊。

33.異常：程序在！運行！時產生的不正常狀況。
異常的由來：異常在現實生活中也是具體的問題，Java在將這些問題描述成類，並封裝成對象。
就是Java對不正常狀況進行描述後的對象表現。

對於問題的劃分：一種是嚴重的問題-Error ,一種則是嚴重的----Exception
對於Error問題不進行代碼處理，而Exception問題進行處理
但Error與Exception都具有一些共性
列如不正常狀況的信息，引起緣由等

Throwable
--Error

--Exception

34.在Exception類中有一個特殊的類RuntimeExceptiom
若是在函數內容拋出異常，函數上能夠不聲明，編譯同樣經過
若是在函數聲明瞭異常，調用者能夠不處理，編譯同樣經過，之因此不須要調用者處理，是由於不須要

當該代碼異常發生時，RuntimeException但願這段代碼中止，由於在運行中，若是出現了中止，則應該中止操做，修改代碼

自定義異常時，若是該異常的發生，程序沒法繼續，則讓自定義類繼承RuntimeException

對於異常分爲兩類
1.編譯時被檢測的異常

2.編譯時不被檢驗的異常，而運行時被檢驗的異常(RuntimeException及其子類)

35.異常在子父類中的覆蓋體現：
1.子類在覆蓋父類時，若是父類的方法拋出異常，那麼子類的覆蓋的方法只能拋出父類的異常或者該異常的子類。
2.若是父類中拋出了多個異常，那麼子類在覆蓋該方法時，那麼子類只能拋出的是父類的子集
3.若是父類或者接口的方法中沒有異常拋出，則子類在覆蓋的方法中也不準拋出異常
若是子類方法中出現了異常，只能進行try處理，不能夠拋出。

36.多線程：
進程：是一個正在執行的程序。
每個進程執行都有一個執行順序。該順序是一個執行路徑，或者叫一個控制單元。即在cpu中開闢運行的空間

線程：是進程中一個獨立的控制單元。線程控制着進程的執行

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

jvm在啓動時會有一個進程 Java。exe

該進程中至少有一個線程在負責Java程序的執行
並且這個線程運行的代碼存在於main方法中
該線程稱之爲主線程。
拓展：
jvm其實啓動的不止一個線程，還有負責垃圾回收機制的線程。

建立線程的第一種方法，繼承Thread類
1.定義類繼承Thread。
2.覆寫Tread中的run方法
將自定義代碼寫入run方法中，使線程運行。
3.調用線程的start方法
start方法：1.啓動線程。2.調用run方法

發如今每次運行時，運行結果都不同。
由於多個線程都在獲取cpu的執行權，cpu執行到誰，誰就運行
明確一點，在某一時刻，cpu只能執行一個線程，cpu在高速地在作着切換,以達到效果上的同時運行(多核除外)
咱們能夠把多線程的運行獲取在搶奪cpu的執行使用權。

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


建立線程的第二種方法，實現Runnable接口
1.將定義的類實現Runnable接口
2.覆蓋Runnable接口中的run方法
將線程要運行的代碼塊定義在run方法中
3.經過Thread來建立線程對象
4.將Runnable的子類對象做爲實際參數傳入Thread類的構造函數
由於自定義的run方法的所屬對象是Runnable接口的子類對象
因此要讓線程去執行指定對象的run方法。必須明確run方法的所屬對象
5.調用Thread中的start方法開始線程並調用Runnable接口中的run方法。

實現與繼承有什麼區別？
實現是爲了不單繼承的侷限性
在定義線程時，建議使用實現Runnable接口方法

區別：
兩種方法最大的區別就是run方法的存在的位置不一樣
繼承Thread類，線程代碼存在於Thread子類中的run方法中
實現Runnable接口，線程代碼存在於Runnable接口中的run方法中

37.泛型類定義：
class 類名<泛型名>
泛型通配符 ？

當須要定義未知引用數據類型的對象時，使用泛型，能夠更好減小代碼

38.Arrays中的asList方法
把數組變成集合，就可使用集合中的方法，更加簡單

但變成集合後不可使用增刪操做，由於數組長度是固定的。會導出.UnsupportedOperationException錯誤

若是數組中的元素都是對象，那麼變成集合時，數組中的元素直接轉換成集合中的元素

若是數組中的元素都是基本數據類型，那麼會講這個數組做爲對象傳入集合。

39.
其實Java自身不具有建立存入數據到文件的功能，只是在調用了windows底層的建立存入方法
Java在其餘操做系統上，就調用操做系統內部底層的方法進行操做

40. IOExcption標準處理方法
FileWriter fw =null;

try
{
fw =new FileWriter("a:\\demo.txt");//若是目的值出錯，fw初始化失敗，fw爲null，不能調用close語句，因此要先判斷

fw.write("sdfasfas");


}
catch (IOException e)
{
System.out.println(e.toString());
}
finally{

try
{
if(fw!=null)
fw.close();//必定要關閉流資源，將其放入finally語句中

}
catch (IOException e)
{

System.out.println(e.toString());
}
}

41.裝飾設計模式：
當想要對已有對象進行功能加強時，能夠定義類，將已有對象傳入，
基於已有的功能，並提供加強的方法，那麼該自定義的類稱爲裝飾類

裝飾類一般會經過構造函數的方法來接受要被裝飾的對象，並基於被裝飾類的
方法來提供更增強大的方法

例子：bufferedReader中的readLine方法就是基於FileReader中的read方法

裝飾設計模式與繼承的區別：
裝飾模式比繼承要靈活，避免了過多繼承而產生的臃腫性，並且下降了類與類之間的聯繫

裝飾類由於是加強已有對象，具有的功能和已有的是類似的，只不過提供了更強的修飾方法
因此裝飾類與被裝飾類一般都是屬於同一體系中的，是組合關係。


42. 流操做的基本規律
三個明確
1.明確源和目的
源：輸入流 ：字節流：InputStream 字符流：Reader
目的：輸出流 ：字節流：OutputStream 字符流：writer

2.明確操做的數據是否爲純文本文件
是：字符流
否：字節流

3.當體系明確後，就要明確具體使用哪一個對象
經過設備來區分
源設備：內存，硬盤，鍵盤錄入
目的設備：內存，硬盤，控制檯


1.將一個文本文件數據複製到另外一個文本文件中
源：由於是源，因此使用輸入流，InputStream Reader

由於操做的文本爲純文本，因此使用字符流 Reader

明確具體使用設備，硬盤中的文本文件，
因此使用Reader類中的具體操做文件的方法 FileReader

文本文件是否過大，是否須要提升效率，使用緩衝區方法

FileReader fr =new FileReader("yuan.xxx");
BufferedReader br =new BufferedReader(fr);

目的：
由於是目的，因此使用輸出流 ，OutputStream Writer

由於操做的文本爲純文本，因此使用字符流 Writer

明確具體使用設備，硬盤中的新文本文件
因此使用Writer類中的具體操做文件的方法 FileWriter

文本文件是否過大，是否須要提升效率，使用緩衝區方法

FileWriter fw =new FileWriter("newmudi.xxx");
BufferedWriter bw =new BufferedWriter(fw);

43.拓展：將鍵盤錄入的數據按照指定編碼表（UTF-8）傳到一個的文件中

源：由於是輸入流，因此爲InputStream，Reader

由於爲純文本，因此使用字符流 Reader

設備：鍵盤，因此使用System.in
但由於要操做方便，因此要轉成字符流來操做要快
因此使用Reader類中的InputStreamReader方法將字節轉成字符

InputStreamReader isr =new InputStreamReader(System.in);

所輸文本是否過大。，是否須要高效，加緩衝區

BufferedRead br =new BufferedRead(isr);

目的：由於是輸出流，因此爲OutputStream，Writer

由於爲純文本，因此使用Writer

設備：硬盤中的一個新文件，因此使用FileWriter
可是FileWriter使用的默認編碼表爲GBK

而存儲一個指定編碼格式爲UTF-8的文本文件，只能用轉換流中的OutputStreamWriter，
而該轉換流要接受一個字節輸出流，並且能夠操做的字節輸出流爲FileOutputStream

OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

是否須要高效，加緩衝

BufferedWriter buw =new BufferedWriter(osw);

涉及到轉碼中的編碼表問題，都須要使用轉換流。

44.jar抓包
先將java文件進行包裝，
再dos中運行javac -d 包須要放的位置 需編譯的java文件
例子：javac -d g:\javab\mypackage AwtDemo5.java 將AwtDemo5進行裝包到g:\javab\mypackage中
運行直接在在mypackage中運行java 包名.類名

在進行抓包中，首先進行聲明主類，即建立一個文件，將Main-Class: 包名.主類名 而後回車表該行結束。注意冒號後必須有空格
例如 ：Main-Class: mymenu.AwtDemo5
抓包格式：jar -cvfn jar名 聲明主類文件 包名
例子：jar -cvfm menu.jar Main.txt mymenu

45.TCP與UDP
UDP：1.將數據，目的及源封裝到數據包中，不須要創建鏈接。
2.每次傳輸的數據包的大小限定在64k內
3.因無鏈接，因此爲不可靠鏈接
4.由於不須要創建鏈接，因此速度相對較快

例子：對講機，郵局寄物，視頻會議，由於傳輸很快，數據丟失無所謂

TCP：1.創建數據鏈接，造成傳輸數據的通道
2.在傳輸通道中能夠進行大數據的傳輸。
3.經過三次握手鍊接完成，是可靠鏈接
三次握手鍊接，即客戶端向服務器發出請求，服務器迴應客戶端的請求，客戶端接受到迴應發回服務器的回饋。
4.由於須要創建鏈接，因此速度相對較慢

例子；兩人打電話，

46.在函數中判斷條件，在循環中只求結果，能夠在循環外定義一個標記，若是循環中標記改變，則記住結果，不然不記住。列如 boolean flag= true

47.*.split(#) *對象以#分割

48. http請求消息頭
/*
http://169.254.84.190:12000/myweb/demo.html
GET /myweb/demo.html HTTP/1.1 發送get請求，將
Accept: text/html, application/xhtml+xml, */* 支持格式 */*表除以上格式還支持
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Tride
nt/5.0)
UA-CPU: AMD64
Accept-Encoding: gzip, deflate 支持封裝格式
Host: 169.254.84.190:12000 客戶端
Connection: Keep-Alive //可爲closed
//空行，必須存在，用來分隔頭與體
//這部分爲請求消息體。
*/

49.InnetAddress 封裝的是ip地址
InnerSocketAddress 封裝的是ip地址加端口號

50.域名解析，若是輸入的是IP地址，直接按照IP地址來打開網頁
若是輸入的是域名，通常先從本地C盤下的host文件來尋找域名與IP地址的映射。若是有，按照本地文件中的映射打開網頁。
若是沒有，再從DNS中尋找映射關係。

51.在對象調用指定方法時，必須指定調用對象，以及傳入參數。

52.正則表達式:符合必定規則的表達式。
做用：用於專門操做字符串。
特色：用於一些特定的符號來表示一些代碼操做。這樣就簡化書寫。
因此學習正則表達式，就是在學習一些特殊符號的使用。
好處：能夠簡化對字符串的複雜操做。
弊端：符號定義越多，正則越長，閱讀性越差。
具體操做功能：
1，匹配：String matches方法。用規則匹配整個字符串，只要有一處不符合規則，就匹配結束，返回false。
2，切割：String split();
3，替換：String replaceAll(regex,str);若是regex中有定義組，能夠在第二參數中經過$符號獲取正則表達式中的已有的組。
正則表達式的第四個功能。
4，獲取:將字符串中的符合規則的子串取出。
操做步驟：
1，將正則表達式封裝成對象。
2，讓正則對象和要操做的字符串相關聯。
3，關聯後，獲取正則匹配引擎。
4，經過引擎對符合規則的子串進行操做，好比取出。

53.\\1 後向引用，表示表達式中，從左往右數，第一個左括號對應的括號內的內容。
以此類推，\2表示第二個，\0表示整個表達式

$1,$2...是表示的小括號裏的內容
$1是第一個小括號裏的 ,$2是第2個小括號裏的
好比 /gai([\w]+?)over([\d]+)/
匹配 gainover123
$1= 括號裏的 n
$2= 第2個括號裏的 123


匹配雙字節字符(包括漢字在內)：[^\x00-\xff]

匹配中文字符的正則表達式： [\u4e00-\u9fa5]

54.static void setErr(PrintStream err)
從新分配「標準」錯誤輸出流。
static void setIn(InputStream in)
從新分配「標準」輸入流。
static void setOut(PrintStream out)
從新分配「標準」輸出流。
即將System.out.println() System.in轉換流

55.隨機訪問流，RandomAccessFile 可讀可寫。

56.html中將數據都使用標籤進行封裝，能夠經過標籤中的屬性來操做被封裝的數據。 數據細節化。 57.