《JAVA語言程序設計-YDL-李娜-機械工業出版社-原書第八版》筆記

時間 2019-11-13

標籤 java 語言程序設計 ydl 李娜機械工業出版社第八筆記欄目 Java 简体版

原文原文鏈接

目錄：硬件-程序-選擇-循環-方法-數組-對象和類-繼承多態-多繼承接口-IO-異常-遞歸java

計算機是經過程序設計語言編寫的軟件發出的本質是電信號的指令對硬件進行存儲和處理數據的電子設備。
硅半導體芯片=晶體管+CPU（control unit+arithmetic/logic unit+內部時鐘）bus(總線)硅半導體芯片=晶體管+內存RAM（電的兩種狀態off/on二進制）bus磁盤（darkdisk）bus輸入輸出設備bus通訊設備
程序設計語言的運行的過程：編輯+編譯+構建+運行+調試。
基本程序設計：如何設計算法以及如何將算法翻譯成程序代碼。
算法algorithm：解決問題須要執行的動做以及這些動做執行的順序。
一個字符在計算機中是以0和1構成的序列的形式來存儲的，將字符映射成它的二進制形式的過程稱爲編碼encoding。
在計算機科學中，197011午夜零點稱爲UNIX時間戳。
遞進式開發和測試incremental development and testing縮小範圍查找bug，程序錯誤可概括爲三類：語法（編譯）、邏輯（程序沒有按預期的方式完成）、運行（引發程序非正常中斷的錯誤）

Java：規範+API+JDK+IDE，類{數據和方法（語句結構體（關鍵（保留）字）：一步一編譯執行）}
JDK：Java程序的開發環境JRE（Java程序的運行環境JVM（保證Java語言跨平臺）+類庫）+工具
simple，portable，robust，high performance，secure，(要求)，interpreted，architecture neutral，object oriented，（思想），distributed，multithreaded，dynamic，（能力特徵）就兩條：開源，跨平臺。
Java程序以一個類的聲明開始：在聲明裏類名緊跟在關鍵詞Class後。

標識符給類，接口，方法，變量等起名字的字符序列

組成規則
英文大小寫字母，區分大小寫，不能是java中的關鍵字
數字，不能以數字開頭
$和_ //習慣上$只用在機器自動產生的源代碼中
常見的命名規則(見名知意)：包小常大，類接首大，方變首小。

常量：在程序執行的過程當中，其值不發生改變的量

分類：字面值常量，自定義常量面試

字面值常量正則表達式

A:字符串常量 "hello"  
B:整數常量    12,23  
C:小數常量    12.345  
D:字符常量    'a','A','0'  
E:布爾常量    true,false  
F:空常量    null(後面講)

在Java中針對整數常量提供了四種表現形式算法

A:二進制    由0，1組成。以0開頭。  
B:八進制    由0，1，...7組成。以0開頭。  
C:十進制    由0，1，...9組成。整數默認是十進制。  
D:十六進制    由0，1，...9,a,b,c,d,e,f(大小寫都可)組成。以0x開頭。

進制轉換

其餘進制到十進制編程

係數：就是每個位上的數值  
基數：x進制的基數就是x  
權：對每個位上的數據，從右，而且從0開始編號，對應的編號就是該數據的權。  
結果：係數*基數^權次冪之和。

十進制到其餘進制小程序

除基取餘，直到商爲0，餘數反轉。

進制轉換的快速轉換法windows

A:十進制和二進制間的轉換  
    8421碼。  
B:二進制到八進制，十六進制的轉換

變量：在程序的執行過程當中，其值在某個範圍內能夠發生改變的量，是指定在程序中用於存儲數據和計算結果的內存位置。設計模式

A:數據類型 變量名 = 初始化值;//在賦值給變量以前，必須聲明變量。直到變量被賦值，該變量才被定義。方法中聲明的變量在使用以前必須被賦值。儘量一步完成變量的聲明和賦初使值，使程序易讀。  
B:數據類型 變量名;//變量名儘可能選擇描述性的名字。  
  變量名 = 初始化值;//也能夠同時聲明和初始化同一類型的變量 例int a=1，b=2;

數據類型：Java是一種強類型語言，針對每種數據都提供了對應的數據類型。數組

基本數據類型fundamental type/primitive data type：4類8種安全

A:整數            佔用字節數  
    byte            1  
    short            2  
    int（默認）             4  
    long（L）            8  
B:浮點數//得名於以科學計數法方式存儲，浮點是近似的  
    float（F）            4  
    double （默認）           8  
C:字符  
    char            2  
D:布爾  
    boolean            1

引用數據類型：類，接口，數組。

類型轉換：拓寬：widening type

縮窄類型：narrowing type(顯式轉換：除整型直接量是在目標變量容許的範圍內，不須要)

類型轉換不改變轉換的變量值。

運算符

(1)算術運算符
A:+,-,*,/,%,++,--
B:+的用法 //做一元操做符僅有一個操做數，二元操做符有兩個操做數。涉及浮點數的計算都是近似的，由於這些數沒有以準確的精度來存儲，整數能夠精確地存儲。
a:加法
b:正號
c:字符串鏈接符
C:/和%的區別
數據作除法操做的時候，/取得是商（整數得整數），%取得是餘數
D:++和--的用法
a:他們的做用是自增或者自減
b:使用
**單獨使用
放在操做數據的前面和後面效果同樣。
a++或者++a效果同樣。
*參與操做使用放在操做數的前面：先自增或者自減，再參與操做 int a = 10; int b = ++a; 放在操做數的後面：先參與操做，再自增或者自減 int a = 10; int b = a++; (2)賦值運算符 A:=,+=,-=,=,/=,%=等
B:=叫作賦值運算符，也是最基本的賦值運算符
int x = 10; 把10賦值給int類型的變量x。
C:擴展的賦值運算符的特色
隱含了自動強制轉換。
(3)比較運算符
A:==,!=,>,>=,<,<=
B:不管運算符兩端簡單仍是複雜最終結果是boolean類型。
C:千萬不要把==寫成了=
(4)邏輯運算符
A:&,|,^,!,&&,||
B:邏輯運算符用於鏈接boolean類型的式子
C:結論
&:有false則false
|:有true則true
^:相同則false，不一樣則true。
情侶關係。
!:非true則false，非false則true
&&:結果和&是同樣的，只不過有短路效果。左邊是false，右邊不執行。
||:結果和|是同樣的，只不過有短路效果。左邊是true，右邊不執行。
(5)位運算符
A:^的特殊用法
一個數據針對另外一個數據位異或兩次，該數不變
B:面試題
a:請實現兩個變量的交換
**採用第三方變量
**用位異或運算符
左邊a,b,a
右邊a^b
b:請用最有效率的方式計算出2乘以8的結果
2<<3
(6)三元運算符
A:格式
比較表達式?表達式1:表達式2;
B:執行流程：
首先計算比較表達式的值，看是true仍是false。
若是是true，表達式1就是結果。
若是是false，表達式2就是結果。
C:案例：
a:比較兩個數據是否相等
b:獲取兩個數據中的最大值
c:獲取三個數據中的最大值
鍵盤錄入

(1)實際開發中，數據是變化的，爲了提升程序的靈活性，咱們加入鍵盤錄入數據。
(2)如何實現呢?
A:導包
import java.util.Scanner;
位置：在class的上邊
B:建立對象
Scanner sc = new Scanner(System.in);
C:獲取數據
int x = sc.nextInt();
(3)next()讀取一個字符串，該字符在一個空白符以前結束（‘ ’，‘\t’，'\f'，'\r'，'\n'），不輸入空白字符，則與後續輸入不分開，不換行。nextLine()表示自成一行。

Scanner的使用

(1)在JDK5之後出現的用於鍵盤錄入數據的類。
(2)構造方法：
A:講解了System.in這個東西。
它實際上是標準的輸入流,對應於鍵盤錄入
B:構造方法
InputStream is = System.in;
```
Scanner(InputStream is)  
C:經常使用的格式  
    Scanner sc = new Scanner(System.in);
```
(3)基本方法格式：
A:hasNextXxx() 判斷是不是某種類型的
B:nextXxx() 返回某種類型的元素
(4)要掌握的兩個方法
A:public int nextInt()
B:public String nextLine()
(5)須要注意的小問題
A:同一個Scanner對象，先獲取數值，再獲取字符串會出現一個小問題。
B:解決方案：
a:從新定義一個Scanner對象
```
b:把全部的數據都用字符串獲取，而後再進行相應的轉換
```

流程控制語句

(1)順序結構從上往下，依次執行
(2)選擇結構按照不一樣的選擇，執行不一樣的代碼
(3)循環結構作一些重複的代碼

if語句

(1)三種格式
A:格式1
if(比較表達式) {
語句體;
}
執行流程：
判斷比較表達式的值，看是true仍是false
若是是true，就執行語句體
若是是false，就不執行語句體

B:格式2  
    if(比較表達式) {  
        語句體1;  
    }else {  
        語句體2;  
    }  
    執行流程：  
        判斷比較表達式的值，看是true仍是false  
        若是是true，就執行語句體1  
        若是是false，就執行語句體2  

C:格式3  
    if(比較表達式1) {  
        語句體1;  
    }else if(比較表達式2){  
        語句體2;  
    }  
    ...  
    else {  
        語句體n+1;  
    }執行流程：  
    判斷比較表達式1的值，看是true仍是false  
    若是是true，就執行語句體1  
    若是是false，就繼續判斷比較表達式2的值，看是true仍是false  
    若是是true，就執行語句體2  
    若是是false，就繼續判斷比較表達式3的值，看是true仍是false  
    ...  
    若是都不知足，就執行語句體n+1  </code></pre>(2)注意事項
    A:比較表達式不管簡單仍是複雜，結果是boolean類型
    B:if語句控制的語句體若是是一條語句，是能夠省略大括號的；若是是多條，不能省略。
        建議：永遠不要省略。
    C:通常來講，有左大括號，就沒有分號，有分號，就沒有左大括號。
    D:else後面若是沒有if，是不會出現比較表達式的。
    E:三種if語句其實都是一個語句，只要有一個執行，其餘的就再也不執行。
(3)案例：
    A:比較兩個數是否相等
    B:獲取兩個數中的最大值
    C:獲取三個數中的最大值(if語句的嵌套)
    D:根據成績輸出對應的等級
    E:根據月份，輸出對應的季節
    F:根據x計算對應y的值並輸出
(4)三元運算符和if語句第二種格式的關係
    全部的三元運算符可以實現的，if語句的第二種格式都能實現。
    反之不成立。  
若是if語句第二種格式控制的語句體是輸出語句，就不能夠。  
由於三元運算符是一個運算符，必需要有一個結果返回，不能是一個輸出語句。

