java基礎總結

1、基礎知識：Java 語言基礎組成

day02

一、組成：關鍵字、標識符、註釋、常量和變量、運算符、語句、函數、數組

2、基礎知識：關鍵字
二、關鍵字的定義和特色：定義：被 Java 語言賦予了特殊含義的單詞。特色：關鍵字中全部 字母都爲小寫。 三、用於定義數據類型的關鍵字：class、interface、byte、short、int、long、float、double、 char、boolean、void。 四、用於定義數據類型值的關鍵字：true、false、null。 五、用於定義流程控制的關鍵字：if、else、switch、case、default、while、do、for、break、

continue、return。 六、用於定義訪問權限修飾的關鍵字：private、protected、public。 七、用於定義類，函數，變量修飾的關鍵字：abstract、final、static、synchronized。 八、用於定義類與類之間關係的關鍵字：extends、implements。 九、用於定義創建實例以及引用實例，判斷實例的關鍵字：new、this、super、instanceof。 十、用於異常處理的關鍵字：try、catch、finally、throw、throws。 十一、用於包的關鍵字：package、import。 十二、其餘修飾符關鍵字：native、strictfp、transient、volatile、assert。

3、基礎知識：標識符
1三、標識符：在程序中自定義的一些名稱；由 26 個英文字母大小寫，數字：0-9，符號_$組 成；定義合法標識符規則：數字不能夠開頭、不可使用關鍵字；Java 中嚴格區分大小寫； 注意：在起名時，爲了提升閱讀性，要儘可能有意義。 1四、Java 中的名稱規範：包名：多單詞組成時全部都小寫，如：xxxyyyzzz；類名接口名：多 單詞組成時，全部單詞的首字母大寫，如：XxxYyyZzz；變量名和函數名：多單詞組成時，第 一個單詞首字母小寫，第二個單詞開始每一個單詞首字母大寫，如：xxxYyyZzz；常量名：全部 字母都大寫，多單詞時每一個單詞用下劃線鏈接，如：XXX_YYY_ZZZ。

4、基礎知識：註釋
1五、註釋：對於單行和多行註釋，被註釋的文字，不會被 JVM（Java 虛擬機）解釋執行；對 於文檔註釋，是 Java 特有的註釋，其中註釋內容能夠被 JDK 提供的工具 javadoc 所解析，生 成一套以網頁文件形式體現的該程序的說明文檔； 註釋是一個程序員必需要具備的良好編程 習慣；初學者編寫程序能夠養成習慣；先寫註釋再寫代碼；將本身的思想經過註釋先整理出 來，再用代碼去體現；由於代碼僅僅是思想的一種體現形式而已；用於註解說明解釋程序的 文字就是註釋；提升了代碼的閱讀性。 1六、Java 中的註釋格式：單行註釋：格式：//註釋文字；多行註釋：格式：/*註釋文字*/； 文檔註釋：格式：/**註釋文字*/。

5、基礎知識：常量
1七、常量表示不能改變的數值。 1八、Java 中常量的分類：整數常量：全部整數；小數常量：全部小數；布爾型常量：較爲特 有，只有兩個數值：true 和 false；字符常量：將一個數字字母或者符號用單引號（’’）標識； 字符串常量：將一個或者多個字符用雙引號（」」）標識；null 常量：只有一個數值就是 null。 1九、對於整數：Java 有三種表現形式：十進制：0-9，滿 10 進 1；八進制：0-7，滿 8 進 1， 用 0 表示開頭；十六進制：0-9，A-F，滿 16 進 1，用 0x 開頭表示。

6、基礎知識：進制轉換
20、進制的轉換特色：八位二進制表示一個字節（基本的數據單元） 。三個二進制位表一個

八進制位。四個二進制位表示一個十六進制位。ASCII 碼編碼表。 2一、二進制和十進制之間的轉換：十進制轉二進制：原理：對十進制數進行除 2 運算（除二 取餘法） ；二進制轉十進制：原理：二進制乘以 2 的 N 次的過程。 2二、快捷方法：8421 法則。 2三、負數的二進制表現形式：對應的正數二進制取反加 1。負數的最高位都是 1。

7、基礎知識：變量
2四、變量的概念：內存中的一個存儲區域；該區域有本身的名稱（變量名）和類型（數據類 型） ；該區域的數據能夠在同一類型範圍內不斷變化；理解：變量就如同數學中的未知數； 變量：就是將不肯定的數據進行存儲，也就是須要在內存中開闢一個空間。 2五、爲何要定義變量：用來不斷的存放同一類型的常量，並能夠重複使用。 2六、使用變量注意：變量的做用範圍（一對{}之間有效） ；初始化值。 2七、定義變量的格式：數據類型變量名=初始化值；注：格式是固定的、記住格式，以不變 應萬變。 2八、Java 語言是強類型語言，對於每一種數據都定義了明確的具體數據類型，在內存總分配 了不一樣打小的內存空間。數據類型：基本數據類型（數值型（整數類型（byte，short，int， long） ；浮點類型（float，double） ） ；字符型（char） ；布爾型（boolean） ） ；引用數據類型（類 （class） ；接口（interface） ；數據（[]） ） 。注意：整數默認：int，小數默認：double。 2九、數據類型空間：byte 8 位二進制（一個 8 位二進制或 1 個字節） ；short 16 位二進制（二 個 8 位二進制或 2 個字節） ；int 32 位二進制（四個 8 位二進制或 4 個字節） ；long 64 位二進 制（八個 8 位二進制或 8 個字節） ；float（單精度）32 位二進制（四個 8 位二進制或 4 個字 節） ；double（雙精度）64 位二進制（八個 8 位二進制或 8 個字節） ；char 取值：0-65535； boolean 取值：true，false。 30、類型轉換。不一樣類型的數據不能進行運算。須要進行數據類型提高，從小往大提高，自 動數據類型提高。強制類型轉換：格式：變量=（類型名） （需轉換的數據） ；何時使用 強制轉換：如：小數保留整數部分。 3一、表達式的數據類型自動提高：全部的 byte 型、short 型和 char 的值將被提高到 int 型； 若是一個操做數是 long 型，計算結果就是 long 型；若是一個操做數是 float 型，計算結果就 是 float 型； 若是一個操做數是 double 型， 計算結果就是 double 型。 分析： system.out.println （ ‘a’ ）與 system.out.println（ ‘a’+1）的區別。

8、基礎知識：運算符
3二、算數運算符：+正號，-負號，+加，-減，*乘，/除，%取模，++自增（前） ，++自增（後） ， --自減（前） ，--自減（後） ，+字符串相加（字符串數據和任何數據使用+都是相鏈接，最終 都會變成字符串） 。 3三、轉義字符：經過\ 來轉變後面字母或者符號的含義。在 Linux 系統中換行是一個字符來 表示\n，windows 系統中，換行由\n\r 實現。\n:換行。\b:退格。至關於 backspace 鍵。\r: 按下回車鍵。\t:製表符。至關於 tab 鍵。 3四、賦值運算符：符號：=：賦值，+=：a+=5 等價於 a=a+5，-=，*=，/=，%=。 3五、比較運算符：==：相等於； ！=：不等於；<：小於；>：大於；<=：小於等於；>=：大於 等於；instanceof：檢查是不是類的對象。注意：比較運算符的結果都是 boolean 型，也就是

要麼是 true，要麼是 false；比較運算符「==」不能誤寫成「=」 。 3六、邏輯運算符：&：AND（與）兩邊的 boolean 表達式結果，有一個爲 false，那麼結果就 是 false，只要兩邊都爲 true，結果爲 true；|：OR（或）兩邊的 boolean 表達式結果，只要 有一個爲 true， 結果爲 true， 只有兩邊都有 false， 結果爲 false； ^： XOR （異或） 兩邊的 boolean 表達式結果相同結果爲 false，兩邊不一樣結果爲 true； ！ ：NOT（非） ；&&：AND（短路） ；||OR： （短路） 。邏輯運算符用於鏈接 boolean 類型的表達式。&和&&的特色：&：不管左邊是真是 假，右邊都運算；&&：當左邊爲假時，右邊不運算。|和||的特色：|：兩邊都作運算；||： 但左邊爲真時，右邊不運算。 3七、位運算符：<<：左移，如：3<<2=12 等價於 3*2^2=12；>>：右移，如：6>>2=1 等價於 6/2^2=1；>>>：無符號右移，如：3>>>1=1；&：與運算，如：6&3=2；|：或運算，如：6|3=7； ^：異或運算，如：6^3=5；~：反碼，如：~6=-7；位運算是直接對二進制進行運算。<<：其 實就是乘以 2 的移動的位數次冪；>>：就是除以 2 的移動的位數次冪。>>：最高位補什麼由 原有數據的最高位值而定；若是最高位 0，右移後，用 0 補空位；若是最高位 1，右移後， 用 1 補空位。>>>：不管最高位是什麼，右移後，都用 0 補。一個數異或同一個數兩次，結 果仍是拿個數。 3八、三元運算符：格式： （條件表達式）？表達式 1：表達式 2；若是條件爲 true，運算後的 結果是表達式 1；若是條件爲 false，運算後的結果是表達式 2。如：獲取兩個數中大數，int x=3,y=4,z;z=(x>y)?x:y//z 變量存儲的就是兩個數的大數。

9、基礎知識：if 語句
3九、程序流程控制：順序結構，判斷結構，選擇結構，循環結構。 40、判斷結構：if 語句三種格式：一層判斷：if(條件表達式){執行語句;}；兩層判斷：if(條件 表達式){執行語句;}else{ 執行語句;}；多層判斷：if(條件表達式){執行語句;}else if(條件表達 式){執行語句;}else{執行語句;}。 4一、if else 結構間歇格式：變量=（條件表達式）？表達式 1：表達式 2；三元運算符：好處： 能夠簡化 if else 代碼；弊端：由於是一個運算符，因此運算完畢須要有一個結果。 4二、解決 DOS 命令下，編譯沒法識別 GDK 碼方法：方法一：使用-encoding 參數指明編碼方 式：javac -encoding UTF-8 XX.java。方法二：保存 java 文件時，選擇編碼格式爲 ANSI。

10、基礎知識：switch 語句
4三、選擇結構：switch 語句：格式：switch(表達式){case 取值 1：執行語句；break；case 取 值 2：執行語句；break；??default：執行語句；//break；} 4四、switch（表達式） ：表達式只接收四種類型：byte，short，int，char。 4五、if 語句與 switch 語句的區別：if 除了能判斷數值，還能判斷具體區間，switch 判斷區間 很累；對於數字是布爾型時，只有 if 能判斷。 4六、if 語句與 switch 語句的用法：若是要對具體數字進行判斷，數值很少，並且符合 byte、 short、int、char 這四種類型，雖然兩個語句均可以使用，建議用 switch 完成。由於效率稍 高。其餘狀況通常用 if。當結果爲布爾型或區間時，用 if 完成。If 的使用範圍更廣。

2016 年 01 月 08 日 day03
1、基礎知識：while 語句
一、循環結構：表明語句：while、do while、for。 二、while 語句格式：while（條件表達式）{執行語句；}。 三、do while 語句格式：do{執行語句；}while（條件表達式） ； 。Do while 特色是條件不管是否 知足，循環體至少被執行一次。 四、while 和 do while 的區別：while：先判斷條件，只有條件知足才執行循環體。do while： 先執行循環體，再判斷條件，條件知足，再繼續執行循環體。簡單一句話：do while：不管 條件是否知足，循環體至少執行一次。

2、基礎知識：for 語句
五、 for 語句格式： for （初始化表達式； 循環條件表達式； 循環後的操做表達式） {執行語句； }。 注意：a：for 裏面的連個表達式運行的順序，初始化表達式只讀一次，判斷循環條件，爲真 就執行循環體，而後再執行循環後的操做表達式，接着繼續判斷循環條件，重複找個過程， 直到條件不知足爲止。b：while 與 for 能夠互換，區別在於 for 爲了循環而定義的變量在 for 循環結束就是在內存中釋放。而 while 循環使用的變量在循環結束後還能夠繼續使用。c： 最簡單無限循環格式：while（true） ，for（； ； ） ，無限循環存在的緣由是並不知道循環多少 次，而是根據某些條件，來控制循環。 六、for 和 while 的區別：a：變量有本身的做用域。對於一個變量來將，若是這個變量僅僅 用於控制循環的次數，用做循環增量時用 for 語句。循環結束時，該變量在內存被釋放。用 於優化內存。b：for 和 while 能夠進行互換，若是定義循環增量，用 for 更爲合適。 七、何時使用循環結構？當要多某些語句執行不少次時，就是用循環結構。 八、循環注意：必定要明確哪些語句須要參與循環，哪些不須要。 九、兩種思想：累加思想：原理：經過變量記錄住每次變化的結果。經過循環的形式，進行 累加動做。計數器思想：原理：經過一個變量記錄住數據的狀態變化。也經過循環完成。 十、循環嵌套：語句嵌套形式，其實就是語句中含有語句。 十一、其餘流程控制語句：break（跳出） ，continue（繼續） 。Break 語句：應用範圍：選擇結 構和循環結構。Continue 語句：應用於循環結構。注意：a：這兩個語句離開應用範圍，存 在是沒有意義的。b： 這兩個語句單獨存在下面都不能夠有語句，由於執行不到。c：continue 語句是結束本次循環繼續下次循環。 d： 標號的出現， 可讓這兩個語句做用於指定的範圍。 十二、注意：標號只能用於循環語句上，給循環起名字。 1三、continue：只能做用於循環結構。繼續循環。特色：結束本次循環，繼續下一次循環。 1四、總結：a：break 和 continue 語句做用的範圍。b：break 和 continue 單獨存在時，下面 能夠有任何語句。由於都執行不到。

3、基礎知識：函數
1五、函數的定義：什麼是函數？函數就是定義在類中的具備特定功能的一段獨立小程序；函

數也稱爲方法。 1六、 函數的格式： 修飾符返回值類型函數名 （參數類型形式參數 1， 參數類型形式參數 2， ?） {執行語句；return 返回值；}。返回值類型：函數運行後的結果的數據類型。參數形式：是 形式參數的數據類型。 形式參數： 是一個變量， 用於存儲調用函數時傳遞給函數的實際參數。 實際參數：傳遞給形式參數的具體數值。Return：用於結束函數。返回值：該值會返回給調 用者。 1七、函數的特色：定義函數能夠將功能代碼進行封裝；便於對該功能進行復用；函數只有被 調用纔會被執行；函數的出現提升了代碼的複用性；對於函數沒有具體返回值的狀況，返回 值類型用關鍵字 void 表示，那麼該函數中的 return 語句若是在最後一行能夠省略不寫。注 意：函數中只能調用函數，不能夠在函數內部定義函數；定義函數時，函數的結果應該返回 給調用者，交由調用者處理。 1八、重點：函數的應用。如何定義一個函數呢？a：既然函數是一個獨立的功能，那麼該功 能的運算結果是什麼先明確。由於這是在明確函數的返回值類型。b：再明確在定義該功能 的過程當中是否須要未知的內容參與運算。 由於是在明確函數的參數列表 （參數的類型和參數 的個數） 。 1九、函數的重載（overload） ：重載的概念：在同一個類中，容許存在一個以上的同名函數， 只要它們的參數個數或者參數類型不一樣便可。重載的特色：與返回值無關，只看參數列表。 重載的好處：方便與閱讀，優化了程序設計。重載示例：//返回兩個整數的和 int add(int x,int y){return x+y;}；//返回三個整數的和 int add(int x,int y,int z){return x+y+z;}；//返回兩個小數的 和 double add(double x,double y){return x+y;}。 20、何時用重載？當定義的功能相同，但參與運算的未知內容不一樣。那麼，這時就定義 一個函數名稱以表示其功能，方便閱讀，而經過參數列表的不一樣來區分多個同名函數。

4、基礎知識：數組
2一、數組的定義：概念：同一種數據類型的集合。其實數組就是一個容器。數組的好處：可 以自動給數組中的元素從 0 開始編號，方便操做這些元素。關鍵字：new：用來在內存中產 生一個容器實體。格式一：元素類型[]數組名=new 元素類型[元素個數或數組長度]；示例： int [] arr=new int[5]； 格式二： 元素類型[]數組名=new 元素類型[]{元素， 元素， ?}； 示例： int[] arr=new int[]{3,5,1,7}；int[] arr={3,5,1,7}。 2二、內存結構：Java 程序在運行時，須要在內存中分配空間。爲了提升運行效率，又對空間 進行了不一樣區域的劃分，由於每一片區域都有特定的處理數據方式和內存的管理方式。 A： 棧內存（棧區） ：用於存儲局部變量，當數據使用完，所佔空間會自動釋放。B：堆內存（堆 區） ：數組和對象，經過 new 創建的實例都存放在堆內存中。每個實體都有內存地址。實 體中的變量都有默認初始化值。實體不在被使用，會在不肯定的時間內被垃圾回收器回收。 C：方法區，本地方法區，寄存器。

2016 年 01 月 09 日
1、基礎知識：數組

day04

一、獲取數組中的元素。一般會用到遍歷。 二、數組中有一個屬性能夠直接得到到數組元素個數。length。使用方式：數組名稱.length。 三、數組排序：選擇排序：內循環結束一次，最值出現頭角標位置。冒泡排序：第一圈：最 值出如今了最後位。 四、java 中排序工具：import.java.util.*；Array.sort(arr)。java 中已經定義好的一種排序方式。 開發中，對數組排序，要使用該句代碼。 五、二維數組：數組中的數組：格式一：int[][] arr=new int[3][2]；定義了名稱爲 arr 的二維數 組；二維數組中有 3 個一維數組；每個一維數組中有 2 個元素；一維數組的名稱分別爲 arr[0]，arr[1]，arr[2]；給第一個一維數組 1 腳標位賦值爲 78 寫法是：arr[0][1]=78。格式二： int[][] arr=new int[3][]；二維數組中有 3 個一維數組；每一個一維數組都是默認初始值 null；可 以對這個三個一維數組分別進行初始化： arr[0]=new int[3]； arr[1]=new int[1]； arr[2]=new int[2]。

2016 年 01 月 10 日
1、面向對象：概述

day05

一、理解面向對象：面向對象是相對面向過程而言；面向對象和麪向過程都是一種思想；面 向過程：強調的是功能行爲；面向對象：將功能封裝進對象，強調了具有了功能的對象；面 向對象是基於面向過程的。 讓咱們的角色從執行者變爲指揮者。 面向過程是面向對象的基礎。 二、一切皆對象，境界：萬物皆對象。 三、寫程序時：先考慮對象。有對象時，直接用。沒對象時，本身造一個對象。 四、人開門：名稱提煉法。事物：人、門。示例：人{開門（門）{門。開（） ；}}；門{開（） {操做門軸等。}}。 五、面向對象的三個特徵：封裝，繼承，多態。 六、之後的開發：其實就是找對象使用。沒有對象，就建立一個對象。 七、找對象，創建對象，使用對象，維護對象的關係。 八、類和對象的關係：類就是：對現實生活中事物的描述。對象：就是這類事物，實實在在 的個體。 映射到 java 中， 描述就是 class 定義的類。 具體對象就是對於 java 在堆內存中用 new 創建實體。 九、類與對象示例：圖紙：汽車，汽車，汽車。能夠理解爲：類就是圖紙；汽車就是堆內存 中的對象。 十、描述事物其實就在是描述事物的屬性和行爲。 十一、屬性對應是類中的變量，行爲對應的類中的函數（方法） 。其實定義類，就是在描述事 物， 就是在定義屬性和行爲。 屬性和行爲共同成爲類中的成員 （成員變量和成員函數 （方法） ） 。 十二、引用變量：類類型變量。記住：類類型變量指向對象。 1三、就須要該對象作使用，在 java 指揮方式是：對象.對象成員。

1四、成員變量和局部變量：做用範圍：成員變量做用於整個類中。局部變量做用於函數中， 或者語句中。 在內存中的位置： 成員變量： 在堆內存中， 由於對象的存在， 纔在內存中存在。 局部變量：存在棧內存中。 1五、匿名對象：匿名對象是對象的簡化形式；匿名對象兩種使用狀況：當對對象方法僅進行 一次調用的時；匿名對象能夠做爲實際參數進行傳遞。

2、面向對象：封裝
1六、封裝的定義：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。 1七、封裝的好處：將變化隔離；便於使用；提升重用性；提升安全性。 1八、 封裝原則： 將不須要對外提供的內容隱藏起來； 把屬性都隱藏， 提供公共方法對其訪問。 1九、函數是最小的封裝體；類是較小的封裝體；包是中級封裝體；框架是較大的封裝體。 20、關鍵字 private：私有，權限修飾符：用於修飾類中的成員（成員變量，成員函數） 。在 類中隱藏。私有隻在本類中有效。 2一、注意：私有僅僅是封裝的一種表現形式。 2二、之因此對外提供訪問方式，就是由於能夠在訪問方式中加入邏輯判斷語句。對訪問的數 據進行操做。提升代碼健壯性。 2三、關鍵字 private：將成員變量私有化。對外提供對應的 set，get 方法對其進行訪問。提 高對數據訪問的安全性。

3、面向對象：構造函數
2四、構造函數的特色：函數名與類名相同；不用定義返回值類型；不能夠寫 return 語句。 2五、構造函數的做用：給對象進行初始化。注意：默認構造函數的特色；多個構造函數是以 重載的形式存在的。 2六、構造函數：對象一創建就會調用與之對應的構造函數。構造函數的做用：能夠用於給對 象進行初始化。 2七、構造函數的小細節：當一個類中沒有定義構造函數時，那麼系統會默認給該類假如一個 空參數的構造函數。當在類中自定義了構造函數後，默認的構造函數就沒有了。 2八、構造函數和通常方法（函數）的區別：A：構造函數和通常函數在寫法上有不一樣。B： 在運行上也有不一樣。構造函數是在對象一創建就運行。就對象初始化。而通常方法是對象調 用才執行，是給對象添加對象具有的功能。C：一個對象創建，構造函數只運行一次。而一 般方法能夠被該對象調用屢次。 2九、何時定義構造函數呢：當分析事物時，該事物存在具有一些特徵或者行爲，那麼將 這些內容定義在構造函數中。 30、 構造代碼塊： 做用： 給對象進行初始化。 對象一創建就運行， 並且優先於構造函數執行。 3一、構造代碼塊和構造函數區別：構造代碼塊是給全部對象進行統一初始化，而構造函數是 給對應的對象進行初始化。 3二、構造代碼塊中定義的是不一樣對象共性的初始化內容。

4、面向對象：this 關鍵字
3三、關鍵字 this：看上去，是用於區分局部變量和成員變量同名狀況。 3四、關鍵字 this 的特色：就表明本類的對象，到底表明哪個呢？this 表明它所在函數所屬 對象的引用。簡單說：哪一個對象在調用 this 所在的函數，this 就表明哪一個對象。 3五、this 的應用：當定義類中功能時，該函數內部要用到該函數的對象時，這時用 this 來表 示這個對象。但凡本類功能內部使用到了本類對象，都用 this 代替。 3六、 this 語句： 用於構造函數之間函數互相調用。 this 語句： 只能定義在構造函數的第一行。 由於初始化要先執行。 3七、this 語句只能用於構造函數間，不能用於通常函數。

2016 年 01 月 11 日
1、面向對象：static 關鍵字

day06

一、static（靜態）關鍵字：用於修飾成員（成員變量和成員函數） 。被修飾後的成員具有以 下特色： 隨着類的加載而加載； 優先於對象存在； 被全部對象所共享； 能夠直接被類名調用。 使用注意：靜態方法只能訪問靜態成員；靜態方法中不能夠寫 this，super 關鍵字；主函數 是靜態的。 二、用法：是一個修飾符，用於修飾成員（成員變量，成員函數） 。當成員被靜態修飾後，就 多了一個調用方式，除了能夠被對象調用外，還能夠直接被類名用。類名.成員變量。 三、實例變量和類變量的區別：A，存放位置：類變量隨着類的加載而存在於方法區中。實 例變量隨着對象的創建存在於堆內存中。B，生命週期：類變量生命週期最長，隨着類的消 失而消失。實例變量隨着對象的消失而消失。 四、靜態使用注意事項：A，靜態方法只能訪問靜態成員。非靜態方法既能夠訪問靜態也可 以訪問非靜態。B，靜態方法中不能夠定義 thsi，super 關鍵字。由於靜態優先於對象存在， 全部靜態方法中不能夠出現 this。C，主函數是靜態的。 五、靜態優缺點：優：對對象的共享數據進行單獨空間的存儲，節省空間。沒有必要每一個對 象中都存儲一份。能夠直接被類名調用。 缺：生命週期過長。訪問出現侷限性。 （靜態雖好， 只能訪問靜態。 ） 六、public static void main(String[] args) 主函數：是一個特殊的函數，做用程序的入口，能夠 被 jvm 調用。 七、主函數的定義：public：表明着該函數訪問權限是最大的。static：表明主函數隨着類的 加載就已經存在了。void：表明主函數沒有具體的返回值。main：不是關鍵字，可是是一個 特殊的單詞，能夠被 jvm 識別。 （String[] args） ：函數的參數，參數類型是一個數組，該數組 中的元素是字符串。字符串類型的數組。 八、主函數是固定格式的：jvm 識別。jvm 在調用主函數時，傳人的是 new String[0]； 。 九、何時使用靜態？要從兩方面下手：由於靜態修飾的內容有成員變量和函數。什麼時 候定義靜態變量（類變量）呢？當對象中出現共享數據時，該數據靜態所修飾。對象中的特 有數據要定義成非靜態存在於堆內存中。 十、何時定義靜態函數呢？當功能內部沒有訪問到非靜態數據（對象的特有數據） ，那

麼該功能能夠定義成靜態的。 十一、靜態的應用：A 每個應用程序中都有共性的功能，能夠將這些功能進行抽取，獨立封 裝。 以便複用。 B 雖然能夠經過創建 ArrayTool 的對象使用這些工具方法，對數組進行操做。 可是：1，對象是用於封裝數據的，能夠 ArrayTool 對象並未封裝特特有數據。2，操做數組 的每個方法都沒有用到 ArrayTool 對象中的特有數據。C 這時就考慮，讓程序更嚴謹，是 不須要對象的。能夠將 ArrayTool 中的方法都定義成 static 的，直接經過類名調用便可。D 將 方法都靜態後， 能夠方便於使用， 可是該類仍是能夠被其餘程序創建對象的。 爲了更爲嚴謹， 強制讓該類不能創建對象。能夠經過將構成函數私有化完成。 十二、接下來，將 ArrayTool.class 文件發送給其餘人，其餘人只要將該文件設置到 classpath 路 徑下，就可使用該工具類。可是，很遺憾，該類中到底定義了多少個方法，對方不清楚。 由於該類並無使用說明書。開始製做程序的說明書。java 的說明書經過文檔註釋來完成。 1三、註釋符號：/***/；@author 做者；@version 版本；@param 參數；@return 返回值。 1四、靜態代碼塊。格式：static{靜態代碼塊中的執行語句。}。 1五、靜態代碼塊的特色：隨着類的加載而執行，只執行一次,並優先於主函數。用於給類進 行初始化的。 1六、 重點： 對象的初始化過程： Person p=new Person(「zhangsan」,20);該句話都作了什麼事情？ A 由於 new 用到了 Person。Class。全部會先找到 Person。Class 文件並加載到內存中。B 執 行該類中的 static 代碼塊，若是有的話，給 Person.class 類進行初始化。C 在堆內存中開闢空 間，分配內存地址。D 在堆內存中創建對象的特有屬性，並進行默認初始化。E 對屬性進行 顯示初始化。F 對對象進行構造代碼塊初始化。G 對對象進行對應的構造函數初始化。H 將 內存地址付給棧內存中的 p 變量。

2、面向對象：單例設計模式
1七、 設計模式： 解決某一類問題最行之有效的方法。 java 中 23 中設計模式： 單例設計模式： 解決一個類在內存只存在一個對象。 1八、想要保證對象惟一。1，爲了不其餘程序過多創建該類對象。先禁止其餘程序創建該 類對象。2，還爲了讓其餘程序能夠訪問到該類對象，只好在本類中，自定義一個對象。3， 爲了方便其餘程序對自定義對象的訪問，能夠對外提供一些訪問方式。 1九、這三步怎麼用代碼體現呢？1，將構造函數私有化。2，在類中建立一個本類對象。3， 提供一個方法能夠獲取到該對象。 20、對於事物該怎麼描述，還怎麼描述。當須要將該事物的對象保證在內存中惟一時，就將 以上的三部加上便可。 2一、單例設計方法一：這個是先初始化對象。稱爲：餓漢式。Single 類一進內存，就已經創 建好了對象。開發通常用餓漢式：安全、簡單。 2二、單例設計方法二：對象被調用時，才初始化，也叫作對象的延時加載。稱爲：懶漢式。 Single 類進內存，對象尚未存在，只有調用了 getInstance 方法時，才創建對象。 2三、記住原則：定義單例，建議使用餓漢式。但面試時：考懶漢式的多。特別是如何解決懶 漢式的缺點。

2016 年 01 月 12 日
1、面向對象：繼承

day07

一、繼承：1，提升代碼的複用性。2，讓類與類之間產生了關係。有了這個關係，纔有了多 態的特性。關鍵字：extends。 二、注意：千萬不要爲了獲取其餘類的功能，簡化代碼而繼承。必須是類與類之間有所屬關 系才能夠繼續。所屬關係 is a。 三、java 語言中：java 只支持單繼承，不支持多繼承。緣由：由於多繼承容易帶來安全隱患： 當多個父類中定義了相同功能， 當功能內容不一樣時， 子類對象不肯定要運行哪個。 可是 java 保留這種機制，並用另外一種體現形式來完成表示，多實現。 四、java 支持多層繼承。也就是一個繼承體系。如何使用一個繼承體系中的功能呢？想要使 用體系，先查閱父類的描述，由於父類中定義的是該體系中共性功能。經過了解共性功能， 就能夠知道該體系的基本功能。那麼這個體系已經能夠基本使用了。 五、那麼在具體調用時，要建立最子類的對象，爲何呢？一是由於有可能父類不能建立對 象，二是建立子類對象可使用更多的功能，包括基本的也包括特有的。 六、簡單一句話：查閱父類功能，建立子類對象使用功能。 七、this 表明本類對象的引用，super 代編父類對象的引用。 八、子父類出現後，類成員的特色：類中成員：A，變量。B，函數。C，構造函數。 九、 子父類中的變量： 若是子類中出現非私有的同名變量時， 之類要訪問本類中的同名變量， 用 this 子類要訪問父類中的同名變量，用 super。super 的使用和 this 的使用幾乎一致。this 表明的是本類對象的引用。super 表明的是父類對象的引用。 十、子父類中的函數：當子類出現和父類如出一轍的函數時，當子類對象調用該函數，會運 行子類函數的內容。如同父類的函數被覆蓋同樣。這種狀況是函數的另外一個特性：重寫（覆 蓋） 。 十一、修改以往的源碼絕對是災難。 十二、單子類繼承父類，沿襲了父類的功能，到子類中，可是子類雖具有該功能，可是功能的 內容卻和父類不一致，這時，沒有必要定義新功能，而是使用覆蓋特殊，保留父類的功能定 義，並重寫功能內容。 1三、注意：覆蓋：子類覆蓋父類，必須保證子類權限大於等於父類權限，才能夠覆蓋，不然 編譯失敗。靜態只能覆蓋靜態。 1四、記住你們：重載：只看同名函數的參數列表。重寫：子父類方法要如出一轍。 1五、子父類中的構造函數：發如今對子類對象進行初始化時，父類的構造函數也會運行。那 是由於子類的構造函數默認第一行有一條隱式的語句 super（） ；super（） ；會訪問父類中空 參數的構造函數。並且子類中全部的構造函數默認第一行都是 super（） ； 。 1六、爲何子類必定要訪問父類中的構造函數：由於父類中的數據子類能夠直接獲取，全部 之類對象在創建時， 須要先查看父類是如何對這些數據進行初始化的。 全部之類在對象初始 化時，要先訪問一下父類中的構造函數。若是要訪問父類中指定的構造函數，能夠經過手動 定義 super 語句的方式來指定。注意：super 語句必定必定在子類構造函數第一行。 1七、子類的實例化過程。結論：子類的全部的構造函數默認都會訪問父類中空參數的構造函 數。由於子類每個構造函數內的每一行都有一句隱式的 super（） ；當父類中沒有空參數的 構造函數時， 子類必須手動經過 super 語句或者 this 語句形式來指定要訪問父類中的構造函

數。固然：子類的構造函數第一行也能夠收到指定 this 語句來訪問本類中的構造函數。子類 中至少會有一個構造函數會訪問父類中的構造函數。 1八、關鍵字：final：final 能夠修飾類，方法（函數） ，變量；final 修飾的類不能夠被繼承； final 修飾的方法（函數）不能夠被覆蓋；final 修飾的變量是一個常量，只能被賦值一次；內 部類只能訪問被 final 修飾的局部變量。

2、面向對象：抽象類
1九、當多個類中出現相同功能，可是功能主體不一樣，這時也能夠進行向上抽取。這時，只抽 取功能定義，而不抽取功能主體。 20、抽象：看不懂。 2一、 抽象類的特色： A， 抽象方法必定定義在抽象類中。 B， 抽象方法和抽象類都必須被 abstract 關鍵字修飾。C，抽象類不能夠被 new 建立對象。由於調用抽象方法沒意義。D，抽象類中 的抽象方法要被使用，必須由子類複寫其全部的抽象方法後，創建子類對象調用。 2二、若是子類只覆蓋了部分抽象方法，那麼該子類仍是一個抽象類。 2三、抽象類和通常類沒有太大的不一樣。該如何描述事物，就如何描述事物，只不過，該事物 中出現了一些看不懂的東西。這些不肯定的部分，也是該事物的功能，須要明確出現，可是 沒法定義主體。經過抽象方法來表示。 2四、抽象類比通常類多了抽象方法（函數） 。就是在類中能夠定義抽象方法。 抽象類不能夠實例化（即不能夠 new） 。特殊：抽象類中能夠不定義抽象方法，這樣作僅僅 是不讓該類創建對象。 2五、什麼是模板方法呢？在定義功能時，功能的一部分是肯定的，可是有一部分是不肯定， 而肯定的部分在使用不肯定的部分。 那麼這時就將不肯定的部分暴露出去。 由該類的子類去 實現。

3、面向對象：接口
2六、接口：格式：interface{}。接口中的成員修飾符是固定的。成員常量：public static final； 成員函數： public abstract。 接口的出現將 「多繼承」 經過另外一種形式體現出來， 即 「多實現」 。 2六、接口：初期理解：能夠認爲是一個特殊的抽象類。當抽象類中的方法都是抽象的，那麼 該類能夠經過接口的形式來表示。class 用於定義類。interface 用於定義接口。 2七、接口：是不能夠建立對象的，由於有抽象方法。須要被子類實現，子類對接口中的抽象 方法所有覆蓋後，子類才能夠實例化。不然子類是一個抽象類。接口能夠被類多實現，也是 對多繼承不支持的轉換形式。java 支持多實現。用關鍵字：implements。 2八、接口與接口之間支持多繼承，類與類之間只支持單繼承。 2九、接口的特色：接口是對外暴露的規則；接口是程序的功能擴展；接口能夠用來多實現； 類與接口之間是實現關係， 並且類能夠繼承一個類的同時實現多個接口； 接口與接口之間可 以有繼承關係。

2016 年 01 月 13 日
1、面向對象：多態

day08

一、多態的定義：某一類事物的多種存在形態，例：動物中貓，狗。貓這個對象對應的類型 是貓類型：貓 x=new 貓（） ；同時貓也是動物中的一種，也能夠把貓稱爲動物。動物 y=new 貓（） ；動物是貓和狗具體事物中抽取出來的父類型；父類型引用指向了子類對象。 二、多態的體現：父類的引用指向了本身的子類對象。父類的引用也能夠接收本身的子類對 象。 三、多態的前提：必須是類與類之間有關係。要麼繼承，要麼實現。一般還有一個前提：存 在覆蓋。 四、多態的弊端：提升了擴展性，可是隻能使用父類的引用訪問父類中的成員。 五、多態的好處：多態的出現大大的提升了程序的擴展性。 六、引用數據類型轉換：類型提高。向上轉型。若是想要調用貓的特有方法時，如何操做？ 強制將父類的引用，轉成子類類型。向下轉型。注意：千萬不要出現這樣的操做，就是將父 類對象轉成子類類型。 咱們能轉換的是父類引用指向了本身的子類對象時， 該引用能夠被提 升，也能夠被強制轉換。多態自始至終都是子類對象在作着變量。 七、關鍵字：instanceof。判斷引用數據類型是否一致。 八、 在多態中成員函數的特色： 在編譯時期： 參閱引用型變量所屬的類中是否有調用的方法。 若是有，編譯經過，若是沒有編譯失敗。在運行時期：參閱對象所屬的類中是否有調用的方 法。簡單總結就是：成員函數在多態調用時，編譯看左邊，運行看右邊。 九、在多態中，成員變量的特色：不管編譯和運行，都參考左邊（引用型變量所屬的類） 。 十、object 類：是全部對象的直接或者間接父類，傳說中的上帝。該類中定義的確定是全部 對象都具有的功能。 十一、Object 類中已經提供了對對象是否相同的比較方法。若是自定義類中也有比較相同的功 能，沒有必要從新定義。只要沿襲父類中的功能，創建本身特有的比較內容便可。這就是覆 蓋。

2016 年 01 月 15 日
1、面向對象：內部類

day09

一、 內部類的定義： 將一個類定義在另外一個類的裏面， 對裏面那個類就稱爲內部類 （內置類， 嵌套類） 。 二、內部類訪問特色：內部類能夠直接訪問外部類中的成員，包括私有成員。之因此能夠直 接訪問外部類中的成員，是由於內部類中持有了一個外部類的引用，格式：外部類名 .this。 而外部類要訪問內部類中的成員必需要創建內部類的對象。 三、訪問格式：當內部類定義在外部類的成員位置上，並且非私有，能夠在外部其餘類中。 能夠直接創建內部類對象。格式：外部類名 . 內部類名變量名 = 外部類對象 . 內部類對象； Outer.Inner in=new Outer().new Inner();。

四、當內部類在成員位置上，就能夠被成員修飾符所修飾。好比，private：將內部類在外部 類中進行封裝。static：內部類就具有了 static 的特性。當內部類被 static 修飾後，只能直接 訪問外部類中的 static 成員。出現了訪問侷限。 5 、 在 外 部 其 他 類 中 ， 如 何 直 接 訪 問 static 內 部 類 的 非 靜 態 成 員 呢 ？ new Outer.Inner().function(); 。在外部其餘類中，如何直接訪問 static 內部類的靜態成員呢？ Outer.Inner().function();。 六、注意：當內部類中定義了靜態成員，該內部類必須是 static 的。當外部類中的靜態方法 訪問內部類時，內部類也必須是 static 的。 七、當描述事物時，事物的內部還有事物，該事物用內部類來描述。由於內部事物在使用外 部事物的內容。 八、 內部類定義在局部時， 1，不能夠被成員修飾符修飾； 2， 能夠直接訪問外部類中的成員， 由於還持有外部類中的引用；可是不能夠訪問它所在的局部中的變量。只能訪問被 final 修 飾的局部變量。 九、匿名內部類：1，匿名內部類其實就是內部類的簡寫格式。2，定義匿名內部類的前提： 內部類必須繼承一個類或者實現接口。3，匿名內部類的格式：new 父類或者接口（）{定 義子類的內容}。4，其實匿名內部類就是一個匿名子類對象。並且這個對象有點胖。能夠理 解爲帶內容的對象。5，匿名內部類中定義的方法最好不要超過 3 個。

2、面向對象：異常
十、異常：異常的體系：Throwable： （Error：一般出現重大問題如：運行的類不存在或者內 存溢出等；不編寫針對代碼對其處理。Exception：在運行時運行出現的一塊兒狀況，能夠經過 try catch finally） 。Exception 和 Error 的子類名稱都是以父類名做爲後綴。 十一、異常：就是程序在運行時出現不正常狀況。 十二、異常由來：問題也是現實生活中一個具體的事物，也能夠經過 java 的類的形式進行描 述，並進行封裝。其實就是 java 對不正常狀況進行描述後的對象體現。 1三、對於問題的劃分：兩種：一種是嚴重的問題。一種是非嚴重的問題。對於 Error 通常不 編寫針對性的代碼對其進行處理。 對於嚴重的， java 經過 Error 類進行描述。 對於非嚴重的， java 經過 Exception 類進行描述。對於 Exception 可使用針對性的處理方式進行處理。 1四、不管 Error 或者 Exception 都具體有一些共性內容。好比：不正常狀況的信息，引起緣由 等。 1五、異常的處理：java 提供了特有的語句進行處理。Try{須要被檢測的代碼；}catch{異常類 變量}{處理異常的代碼： （處理方式）}finally{必定會執行的語句；}。 1五、throws Exception//在功能上經過 throws 的關鍵字聲明瞭該功能有可能會出現問題。在 函數上聲明異常。便於提升安全性，讓調用者進行處理。不處理編譯失敗。 1六、對多異常的處理。1， 聲明異常時，建議聲明更爲具體的異常。 這樣處理得能夠更具體。 2，對聲明幾個異常，就對應有幾個 catch 塊。不要定義多餘的 catch 塊。若是多個 catch 塊 中的異常出現繼承關係，父類異常 catch 塊放在最下面。 17 、建議在進行 catch 處理時， catch 中必定要定義具體處理方式。不要簡單定義一句 e.printStackTrace()，也不要簡單的就書寫一條輸出語句。 1八、自定義異常：由於項目中會出現特有的問題，而這些問題並未被 java 所描述並封裝對 象。全部對於這些特有的問題能夠按照 java 的對問題封裝的思想。將特有的問題，進行自 定義的異常封裝。 1九、當在函數內部出現了 throw 拋出了異常對象，那麼就必需要給對應的處理動做。要麼在

內部 try catch 處理。要麼在函數上聲明讓調用者處理。 20、 如何定義異常信息呢？由於父類中已經把異常信息的操做都完成了。 全部子類只要在構 造時，將異常信息傳遞給父類經過 super 語句。那麼就能夠直接經過 getMessage 方法獲取 自定義的異常信息。 2一、自定義異常：必須是自定義類繼承 Exception。繼承 Exception 緣由：異常體系有一個特 點：由於異常類和異常對象都被拋出。他們都具有可拋性。這個可拋性是 Throwable 這個體 系中獨有特色。 2二、只有這個體系中的類和對象才能夠被 throws 和 throw 操做。 2三、throws 和 throw 的區別：throws 使用在函數上。throw 使用在函數內。throws 後面跟的 異常類。能夠跟多個。用逗號隔開。throw 後跟的是異常對象。 2四、Exception 中有一個特殊的子類異常 RuntimeException 運行時異常。若是在函數內容拋 出該異常，函數上能夠不用聲明，編譯同樣經過。若是在函數上聲明瞭該異常。調用者能夠 不用進行處理，編譯同樣經過。 2五、之因此不用在函數聲明，是由於不須要讓調用者處理。當該異常發生，但願程序中止。 由於在運行時，出現了沒法繼續運算的狀況，但願中止程序。對代碼進行修正。 26 、自定義異常時：若是該異常的發生，沒法在繼續進行運算，就讓自定義異常繼承 RuntimeException。 2七、對於異常分兩種：1，編譯時被檢測的異常。2，編譯時不被檢測的異常（運行時異常， RuntimeException 以及其子類） 。

2016 年 01 月 16 日
1、面向對象：異常

day10

一、finally 中存放的是必定會被執行的代碼。 二、finally 代碼塊：定義必定執行的代碼。一般用於關閉資料。 三、記住一點：catch 是用於處理異常。若是沒有 catch 就表明沒有被處理過，若是該異常時 檢測時的異常，就必須聲明出去。 四、異常在子父類覆蓋中的體現：A，子類在覆蓋父類時，若是父類的方法拋出異常，那麼 子類的覆蓋方法， 只能拋出父類的異常或者該異常的子類。 B， 若是父類方法拋出多個異常， 那麼子類在覆蓋該方法時，只能拋出父類異常的子集。C，若是父類或者接口的方法中沒有 異常拋出，那麼子類在覆蓋方法時，也不能夠拋出異常。若是子類方法發生了異常。就必須 要進行 try 處理。絕對不能拋。 五、異常：是什麼？是對問題的描述，將問題進行對象的封裝。 六、異常體系：Throwable：|--Error；|--Exception（|--RuntimeException） 。 七、異常體系的特色：異常體系中的全部類以及創建的對象都具有可拋性。也就是說能夠被 throw 和 throws 關鍵字所操做。只有異常體系具有這個特色。 八、throw 和 throws 的用法：throw 定義在函數內，用於拋出異常對象。throws 定義在函數 上，用於拋出異常類，能夠拋出多個用逗號隔開。 九、當函數內容有 throw 拋出異常對象，並未進行 try 處理。必需要在函數上聲明，都在編 譯失敗。注意：RuntimeException 除外。也就是說，函數內若是拋出的 RuntimeException 異 常，函數上能夠不用聲明。

十、若是函數聲明瞭異常，調用者須要進行處理。處理方法能夠 throws 和 try。 十一、 異常有兩種： 編譯時被檢測異常： 該異常在編譯時， 若是沒有處理 （沒有拋也沒有 try） ， 編譯失敗。該異常被標識，表明着能夠被處理。運行時異常（編譯時不檢測） ：在編譯時， 不須要處理，編譯器不檢查。該異常的發生，創建不處理，讓程序中止。須要對代碼進行修 正。 十二、異常處理語句：try（須要被檢測的代碼； ） catch（處理異常的代碼； ） finally（必定會 執行的代碼； ） 。有三種結合格式：try catch；try finally；try catch finally。注意：A，finally 中 定義的一般是關閉資源代碼。由於資源必須釋放。B，finally 只有一種狀況不會執行。當執 行到 System.exit(0);finally 不會執行。 1三、自定義異常：定義類繼續 Exception 或者 RuntimeException。A，爲了讓該自定義類具有 可拋性。B，讓該類具有操做異常的共性方法。當要定義自定義異常的信息時，可使用父 類已經定義好的功能。異常異常信息傳遞給父類的構成函數。 class MyException extends Exception{MyException(String message){super(message);}}。 1四、自定義異常：按照 java 的面向對象思想，將程序中出現的特有問題進行封裝。 1五、異常的好處：A，將問題進行封裝。B，將正常流程代碼和問題處理代碼相分離，方便 於閱讀。 1六、異常的處理原則：A，處理方式有兩種：try 或者 throws。B，調用到拋出異常的功能時， 拋出幾個， 就處理幾個。 一個 try 對應多個 catch。 C， 多個 catch， 父類的 catch 放到最下面。 D，catch 內須要定義針對性的處理方式。不要簡單的定義 printStackTrace,輸出語句。也不要 不寫。當捕獲到的異常，本功能處理不了時，能夠繼續在 catch 中拋出。 1七、異常的注意事項：在子父類覆蓋時：A，子類拋出的異常必須是父類異常的子類或者子 集。B，若是父類或者接口沒有異常拋出時，子類覆蓋出現異常，只能 try 不能拋。

2、面向對象：包
1八、包（package） ：對類文件進行分類管理。給類提供多層命名空間。寫在程序文件的第一 行。類名的全稱的格式是：包名.類名。包也是一種封裝形式。 1九、關鍵字 protected：/*保護*/權限。權限修飾符。可用於修飾包裏的父類。 20、總結：包與包之間進行訪問，被訪問的包中的類以及類中的成員，須要 public 修飾。不 同包中的子類還能夠訪問直接父類中被 protected 權限修飾的成員。 2一、包與包之間可使用的權限只有兩種，public protected。 2二、public protected default private 同一個類中能夠能夠能夠能夠 同一個包中能夠 能夠能夠 不能夠 子類能夠 能夠不能夠不能夠 不一樣包中 能夠不能夠不能夠不能夠。 2三、爲了簡化類名的書寫，使用一個關鍵字 import。import 導入的是包中的類。建議，不要 寫通配符*，須要用到包中的哪一個類，就導入哪一個類。 2四、建議定義包名不要重複，可使用 url 來完成定義，url 是惟一的。 2五、jar 包：java 的壓縮包：方便項目的攜帶。方便於使用，只要在 classpath 設置 jar 路徑即 可。數據庫驅動，SSH 框架等都以 jar 包體現的。

2016 年 01 月 17 日
1、多線程：概述

day11

一、進程：是一個正在執行中的程序。每個進程執行都有一個執行順序。該順序是一個執 行路徑，或者叫一個控制單元。 二、線程：就是進程中的一個獨立的控制單元。線程在控制着進程的執行。一個進程中至少 有一個線程。 三、Java VM 啓動的時候會有一個進程 java.exe。該進程中至少有一個線程負責 java 程序的 執行。並且這個線程運行的代碼存在於 main 方法中。該線程稱之爲主線程。擴展：其實更 細節說明 jvm，jvm 啓動不止一個線程，還有負責垃圾回收機制的線程。 四、如何在自定義的代碼中，自定義一個線程呢？經過對 API 的查找，java 已經提供了對線 程這類事物的描述。就是 Thread 類。 五、建立線程的第一種方式：繼承 Thread 類。步驟：1，定義類繼承 Thread。2，複寫 Thread 類中的 run 方法。目的：將自定義代碼存儲在 run 方法中，讓線程運行。3，調用線程的 start 方法，該方法有兩個做用：啓動線程；調用 run 方法。 六、發現運行結果每一次都不一樣：由於多個線程都獲取 cpu 的執行權。cpu 執行到誰，誰就 運行。明確一點，在某一時刻，只能有一個程序在運行。 （多核除外）cpu 在作着快速的切 換，以達到看上去是同時運行的效果。咱們能夠形象把多線程的運行形容爲在互相搶奪 cpu 的執行權。 這就是多線程的一個特性： 隨機性。 誰搶到誰執行， 至於執行多長， cpu 說了算。 七、爲何要覆蓋 run 方法呢？Thread 類用於描述線程。該類就定義了一個功能，用於存儲 線程要運行的代碼，該存儲功能就是 run 方法。也就是說 Thread 類中的 run 方法，用於存 儲線程要運行的代碼。 八、 原來線程都有本身默認的名稱。 Thread-編號。 該編號從 0 開始。 static Thread currentThread()： 獲取當前線程對象。getName()：獲取線程名稱。設置線程名稱：setName 或者構造函數。 九、建立線程的第二種方式：實現 Runnable 接口。 步驟：1，定義類實現 Runnable 接口。2，覆蓋 Runnable 接口中的 run 方法。目的：將線程 要運行的代碼存放在 run 方法中。3，經過 Thread 類創建線程對象。4，將 Runnable 接口的 子類對象做爲實際參數傳遞給 Thread 類的構造函數。爲何要將 Runnable 接口的子類對象 傳遞給 Thread 的構造函數？由於，自定義的 run 方法所屬的對象時 Runnable 接口的子類對 象。全部要讓線程去指定指定對象的 run 方法。就必須明確該 run 方法所屬對象。5，調用 Thread 類的 start 方法開啓線程並調用 Runnable 接口子類的 run 方法。 十、實現方式和基礎方法有什麼區別呢？實現方式好處：避免了單繼承的侷限性。在定義線 程時，建議使用實現方式。兩種方式區別：繼承 Thread：線程代碼存放在 Thread 子類 run 方法中。實現 Runnable：線程代碼存放在接口的子類的 run 方法中。

2、多線程：同步
十一、 多線程的運行出現了安全問題： 問題的緣由： 當多條語句在操做同一個線程共享數據時， 一個線程對多條語句只執行了一部分，汗沒有執行完，另外一個線程參與進來執行。致使共享 數據的錯誤。解決辦法：對多條操做共享數據的語句，只能讓一個線程都執行完。在執行過

程過，其餘線程不能夠參與執行。java 對於多線程的安全問題提供了專業的解決方式。就是 同步代碼塊。synchronized(對象){須要被同步的代碼；}。 十二、 對象如同鎖。 持有鎖的線程能夠在同步中執行。 沒有鎖的線程即便獲取了 cpu 的執行權， 也進不去，由於沒有獲取鎖。 1三、 同步的前提： 1， 必需要有兩個或者兩個以上的線程。 2， 必須是多個線程使用同一個鎖。 必須保證同步中只能有一個線程在運行。 1四、好處：解決了多線程的安全問題。弊端：多個線程須要判斷鎖，較爲消耗資源。 1五、多線程安全問題：如何找到問題：1，明確哪些代碼是多線程運行代碼。2，明確共享數 據。3，明確多線程運行代碼中哪些語句是操做共享數據的。 1六、 同步函數： 將關鍵字 synchronized 放到函數名稱前。 即把 synchronized 看成修飾符使用。 1七、同步函數用的是哪個鎖呢？函數須要被對象調用。那麼函數都有一個所屬對象引用。 就是 this。全部同步函數使用的鎖是 this。 1八、若是同步函數被靜態修飾後，使用的鎖是什麼呢？經過驗證，發現再也不是 this。由於靜 態方法中也不能夠定義 this。靜態進內存時，內存中沒有本類對象，可是必定有該類對應的 字節碼文件對象。類名.class 該對象的類型是 Class。靜態的同步方法，使用的鎖是該方法所 在類的字節碼文件對象。類名.class。 1九、死鎖：同步中嵌套同步。而鎖卻不一樣。

2016 年 01 月 18 日
1、多線程：線程間通訊

day12

一、wait()，notify()，notifyALL()，用來操做線程爲何定義在了 Object 類中？這些方法存在 於同步中。使用這些方法時必需要標識所屬的同步的鎖。鎖能夠是任意對象，因此任意對象 調用的方法必定定義 Object 類中。 二、wait()和 sleep()有什麼區別？wait()：釋放資源，釋放鎖。sleep()：釋放資源，不釋放鎖。 三、wait：notify：notifyALL：都被使用在同步中，由於要對持有監視器（鎖）的線程操做。 全部要使用在同步中，由於只有同步才具備鎖。 四、 爲何這些操做線程的方法要定義在 Object 類中呢？由於這些方法在操做同步中線程時， 都必需要標識他們所操做線程只有的鎖。 只有同一個鎖上的被等待線程， 能夠被同一個鎖上 notify 喚醒。不能夠對不一樣鎖中的線程進行喚醒。也就是說，等待和喚醒必須是同一個鎖。 而鎖能夠是任意對象，全部能夠被任意對象調用的方法定義在 Object 類中。 五、JDK1.5 中提供個多線程升級解決方案。將同步 synchronized 替換成現實 Lock 操做。將 Object 中的 wait，notify，notifyAll，替換了 condition 對象。該對象能夠 Lock 鎖，進行獲取。

2、多線程：其餘操做
六、中止線程：A：定義循環結束標記：由於線程運行代碼通常都是循環，只要控制了循環 便可。B：使用 interrupt（中斷）方法：該方法時結束線程的凍結狀態，使線程回到運行狀 態中來。注意：stop 方法已通過時再也不使用。 七、如何中止線程？只有一種，run 方法結束。開啓多線程運行，運行代碼一般是循環結構。

只要控制住循環，就可讓 run 方法結束，也就是線程結束。特殊狀況：當線程處於了凍結 狀態。就不會讀取到標記。那麼線程就不會結束。 八、當沒有指定的方式讓凍結的線程恢復到運行狀態時，這時須要對凍結進行清除。強制讓 線程恢復到運行狀態中來。這樣就能夠操做標記讓線程結束。 Thread 類中提供該方法： interrupt 方法。 九、join 方法：當 A 線程執行到了 B 線程的.join()方法時，A 就會等待。等 B 線程都執行完， A 纔會執行。join 能夠用來臨時加入線程執行。

2016 年 01 月 19 日
1、String 類：概述

day13

一、 String 類： 字符串是一個特殊的對象。 字符串一旦初始化就不能夠被改變。 String str=」abc」； String str1=new String(「abc」)； 。Str 和 str1 的區別：str 在內存中有一個對象。Str1 在內存中有 兩個對象。

2、***重點：String 類：常見操做
常見的操做有哪些？ "abcd" 1，獲取。 1.1 字符串中包含的字符數，也就是字符串的長度。 int length()：獲取長度。 1.2 根據位置獲取位置上某個字符。 char charAt(int index)：獲取位置上某個字符。 1.3 根據字符獲取該字符在字符串中位置。 int indexOf(int ch)：獲取該字符在字符串中位置。返回的是 ch 在字符串中第一次出 現的位置。 int indexOf(int ch,int fromIndex)：從 fromIndex 指定位置開始，獲取 ch 在字符串中 出現的位置。 int indexOf(String str)：返回的是 str 在字符串中第一次出現的位置。 int indexOf(String str,int fromIndex)：從 fromIndex 指定位置開始，獲取 str 在字符串 中出現的位置。 int lastIndexOf(int ch)：反向索引。 2，判斷。 2.1 字符串中是否包含某一個子串。 boolean contains(str); 特殊之處：indexOf(str)：能夠索引 str 第一次出現位置，若是返回-1,表示該 str 不在 字符串中存在。

因此，也能夠用於對指定判斷是否包含。 if(str.indexOf("aa")!=-1) 並且該方法既能夠判斷又能夠獲取出現的位置。 2.2 字符串是否有內容。 boolean isEmpty(str)：原理就是判斷長度是否爲 0。 2.3 字符串是不是以指定內容開頭。 boolean startsWith(str); 2.4 字符串是不是以指定內容結尾。 boolean endsWith(str); 2.5 判斷字符串的內容是否相同。複寫了 Object 類中的 equals 方法。 boolean equals(str); 2.6 判斷內容是否相同，並忽略大小寫。 boolean equalsIgnoreCass(); 3，轉換。 3.1 將字符數組轉成字符串。 構造函數：String(char[]) String(char[],offset,count)：將字符數組中的一部分轉成字符串。 靜態方法：static String copyValueOf(char[]); static String copyValueOf(char[] data,int offset,int count); static String valueOf(char[]); 3.2 將字符串轉成字符數組。//重點**。 char[] toCharArray(); 3.3 將字節數組轉成字符串。 String(byte[]) String(byte[],offset,count)：將字節數組中的一部分轉成字符串。 3.4 將字符串轉成字節數組。 byte[] getBytes(); 3.5 將基本數據類型轉成字符串。 static String valueOf(int) static String valueOf(double) //3+"";//String.valueOf(3); 特殊：字符串和字節數組在轉換過程當中，是能夠指定編碼表的。 4，替換。 String replace(oldchar,newchar); 5，切割。 String[] split(regex); 6，子串。獲取字符串中的一部分。 String substring(begin); String substring(begin,end); 7，轉換，去除空格，比較。 7.1 將字符串轉成大寫或者小寫。 String toUpperCase(); String toLowerCase(); 7.2 將字符串兩端的多個空格去除。

String trim(); 7.3 對兩個字符串進行天然順序的比較。 int compareTo(string);

3、String 類：StringBuffer
八、StringBuffer 類：字符串的注組成原理就是經過該類實現的。StringBuffer 能夠對字符串內 容進行增刪。StringBuffer 是一個容器。不少方法與 String 相同。StringBuffer 是可變長度的。 九、StringBuffer 是字符串緩衝區。是一個容器。 十、緩衝區的特色：1，並且長度是可變化的。2，能夠直接操做多個數據類型。3，最終會 經過 toString 方法變成字符串。 十一、StringBuffer 常見操做： C create U update R read D delete 1，存儲。 StringBuffer append()：將指定數據做爲參數添加到已有數據的結尾處。 StringBuffer insert(index,數據)：能夠將數據插入到指定 index 位置。 2，刪除。 StringBuffer delete(start,end)：刪除緩衝區中的數據，包含 start，不包含 end。 StringBuffer deleteCharAt(index)：刪除指定 index 位置的字符。 3，獲取。 char charAt(int index); int indexOf(String str); int lastIndexOf(String str); int length(); String substring(int start,int end); 4，修改。 StringBuffer replace(start,end,string); void setCharAt(int index,char ch); 5，反轉。 StringBuffer reverse(); 6，將緩衝區中指定數據存儲到指定字符數組中。 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)。 十二、JDK1.5 版本以後出現了 StringBuilder。 StringBuffer 是線程同步。單線程使用 StringBuffer 效率較低。多線程使用 StringBuffer 保證了 安全性。 StringBuilder 是線程不一樣步。單線程使用 StringBuilder 提升了效率。多線程使用 StringBuilder 可能存在安全問題，但能夠經過自定義鎖來解決安全問題。 之後開發，建議使用 StringBuilder。 1三、升級三個因素：1，提升效率。2，簡化書寫。3，提升安全性。