`- switch語句

(1)格式：  
switch(表達式) {  
case 值1:  
語句體1;  
break;  
case 值2:  
語句體2;  
break;  
…  
default:  
語句體n+1;  
break;  
}  
格式解釋說明：  
switch:說明這是switch語句。  
表達式:能夠是byte,short,int,char  
JDK5之後能夠是枚舉  
JDK7之後能夠是字符串  
case:後面的值就是要和表達式進行比較的值  
break:表示程序到這裏中斷，跳出switch語句  
default:若是全部的狀況都不匹配,就執行這裏,至關於if語句中的else  
(2)面試題  
switch語句的表達式能夠是byte嗎?能夠是long嗎?能夠是String嗎?  
能夠,不能夠,JDK7之後能夠  
(3)執行流程:  
A:首先計算表達式的值  
B:和每個case進行匹配，若是有就執行對應的語句體，看到break就結束。  
C:若是沒有匹配，就執行default的語句體n+1。  
(4)注意事項:  
A:case後面只能是常量，不能是變量，並且，多個case後面的值不能出現相同的  
B:default能夠省略嗎?  
能夠省略，可是不建議，由於它的做用是對不正確的狀況給出提示。  
特殊狀況：  
case就能夠把值固定。  
A,B,C,D  
C:break能夠省略嗎?  
能夠省略，可是結果可能不是咱們想要的。  
會出現一個現象：case穿透。  
最終咱們建議不要省略  
D:default必定要在最後嗎?  
不是，能夠在任意位置。可是建議在最後。  
E:switch語句的結束條件  
a:遇到break就結束了  
b:執行到末尾就結束了  
(5)案例：  
A:鍵盤錄入一個數字(1-7),輸出對應的星期幾。  
B:單項選擇題  
C:鍵盤錄入一個字符串的問題  
String s = sc.nextLine();  
D:根據給定的月份,輸出對應的季節  
(6)if語句和switch語句各自的場景  
A:if  
針對boolean類型的判斷  
針對一個範圍的判斷  
針對幾個常量的判斷  
B:switch  
針對幾個常量的判斷

循環語句

(1)有三種:for,while,do…while `

```````````

for循環語句

A:格式  
    for(初始化語句;判斷條件語句;控制條件語句){  
        循環體語句;  
    }   
    執行流程：  
        a:執行初始化語句  
        b:執行判斷條件語句  
            若是這裏是true，就繼續  
            若是這裏是false，循環就結束  
        c:執行循環體語句  
        d:執行控制條件語句  
        e:回到b  
B:注意事項  
    a:判斷條件語句不管簡單仍是複雜，結果是boolean類型  
    b:循環體語句若是是一條，能夠省略大括號，可是不建議  
    c:有分號就沒有左大括號，有左大括號就沒有分號  
C:案例  
    a:輸出10次HelloWorld  
    b:輸出1-10的數據  
    c:輸出10-1的數據  
    d:求1-10的和  
    e:求1-100的和,求1-100的偶數和,求1-100的奇數和  
    f:求5的階乘  
    g:在控制檯打印水仙花數  
    h:統計水仙花個數  
    i:改進版的迴文數  
        一個五位數  
        個位 = 萬位  
        十位 = 千位  
        個位 \+ 十位 \+ 千位 \+ 萬位 = 百位  
    j:統計1-1000之間同時知足以下條件的數據有多少個  
        x%3==2  
        x%5==3  
        x%7==2

while循環

A:基本格式  
    while(判斷條件語句) {  
        循環體語句;  
    }  擴展格式：  
初始化語句;  
while(判斷條件語句){  
    循環體語句;  
    控制條件語句;  
}  

經過查看這個格式，咱們就知道while循環能夠和for循環等價轉換。  B:while的練習  
    把for語句的練習用while改進  
C:for和while的區別  
    a:使用上的區別  
        for語句的那個控制條件變量,在循環結束後不能在使用了。  
        而while的能夠繼續使用。  
    b:理解上的區別  
        for適合於一個範圍的判斷  
        while適合次數不明確的  
            舉例:吃葡萄  
D:案例：  
    a:珠穆朗瑪峯問題  
    b:小芳存錢問題(break之後才能作)

do…while循環

A:基本格式  
    do {  
        循環體語句;  
    }while(判斷條件語句);  擴展格式：  
初始化語句;  
do {  
    循環體語句;  
    控制條件語句;  
}while(判斷條件語句);  

經過查看格式，咱們就能夠看出其實三種循環的格式能夠是統一的。  B:三種循環的區別  
    a:do...while循環至少執行一次循環體  
    b:for和while必須先判斷條件是不是true，而後後才能決定是否執行循環體

循環使用的注意事項(死循環)

A:必定要注意修改控制條件,不然容易出現死循環。  
B:最簡單的死循環格式  
    a:while(true){...}  
    b:for(;;){}

控制跳轉語句

(1)break:中斷的意思
A:用在循環和switch語句中，離開此應用場景無心義。
B:做用
a:跳出單層循環
b:跳出多層循環，須要標籤語句的配合
(2)continue:繼續
A:用在循環中，離開此應用場景無心義。
B:做用
a:跳出單層循環的一次，能夠繼續下一次
C:填空題
for(int x=1; x<=10; x++) {
if(x%3 == 0) {
//補齊代碼
}
System.out.println("Java基礎班");
}
如何讓控制檯輸出2次：Java基礎班
如何讓控制檯輸出7次：Java基礎班
如何讓控制檯輸出13次：Java基礎班
(3)return:返回
A:用於結束方法的，後面還會在繼續講解和使用。
B:一旦遇到return,程序就不會在繼續日後執行。

方法

(1)方法：就是完成特定功能的代碼塊。
注意：在不少語言裏面有函數的定義，而在Java中，函數被稱爲方法。
(2)格式：
修飾符返回值類型方法名(參數類型參數名1,參數類型參數名2…) {
方法體語句;
return 返回值;
}
返回值類型：就是功能結果的數據類型
方法名：就是起了一個名字，方便咱們調用該方法。
參數分類：
實參：實際參與運算的數據
形參：方法上定義的，用於接收實際參數的變量
```
Java中的參數傳遞問題  
    Java中只有值傳遞。  
    基本類型：形式參數的改變不影響實際參數  
    引用類型：形式參數的改變直接影響實際參數  
方法體語句：就是完成功能的代碼塊  
return：結束方法  
返回值：就是功能的結果，由return帶給調用者。
```
(3)兩個明確：
返回值類型：結果的數據類型
參數列表：參數的個數及對應的數據類型
(4)方法調用
A:有明確返回值的方法
a:單獨調用，沒有意義
b:輸出調用，不是很好，由於我可能須要不結果進行進一步的操做。可是講課通常我就用了。
c:賦值調用，推薦方案
B:void類型修飾的方法
a:單獨調用
(5)案例：
A:求和方案
B:獲取兩個數中的較大值
C:比較兩個數據是否相同
D:獲取三個數中的最大值
E:輸出m行n列的星形
F:輸出nn乘法表
(6)方法的注意事項
A:方法不調用不執行
B:方法之間是平級關係，不能嵌套定義
C:方法定義的時候，參數是用，隔開的
D:方法在調用的時候，不用在傳遞數據類型
E:若是方法有明確的返回值類型，就必須有return語句返回。
(7)方法重載
在同一個類中，方法名相同，參數列表不一樣。與返回值無關。
參數列表不一樣：
參數的個數不一樣。
參數的對應的數據類型不一樣。
(8)方法重載案例
不一樣的類型的多個同名方法的比較。
數組

(1)數組：存儲同一種數據類型的多個元素的容器。
(2)特色：每個元素都有編號，從0開始，最大編號是長度-1。
編號的專業叫法：索引
(3)定義格式
A:數據類型[] 數組名;
B:數據類型數組名[];
(4)數組的初始化
A:動態初始化
只給長度，系統給出默認值
舉例：int[] arr = new int[3];
B:靜態初始化
給出值，系統決定長度
舉例：int[] arr = new int[]{1,2,3};
簡化版：int[] arr = {1,2,3};
(5)Java的內存分配
A:棧存儲局部變量
B:堆存儲全部new出來的
C:方法區(面向對象部分詳細講解)
D:本地方法區(系統相關)
E:寄存器(CPU使用)
```
注意：  
    a:局部變量 在方法定義中或者方法聲明上定義的變量。  
    b:棧內存和堆內存的區別  
        棧：數據使用完畢，就消失。  
        堆：每個new出來的東西都有地址  
            每個變量都有默認值  
                byte,short,int,long 0  
                float,double 0.0  
                char '\\u0000'  
                boolean false  
                引用類型 null  
            數據使用完畢後，在垃圾回收器空閒的時候回收。
```
(6)數組內存圖
A:一個數組
B:二個數組
C:三個數組(兩個棧變量指向同一個堆內存)
(7)數組的常見操做
A:遍歷
方式1：
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}
```
方式2：  
        public static void printArray(int\[\] arr) {  
            System.out.print("\[");  
            for(int x=0; x<arr.length; x++) {  
                if(x == arr.length-1) {  
                    System.out.println(arr\[x\]+"\]");  
                }else {  
                    System.out.println(arr\[x\]+", ");  
                }  
            }  
        }  
B:最值  
    最大值：  
        public static int getMax(int\[\] arr) {  
            int max = arr\[0\];  
            for(int x=1; x<arr.length; x++) {  
                if(arr\[x\] > max) {  
                    max = arr\[x\];  
                }  
            }  
            return max;  
        }  最小值：  
    public static int getMin(int\[\] arr) {  
        int min = arr\[0\];
```
```
for(int x=1; x&amp;lt;arr.length; x++) { if(arr\[x\] &amp;lt; min) { min = arr\[x\]; } } return min; } C:逆序 方式1： public static void reverse(int\[\] arr) { for(int x=0; x&lt;arr.length/2; x++) { int temp = arr\[x\]; arr\[x\] = arr\[arr.length-1-x\]; arr\[arr.length-1-x\] = temp; } } 方式2： public static void reverse(int\[\] arr) { for(int start=0,end=arr.length-1; start&amp;lt;=end; start++,end--) { int temp = arr\[start\]; arr\[start\] = arr\[end\]; arr\[end\] = temp; } } D:查表 public static String getString(String\[\] strArray,int index) { return strArray\[index\]; } for(int x=1; x&amp;lt;arr.length; x++) { if(arr\[x\] &amp;lt; min) { min = arr\[x\]; } } return min; } C:逆序 方式1： public static void reverse(int\[\] arr) { for(int x=0; x&lt;arr.length/2; x++) { int temp = arr\[x\]; arr\[x\] = arr\[arr.length-1-x\]; arr\[arr.length-1-x\] = temp; } } 方式2： public static void reverse(int\[\] arr) { for(int start=0,end=arr.length-1; start&amp;lt;=end; start++,end--) { int temp = arr\[start\]; arr\[start\] = arr\[end\]; arr\[end\] = temp; } } D:查表 public static String getString(String\[\] strArray,int index) { return strArray\[index\]; }
```
E:基本查找方式1： public static int getIndex(int\[\] arr,int value) { for(int x=0; x<arr.length; x++) { if(arr\[x\] == value) { return x; } } return -1; } 方式2： public static int getIndex(int\[\] arr,int value) { int index = -1;
```
 for(int x=0; x&amp;lt;arr.length; x++) { if(arr\[x\] == value) { index = x; break; } } return index; }&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;二維數組for(int x=0; x&amp;lt;arr.length; x++) { if(arr\[x\] == value) { index = x; break; } } return index; }&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;二維數組