4、基本數據類型對象包裝類
1四、 基本數據類型對象包裝類的最多見做用： 就是用於基本數據類型和字符串類型之間作轉

換。 1五、數據類型轉換： A：基本數據類型轉成字符串。 基本數據類型+"" 基本數據類型.toString(基本數據類型值); 如：Integer.toString(34);//將 34 整數變成"34"。 B：字符串轉成基本數據類型。 靜態：基本數據類型包裝類.parseInt(字符串); 如：xxx a=Xxx.parseXxx(String); int a=Integer.parseInt("123"); double d=Double.parseDouble("12.23"); boolean b=Boolean.parseBoolean("true"); 非靜態： Integer i=new Integer("123"); int num=i.intValue(); C：十進制轉成其餘進制。 toBinaryString(); toHexString(); toOctalString(); D：其餘進制轉成十進制。 parseInt(string,radix);。

2016 年 01 月 22 日
1、集合框架：概述

day14

一、集合類：爲何會出現集合類？面嚮對象語言對事物的體現都是以對象的形式，全部爲 了方便對多個對象的操做，就對對象進行存儲，集合就是存儲對象最經常使用的一種方式。 二、數組和集合類同是容器，有何不一樣？數組雖然也能夠存儲對象，但長度是固定的；集合 長度是可變的，數組中能夠存儲基本數據類型，集合只能存儲對象。 三、集合類的特色：集合只用於存儲對象，集合長度是可變的，集合能夠存儲不一樣類型的對 象。 四、爲何會出現這麼多的容器呢？由於每個容器對數據的存儲方式有所不一樣。這個存儲 方式稱之爲：數據結構。 五、add 方法的參數類型是 Object。以便於接收任意類型對象。集合中存儲的都是對象的引 用（地址） 。 六、什麼是迭代器呢？其實就是集合的取出元素的方式。