```
(1)元素是一維數組的數組。 (2)格式： A:數據類型[][] 數組名 = new 數據類型[m][n]; B:數據類型[][] 數組名 = new 數據類型[m][]; C:數據類型[][] 數組名 = new 數據類型[][]{{…},{…},{…}}; D:數據類型[][] 數組名 = {{…},{…},{…}}; (3)案例(掌握): A:二維數組的遍歷 B:二維數組的求和 C:楊輝三角形面向對象 (1)面向對象面向對象是基於面向過程的編程思想 (2)面向對象的思想特色 A:是一種更符合咱們思考習慣的思想 B:把複雜的事情簡單化 C:讓咱們從執行者變成了指揮者 A:有哪些類 B:每一個類有哪些成員 C:類與類的關係 (4)類與對象 A:現實世界的事物屬性事物的基本描述行爲事物的功能 B:Java語言中最基本的單位是類。因此，咱們要用類來體現事物 C:類成員變量事物屬性成員方法事物行爲 D:類：是一組相關的屬性和行爲的集合。是一個抽象的概念。對象：是該類事物的具體存在，是一個具體的實例。(對象) 舉例：學生：類班長：對象 (5)類的定義及使用 A:類的定義成員變量定義格式和之前同樣，就是位置不一樣，在類中，方法外。成員方法定義格式和之前同樣，就是去掉了static。 B:使用類的內容 a:建立對象? 格式類名對象名 = new 類名(); b:如何使用成員變量和成員方法呢對象名.成員變量對象名.成員方法() (6)案例： A:學生類的定義和使用 B:手機類的定義和使用 (7)內存圖 A:一個對象的內存圖 B:二個對象的內存圖 C:三個對象的內存圖 (8)Java程序的開發，設計和特徵 A:開發：就是不斷的建立對象，經過對象調用功能 B:設計：就是管理和維護對象間的關係 C:特徵 a:封裝 b:繼承 c:多態

``````````

成員變量和局部變量的區別

(1)在類中的位置不一樣
成員變量：類中方法外
局部變量：方法定義中或者方法聲明上
(2)在內存中的位置不一樣
成員變量：在堆中
局部變量：在棧中
(3)生命週期不一樣
成員變量：隨着對象的建立而存在，隨着對象的消失而消失
局部變量：隨着方法的調用而存在，隨着方法的調用完畢而消失
(4)初始化值不一樣
成員變量：有默認值
局部變量：沒有默認值，必須定義，賦值，而後才能使用
類做爲形式參數的問題

(1)若是你看到一個方法須要的參數是一個類名，就應該知道這裏實際須要的是一個具體的對象。
匿名對象

(1)沒有名字的對象
(2)應用場景
A:調用方法，僅僅只調用一次的時候。
b:能夠做爲實際參數傳遞。
封裝

(1)隱藏實現細節，提供公共的訪問方式
(2)好處：
A:隱藏實現細節，提供公共的訪問方式
B:提升代碼的複用性
C:提升代碼的安全性
(3)設計原則
把不想讓外界知道的實現細節給隱藏起來，提供公共的訪問方式
(4)private是封裝的一種體現。
封裝：類，方法，private修飾成員變量
private關鍵字

(1)私有的意義，能夠修飾成員變量和成員方法
(2)特色：
被private修飾後的成員只能在本類中被訪問
(3)private的應用：
之後再寫一個類的時候：
把全部的成員變量給private了
提供對應的getXxx()/setXxx()方法
this關鍵字

(1)表明當前類的引用對象
記住：哪一個對象調用方法，該方法內部的this就表明那個對象
(2)this的應用場景：
A:解決了局部變量隱藏成員變量的問題

構造方法

(1)做用：用於對對象的數據進行初始化
(2)格式：
A:方法名和類名相同
B:沒有返回值類型，連void都不能有
C:沒有返回值

思考題：構造方法中可不能夠有return語句呢?  
能夠。而是咱們寫成這個樣子就OK了：return;  
其實，在任何的void類型的方法的最後你均可以寫上：return;

(3)構造方法的注意事項
A:若是咱們沒寫構造方法，系統將提供一個默認的無參構造方法
B:若是咱們給出了構造方法，系統將再也不提供默認構造方法
若是這個時候，咱們要使用無參構造方法，就必須本身給出。
推薦：永遠手動本身給出無參構造方法。
(4)給成員變量賦值的方式
A:setXxx()
B:帶參構造方法
(5)標準案例
class Student {
private String name;
private int age;

public Student(){}  public Student(String name,int age) {  
    this.name = name;  
    this.age = age;  
}  

public String getName() {  
    return name;  
}  

public void setName(String name) {  
    this.name = name;  
}  

public int getAge() {  
    return age;  
}  

public void setAge(int age) {  
    this.age = age;  
}  }  

測試：  
class StudentDemo {  
    public static void main(String\[\] args) {  
        //方式1  
        Student s1 = new Student();  
        s1.setName("林青霞");  
        s1.setAge(27);  
        System.out.println(s1.getName()+"---"+s1.getAge());      //方式2  
    Student s2 = new Student("劉意",30);  
    System.out.println(s2.getName()+"---"+s2.getAge());  
}  }

代碼：Student s = new Student();作了哪些事情
(1)把Student.class文件加載到內存
(2)在棧內存爲s開闢空間
(3)在堆內存爲學生對象申請空間
(4)給學生的成員變量進行默認初始化。null,0
(5)給學生的成員變量進行顯示初始化。林青霞,27
(6)經過構造方法給成員變量進行初始化。劉意,30
(7)對象構造完畢，把地址賦值給s變量

面向對象的練習題
(1)標準的手機類的定義和測試
(2)Demo類有求和方法，Test類進行測試。
何時定義成員變量?
當該變量是用來描述一個類的時候。
(3)長方形案例
(4)員工案例
(5)MyMath案例(本身提供加減乘除並測試)

static關鍵字

(1)靜態的意思。能夠修飾成員變量和成員方法。
(2)靜態的特色：
A:隨着類的加載而加載
B:優先與對象存在
C:被類的全部對象共享
這其實也是咱們判斷該不應使用靜態的依據。
舉例：飲水機和水杯的問題思考
D:能夠經過類名調用
既能夠經過對象名調用，也能夠經過類名調用，建議經過類名調用。
(3)靜態的內存圖
靜態的內容在方法區的靜態區
(4)靜態的注意事項；
A:在靜態方法中沒有this對象
B:靜態只能訪問靜態(代碼測試過)
(5)靜態變量和成員變量的區別
A:所屬不一樣
靜態變量：屬於類，類變量
成員變量：屬於對象，對象變量，實例變量
B:內存位置不一樣
靜態變量：方法區的靜態區
成員變量：堆內存
C:生命週期不一樣
靜態變量：靜態變量是隨着類的加載而加載，隨着類的消失而消失
成員變量：成員變量是隨着對象的建立而存在，隨着對象的消失而消失
D:調用不一樣
靜態變量：能夠經過對象名調用，也能夠經過類名調用
成員變量：只能經過對象名調用
(6)main方法是靜態的
public:權限最大
static:不用建立對象調用
void:返回值給jvm沒有意義
main:就是一個常見的名稱。
String[] args:能夠接收數據，提供程序的靈活性

製做幫助文檔

(1)寫一個類
(2)加入文檔註釋
(3)經過javadoc工具生成便可
javadoc -d 目錄 -author -version ArrayTool.java

經過JDK提供的API學習了Math類

(1)針對數學運算進行操做的類,沒有構造方法，由於它的成員都是靜態的
(2)常見方法
A:絕對值
B:向上取整
C:向下取整
D:兩個數據中的大值
E:a的b次冪
F:隨機數
G:四捨五入
H:正平方根
(3)案例：
A:猜數字小遊戲
B:獲取任意範圍的隨機數
C:產生隨機數
public static double random(): [0.0,1.0)
D:如何產生一個1-100之間的隨機數
int number = (int)(Math.random()*100)+1;
代碼塊

(1)用{}括起來的代碼。
(2)分類：
A:局部代碼塊
用於限定變量的生命週期，及早釋放，提升內存利用率。
B:構造代碼塊
把多個構造方法中相同的代碼能夠放到這裏，每一個構造方法執行前，首先執行構造代碼塊。
C:靜態代碼塊
對類的數據進行初始化，僅僅只執行一次。
(3)靜態代碼塊,構造代碼塊,構造方法的順序問題?
靜態代碼塊 > 構造代碼塊 > 構造方法

繼承

(1)把多個類中相同的成員給提取出來定義到一個獨立的類中。而後讓這多個類和該獨立的類產生一個關係，
這多個類就具有了這些內容。這個關係叫繼承。
(2)Java中如何表示繼承呢?格式是什麼呢?
A:用關鍵字extends表示
B:格式：
class 子類名 extends 父類名 {}
(3)繼承的好處：
A:提升了代碼的複用性
B:提升了代碼的維護性
C:讓類與類產生了一個關係，是多態的前提
(4)繼承的弊端：
A:讓類的耦合性加強。這樣某個類的改變，就會影響其餘和該類相關的類。
原則：低耦合，高內聚。
耦合：類與類的關係
內聚：本身完成某件事情的能力
B:打破了封裝性
(5)Java中繼承的特色
A:Java中類只支持單繼承
B:Java中能夠多層(重)繼承(繼承體系)
(6)繼承的注意事項：
A:子類不能繼承父類的私有成員
B:子類不能繼承父類的構造方法，可是能夠經過super去訪問
C:不要爲了部分功能而去繼承
(7)何時使用繼承呢?
A:繼承體現的是：is a的關係。
B:採用假設法
(8)Java繼承中的成員關係
A:成員變量
a:子類的成員變量名稱和父類中的成員變量名稱不同，這個太簡單
b:子類的成員變量名稱和父類中的成員變量名稱同樣，這個怎麼訪問呢?
子類的方法訪問變量的查找順序：
在子類方法的局部範圍找，有就使用。
在子類的成員範圍找，有就使用。
在父類的成員範圍找，有就使用。
找不到，就報錯。
B:構造方法
a:子類的構造方法默認會去訪問父類的無參構造方法
是爲了子類訪問父類數據的初始化
b:父類中若是沒有無參構造方法，怎麼辦?
子類經過super去明確調用帶參構造
子類經過this調用自己的其餘構造，可是必定會有一個去訪問了父類的構造
讓父類提供無參構造
C:成員方法
a:子類的成員方法和父類中的成員方法名稱不同，這個太簡單
b:子類的成員方法和父類中的成員方法名稱同樣，這個怎麼訪問呢?
經過子類對象訪問一個方法的查找順序：
在子類中找，有就使用
在父類中找，有就使用
找不到，就報錯
(9)兩個面試題：
A:Override和Overload的區別?Overload是否能夠改變返回值類型?
B:this和super的區別和各自的做用?
(10)數據初始化的面試題
A:一個類的初始化過程
B:子父類的構造執行過程
C:分層初始化
(11)案例：
A:學生和老師案例
繼承前
繼承後
B:貓狗案例的分析和實現

final關鍵字

(1)是最終的意思，能夠修飾類，方法，變量。
(2)特色：
A:它修飾的類，不能被繼承。
B:它修飾的方法，不能被重寫。
C:它修飾的變量，是一個常量。
(3)面試相關：
A:局部變量
a:基本類型值不能發生改變
b:引用類型地址值不能發生改變，可是對象的內容是能夠改變的
B:初始化時機
a:只能初始化一次。
b:常見的給值
定義的時候。(推薦)
構造方法中。

多態

(1)同一個對象在不一樣時刻體現出來的不一樣狀態。
(2)多態的前提：
A:有繼承或者實現關係。
B:有方法重寫。
C:有父類或者父接口引用指向子類對象。
多態的分類：
a:具體類多態
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象類多態
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多態
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多態中的成員訪問特色
A:成員變量
編譯看左邊，運行看左邊
B:構造方法
子類的構造都會默認訪問父類構造
C:成員方法
編譯看左邊，運行看右邊
D:靜態方法
編譯看左邊，運行看左邊
爲何?
由於成員方法有重寫。
(4)多態的好處：
A:提升代碼的維護性(繼承體現)
B:提升代碼的擴展性(多態體現)
(5)多態的弊端：
父不能使用子的特有功能。
現象：
子能夠看成父使用，父不能看成子使用。
(6)多態中的轉型
A:向上轉型
從子到父
B:向下轉型
從父到子
(7)多態的練習
A:貓狗案例
B:老師和學生案例
抽象類

(1)把多個共性的東西提取到一個類中，這是繼承的作法。
可是呢，這多個共性的東西，在有些時候，方法聲明同樣，可是方法體。
也就是說，方法聲明同樣，可是每一個具體的對象在具體實現的時候內容不同。
因此，咱們在定義這些共性的方法的時候，就不能給出具體的方法體。
而一個沒有具體的方法體的方法是抽象的方法。
在一個類中若是有抽象方法，該類必須定義爲抽象類。
(2)抽象類的特色
A:抽象類和抽象方法必須用關鍵字abstract修飾
B:抽象類中不必定有抽象方法,可是有抽象方法的類必定是抽象類
C:抽象類不能實例化
D:抽象類的子類
a:是一個抽象類。
b:是一個具體類。這個類必須重寫抽象類中的全部抽象方法。
(3)抽象類的成員特色：
A:成員變量
有變量，有常量
B:構造方法
有構造方法
C:成員方法
有抽象，有非抽象
(4)抽象類的練習
A:貓狗案例練習
B:老師案例練習
C:學生案例練習
D:員工案例練習
(5)抽象類的幾個小問題
A:抽象類有構造方法，不能實例化，那麼構造方法有什麼用?
用於子類訪問父類數據的初始化
B:一個類若是沒有抽象方法,卻定義爲了抽象類，有什麼用?
爲了避免讓建立對象
C:abstract不能和哪些關鍵字共存
a:final 衝突
b:private 衝突
c:static 無心義
接口

(1)回顧貓狗案例，它們僅僅提供一些基本功能。
好比：貓鑽火圈，狗跳高等功能，不是動物自己就具有的，
是在後面的培養中訓練出來的，這種額外的功能，java提供了接口表示。
(2)接口的特色：
A:接口用關鍵字interface修飾
interface 接口名 {}
B:類實現接口用implements修飾
class 類名 implements 接口名 {}
C:接口不能實例化
D:接口的實現類
a:是一個抽象類。
b:是一個具體類，這個類必須重寫接口中的全部抽象方法。
(3)接口的成員特色：
A:成員變量
只能是常量
默認修飾符：public static final
B:構造方法
沒有構造方法
C:成員方法
只能是抽象的
默認修飾符：public abstract
(4)類與類,類與接口,接口與接口
A:類與類
繼承關係，只能單繼承，能夠多層繼承
B:類與接口
實現關係，能夠單實現，也能夠多實現。
還能夠在繼承一個類的同時，實現多個接口
C:接口與接口
繼承關係，能夠單繼承，也能夠多繼承
(5)抽象類和接口的區別
A:成員區別
抽象類：
接口：
B:關係區別:
類與類：
類與接口：
接口與接口：
C:設計理念不一樣
抽象類：is a，抽象類中定義的是共性功能。
接口：like a，接口中定義的是擴展功能。
(6)練習：
A:貓狗案例，加入跳高功能
B:老師和學生案例，加入抽菸功能0
形式參數和返回值的問題

(1)形式參數：
類名：須要該類的對象
抽象類名：須要該類的子類對象
接口名：須要該接口的實現類對象
(2)返回值類型：
類名：返回的是該類的對象
抽象類名：返回的是該類的子類對象
接口名：返回的是該接口的實現類的對象
(3)鏈式編程
對象.方法1().方法2()…….方法n();
```
這種用法：其實在方法1()調用完畢後，應該一個對象；  
          方法2()調用完畢後，應該返回一個對象。  
          方法n()調用完畢後，多是對象，也能夠不是對象。
```
包

(1)其實就是文件夾
(2)做用：
A:區分同名的類
B:對類進行分類管理
a:按照功能分
b:按照模塊分
(3)包的定義
```
package 包名;  
多級包用.分開。
```
(4)注意事項：
A:package語句必須在文件中的第一條有效語句
B:在一個java文件中，只能有一個package
C:若是沒有package，默認就是無包名
(5)帶包的編譯和運行
A:手動式
B:自動式
javac -d . HelloWorld.java

導包

(1)咱們屢次使用一個帶包的類，很是的麻煩，這個時候，Java就提供了一個關鍵字import。
(2)格式：
import 包名…類名;
另外一種：
import 包名…;(不建議) (3)package,import,class的順序 package > import > class java.lang不須要導入 java.xxx.yyy.類名; 導入到類的級別 java.xxx.yyy.; 這個也能夠，可是不建議
權限修飾符

(1)權限修飾符
本類同一個包下不一樣包下的子類不一樣包下的無關類
private Y
默認 Y Y
protected Y Y Y
public Y Y Y Y
(2)這四種權限修飾符在任意時刻只能出現一種。
public class Demo {}

常見的修飾符

(1)分類：
權限修飾符：private,默認,protected,public
狀態修飾符：static,final
抽象修飾符：abstract
(2)常見的類及其組成的修飾
類：
默認,public,final,abstract

經常使用的：public  

成員變量：  
    private,默認,protected,public,static,final  經常使用的：private  構造方法：  
    private,默認,protected,public  經常使用的：public  成員方法：  
    private,默認,protected,public,static,final,abstract  經常使用的：public  </code></pre>(3)另外比較常見的：
    public static final int X = 10;
    public static void show() {}
    public final void show() {}
    public abstract void show();

`````````

內部類

(1)把類定義在另外一個類的內部，該類就被稱爲內部類。
舉例：把類B定義在類A中，類B就被稱爲內部類。
(2)內部類的訪問規則
A:能夠直接訪問外部類的成員，包括私有
B:外部類要想訪問內部類成員，必須建立對象
(3)內部類的分類
A:成員內部類
B:局部內部類
(4)成員內部類
A:private 爲了數據的安全性
B:static 爲了訪問的方便性
成員內部類不是靜態的：
外部類名.內部類名對象名 = new 外部類名.new 內部類名();
成員內部類是靜態的：
外部類名.內部類名對象名 = new 外部類名.內部類名();
(5)成員內部類的面試題(填空)
30,20,10
```
class Outer {  
    public int num = 10;  class Inner {  
    public int num = 20;
```
```
public viod show() { int num = 30; System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); } public viod show() { int num = 30; System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); }
```
} }
(6)局部內部類
A:局部內部類訪問局部變量必須加final修飾。
B:爲何呢?
由於局部變量使用完畢就消失，而堆內存的數據並不會當即消失。
因此，堆內存仍是用該變量，而改變量已經沒有了。
爲了讓該值還存在，就加final修飾。
經過反編譯工具咱們看到了，加入final後，堆內存直接存儲的是值，而不是變量名。
(7)匿名內部類
A:是局部內部類的簡化形式
B:前提
存在一個類或者接口
C:格式:
new 類名或者接口名() {
重寫方法;
}
D:本質：
實際上是繼承該類或者實現接口的子類匿名對象
(8)匿名內部類在開發中的使用
咱們在開發的時候，會看到抽象類，或者接口做爲參數。
而這個時候，咱們知道實際須要的是一個子類對象。
若是該方法僅僅調用一次，咱們就可使用匿名內部類的格式簡化。
```
interface Person {  
    public abstract void study();  
}  

class PersonDemo {  
    public void method(Person p) {  
        p.study();  
    }  
}  

class PersonTest {  
    public static void main(String\[\] args) {  
        PersonDemo pd = new PersonDemo();  
        pd.method(new Person() {  
            public void study() {  
                System.out.println("好好學習，每天向上");  
            }  
        });  
    }  
}
```
API：應用程序編程接口。是JDK提供給咱們的一些提升編程效率的java類。

Object類

(1)Object是類層次結構的根類，全部的類都直接或者間接的繼承自Object類。
(2)Object類的構造方法有一個，而且是無參構造
這其實就是理解當時咱們說過，子類構造方法默認訪問父類的構造是無參構造
(3)要掌握的方法：
A:toString()
返回對象的字符串表示，默認是由類的全路徑+'@'+哈希值的十六進制表示。
這個表示實際上是沒有意義的，通常子類都會重寫該方法。
如何重寫呢?過程我也講解過了，基本上就是要求信息簡單明瞭。
可是最終仍是自動生成。
B:equals()
比較兩個對象是否相同。默認狀況下，比較的是地址值是否相同。
而比較地址值是沒有意義的，因此，通常子類也會重寫該方法。
重寫過程，我也詳細的講解和分析了。
可是最終仍是自動生成。
(4)要了解的方法：
A:hashCode() 返回對象的哈希值。不是實際地址值，能夠理解爲地址值。
B:getClass() 返回對象的字節碼文件對象，反射中咱們會詳細講解
C:finalize() 用於垃圾回收，在不肯定的時間
D:clone() 能夠實現對象的克隆，包括成員變量的數據複製，可是它和兩個引用指向同一個對象是有區別的。
(5)兩個注意問題；
A:直接輸出一個對象名稱，其實默認調用了該對象的toString()方法。
B:面試題
==和equals()的區別?
A:==
基本類型：比較的是值是否相同
引用類型：比較的是地址值是否相同
B:equals()
只能比較引用類型。默認狀況下，比較的是地址值是否相同。
可是，咱們能夠根據本身的須要重寫該方法。

String類

(1)多個字符組成的一串數據。
其實它能夠和字符數組進行相互轉換。
(2)構造方法：
A:public String()
B:public String(byte[] bytes)
C:public String(byte[] bytes,int offset,int length)
D:public String(char[] value)
E:public String(char[] value,int offset,int count)
F:public String(String original)
下面的這一個雖然不是構造方法，可是結果也是一個字符串對象
G:String s = "hello";
(3)字符串的特色
A:字符串一旦被賦值，就不能改變。
注意：這裏指的是字符串的內容不能改變，而不是引用不能改變。
B:字面值做爲字符串對象和經過構造方法建立對象的不一樣
String s = new String("hello");和String s = "hello"的區別?
(4)字符串的面試題(看程序寫結果)
A:==和equals()
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true

String s3 = new String("hello");  
    String s4 = "hello";  
    System.out.println(s3 == s4);// false  
    System.out.println(s3.equals(s4));// trueString s5 = "hello";  
String s6 = "hello";  
System.out.println(s5 == s6);// true  
System.out.println(s5.equals(s6));// true  B:字符串的拼接  
    String s1 = "hello";  
    String s2 = "world";  
    String s3 = "helloworld";  
    System.out.println(s3 == s1 + s2);// false  
    System.out.println(s3.equals((s1 + s2)));// trueSystem.out.println(s3 == "hello" + "world");// false 這個咱們錯了，應該是true  
System.out.println(s3.equals("hello" + "world"));// true  </code></pre>(5)字符串的功能(本身補齊方法中文意思)
    A:判斷功能
        boolean equals(Object obj)
        boolean equalsIgnoreCase(String str)
        boolean contains(String str)
        boolean startsWith(String str)
        boolean endsWith(String str)
        boolean isEmpty()
    B:獲取功能
        int length()
        char charAt(int index)
        int indexOf(int ch)
        int indexOf(String str)
        int indexOf(int ch,int fromIndex)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)
    C:轉換功能
        byte[] getBytes()
        char[] toCharArray()
        static String valueOf(char[] chs)
        static String valueOf(int i)
        String toLowerCase()
        String toUpperCase()
        String concat(String str)
    D:其餘功能
        a:替換功能
            String replace(char old,char new)
            String replace(String old,String new)
        b:去空格功能
            String trim()
        c:按字典比較功能
            int compareTo(String str)
            int compareToIgnoreCase(String str)