2、集合框架：List 類
七、List:

特有方法。凡是能夠操做角標的方法都是該體系特有的方法。 增 add(index,element); addAll(index,Collection); 刪 remove(index); 改 set(index,element); 查 get(index); subList(from,to); listIterator(); 八、List 集合特有的迭代器。ListIterator 是 Iterator 的子接口。在迭代時，不能夠經過集合對 象的方法操做集合中的元素。由於會發生 ConcurrentModificationException 異常。全部，在 迭代器時，只能用迭代器的方法操做元素，能夠 Iterator 方法時優先的，只能對元素進行判 斷， 取出， 刪除的操做， 若是想要其餘的操做如添加， 修改等， 就須要使用其子接口， ListIterator。 該接口只能經過 List 集合的 ListIterator 方法獲取。 九、Collection |--List:元素是有序的，元素能夠重複。由於該集合體繫有索引。 |--ArrayList:底層的數據結構使用的是數組結構。特色：查詢速度很快。可是增刪稍 慢。線程不一樣步。 |--LinkedList:底層使用的是鏈表數據結構。特色：增刪速度很快，查詢速度稍慢。 |--Vector:底層是數據數據結構。線程同步。被 ArrayList 替代了。 |--Set:元素是無序的，元素不能夠重複。 十、 枚舉就是 Vector 特有的取出方式。 發現枚舉和迭代器很像。 其實枚舉和迭代是同樣的。 由於枚舉的名稱以及方法的名稱都過長。全部被迭代器取代了。枚舉鬱鬱而終了。 十一、LinkedList：特有方法： addFirst(); addLast(); getFirst(); getLast(); 獲取元素，可是不刪除元素。若是集合中沒有元素，會出現 NoSuchElementException。 removeFirst(); removeLast(); 獲取元素，可是元素被刪除。若是集合中沒有元素，會出現 NoSuchElementException。 在 JDK1.6 出現了替代方法。 offerFirst(); offerLast(); peekFirst(); peekLast();

獲取元素，可是不刪除元素。若是集合中沒有元素，會返回 null。 pollFirst(); pollLast(); 獲取元素，可是元素被刪除。若是集合中沒有元素，會返回 null。

3、集合框架：Set 類
十二、HaseSet 是如何保證元素惟一性的呢？是經過元素的兩個方法，hashCode 和 equals 來完 成。若是元素的 hashCode 值相同，纔會判斷 equals 是否爲 true。若是元素的 hashCode 值 不一樣，不會調用 equals。 1三、注意：對於判斷元素是否存在，以及刪除操做，依賴的方法時元素的 hashcode 和 equals 方法。

2016 年 1 月 23 日
1、集合框架：Set 類

day15

一、Set：無序，不能夠重複元素。 |--HashSet：數據結構是哈希表。線程是非同步的。 保證元素惟一性的原理：判斷元素的 hashCode 值是否相同。 若是相同，還會繼續判斷元素的 equals 方法，是否爲 true。 |--TreeSet：能夠對 Set 集合中的元素進行排序。 底層數據結構是二叉樹。 保證元素惟一性的依據： compareTo 方法和 return 0。 二、TreeSet 排序的第一種方式：讓元素自身具有比較性。元素須要實現 comparable 接口， 覆蓋 comparaeTo 方法。這種方式也稱爲元素的天然順序，或者默認順序。 三、TreeSet 排序的第二種方式：當元素自身不具有比較性時，或者具有的比較性不是所須要 的。這時就須要讓集合自身具有比較性。在集合初始化時，就有了比較方式。 四、當元素自身不具有比較性，或者具有的比較性不是所須要的。這時須要讓容器自身具有 比較性。定義了比較器，將比較器對象做爲參數傳遞給 TreeSet 集合的構造函數。 五、 當兩種排序都存在時， 以比較器爲主。 定義一個類， 實現 Comparator 接口， 覆蓋 compare 方法。