(6)字符串的案例
    A:模擬用戶登陸
    B:字符串遍歷
    C:統計字符串中大寫，小寫及數字字符的個數
    D:把字符串的首字母轉成大寫，其餘小寫
    E:把int數組拼接成一個指定格式的字符串
    F:字符串反轉
    G:統計大串中小串出現的次數

````- StringBuffer

(1)用字符串作拼接，比較耗時而且也耗內存，而這種拼接操做又是比較常見的，爲了解決這個問題，Java就提供了  
一個字符串緩衝區類。StringBuffer供咱們使用。  
(2)StringBuffer的構造方法  
A:StringBuffer()  
B:StringBuffer(int size)  
C:StringBuffer(String str)  
(3)StringBuffer的常見功能(本身補齊方法的聲明和方法的解釋)  
A:添加功能  
B:刪除功能  
C:替換功能  
D:反轉功能  
E:截取功能(注意這個返回值)  
(4)StringBuffer的練習(作一遍)  
A:String和StringBuffer相互轉換  
String -- StringBuffer  
構造方法  
StringBuffer -- String  
toString()方法  
B:字符串的拼接  
C:把字符串反轉  
D:判斷一個字符串是否對稱  
(5)面試題  
小細節：  
StringBuffer：同步的，數據安全，效率低。  
StringBuilder：不一樣步的，數據不安全，效率高。  
A:String,StringBuffer,StringBuilder的區別  
B:StringBuffer和數組的區別?  
(6)注意的問題：  
String做爲形式參數，StringBuffer做爲形式參數。

數組高級以及Arrays

(1)排序
A:冒泡排序
相鄰元素兩兩比較，大的日後放，第一次完畢，最大值出如今了最大索引處。同理，其餘的元素就能夠排好。

public static void bubbleSort(int\[\] arr) {  
        for(int x=0; x<arr.length-1; x++) {  
            for(int y=0; y<arr.length-1-x; y++) {  
                if(arr\[y\] > arr\[y+1\]) {  
                    int temp = arr\[y\];  
                    arr\[y\] = arr\[y+1\];  
                    arr\[y+1\] = temp;  
                }  
            }  
        }  
    }  

B:選擇排序  
    把0索引的元素，和索引1之後的元素都進行比較，第一次完畢，最小值出如今了0索引。同理，其餘的元素就能夠排好。  public static void selectSort(int\[\] arr) {  
    for(int x=0; x&lt;arr.length-1; x++) {  
        for(int y=x+1; y&lt;arr.length; y++) {  
            if(arr\[y\] &lt; arr\[x\]) {  
                int temp = arr\[x\];  
                arr\[x\] = arr\[y\];  
                arr\[y\] = temp;  
            }  
        }  
    }  
}  </code></pre>(2)查找
    A:基本查找
        針對數組無序的狀況  
    public static int getIndex(int\[\] arr,int value) {  
        int index = -1;      for(int x=0; x&lt;arr.length; x++) {  
        if(arr\[x\] == value) {  
            index = x;  
            break;  
        }  
    }

return index; return index;

} B:二分查找(折半查找) 針對數組有序的狀況(千萬不要先排序，在查找) public static int binarySearch(int\[\] arr,int value) { int min = 0; int max = arr.length-1; int mid = (min+max)/2;

while(arr\[mid\] != value) { if(arr\[mid\] &amp;gt; value) { max = mid - 1; }else if(arr\[mid\] &amp;lt; value) { min = mid + 1; } if(min &amp;gt; max) { return -1; } mid = (min+max)/2; } return mid; while(arr\[mid\] != value) { if(arr\[mid\] &amp;gt; value) { max = mid - 1; }else if(arr\[mid\] &amp;lt; value) { min = mid + 1; } if(min &amp;gt; max) { return -1; } mid = (min+max)/2; } return mid;

} </code></pre>(3)Arrays工具類 A:是針對數組進行操做的工具類。包括排序和查找等功能。 B:要掌握的方法 把數組轉成字符串： 排序： 二分查找： (4)Arrays工具類的源碼解析 (5)把字符串中的字符進行排序 舉例： "edacbgf" 獲得結果 "abcdefg"

`- Integer

(1)爲了讓基本類型的數據進行更多的操做，Java就爲每種基本類型提供了對應的包裝類類型  
byte Byte  
short Short  
int Integer  
long Long  
float Float  
double Double  
char Character  
boolean Boolean  
(2)Integer的構造方法  
A:Integer i = new Integer(100);  
B:Integer i = new Integer("100");  
注意：這裏的字符串必須是由數字字符組成  
(3)String和int的相互轉換  
A:String -- int  
Integer.parseInt("100");  
B:int -- String  
String.valueOf(100);  
(4)其餘的功能(瞭解)  
進制轉換  
(5)JDK5的新特性  
自動裝箱 基本類型--引用類型  
自動拆箱 引用類型--基本類型

```
把下面的這個代碼理解便可：  
    Integer i = 100;  
    i += 200;  
```

(6)面試題  
-128到127之間的數據緩衝池問題

Character

(1)Character構造方法
Character ch = new Character('a');
(2)要掌握的方法：(本身補齊)
A:判斷給定的字符是不是大寫
B:判斷給定的字符是不是小寫
C:判斷給定的字符是不是數字字符
D:把給定的字符轉成大寫
E:把給定的字符轉成小寫
(3)案例：
統計字符串中大寫，小寫及數字字符出現的次數 ` `` ````

正則表達式

(1)就是符合必定規則的字符串
(2)常見規則
A:字符
x 字符 x。舉例：'a'表示字符a
\ 反斜線字符。
\n 新行（換行）符 ('\u000A')
\r 回車符 ('\u000D')

B:字符類  
    \[abc\] a、b 或 c（簡單類）   
    \[^abc\] 任何字符，除了 a、b 或 c（否認）   
    \[a-zA-Z\] a到 z 或 A到 Z，兩頭的字母包括在內（範圍）   
    \[0-9\] 0到9的字符都包括  

C:預約義字符類  
    . 任何字符。個人就是.字符自己，怎麼表示呢? \\.  
    \\d 數字：\[0-9\]  
    \\w 單詞字符：\[a-zA-Z_0-9\]  
        在正則表達式裏面組成單詞的東西必須有這些東西組成

D:邊界匹配器  
    ^ 行的開頭   
    $ 行的結尾   
    \\b 單詞邊界  
        就是否是單詞字符的地方。  
        舉例：hello world?haha;xixi  

E:Greedy 數量詞   
    X? X，一次或一次也沒有  
    X* X，零次或屢次  
    X+ X，一次或屢次  
    X{n} X，剛好 n 次   
    X{n,} X，至少 n 次   
    X{n,m} X，至少 n 次，可是不超過 m 次

(3)常見功能：(分別用的是誰呢?)
A:判斷功能
String類的public boolean matches(String regex)
B:分割功能
String類的public String[] split(String regex)
C:替換功能
String類的public String replaceAll(String regex,String replacement)
D:獲取功能
Pattern和Matcher
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");

find():查找存不存在  
        group():獲取剛纔查找過的數據

(4)案例
A:判斷電話號碼和郵箱
B:按照不一樣的規則分割數據
C:把論壇中的數字替換爲*
D:獲取字符串中由3個字符組成的單詞

Random

(1)用於產生隨機數的類
(2)構造方法:
A:Random() 默認種子，每次產生的隨機數不一樣
B:Random(long seed) 指定種子，每次種子相同，隨機數就相同
(3)成員方法:
A:int nextInt() 返回int範圍內的隨機數
B:int nextInt(int n) 返回[0,n)範圍內的隨機數
System

(1)系統類,提供了一些有用的字段和方法
(2)成員方法(本身補齊)
A:運行垃圾回收器
B:退出jvm
C:獲取當前時間的毫秒值
D:數組複製
BigInteger

(1)針對大整數的運算
(2)構造方法
A:BigInteger(String s)
(3)成員方法(本身補齊)
A:加
B:減
C:乘
D:除
E:商和餘數
BigDecimal

(1)浮點數據作運算，會丟失精度。因此，針對浮點數據的操做建議採用BigDecimal。(金融相關的項目)
(2)構造方法
A:BigDecimal(String s)
(3)成員方法：
A:加
B:減
C:乘
D:除
E:本身保留小數幾位
Date/DateFormat

(1)Date是日期類，能夠精確到毫秒。
A:構造方法
Date()
Date(long time)
B:成員方法
getTime()
setTime(long time)
C:日期和毫秒值的相互轉換
案例：你來到這個世界多少天了?
(2)DateFormat針對日期進行格式化和針對字符串進行解析的類，可是是抽象類，因此使用其子類SimpleDateFormat
A:SimpleDateFormat(String pattern) 給定模式
yyyy-MM-dd HH:mm:ss
B:日期和字符串的轉換
a:Date -- String
format()
```
b:String -- Date  
        parse()  
C:案例：  
    製做了一個針對日期操做的工具類。
```
Calendar

(1)日曆類，封裝了全部的日曆字段值，經過統一的方法根據傳入不一樣的日曆字段能夠獲取值。
(2)如何獲得一個日曆對象呢?
Calendar rightNow = Calendar.getInstance();
本質返回的是子類對象
(3)成員方法
A:根據日曆字段獲得對應的值
B:根據日曆字段和一個正負數肯定是添加仍是減去對應日曆字段的值
C:設置日曆對象的年月日
(4)案例：
計算任意一年的2月份有多少天?
對象數組

(1)數組既能夠存儲基本數據類型，也能夠存儲引用類型。它存儲引用類型的時候的數組就叫對象數組。
(2)案例：
用數組存儲5個學生對象，並遍歷數組。
集合(Collection)

(1)集合的由來?
咱們學習的是Java -- 面向對象 -- 操做不少對象 -- 存儲 -- 容器(數組和StringBuffer) -- 數組
而數組的長度固定，因此不適合作變化的需求，Java就提供了集合供咱們使用。
(2)集合和數組的區別?
A:長度區別
數組固定
集合可變
B:內容區別
數組能夠是基本類型，也能夠是引用類型
集合只能是引用類型
C:元素內容
數組只能存儲同一種類型
集合能夠存儲不一樣類型(其實集合通常存儲的也是同一種類型)
(3)集合的繼承體系結構
因爲需求不一樣，Java就提供了不一樣的集合類。這多個集合類的數據結構不一樣，可是它們都是要提供存儲和遍歷功能的，
咱們把它們的共性不斷的向上提取，最終就造成了集合的繼承體系結構圖。
```
Collection  
    |--List  
        |--ArrayList  
        |--Vector  
        |--LinkedList  
    |--Set  
        |--HashSet  
        |--TreeSet
```
(4)Collection的功能概述
A:添加功能
B:刪除功能
C:判斷功能
D:獲取功能
E:長度功能
F:交集(瞭解)
G:把集合轉數組(瞭解)
(5)Collection集合的遍歷
A:把集合轉數組(瞭解)
B:迭代器(集合專用方式)
(6)迭代器
A:是集合的獲取元素的方式。
B:是依賴於集合而存在的。
C:迭代器的原理和源碼。
a:爲何定義爲了一個接口而不是實現類?
b:看了看迭代器的內部類實現。
(7)Collection集合的案例(遍歷方式迭代器)
集合的操做步驟：
A:建立集合對象
B:建立元素對象
C:把元素添加到集合
D:遍歷集合
```
A:存儲字符串並遍歷  
    import java.util.Collection;  
    import java.util.ArrayList;  
    import java.util.Iterator;  public class CollectionDemo {  
    public static void main(String\[\] args) {  
        //建立集合對象  
        Collection c = new ArrayList();
```
```
//建立並添加元素 c.add("hello"); c.add("world"); c.add("java"); //遍歷集合 Iterator it = c.iterator(); while(it.hasNext()) { String s =(String) it.next(); System.out.println(s); } } //建立並添加元素 c.add("hello"); c.add("world"); c.add("java"); //遍歷集合 Iterator it = c.iterator(); while(it.hasNext()) { String s =(String) it.next(); System.out.println(s); } }
```
} B:存儲自定義對象並遍歷 public class Student { private String name; private int age; public Student(){}
```
public Student(String name,int age) { this.name = name; this.age = age; } //getXxx()/setXxx() public Student(String name,int age) { this.name = name; this.age = age; } //getXxx()/setXxx()
```
} import java.util.Collection; import java.util.ArrayList; import java.util.Iterator; public class StudentDemo { public static void main(String\[\] args) { //建立集合對象 Collection c = new ArrayList();
```
 //建立學生對象 Student s1 = new Student("林青霞",27); Student s2 = new Student("風清揚",30); Student s3 = new Student("劉意",30); Student s4 = new Student("武鑫",25); Student s5 = new Student("劉曉曲",16); //添加元素 c.add(s1); c.add(s2); c.add(s3); c.add(s4); c.add(s5); //遍歷集合 Iterator it = c.iterator(); while(it.hasNext()) { Student s = (Student)it.next(); System.out.println(s.getName()+"---"+s.getAge()); } } //建立學生對象 Student s1 = new Student("林青霞",27); Student s2 = new Student("風清揚",30); Student s3 = new Student("劉意",30); Student s4 = new Student("武鑫",25); Student s5 = new Student("劉曉曲",16); //添加元素 c.add(s1); c.add(s2); c.add(s3); c.add(s4); c.add(s5); //遍歷集合 Iterator it = c.iterator(); while(it.hasNext()) { Student s = (Student)it.next(); System.out.println(s.getName()+"---"+s.getAge()); } }
```
}</code></pre></li>List (1)List是Collection的子接口特色：有序(存儲順序和取出順序一致)，可重複。 (2)List的特有功能： A:添加功能 B:刪除功能 C:獲取功能 D:迭代器功能 E:修改功能 (3)List集合的特有遍歷功能 A:由size()和get()結合。 B:代碼演示 //建立集合對象 List list = new ArrayList(); //建立並添加元素 list.add("hello"); list.add("world"); list.add("java"); //遍歷集合 Iterator it = list.iterator(); while(it.hasNext()) { String s =(String) it.next(); System.out.println(s); } System.out.println("----------");
```
 for(int x=0; x&amp;lt;list.size(); x++) { String s =(String) list.get(x); System.out.println(s); } &lt;/code&gt;&lt;/pre&gt;(4)列表迭代器的特有功能； 能夠逆向遍歷，可是要先正向遍歷，因此無心義，基本不使用。for(int x=0; x&amp;lt;list.size(); x++) { String s =(String) list.get(x); System.out.println(s); } &lt;/code&gt;&lt;/pre&gt;(4)列表迭代器的特有功能； 能夠逆向遍歷，可是要先正向遍歷，因此無心義，基本不使用。
```
(5)併發修改異常 A:出現的現象迭代器遍歷集合，集合修改集合元素 B:緣由迭代器是依賴於集合的，而集合的改變迭代器並不知道。 C:解決方案 a:迭代器遍歷，迭代器修改(ListIterator) 元素添加在剛纔迭代的位置 b:集合遍歷，集合修改(size()和get()) 元素添加在集合的末尾 (6)常見數據結構 A:棧先進後出 B:隊列先進先出 C:數組查詢快，增刪慢 D:鏈表查詢慢，增刪快 (7)List的子類特色(面試題) ArrayList 底層數據結構是數組，查詢快，增刪慢。線程不安全，效率高。 Vector 底層數據結構是數組，查詢快，增刪慢。線程安全，效率低。 LinkedList 底層數據結構是鏈表，查詢慢，增刪快。線程不安全，效率高。到底使用誰呢?看需求? 分析：要安全嗎? 要：Vector(即便要，也不使用這個，後面再說) 不要：ArrayList或者LinkedList 查詢多；ArrayList 增刪多：LinkedList 什麼都不知道，就用ArrayList。 (8)List集合的案例(遍歷方式迭代器和普通for) A:存儲字符串並遍歷 B:存儲自定義對象並遍歷 (1)List的子類特色 ArrayList: 底層數據結構是數組，查詢快，增刪慢線程不安全，效率高 Vector: 底層數據結構是數組，查詢快，增刪慢線程安全，效率低 LinkedList: 底層數據結構是鏈表，查詢慢，增刪快線程不安全，效率高 (2)ArrayList A:沒有特有功能須要學習 B:案例 a:ArrayList存儲字符串並遍歷 b:ArrayList存儲自定義對象並遍歷 (3)Vector A:有特有功能 a:添加 public void addElement(E obj) -- add() b:獲取 public E elementAt(int index) -- get() public Enumeration elements() -- iterator() B:案例 a:Vector存儲字符串並遍歷 b:Vector存儲自定義對象並遍歷 (4)LinkedList A:有特有功能 a:添加 addFirst() addLast() b:刪除 removeFirst() removeLast() c:獲取 getFirst() getLast() B:案例 a:LinkedList存儲字符串並遍歷 b:LinkedList存儲自定義對象並遍歷 (5)案例： A:去除集合中的多個字符串的重複元素若是字符串的內容相同，即爲重複元素 B:去除集合中的多個自定義對象的重複元素若是自定義對象的成員變量值都相同，即爲重複元素 C:用LinkedList模擬一個棧數據結構的集合類，並測試。你要定義一個集合類，只不過內部可使用LinkedList來實現。

泛型

(1)泛型概述
是一種把明確類型的工做推遲到建立對象或者調用方法的時候纔去明確的特殊的類型。
(2)格式：
<數據類型>
注意：該數據類型只能是引用類型。
(3)好處：
A:把運行時期的問題提早到了編譯期間
B:避免了強制類型轉換
C:優化了程序設計，解決了黃色警告線問題，讓程序更安全
(4)泛型的前世此生
A:泛型的由來
Object類型做爲任意類型的時候，在向下轉型的時候，會隱含一個轉型問題
B:泛型類
C:泛型方法
D:泛型接口
E:泛型高級通配符
?
? extends E
? super E
(5)咱們在哪裏使用呢?
通常是在集合中使用。
加強for循環

(1)是for循環的一種
(2)格式：
for(元素的數據類型變量名 : 數組或者Collection集合的對象) {
使用該變量便可，該變量其實就是數組或者集合中的元素。
}
(3)好處：
簡化了數組和集合的遍歷
(4)弊端
加強for循環的目標不能爲null。建議在使用前，先判斷是否爲null。

靜態導入

(1)能夠導入到方法級別的導入
(2)格式：
import static 包名….類名.方法名;
(3)注意事項：
A:方法必須是靜態的
B:若是多個類下有同名的方法，就很差區分了，還得加上前綴。
因此通常咱們並不使用靜態導入，可是必定要可以看懂。
可變參數

(1)若是咱們在寫方法的時候，參數個數不明確，就應該定義可變參數。
(2)格式：
修飾符返回值類型方法名(數據類型… 變量) {}
```
注意：  
    A:該變量實際上是一個數組名  
    B:若是一個方法有多個參數，而且有可變參數，可變參數必須在最後
```
(3)Arrays工具類的一個方法
asList()把數組轉成集合。
注意：這個集合的長度不能改變。
Set集合

(1)Set集合的特色
無序,惟一
(2)HashSet集合(掌握)
A:底層數據結構是哈希表(是一個元素爲鏈表的數組)
B:哈希表底層依賴兩個方法：hashCode()和equals()
執行順序：
首先比較哈希值是否相同
相同：繼續執行equals()方法
返回true：元素重複了，不添加
返回false：直接把元素添加到集合
不一樣：就直接把元素添加到集合
C:如何保證元素惟一性的呢?
由hashCode()和equals()保證的
D:開發的時候，代碼很是的簡單，自動生成便可。
E:HashSet存儲字符串並遍歷
F:HashSet存儲自定義對象並遍歷(對象的成員變量值相同即爲同一個元素)
(3)TreeSet集合
A:底層數據結構是紅黑樹(是一個自平衡的二叉樹)
B:保證元素的排序方式
a:天然排序(元素具有比較性)
讓元素所屬的類實現Comparable接口
b:比較器排序(集合具有比較性)
讓集合構造方法接收Comparator的實現類對象
C:把咱們講過的代碼看一遍便可
(4)案例：
A:獲取無重複的隨機數
B:鍵盤錄入學生按照總分從高到底輸出

Collection

|--List    有序,可重複  
    |--ArrayList  
        底層數據結構是數組，查詢快，增刪慢。  
        線程不安全，效率高  
    |--Vector  
        底層數據結構是數組，查詢快，增刪慢。  
        線程安全，效率低  
    |--LinkedList  
        底層數據結構是鏈表，查詢慢，增刪快。  
        線程不安全，效率高  
|--Set    無序,惟一  
    |--HashSet  
        底層數據結構是哈希表。  
        如何保證元素惟一性的呢?  
            依賴兩個方法：hashCode()和equals()  
            開發中自動生成這兩個方法便可  
        |--LinkedHashSet  
            底層數據結構是鏈表和哈希表  
            由鏈表保證元素有序  
            由哈希表保證元素惟一  
    |--TreeSet  
        底層數據結構是紅黑樹。  
        如何保證元素排序的呢?  
            天然排序  
            比較器排序  
        如何保證元素惟一性的呢?  
            根據比較的返回值是不是0來決定

4:針對Collection集合咱們到底使用誰呢?
惟一嗎?
是：Set
排序嗎?
是：TreeSet
否：HashSet
若是你知道是Set，可是不知道是哪一個Set，就用HashSet。

否：List  
        要安全嗎?  
            是：Vector  
            否：ArrayList或者LinkedList  
                查詢多：ArrayList  
                增刪多：LinkedList  
    若是你知道是List，可是不知道是哪一個List，就用ArrayList。  

若是你知道是Collection集合，可是不知道使用誰，就用ArrayList。  

若是你知道用集合，就用ArrayList。

5:在集合中常見的數據結構(掌握)
ArrayXxx:底層數據結構是數組，查詢快，增刪慢
LinkedXxx:底層數據結構是鏈表，查詢慢，增刪快
HashXxx:底層數據結構是哈希表。依賴兩個方法：hashCode()和equals()
TreeXxx:底層數據結構是二叉樹。兩種方式排序：天然排序和比較器排序

Map

(1)將鍵映射到值的對象。一個映射不能包含重複的鍵；每一個鍵最多隻能映射到一個值。
(2)Map和Collection的區別?
A:Map 存儲的是鍵值對形式的元素，鍵惟一，值能夠重複。夫妻對
B:Collection 存儲的是單獨出現的元素，子接口Set元素惟一，子接口List元素可重複。光棍
(3)Map接口功能概述(本身補齊)
A:添加功能
B:刪除功能
C:判斷功能
D:獲取功能
E:長度功能
(4)Map集合的遍歷
A:鍵找值
a:獲取全部鍵的集合
b:遍歷鍵的集合,獲得每個鍵
c:根據鍵到集合中去找值

B:鍵值對對象找鍵和值  
    a:獲取全部的鍵值對對象的集合  
    b:遍歷鍵值對對象的集合，獲取每個鍵值對對象  
    c:根據鍵值對對象去獲取鍵和值  

代碼體現：  
    Map<String,String> hm = new HashMap<String,String>();  hm.put("it002","hello");  
hm.put("it003","world");  
hm.put("it001","java");  

//方式1 鍵找值  
Set&lt;String&gt; set = hm.keySet();  
for(String key : set) {  
    String value = hm.get(key);  
    System.out.println(key+"---"+value);  
}  

//方式2 鍵值對對象找鍵和值  
Set&lt;Map.Entry&lt;String,String&gt;&gt; set2 = hm.entrySet();  
for(Map.Entry&lt;String,String&gt; me : set2) {  
    String key = me.getKey();  
    String value = me.getValue();  
    System.out.println(key+"---"+value);  
}  </code></pre>(5)HashMap集合的練習
    A:HashMap
    B:HashMap
    C:HashMap
    D:HashMap
(6)TreeMap集合的練習
    A:TreeMap
    B:TreeMap
(7)案例
    A:統計一個字符串中每一個字符出現的次數
    B:集合的嵌套遍歷
        a:HashMap嵌套HashMap
        b:HashMap嵌套ArrayList
        c:ArrayList嵌套HashMap
        d:多層嵌套

``- Collections

(1)是針對集合進行操做的工具類  
(2)面試題：Collection和Collections的區別  
A:Collection 是單列集合的頂層接口，有兩個子接口List和Set  
B:Collections 是針對集合進行操做的工具類，能夠對集合進行排序和查找等  
(3)常見的幾個小方法：  
A:public static void sort(List list)  
B:public static int binarySearch(List list,T key)  
C:public static T max(Collection coll)  
D:public static void reverse(List list)  
E:public static void shuffle(List list)  
(4)案例  
A:ArrayList集合存儲自定義對象的排序  
B:模擬鬥地主洗牌和發牌  
C:模擬鬥地主洗牌和發牌並對牌進行排序

異常

(1)程序出現的不正常的狀況。
(2)異常的體系
Throwable
|--Error 嚴重問題，咱們不處理。
|--Exception
|--RuntimeException 運行期異常，咱們須要修正代碼
|--非RuntimeException 編譯期異常，必須處理的，不然程序編譯不經過
(3)異常的處理：
A:JVM的默認處理
把異常的名稱,緣由,位置等信息輸出在控制檯，可是呢程序不能繼續執行了。
B:本身處理
a:try…catch…finally
本身編寫處理代碼,後面的程序能夠繼續執行
b:throws
把本身處理不了的，在方法上聲明，告訴調用者，這裏有問題
(4)面試題
A:編譯期異常和運行期異常的區別?
編譯期異常必需要處理的，不然編譯不經過
運行期異常能夠不處理，也能夠處理
B:throw和throws是的區別
throw:
在方法體中,後面跟的是異常對象名,而且只能是一個
throw拋出的是一個異常對象，說明這裏確定有一個異常產生了
throws:
在方法聲明上,後面跟的是異常的類名,能夠是多個
throws是聲明方法有異常，是一種可能性，這個異常並不必定會產生
(5)finally關鍵字及其面試題
A:finally用於釋放資源，它的代碼永遠會執行。特殊狀況：在執行到finally以前jvm退出了
B:面試題
a:final,finally,finalize的區別?
b:若是在catch裏面有return,請問finally還執行嗎?若是執行,在return前仍是後
會，前。
實際上在中間。這個上課咱們講過
C:異常處理的變形
try…catch…finally
try…catch…
try…catch…catch…
try…catch…catch…fianlly
try…finally
(6)自定義異常
繼承自Exception或者RuntimeException,只須要提供無參構造和一個帶參構造便可
(7)異常的注意實現
A:父的方法有異常拋出,子的重寫方法在拋出異常的時候必需要小於等於父的異常
B:父的方法沒有異常拋出,子的重寫方法不能有異常拋出
C:父的方法拋出多個異常,子的重寫方法必須比父少或者小
File

(1)IO流操做中大部分都是對文件的操做，因此Java就提供了File類供咱們來操做文件
(2)構造方法
A:File file = new File("e:\demo\a.txt");
B:File file = new File("e:\demo","a.txt");
C:File file = new File("e:\demo");
File file2 = new File(file,"a.txt");
(3)File類的功能(本身補齊)
A:建立功能
B:刪除功能
C:重命名功能
D:判斷功能
E:獲取功能
F:高級獲取功能
G:過濾器功能
(4)案例：
A:輸出指定目錄下指定後綴名的文件名稱
a:先獲取全部的，在遍歷的時候判斷，再輸出
b:先判斷，再獲取，最後直接遍歷輸出便可
B:批量修改文件名稱
遞歸

(1)方法定義中調用方法自己的現象
舉例：老和尚給小和尚講故事，咱們學編程
(2)遞歸的注意事項；
A:要有出口，不然就是死遞歸
B:次數不能過多，不然內存溢出
C:構造方法不能遞歸使用
(3)遞歸的案例：
A:遞歸求階乘
B:兔子問題
C:遞歸輸出指定目錄下全部指定後綴名的文件絕對路徑
D:遞歸刪除帶內容的目錄(當心使用)

IO流

(1)IO用於在設備間進行數據傳輸的操做
(2)分類：
A:流向
輸入流讀取數據
輸出流寫出數據
B:數據類型
字節流
字節輸入流
字節輸出流
字符流
字符輸入流
字符輸出流
注意：
a:若是咱們沒有明確說明按照什麼分，默認按照數據類型分。
b:除非文件用windows自帶的記事本打開咱們可以讀懂，才採用字符流，不然建議使用字節流。
(3)FileOutputStream寫出數據
A:操做步驟
a:建立字節輸出流對象
b:調用write()方法
c:釋放資源

B:代碼體現：  
    FileOutputStream fos = new FileOutputStream("fos.txt");  fos.write("hello".getBytes());  

fos.close();  C:要注意的問題?  
    a:建立字節輸出流對象作了幾件事情?  
    b:爲何要close()?  
    c:如何實現數據的換行?  
    d:如何實現數據的追加寫入?

(4)FileInputStream讀取數據
A:操做步驟
a:建立字節輸入流對象
b:調用read()方法
c:釋放資源

B:代碼體現：  
    FileInputStream fis = new FileInputStream("fos.txt");  //方式1  
int by = 0;  
while((by=fis.read())!=-1) {  
    System.out.print((char)by);  
}  

//方式2  
byte\[\] bys = new byte\[1024\];  
int len = 0;  
while((len=fis.read(bys))!=-1) {  
    System.out.print(new String(bys,0,len));  
}  

fis.close();  </code></pre>(5)案例：2種實現
    A:複製文本文件
    B:複製圖片
    C:複製視頻
(6)字節緩衝區流
    A:BufferedOutputStream
    B:BufferedInputStream
(7)案例：4種實現
    A:複製文本文件
    B:複製圖片
    C:複製視頻

`- 字節流：

```
    InputStream  
        FileInputStream  
        BufferedInputStream  
    OutputStream  
        FileOutputStream  
        BufferedOutputStream
```

字符流：

Reader  
        FileReader  
        BufferedReader  
    Writer  
        FileWriter  
        BufferedWriter

(1)字節流操做中文數據不是特別的方便，因此就出現了轉換流。
轉換流的做用就是把字節流轉換字符流來使用。
(2)轉換流實際上是一個字符流
字符流 = 字節流 + 編碼表
(3)編碼表
A:就是由字符和對應的數值組成的一張表
B:常見的編碼表
ASCII
ISO-8859-1
GB2312
GBK
GB18030
UTF-8
C:字符串中的編碼問題
編碼
String -- byte[]
解碼
byte[] -- String
(4)IO流中的編碼問題
A:OutputStreamWriter
OutputStreamWriter(OutputStream os):默認編碼，GBK
OutputStreamWriter(OutputStream os,String charsetName):指定編碼。
B:InputStreamReader
InputStreamReader(InputStream is):默認編碼，GBK
InputStreamReader(InputStream is,String charsetName):指定編碼
C:編碼問題其實很簡單
編碼只要一致便可
(5)字符流
Reader
|--InputStreamReader
|--FileReader
|--BufferedReader
Writer
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
(6)複製文本文件(5種方式)

IO流
|--字節流
|--字節輸入流
InputStream
int read():一次讀取一個字節
int read(byte[] bys):一次讀取一個字節數組

|--FileInputStream  
            |--BufferedInputStream  
    |--字節輸出流  
        OutputStream  
            void write(int by):一次寫一個字節  
            void write(byte\[\] bys,int index,int len):一次寫一個字節數組的一部分          |--FileOutputStream  
        |--BufferedOutputStream  |--字符流  
    |--字符輸入流  
        Reader  
            int read():一次讀取一個字符  
            int read(char\[\] chs):一次讀取一個字符數組          |--InputStreamReader  
            |--FileReader  
        |--BufferedReader  
            String readLine():一次讀取一個字符串  
|--字符輸出流  
    Writer  
        void write(int ch):一次寫一個字符  
        void write(char\[\] chs,int index,int len):一次寫一個字符數組的一部分

|--OutputStreamWriter |--FileWriter |--BufferedWriter void newLine():寫一個換行符 void write(String line):一次寫一個字符串&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;</code></pre>|--OutputStreamWriter |--FileWriter |--BufferedWriter void newLine():寫一個換行符 void write(String line):一次寫一個字符串&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;</code></pre>

` ``

2:數據操做流(操做基本類型數據的流) (1)能夠操做基本類型的數據 (2)流對象名稱 DataInputStream DataOutputStream

3:內存操做流 (1)有些時候咱們操做完畢後，未必須要產生一個文件，就可使用內存操做流。 (2)三種 A:ByteArrayInputStream,ByteArrayOutputStream B:CharArrayReader,CharArrayWriter C:StringReader,StringWriter

4:打印流 (1)字節打印流，字符打印流 (2)特色： A:只操做目的地,不操做數據源 B:能夠操做任意類型的數據 C:若是啓用了自動刷新，在調用println()方法的時候，可以換行並刷新 D:能夠直接操做文件問題：哪些流能夠直接操做文件呢? 看API，若是其構造方法可以同時接收File和String類型的參數，通常都是能夠直接操做文件的 (3)複製文本文件 BufferedReader br = new BufferedReader(new FileReader("a.txt")); PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);

 String line = null; while((line=br.readLine())!=null) { pw.println(line); } pw.close(); br.close(); String line = null; while((line=br.readLine())!=null) { pw.println(line); } pw.close(); br.close();