2、集合框架：泛型
六、泛型：JDK1.5 版本之後出現的新特性。用於解決安全問題，是一個類型安全機制。 七、泛型的好處：好處：1，將運行時期出現問題 ClassCastException，轉移到了編譯時期。方 便於程序員解決問題。讓運行時期問題減小。更加安全。2，避免了強制轉換麻煩。 八、泛型格式：經過<>來定義要操做的引用數據類型。在使用 java 提供的對象時，何時

寫泛型呢？一般在集合框架中很常見。 只要見到<>就要定義泛型。 其實<>就是用來接收類型 的。當使用集合時，將集合中要存儲的數據類型做爲參數傳遞到<>便可。 九、何時定義泛型類？當類中要操做的引用數據類型不肯定的時候，早期定義 Object 來 完成擴展。如今定義泛型來完成擴展。 十、泛型類定義的泛型，在整個類中有效。若是被方法使用，那麼泛型類的對象明確要操做 的具體類型後，全部要操做的類型就已經固定了。爲了讓不一樣方法能夠操做不一樣類型，並且 類型還不肯定，那麼能夠將泛型定義在方法上。 十一、特殊之處：靜態方法不能夠訪問類上定義的泛型。若是靜態方法操做的引用數據類型不 肯定，能夠將泛型定義在方法上。 十二、? 通配符。也理解爲佔位符。 泛型的限定： ？ extends E：能夠接收 E 類型或者 E 的子類型。上限。 ？ super E：能夠接收 E 類型或者 E 的父類型。下限。