5:標準輸入輸出流 (1)System類下面有這樣的兩個字段 in 標準輸入流 out 標準輸出流 (2)三種鍵盤錄入方式 A:main方法的args接收參數 B:System.in經過BufferedReader進行包裝 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); C:Scanner Scanner sc = new Scanner(System.in); (3)輸出語句的原理和如何使用字符流輸出數據 A:原理 System.out.println("helloworld");

 PrintStream ps = System.out; ps.println("helloworld"); B:把System.out用字符緩衝流包裝一下使用 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));PrintStream ps = System.out; ps.println("helloworld"); B:把System.out用字符緩衝流包裝一下使用 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

6:隨機訪問流 (1)能夠按照文件指針的位置寫數據和讀數據。 (2)案例： A:寫數據 B:讀數據 C:獲取和改變文件指針的位置

7:合併流 (1)把多個輸入流的數據寫到一個輸出流中。 (2)構造方法： A:SequenceInputStream(InputStream s1, InputStream s2) B:SequenceInputStream(Enumeration e)

8:序列化流 (1)能夠把對象寫入文本文件或者在網絡中傳輸 (2)如何實現序列化呢? 讓被序列化的對象所屬類實現序列化接口。該接口是一個標記接口。沒有功能須要實現。 (3)注意問題：把數據寫到文件後，在去修改類會產生一個問題。如何解決該問題呢? 在類文件中，給出一個固定的序列化id值。並且，這樣也能夠解決黃色警告線問題 (4)面試題：何時序列化? 如何實現序列化? 什麼是反序列化?

Properties

(1)是一個集合類，Hashtable的子類 (2)特有功能 A:public Object setProperty(String key,String value) B:public String getProperty(String key) C:public Set stringPropertyNames() (3)和IO流結合的方法把鍵值對形式的文本文件內容加載到集合中 public void load(Reader reader) public void load(InputStream inStream)
```
把集合中的數據存儲到文本文件中 public void store(Writer writer,String comments) public void store(OutputStream out,String comments) 把集合中的數據存儲到文本文件中 public void store(Writer writer,String comments) public void store(OutputStream out,String comments)
```
(4)案例： A:根據給定的文件判斷是否有鍵爲"lisi"的，若是有就修改其值爲100 B:寫一個程序實現控制猜數字小遊戲程序不能玩超過5次
NIO

(1)JDK4出現的NIO，對之前的IO操做進行了優化，提供了效率。可是大部分咱們看到的仍是之前的IO (2)JDK7的NIO的使用 Path:路徑 Paths:經過靜態方法返回一個路徑 Files:提供了常見的功能複製文本文件把集合中的數據寫到文本文件

多線程

(1)多線程：一個應用程序有多條執行路徑進程：正在執行的應用程序線程：進程的執行單元，執行路徑單線程：一個應用程序只有一條執行路徑多線程：一個應用程序有多條執行路徑

多進程的意義? 提升CPU的使用率 多線程的意義? 提升應用程序的使用率 多進程的意義? 提升CPU的使用率 多線程的意義? 提升應用程序的使用率

(2)Java程序的運行原理及JVM的啓動是多線程的嗎? A:Java命令去啓動JVM，JVM會啓動一個進程，該進程會啓動一個主線程。 B:JVM的啓動是多線程的，由於它最低有兩個線程啓動了，主線程和垃圾回收線程。 (3)多線程的實現方案(本身補齊步驟及代碼掌握) A:繼承Thread類 B:實現Runnable接口 (4)線程的調度和優先級問題 A:線程的調度 a:分時調度 b:搶佔式調度 (Java採用的是該調度方式) B:獲取和設置線程優先級 a:默認是5 b:範圍是1-10 (5)線程的控制(常見方法) A:休眠線程 B:加入線程 C:禮讓線程 D:後臺線程 E:終止線程(掌握) (6)線程的生命週期 A:新建 B:就緒 C:運行 D:阻塞 E:死亡 (7)電影院賣票程序的實現 A:繼承Thread類 B:實現Runnable接口 (8)電影院賣票程序出問題 A:爲了更符合真實的場景，加入了休眠100毫秒。 B:賣票問題 a:同票屢次 b:負數票 (9)多線程安全問題的緣由(也是咱們之後判斷一個程序是否有線程安全問題的依據) A:是否有多線程環境 B:是否有共享數據 C:是否有多條語句操做共享數據 (10)同步解決線程安全問題 A:同步代碼塊 synchronized(對象) { 須要被同步的代碼; }

 這裏的鎖對象能夠是任意對象。 B:同步方法 把同步加在方法上。 這裏的鎖對象是this C:靜態同步方法 把同步加在方法上。 這裏的鎖對象是當前類的字節碼文件對象(反射再講字節碼文件對象) </code></pre>(11)回顧之前的線程安全的類 A:StringBuffer B:Vector C:Hashtable D:如何把一個線程不安全的集合類變成一個線程安全的集合類 用Collections工具類的方法便可。 (1)JDK5之後的針對線程的鎖定操做和釋放操做 Lock鎖 (2)死鎖問題的描述和代碼體現 (3)生產者和消費者多線程體現(線程間通訊問題) 以學生做爲資源來實現的 資源類：Student 設置數據類：SetThread(生產者) 獲取數據類：GetThread(消費者) 測試類：StudentDemo 代碼： A:最基本的版本，只有一個數據。 B:改進版本，給出了不一樣的數據，並加入了同步機制 C:等待喚醒機制改進該程序，讓數據可以實現依次的出現 wait() notify() notifyAll() (多生產多消費) D:等待喚醒機制的代碼優化。把數據及操做都寫在了資源類中 (4)線程組 (5)線程池 (6)多線程實現的第三種方案 (7)多線程的面試題這裏的鎖對象能夠是任意對象。 B:同步方法 把同步加在方法上。 這裏的鎖對象是this C:靜態同步方法 把同步加在方法上。 這裏的鎖對象是當前類的字節碼文件對象(反射再講字節碼文件對象) </code></pre>(11)回顧之前的線程安全的類 A:StringBuffer B:Vector C:Hashtable D:如何把一個線程不安全的集合類變成一個線程安全的集合類 用Collections工具類的方法便可。 (1)JDK5之後的針對線程的鎖定操做和釋放操做 Lock鎖 (2)死鎖問題的描述和代碼體現 (3)生產者和消費者多線程體現(線程間通訊問題) 以學生做爲資源來實現的 資源類：Student 設置數據類：SetThread(生產者) 獲取數據類：GetThread(消費者) 測試類：StudentDemo 代碼： A:最基本的版本，只有一個數據。 B:改進版本，給出了不一樣的數據，並加入了同步機制 C:等待喚醒機制改進該程序，讓數據可以實現依次的出現 wait() notify() notifyAll() (多生產多消費) D:等待喚醒機制的代碼優化。把數據及操做都寫在了資源類中 (4)線程組 (5)線程池 (6)多線程實現的第三種方案 (7)多線程的面試題

`- 設計模式

(1)面試對象的常見設計原則 單一 開閉 里氏 依賴注入 接口 迪米特 (2)設計模式概述和分類 A:經驗的總結 B:三類 建立型 結構型 行爲型 (3)改進的設計模式 A:簡單工廠模式 B:工廠方法模式 C:單例模式(掌握) a:餓漢式 b:懶漢式 (4)Runtime JDK提供的一個單例模式應用的類。 還能夠調用dos命令。 (1)裝飾設計模式 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); ``` Scanner sc = new Scanner(System.in); ``` (2)模版設計模式 `(1)面試對象的常見設計原則 單一 開閉 里氏 依賴注入 接口 迪米特 (2)設計模式概述和分類 A:經驗的總結 B:三類 建立型 結構型 行爲型 (3)改進的設計模式 A:簡單工廠模式 B:工廠方法模式 C:單例模式(掌握) a:餓漢式 b:懶漢式 (4)Runtime JDK提供的一個單例模式應用的類。 還能夠調用dos命令。 (1)裝飾設計模式 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); ``` Scanner sc = new Scanner(System.in); ``` (2)模版設計模式 `

1:如何讓Netbeans的東西Eclipse能訪問。在Eclipse中建立項目，把Netbeans項目的src下的東西給拿過來便可。注意：修改項目編碼爲UTF-8

GUI

(1)用戶圖形界面 GUI:方便直觀 CLI:須要記憶一下命令，麻煩 (2)兩個包： java.awt:和系統關聯較強 javax.swing:純Java編寫 (3)GUI的繼承體系組件：組件就是對象容器組件：是能夠存儲基本組件和容器組件的組件。基本組件：是可使用的組件，可是必須依賴容器。 (4)事件監聽機制 A:事件源 B:事件 C:事件處理 D:事件監聽 (5)適配器模式 A:接口 B:抽象適配器類 C:實現類 (6)案例： A:建立窗體案例 B:窗體關閉案例 C:窗體添加按鈕並對按鈕添加事件案例。界面中的組件佈局。 D:把文本框裏面的數據轉移到文本域 E:更改背景色 F:設置文本框裏面不能輸入非數字字符 G:一級菜單 H:多級菜單 (7)Netbeans的概述和使用 A:是能夠作Java開發的另外一個IDE工具。 B:使用 A:四則運算 a:修改圖標 b:設置皮膚 c:設置居中 d:數據校驗 B:登陸註冊
網絡編程

(1)網絡編程：用Java語言實現計算機間數據的信息傳遞和資源共享 (2)網絡編程模型 (3)網絡編程的三要素 A:IP地址 a:點分十進制 b:IP地址的組成 c:IP地址的分類 d:dos命令 e:InetAddress B:端口是應用程序的標識。範圍：0-65535。其中0-1024不建議使用。 C:協議 UDP:數據打包,有限制,不鏈接,效率高,不可靠 TCP:創建數據通道,無限制,效率低,可靠 (3)Socket機制 A:通訊兩端都應該有Socket對象 B:全部的通訊都是經過Socket間的IO進行操做的 (4)UDP協議發送和接收數據(掌握本身補齊代碼) 發送：建立UDP發送端的Socket對象建立數據並把數據打包發送數據釋放資源
```
接收： 建立UDP接收端的Socket對象 建立數據包用於接收數據 接收數據 解析數據包 釋放資源 接收： 建立UDP接收端的Socket對象 建立數據包用於接收數據 接收數據 解析數據包 釋放資源
```
(5)TCP協議發送和接收數據(掌握本身補齊代碼) 發送：建立TCP客戶端的Socket對象獲取輸出流，寫數據釋放資源
```
接收： 建立TCP服務器端的Socket對象 監聽客戶端鏈接 獲取輸入流，讀取數據 釋放資源 接收： 建立TCP服務器端的Socket對象 監聽客戶端鏈接 獲取輸入流，讀取數據 釋放資源
```
(6)案例： A:UDP a:最基本的UDP協議發送和接收數據 b:把發送數據改進爲鍵盤錄入 c:一個簡易聊天小程序並用多線程改進 B:TCP a:最基本的TCP協議發送和接收數據 b:服務器給出反饋 c:客戶端鍵盤錄入服務器控制檯輸出 d:客戶端鍵盤錄入服務器寫到文本文件 e:客戶端讀取文本文件服務器控制檯輸出 f:客戶端讀取文本文件服務器寫到文本文件 g:上傳圖片 h:多線程改進上傳文件
反射

(1)類的加載及類加載器 (2)反射：經過字節碼文件對象，去使用成員變量，構造方法，成員方法 (3)反射的使用 A:經過反射獲取構造方法並使用 B:經過反射獲取成員變量並使用 C:經過反射獲取成員方法並使用 (4)反射案例 A:經過反射運行配置文件的內容 B:經過反射越過泛型檢查 C:經過反射給任意的一個對象的任意的屬性賦值爲指定的值 (5)動態代理
JDK新特性

(1)JDK5 裝箱和拆箱泛型加強for 靜態導入可變參數枚舉 (2)JDK7 二進制的表現形式用_分隔數據 switch語句但是用字符串泛型推斷(菱形泛型) 多catch的使用自動釋放資源的用法