2016 年 01 月 24 日
1、集合：Map 概述

day16

一、Map 集合：該集合存儲鍵值對。一對一對往裏存，並且要保證鍵的惟一性。 二、Map 框架： 1，添加。 put(K key,V value) putAll(Map<? extends K,? extends V> m) 2，刪除。 clear() remove(Object key) 3，判斷。 containsValue(Object value) containsKey(Object key) isEmpty() 4，獲取。 get(Object key) size() values() entrySet() keySet() 三、Map |--HashTable：底層是哈希表數據結構，不能夠存入 null 鍵 null 值，該集合是線程同步 的。JDK1.0。效率低。 |--HashMap：底層是哈希表數據結構，容許使用 null 鍵和 null 值，該集合是不一樣步的。 JDK1.2。效率高。

|--TreeMap：底層是二叉樹數據結構，線程不一樣步，能夠用於給 map 集合中的鍵進行排 序。 四、和 Set 很像。其實你們，Set 底層就是使用了 Map 集合。 五、map 集合的兩種取出方式：1，keySet：將 map 中全部的鍵存入到 Set 集合。由於 Set 具 備迭代器。因此能夠迭代方式取出全部的鍵，在根據 get 方法，獲取每個鍵對應的值。 Map 集合的取出原理： 將 map 集合轉成 set 集合。 在經過迭代器取出。 2， Set<Map.Entry<k,v>> entrySet：將 map 集合中的映射關係存入到了 set 集合中，而這個關係的數據類型就是： Map.Entry。 六、Map.Entey 其實 Entry 也是一個接口，它是 Map 接口中的一個內部接口。 七、何時使用 map 集合呢？當數據之間存在映射關係時，就要先想到 map 集合。 八、map 擴展知識：map 集合被使用是由於具有映射關係。

2016 年 01 月 26 日
1、集合：Collections
一、fill 方法能夠將 list 集合中全部元素替換成指定元素。

day17

2、集合：Arrays
二、Arrays：用於操做數組的工具類。裏面都是靜態方法。 三、asList：將數組變成 list 集合。 四、把數組變成 list 集合有什麼好處？可使用集合的思想和方法來操做數組中的元素。注 意： 將數組變成集合， 不可使用集合的增刪方法。 由於數據的長度是固定的。 若是你增刪， 那麼會發生 UnsupportedOperationException。 五、數組變集合：若是數組中的元素都是對象。那麼變成集合時，數組中的元素就直接轉成 集合中的元素。 若是數組中的元素都是基本數據類型， 那麼會將該數組做爲集合中的元素存 在。 六、集合變數組：指定類型的數組到底要定義多長呢？當指定類型的數組長度小於了集合的 size，那麼該方法內部會建立一個新的數組，長度爲集合的 size。當指定類型的數組長度大 於了集合的 size，就不會新建立數組，而是使用傳遞進來的數組。因此建立一個剛恰好的數 組最優。 七、爲何要講集合變數組？爲了限定對元素的操做。不須要進行增刪了。 八、高級 for 循環：格式：for（數據類型變量名：被遍歷的集合（Collection）或者數組） ｛｝ 。 九、高級 for 循環、迭代器、ListIterator 的區別： 高級 for 循環對集合進行遍歷。只能獲取集合元素，可是不能對集合進行操做。 迭代器除了遍歷，還能夠進行 remove 集合中元素的動做。 若是使用 ListIterator，還能夠在遍歷過程當中對集合進行增刪改查的操做。 十、傳統 for 和高級 for 有什麼區別呢？高級 for 有一個侷限性：必須有被遍歷的目標。建議 在遍歷數組的時候，仍是但願使用傳統 for。由於傳統 for 能夠定義角標。 十一、JDK1.5 版本出現的新特性：可變參數：其實就是上一種數組參數的簡寫形式。不用每一

次都手動的創建數組對象。 只要將要操做的元素做爲參數傳遞便可。 隱式將這些參數封裝成 了數組。 十二、方法的可變參數。在使用時注意：可變參數必定要定義在參數列表最後面。 1三、import static：靜態導入：例如：import static java.lang.System.*;//導入了 System 類中所 有靜態成員。注意：當類名重名時，須要制定具體的包名。當方法重名時，指定具有所屬的 對象或者類。

2016 年 01 月 28 日
1、其餘對象：System

day18

一、System:類中的方法和屬性都是靜態的。out:標準輸出，默認是控制檯。int:標準輸入，默 認是鍵盤。描述系統一些信息。 二、獲取系統屬性信息：Properties getProperties();。由於 Properties 是 Hashtable 的子類，也 就是 Map 集合的一個子類對象。那麼能夠經過 map 的方法取出該集合中的元素。該集合中 存儲都是字符串。沒有泛型定義。 三、Runtime 對象：該類並無提供構造函數。說明不能夠 new 對象。那麼會直接想到該類 中的方法都是靜態的。 發現該類中還有非靜態方法。 說明該類確定會提供方法獲取本類對象。 並且該方法是靜態的， 並返回值類型是本類類型。 由這個特色能夠看出該類使用了單例設計 模式完成。該方式的 static Runtime getRuntime();。 四、Math 類：ceil 方法：返回大於指定數據的最小整數。floor 方法：返回小於指定數據的最 大整數。round 方法：四捨五入。pow 方法：冪運算。random：返回 0-1 之間的隨機數。

2、IO 流：概述
五、IO(Input Outpu)流：IO 流用來處理設備之間的數據傳輸。Java 對數據的操做是經過流的 方式。Java 用於操做流的對象都在 IO 包中。流按操做數據分爲兩種：字節流與字符流。流 按流向分爲：輸入流，輸出流。 六、IO 流經常使用基類：字節流的抽象基類：InputStream，OutputStream。字節流的抽象基類： Reader， Writer。 注： 由這四個類派生出來的子類名稱都是以其父類名做爲子類名的後綴 （如： InputStream 的子類 FilelnputStream，如：Reader 的子類 FileReader。 ） 。 七、 字符流和字節流： 字節流兩個基類： InputStream OutputStream。 字符流兩個基類： Reader Writer。 先學習字符流的特色： 既然 IO 流是用於操做數據的， 那麼數據的最多見體現形式是： 文件。

2016 年 01 月 30 日
1、IO 流：Buffered 緩衝區

day19

一、字符流的緩衝區：緩衝區的出現提升了對數據的讀寫效率。對應類：BufferedWriter； BufferedReader。緩衝區要結合流纔可使用。在流的基礎上對流的功能進行了加強。 二、緩衝區的出現是爲了提升流的操做效率而出現的。因此在建立緩衝區以前，必需要先有 流對象。該緩衝區中提供了一個跨平臺的換行符。newLine();。 三、字符讀取流緩衝區：該緩衝區提供了一次讀一行的方法 readLine()，方便於對文本數據的 獲取。當返回 null 時，表示讀到文件末尾。 四、readLine 方法返回的時候只返回回車符以前的數據內容。並不返回回車符。 五、裝飾設計模式：當想要對已有的對象進行功能加強時，能夠定義類，將已有對象傳入， 基於已有的功能，並提供增強功能。那麼自定義的該類稱爲裝飾類。 六、裝飾類一般會經過構造方法接收被裝飾的對象。並基於被裝飾的對象的功能，提供更強 的功能。 七、裝飾模式比繼承要靈活，避免了繼承體系臃腫。並且下降了類與類之間的關係。裝飾類 由於是加強已有對象，具有的功能和已有的是相同的，只不過提供了更強功能。因此裝飾類 和被裝飾類一般是都屬於一個體系中的。

2、IO 流：字節流
八、字符流： FileReader FileWriter BufferedReader BufferedWriter 字節流： InputStream OutputStream BufferedInputStream BufferedOutputStream 九、流操做的基本規律： 最痛苦的就是流對象有不少，不知道該用哪個。 經過兩個明確來完成。 1，明確源和目的。 源：輸入流。InputStream Reader。 目的：輸出流。OutputStream Writer。 2，明確操做的數據是不是純文本。 是：字符流。 不是：字節流。 3，當體系明確後，再明確要使用哪一個具體的對象。

經過設備來進行區分： 源設備：內存，硬盤，鍵盤。 目的設備：內存，硬盤，控制檯。

2016 年 01 月 31 日
1、IO 流：File 類

day20

一、File 類：用來將文件或者文件夾封裝成對象。方便對文件與文件夾進行操做。File 對象可 以做爲參數傳遞給流的構造函數。瞭解 File 類中的經常使用方法。 二、File 類常見方法： 1，建立。 boolean createNewFile()；在指定位置建立文件，若是該文件已經存在，則不建立，返回 false。 和輸出流不同， 輸出流對象一創建建立對象。 並且文件已 經存在，會覆蓋。 boolean mkdir();建立一級文件夾。 boolean mkdirs();建立多級文件夾。 2，刪除。 boolean delete();刪除失敗返回 false。 void deleteOnExit();在程序退出時刪除指定文件。 3，判斷。 boolean exists();文件是否存在。 boolean isFile();判斷是不是文件。 boolean isDirectory();判斷是不是文件夾。 boolean isHidden();判斷是不是隱藏文件。 boolean isAbsolute();判斷是不是絕對路徑。 4，獲取信息。 String getName();獲取文件名稱。 String getPath();獲取文件相對路徑。 String getParent();該方法返回的是絕對路徑中的父目錄。若是獲取的是相對路徑，返回 null。 若是相對路徑中有上一層目錄那麼該目錄就是返回結果。 getAbsolute();獲取文件絕對路徑。 lastModified();返回文件最後一次被修改的時間。 length();。 三、由於目錄中還有目錄，只要使用同一個列出目錄功能的函數完成便可。在列出過程當中出 現的仍是目錄的話，還能夠再次調用本功能。也就是函數自身調用自身。這種表現形式，或 者編程手法，稱爲遞歸。 遞歸要注意：1，限定條件。2，要注意遞歸的次數。儘可能避免內存溢出。 四、 練習： 將一個指定目錄下的 java 文件的絕對路徑， 存儲到一個文本文件中。 創建一個 java 文件列表文件。思路：1，對指定的目錄進行遞歸。2，獲取遞歸過程全部的 java 文件的路

徑。3，將這些路徑存儲到集合中。4，將集合中的數據寫入到一個文件中。

2、IO 流：Properties 類
五、Properties 是 hashtable 的子類。也就是說它具有 map 集合的特色。並且它裏面存儲的鍵 值對都是字符串。是集合中和 IO 技術相結合的集合容器，該對象的特色：能夠用於鍵值對 形式的配置文件。 六、那麼在加載數據時，須要數據有固定格式：鍵=值。

3、IO 流：其餘類
七、打印流：PrintWriter 與 PrintStream：能夠直接操做輸入流和文件。 打印流： 該流提供了打印方法，能夠將各類數據類型的數據都原樣打印。 字節打印流：PrintStream 構造函數能夠接收的參數類型： 1，file 對象。File。 2，字符串路徑。String。 3，字節輸出流。OutputStream。 字符打印流：PrintWriter 構造函數能夠接收的參數類型： 1，file 對象。File。 2，字符串路徑。String。 3，字節輸出流。OutputStream。 4，字符數出來：Writer。 八、序列流：SequenceInputStream：對多個流進行合併。 九、操做對象：ObjectInputStream 與 ObjectOutputStream：被操做的對象須要實現 Serializable （標記接口） 。

2016 年 02 月 01 日
1、IO 流：其餘類

day21

一、RandomAccessFile：隨機訪問文件，自身具有讀寫的方法。經過 skipBytes(int x),seek(int x) 來達到隨機訪問。 二、管道流：PipedInputStream 和 PipedOutputStream：輸入輸出能夠直接進行鏈接，經過結 合線程使用。 三、RandomAccessFile：該類不算是 IO 體系中子類。而是直接繼承自 Object。可是它是 IO 包 中成員。由於它具有讀和寫功能。內部封裝了一個數組，並且經過指針對數據的元素進行操 做。能夠經過 getFilePointer 獲取指針位置。同時能夠經過 seek 改變指針的位置。其實完成 讀寫的原理就是內部封裝了字節輸入流和輸出流。 經過構造函數能夠看出， 該類只能操做文

件。並且操做文件還有模式：只讀 r，讀寫 rw 等。 四、若是模式爲只讀 r。不會建立文件。會去讀取一個已存在文件，若是該文件不存在，則 會出現異常。若是模式爲讀寫 rw。操做的文件不存在，會自動建立。 若是存在則不會覆蓋。 五、IO 包中的其餘類： 操做基本數據類型：DataInputStream 與 DataOutputStream。 操做字節數組：ByteArrayInputStream 與 ByteArrayOutputStream。 操做字符數組：CharArrayReader 與 CharArrayWrite。 操做字符串：StringReader 與 StringWriter。 六、用於操做字節數組的流對象。 ByteArrayInputStream ：在構造的時候，須要接收數據源，並且數據源是一個字節數組。 ByteArrayOutputStream ：在構造的時候，不用定義數據目的，由於該對象中已經內部封裝 了可變長度的字節數組。這就是數據目的地。由於這兩個流對象都操做的數組，並無使用 系統資源。因此，不用進行 close 關閉。 在流操做規律講解時： 源設備： 鍵盤 System.in，硬盤 FileStream，內存 ArrayStream。 目的設備： 控制檯 System.out，硬盤 FileStream，內存 ArrayStream。 用流的讀寫思想來操做數組。

2、IO 流：字符編碼
七、字符編碼：字符流的出現爲了方便操做字符。更重要是的加入了編碼轉換。經過子類轉 換流來完成：InputStreamReader；OutputStreamWriter。在兩個對象進行構造的時候能夠加 入字符集。 八、 編碼表的由來： 計算機只能識別二進制數據， 早期由來是電信號。 爲了方便應用計算機， 讓它能夠識別各個國家的文字。就將各個國家的文字用數字來表示，並一一對應，造成一張 表。這就是編碼表。 九、常見的編碼表： ASCII：美國標準信息交換碼。用一個字節的 7 位能夠表示。 ISO8859-1：拉丁碼錶。歐洲碼錶。用一個字節的 8 位表示。 GBK2312：中國的中文編碼表。用兩個字節的 16 位來表示。 GBK：中國的中文編碼表升級，融合了更多的中文文字符號。 Unicode：國際標準碼，融合了多種文字。全部文字都用兩個字節來表示，Java 語言使用的 就是 Unicode。 UTF-8：最多用三個字節來表示一個字符。 ?? 十、編碼：字符串變成字節數組。 解碼：字節數組變成字符串。 String-->byte[]; str.getBytes(charsetName); byte[]-->String; new String(byte[],charsetName);。

2016 年 02 月 02 日
1、GUI：概述

day22

一、GUI：圖形用戶界面。 GUI：Graphical User Interface（圖形用戶接口） 。用圖形的方式，來顯示計算機操做的界面， 這樣更方便跟直觀。 CLI：Command line User Inteface（命令行用戶接口） 。就是常見的 Dos 命令行操做。須要記 憶一些經常使用的命令，操做不直觀。 舉例：好比：建立文件夾，或者刪除文件夾等。 Java 爲 GUI 提供的對象都存在 java.Awt 和 javax.Swing 兩個包中。 二、Awt 與 Swing： java.Awt：Abstract Window ToolKit（抽象窗口工具包） ，需調用本地系統方法實現功能。屬重 量級控件。 javax.Swing：在 Awt 的基礎上，創建的一套圖形界面系統，其中提供了更多的組件，並且完 全由 Java 實現。加強了移植性，屬輕量級控件。 三、繼承關係圖：

四、佈局管理器： 容器中的組件的排放方式，就是佈局。 常見的佈局管理器： FlowLayout（流式佈局管理器） 從左到右的順序排列。 Panel 默認的佈局管理器。 BorderLayout（邊界佈局管理器） 東，南，西，北，中。 Frame 默認的佈局管理器。

GridLayout（網格佈局管理器） 規則的矩陣。 CardLayout（卡片佈局管理器） 選項卡。 GridBagLayout（網格包佈局管理器） 非規則的矩陣。 五、建立圖形化界面： 1，建立 frame 窗體。 2，對窗體進行基本設置。 好比：大小、位置、佈局。 3，定義組件。 4，將組件經過窗體的 add 方法添加到窗體中。 5，讓窗體顯示，經過 setVisible(true)來完成。 六、創建一個簡單的窗體： Container 經常使用子類：Window Panel（面板，不能單獨存在。 ） Window 經常使用子類：Frame Dialog。 簡單的窗體建立過程： Frame f = new Frame(「my window」); f.setLayout(new FlowLayout()); f.setSize(500,400);//設置窗體大小。 f.setLocation(300,200);//設置窗體出如今屏幕的位置。 f.setVisible(true);。

2、GUI：事件監聽機制
七、事件監聽機制組成：事件源（組件） ；事件（Event） ；監聽器（Listener） ；事件處理（引 發事件後處理方式） 。 八、事件監聽機制流程圖：

九、事件監聽機制的特色： 1，事件源。 2，事件。 3，監聽器。 4，事件處理。 事件源：就是 awt 或者 swing 包中的那些圖形界面組件。 事件：每個事件源都有本身特有的對應事件和共性事件。 監聽器：將能夠觸發某一個事件的動做（不止一個動做）都已經封裝到了監聽器中。 以上三者，在 java 中都已經定義好了。直接獲取其對象來用就能夠了。 咱們要作的事情是，就是對產生的動做進行處理。

2016 年 02 月 03 日
1、網絡編程：概述
一、網絡編程： 網絡模型：OSI 參考模型。TCP/IP 參考模型。 網絡通信要素：IP 地址。端口號。傳輸協議。 二、網絡參考模型：

day23

三、網絡通信要素： IP 地址： 網絡中設備的標識。 不易記憶， 可用主機名。 本地迴環地址： 127.0.0.1 主機名： localhost。 端口號：用於標識進程的邏輯地址，不一樣進程的標識。有效端口： 0~65535，其中 0~1024 系統使用或保留端口。 傳輸協議：通信的規則。常見協議：TCP，UDP。

四、UDP 和 TCP： UDP： 將數據及源和目的封裝成數據包中，不須要創建鏈接。 每一個數據報的大小在限制在 64k 內。 因無鏈接，是不可靠協議。 不須要創建鏈接，速度快。 特色：面向無鏈接。數據會被封包。不可靠。速度快。 好比：聊天，視頻會議，桌面共享。 TCP： 創建鏈接，造成傳輸數據的通道。 在鏈接中進行大數據量傳輸。 經過三次握手完成鏈接，是可靠協議。 必須創建鏈接，效率會稍低。 特色：面向鏈接。可大數據量傳輸。比較可靠。稍微有點慢。 好比：下載。 五、Socket： Socket 就是爲網絡服務提供的一種機制。 通訊的兩端都有 Socket。 網絡通訊其實就是 Socket 間的通訊。 數據在兩個 Socket 間經過 IO 傳輸。

2、網絡編程：UDP
六、UDP 傳輸： DatagramSocket 與 DatagramPacket。 創建發送端，接收端。 創建數據包。 調用 Socket 的發送接收方法。 關閉 Socket。 發送端與接收端是兩個獨立的運行程序。

3、網絡編程：TCP
七、TCP 傳輸： Socket 和 ServerSocket。 創建客戶端和服務器端。 創建鏈接後，經過 Socket 中的 IO 流進行數據的傳輸。 關閉 socket。 一樣，客戶端與服務器端是兩個獨立的應用程序。

2016 年 02 月 04 日
1、網絡編程：瀏覽器客戶端
一、視頻演示講解。

day24

2016 年 02 月 6 日
1、正則表達式

day25

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