總結

1.1                知識點總結

l  資料型別轉換

n  資料類型範圍從小到大排序（byte < char < short < int < long < float < double），布林型別Boolean不能參與型別轉換；

n  自動型別轉換，範圍小的資料型別向範圍大的資料型別轉換時使用；

n  強制型別轉換，範圍大的資料型別向範圍小的資料型別轉換時使用。

 

l  算數運算子

n  用來完成算數運算（如加減乘除計算等）

n  ++，--運算子的使用

u  ++，--前置（如++a），當參與運算時，變數a的值先自增1，然後用自增後的新值再參與運算；

u  ++，--後置（如a++），當參與運算時，變數a先使用原有值參與運算子，變數a的值再自增1。

 

l  賦值運算子

n  用來完成資料的賦值（如 int a = 100;）

n  +=,-,*=,/=這樣的賦值運算子包含了一個強制轉換的操作，會將左右兩邊運算後的結果，強制型別轉換後賦值給左邊

int n = 10;

byte by = 20;

by += n; // 運算完畢後，by的值為byte型別30， 相當於程式碼 by = (byte)(by + n);

 

l  比較運算子

n  用來比較資料的大小（如 3>4），比較運算子也稱為條件運算子。

n  比較後的結果為布林型別Boolean的值

n  “==”兩個等號代表比較是否相等，“=”一個等號代表賦值。

 

l  邏輯運算子

n  邏輯與& 和邏輯短路與&&：代表著並且的意思，左右兩邊都要條件成立，結果才為true；

n  邏輯或| 和邏輯短路或||：代表著或者的意思，左邊兩邊有一個條件成立，結果就為true；

n  邏輯非!：代表著相反的意思，原先是false，結果就為true；原先是ture，結果就為false；

n  邏輯異或^： 左右兩邊條件結果相同，結果就為false，左右兩邊條件結果不同，結果就為true；

 

l  三元運算子

n  根據判斷條件運算結果，執行不同的表示式值；條件為true，執行表示式1，否則，執行表示式2。

 

 

第2章     總結

2.1      知識點總結

l  選擇結構 if

n  方式1:

                   格式：

                            if(條件表示式) {

                                     語句體;

                            }

                   執行流程：

                            如果條件表示式值為true, 執行語句體

                            如果條件表示式值為false,不執行語句體

                           

n  方式2：

                   格式:

                            if(條件表示式) {

                                     語句體1;

                            } else {

                                     語句體2;

                            }

                   執行流程：

                            如果條件表示式值為true, 執行語句體1

                            如果條件表示式值為fales,執行語句體2

n  方式3：

                   格式：

                            if(條件表示式1) {

                                     語句體1;

                            } else if (條件表示式2) {

                                語句體2;

                            } else if (條件表示式n...) {

                                     語句體n...

                            }

                            ...

                            else {

                                     語句體n+1;

                            }

                   執行流程：

                            哪一個條件表示式成立，執行對應的語句體，

                            如果所有的條件表示式都不成立，執行最後else中的語句體

                           

n  注意事項：

                   1，條件表示式無論是簡單還是複雜，結果都是boolean型別的值

                   2, 如果語句體只有一條語句，大括號可以省略，

                      如果是多條語句，大括號不能省略，建議什麼時候都寫上大括號

l  迴圈語句For

n  格式：

                   for (初始化表示式;條件表示式; 控制條件表示式) {

                            語句體;

                   }

n  執行流程：

                   1，初始化表示式；

                   2，條件表示式

                             如果結果為true, 執行語句體

                             如果結果為flase, 迴圈結束

                   3, 當語句體執行後， 執行控制條件表示式

                   4，接下來，回到第二步, 直到條件表示式為false 迴圈結束

l  迴圈語句 while

n  格式：

                   初始化表示式;

                   while (條件表示式) {

                            語句體;

                            控制條件表示式;

                   }

n  執行流程；

                   1，初始化表示式；

                   2，條件表示式

                             如果結果為true, 執行語句體

                             如果結果為flase, 迴圈結束

                   3, 當語句體執行後， 執行控制條件表示式

                   4，接下來，回到第二步, 直到條件表示式為false 迴圈結束跳轉語句（break、continue）

l  迴圈語句  do...while

n  格式：

                   初始化表示式;

                   do {

                            語句體;

                            控制條件表示式;

                   } while (條件表示式);

n  執行流程:

                   1，初始化表示式；

                   2, 執行語句體

                   3, 執行控制條件表示式

                   4, 執行條件表示式,

                            如果結果為true, 繼續執行語句體

                            如果結果為false, 迴圈結束

l  跳轉控制語句

         break; 跳出迴圈

         continue; 結束本次迴圈

l  Scanner類

n  獲取鍵盤錄入的資料，對獲取資料的具體操作進行了封裝，只需要呼叫方法，即可得到鍵盤錄入的資料。

n  常用的方法

public int nextInt()：獲取鍵盤錄入的資料，返回int型別值

public String next()：獲取鍵盤錄入的資料，返回String型別值

l  Random類：隨機數類，用來產生多種型別的隨機數

n  方法：

public int nextInt(int n) 返回一個，在 0（包括）和指定值（不包括）之間int隨機數

        

第3章     總結

3.1      知識點總結

l  陣列

n  它是一個用來儲存同一個資料型別多個元素的一個容器（陣列長度是固定的，陣列中儲存的元素的資料型別要求一致）

n  格式：

                            格式1：

                                     資料型別[] 陣列名 = new 資料型別[陣列長度];

                           

                            格式2:

                                     資料型別[] 陣列名 = new 資料型別[]{元素值1,元素值2,..};

                                    

                            格式3：

                                     資料型別[] 陣列名 = {元素值1,元素值2,..};

n  陣列操作的常見問題：

NullPointerException: 空指標異常

ArrayIndexOutOfBoundsException: 陣列越界異常

l  二維陣列：

n  它是一個包含多個一維陣列的陣列

n  特點：二維陣列中的每個元素都是一個一維陣列

n  格式：

                            格式1：

                                     資料型別[][] 陣列名 = new 資料型別[m][n];

                            m: 代表二維陣列中一維陣列的個數

                                     n: 代表每個一維陣列中元素的個數

                            格式2：

                                     資料型別[][] 陣列名 = new 資料型別[m][];       

                                     m: 代表二維陣列中一維陣列的個數

                                     每一個一維陣列通過賦值來確定陣列長度

                            格式3：

                                     資料型別[][] 陣列名 = {{元素值1，元素值2,..},{元素值1，元素值2,..},..};

 

第4章     總結

4.1      知識點總結

l  方法

n  格式：

                            修飾符 返回值型別 方法名(引數型別 引數名1, 引數型別 引數名2, ...) {

                                     方法體;

                                     return 返回值;

                           }

n  方法使用的注意事項：

                            1，方法不呼叫，自己不執行

                            2，方法中不能定義方法， 但是，方法中可以呼叫方法

                            3, 方法定義的位置在類中，其他方法的外面

                            4, 如果方法沒有明確的返回值型別，使用'空'型別， void表示

                            5，void只能在方法返回值型別位置使用，不能作為 普通的資料型別使用

                            6, 如果方法返回值型別為void型別，可以省略 return ;

n  方法呼叫方式：

         有明確返回值型別的方法呼叫方式：

                   1，單獨呼叫

                   2，輸出呼叫

                   3，賦值呼叫

         沒有明確返回值型別的方法呼叫方式：

1，  單獨呼叫

n  方法過載：

方法過載，在同一個類中，出現了多個同名的方法，他們的引數列表不同 (引數列表的個數不同，引數列表的資料型別不同，引數列表的順序不同)。

方法過載特點：

與方法的返回值型別無關，與方法的引數名無關，只看方法名與引數列表；

         方法過載，是通過JVM來完成同名方法的呼叫的，通過引數列表來決定呼叫的是哪一個方法。

 

第5章     總結

5.1      知識點總結

l  引用資料型別（類）

n  類的型別為兩種：

u  第一種，Java為我們提供好的類，如Scanner類，Scanner類等，這些已存在的類中包含了很多的方法與屬性，可供我們使用。

u  第二種，我們自己建立的類，按照類的定義標準，可以在類中包含多個方法與屬性，來供我們使用。

n  建立類的格式

public class 類名 {

              //可以定義屬性

              //也可以定義方法

}

n  使用類的格式：

類名 變數名 = new 類名();

n  使用類中的屬性與方法格式

使用屬性： 變數名.屬性

使用方法： 變數名.方法()

l  ArrayList集合

n  它屬於引用資料型別（類）。我們可以看作一個長度可變的陣列。

n  建立集合的方式

ArrayList<要儲存元素的資料型別> 變數名 = new ArrayList<要儲存元素的資料型別>();

n  集合中的常用方法

u  boolean add（Object obj）

u  Object get（int index）

u  int size（）

u  boolean add（int index,  Object obj）

u  Object set（int index, Object obj）

u  Object remve（int index）

u  void clear（）

第6章     總結

6.1      知識點總結

l  類與物件

n  類，用於描述多個物件的共同特徵，它是物件的模板。

n  物件，用於描述現實中的個體，它是類的例項。

n  類的定義：使用關鍵字class來定義java中的類

u  格式：

            class 類名 {

                //屬性

                資料型別 變數名;

                …

                //方法

                修飾符 返回值型別 方法名(引數){   }

                …

            }

n  建立物件：

u  格式：

類名 物件名 = new 類名();

l  封裝（private關鍵字）

n  封裝，把物件的屬性與方法的實現細節隱藏，僅對外提供一些公共的訪問方式

n  封裝的體現：

u  變數:使用 private 修飾，這就是變數的封裝

u  方法:也是一種封裝，封裝了多條程式碼

u  類： 也是一種封裝，封裝了多個方法

n  private關鍵字，私有的意思

u  它可以用來修飾類中的成員(成員變數，成員方法)

u  private的特點：

l  private修飾的成員只能在當前類中訪問，其他類中無法直接訪問

l  this關鍵字

n  this關鍵字，本類物件的引用

u  this是在方法中使用的，哪個物件呼叫了該方法，那麼，this就代表呼叫該方法的物件引用

u  this什麼時候存在的？當建立物件的時候，this存在的

u  this的作用：用來區別同名的成員變數與區域性變數（this.成員變數）

            public void setName(String name) {

                this.name = name;

            }

 

第7章  總結

7.1      知識點總結

l  繼承：是指在一個現有類的基礎上去構建一個新的類，構建出來的新類被稱作子類，現有類被稱作父類，子類會自動擁有父類所有

l  繼承的好處：可繼承的屬性和方法。

n   

                            提高了代表的可維護性

                            提高了程式碼的複用性

                            讓類與類之間產生了繼承關係

n  繼承的弊端：

                            類與類之間的耦合度過高

n  繼承特點：

                            java中類只能夠單繼承，不能多繼承，可以多層繼承

                                     class Yy extends Object {}

                                     class Fu extends Yy{}

                                     class Zi extends Fu {}

                            所有的類都直接或者間接的繼承了 Object類，Object類稱為祖宗類

n  繼承的注意事項：

                            1，使用關鍵字 extends 讓類與類之間 產生繼承關係

                            2, 父類私有的成員，子類不能繼承，因為根本看不到

                            3，不能為了繼承某個功能而隨意進行繼承操作， 必須要符合 is a 的關係

                                     蘋果 is a 水果

                                     男人 is a 人

                                     狗   is a 人 ， 這種情況就不能繼承了

n  繼承中的成員變數關係：

                            不同名的變數：

                                     子類直接繼承使用

                            同名的變數：

預設訪問的是子類自己的成員變數, 想訪問父類中的同名變數，請使用 super.成員變數;

n  繼承中的成員方法關係：

不同名的方法：

子類直接繼承使用

同名的方法：

預設訪問的是子類自己的成員方法，想訪問父類中的同名方法，請使用 super.成員方法();

n  super:用來表示當前物件中包含的父類物件空間的引用

呼叫父類的成員變數：

super.成員變數;

                            呼叫方法的成員方法:

super.成員方法();

n  方法重寫(override)：指 在子父類中，出現了方法宣告相同的情況，也叫做方法覆蓋，方法複寫

u  方法重寫的注意事項：

1， 子類的方法宣告要與父類相同

2, 子類要重寫方法的方法，方法的許可權修飾符不能比父類的更低

n  3, 父類私有的方法，子類不能夠進行方法重寫

n  方法過載(overload)：指 在同一個類中，多個方法名稱相同，它們的引數列表不同(個數不同，資料型別不同)

l  抽象

n  抽象方法： 方法只有宣告部分，沒有方法體

n  抽象類： 包含抽象方法的類，一定是抽象類

      使用 abstract 修飾的類，是抽象類

n  抽象類的特點：     

    1，抽象類與抽象方法都必須使用 abstract來修飾       

        2，抽象類不能直接建立物件

        3，抽象類中可以有抽象方法，也可以沒有抽象方法

        4，抽象類的子類

            a，實現了抽象方法的具體類

            b，抽象類

n  抽象類面試題：

        1，抽象類中是否可以沒有抽象方法？如果可以，那麼，該類還定義成抽象類有意義嗎？為什麼？

    可以沒有抽象方法，有意義，不會讓其他人直接建立該類物件

 

第8章  總結

8.1      知識點總結

l  介面：理解為是一個特殊的抽象類，但它不是類，是一個介面

n  介面的特點：

    1，定義一個介面用interface關鍵字

            interface Inter{}

        2，一個類實現一個介面，實現implements關鍵字

            class Demo implements Inter{}

        3, 介面不能直接建立物件

           通過多型的方式，由子類來建立物件，介面多型  

n  介面中的成員特點：

        成員變數：

            只能是final 修飾的常量

            預設修飾符： public static final

        構造方法：

            無

        成員方法：

            只能是抽象方法

            預設修飾符: public abstract

n  類與類，類與介面，介面與介面之間的關係

        類與類之間：繼承關係，單繼承，可以是多層繼承

        類與介面之間: 實現關係，單實現，也可以多實現

        介面與介面之間：繼承關係，單繼承，也可以是多繼承           

        Java中的類可以繼承一個父類的同時，實現多個介面

 

l  多型：理解為同一種物質的多種形態

n  多型使用的前提：

                            1，有繼承或者實現關係

                            2，要方法重寫

                            3，父類引用指向子類物件

n  多型的成員訪問特點：

                            方法的執行看右邊，其他都看左邊

n  多型的好處：

                            提高了程式的擴充套件性

n  多型的弊端：

                            不能訪問子類的特有功能

n  多型的分類

u  類的多型

abstract class Fu {

                  public abstract void method();

}

class Zi extends Fu {

public void method(){

                     System.out.println(“重寫父類抽象方法”);

}

}

//類的多型使用

Fu fu= new Zi();

 

u  介面的多型

interface Fu {

   public abstract void method();

}

class Zi implements Fu {

   public void method(){

        System.out.println(“重寫介面抽象方法”);

}

}

//介面的多型使用

Fu fu = new Zi();

 

l  instanceof 關鍵字

                   格式： 物件名 instanceof 類名

                   返回值： true, false

                   作用： 判斷指定的物件 是否為 給定類建立的物件

 

第9章  總結

9.1      知識點總結

l  this關鍵字

n  this關鍵字，本類物件的引用

u  this是在方法中使用的，哪個物件呼叫了該方法，那麼，this就代表呼叫該方法的物件引用

u  this什麼時候存在的？當建立物件的時候，this存在的

u  this的作用：用來區別同名的成員變數與區域性變數（this.成員變數）

            public void setName(String name) {

                this.name = name;

            }

l  構造方法： 用來給類的成員進行初始化操作

n  格式：

        修飾符 類名 (引數列表) {

            ...

        }

n  構造方法的特點：

u  1, 方法名與類名相同

u  2，沒有返回值，也沒有返回值型別，連void也沒有

n  構造方法什麼時候會被呼叫執行？

                            只有在建立物件的時候才可以被呼叫

 

l  super: 指的是父類的儲存空間(理解為父類的引用)

呼叫父類的成員變數：

super.成員變數;

                            呼叫父類的構造方法:

super(引數);

                            呼叫方法的成員方法:

super.成員方法();

l  繼承中的構造方法注意事項：

    1，如果我們手動給出了構造方法，編譯器不會在給我們提供預設的空引數構造方法

           如果我們沒寫任何的構造方法，編譯器提供給我們一個空引數構造方法

    2, 在構造方法中，預設的第一條語句為 super();

       它是用來訪問父類中的空引數構造方法，進行父類成員的初始化操作

        3, 當父類中沒有空引數構造方法的時候，怎麼辦？

            a: 通過 super(引數) 訪問父類有引數的構造方法

            b: 通過 this(引數) 訪問本類中其他構造方法

               注意:[本類中的其他構造方法已經能夠正常訪問父類構造方法]

        4, super(引數) 與 this(引數) 不能同時在構造方法中存在

 

第10章    總結

10.1 知識點總結

l  final：關鍵字，最終的意思

                   final修飾的類：最終的類，不能被繼承

                   final修飾的變數： 相當於是一個常量, 在編譯生產.class檔案後，該變數變為常量值

                   final修飾的方法： 最終的方法，子類不能重寫，可以繼承過來使用

 

l  static : 關鍵字， 靜態的意思

                   可以用來修飾類中的成員(成員變數，成員方法)

                   注意： 也可以用來修飾成員內部類

n  特點：

                            被靜態所修飾的成員，會被所有的物件所共享

                            被靜態所修飾的成員，可以通過類名直接呼叫，方便

                                     Person.country = "中國";

                                     Person.method();

n  注意事項：

                            靜態的成員，隨著類的載入而載入，優先於物件存在

                            在靜態方法中，沒有this關鍵字

                            靜態方法中，只能呼叫靜態的成員(靜態成員變數，靜態成員方法

 

l  匿名物件：一個沒有名字的物件

n  特點：

建立匿名物件直接使用，沒有變數名

匿名物件在沒有指定其引用變數時，只能使用一次

匿名物件可以作為方法接收的引數、方法返回值使用

 

l  內部類：在一個類中，定義了一個新類，這個新的類就是內部類   

                   class A {//外部類

                            class B{// 內部類

                            }

                  }

n  特點：

                            內部類可以直接訪問外部類的成員，包含私有的成員

 

l  包的宣告與訪問

n  類中包的宣告格式：

package 包名.包名.包名…;

n  帶有包的類，建立物件格式：包名.類名 變數名 = new包名.類名();

com.oracle.Demo d = new com.oracle.Demo();

n  導包的格式：

import 包名.類名;

 

l  許可權修飾符

                   public : 公共的

                   protected: 受保護的

                  

                   private : 私有的

                    public  protected   預設的   private

    在當前類中       Y       Y           Y       Y

    同一包中的其他類  Y       Y           Y

    不同包中的子類    Y       Y

    不同包中的其他類  Y

 

l  程式碼塊：

                   區域性程式碼塊：定義在方法中的，用來限制變數的作用範圍

                   構造程式碼塊：定義在類中方法外，用來給物件中的成員初始化賦值

                   靜態程式碼塊：定義在類中方法外，用來給類的靜態成員初始化賦值

第11章    總結

11.1 知識點總結

l  不同修飾符的使用

n  類，最常使用public修飾

n  成員變數，最常使用private修飾

n  成員方法，最常使用public修飾

l  自定義資料型別的使用

n  類作為方法引數時，說明要向方法中傳入該類的物件

n  類作為方法返回值時，說明該方法要返回一個該類的物件。

n  抽象類作為方法引數時，說明要傳入一個實現抽象類所有抽象方法的子類物件。

n  抽象類作為方法返回值時，說明需要返回一個實現抽象類所有抽象方法的子類物件。

n  介面作為方法引數時，說明該方法要傳入一個介面實現類物件。

n  介面作為方法返回值時，說明該方法需要返回一個介面實現類物件。

第12章    總結

12.1 知識點總結

l  Object: 它是所有類的超類，祖宗類。java中所有的類都直接或間接的繼承這個類

n  方法

public String toString() 返回當前物件中的內容, 對於Object類預設操作來說，返回的物件的型別[email protected]+記憶體地址值

                   public boolean equals(Object obj) 比較兩個物件內容是否相同，對於Object類預設操作來說,比較的是地址值

 

l  String: 字串類，字串是常量；它們的值在建立之後不能更改

n  方法

                   boolean equals(Object obj) 判斷兩個字串中的內容是否相同

                   boolean equalsIgnoreCase(String str)  判斷兩個字串中的內容是否相同, 忽略大小寫

                   boolean contains(String str) 判斷該字串中 是否包含給定的字串

                   boolean startsWith(String str) 判斷該字串 是否以給定的字串開頭

                   boolean endsWith(String str) 判斷該字串 是否以給定的字串結尾

                   boolean isEmpty() 判斷該字串的內容是否為空的字串  ""

                   int length() 獲取該字串的長度

                   char charAt(int index) 獲取該字串中指定位置上的字元

        String substring(int start) 從指定位置開始，到末尾結束，擷取該字串，返回新字串

                   String substring(int start,int end) 從指定位置開始，到指定位置結束，擷取該字串，返回新字串

                   int indexOf(int ch ) 獲取給定的字元，在該字串中第一次出現的位置

                   int indexOf(String str) 獲取給定的字串，在該字串中第一次出現的位置

                   int indexOf(int ch,int fromIndex) 從指定位置開始，獲取給定的字元，在該字元

byte[] getBytes() 把該字串 轉換成 位元組陣列

                   char[] toCharArray() 把該字串 轉換成 字元陣列

String replace(char old,char new) 在該字串中，將給定的舊字元，用新字元替換

                   String replace(String old,String new) 在該字串中， 將給定的舊字串，用新字串替換

                   String trim() 去除字串兩端空格，中間的不會去除，返回一個新字串

                   String toLowerCase() 把該字串轉換成 小寫字串

                   String toUpperCase() 把該字串轉換成 大寫字串

                   int indexOf(String str,int fromIndex) 從指定位置開始，獲取給定的字串，在該字串中第一次出現的位置

 

l  StringBuffer/StringBuilder:

n  方法

public StringBuffer append(String str) 在原有字串緩衝區內容基礎上，在末尾追加新資料

                   public StringBuffer insert(int offset,String str) 在原有字串緩衝區內容基礎上，在指定位置插入新資料

                   public StringBuffer deleteCharAt(int index) 在原有字串緩衝區內容基礎上，刪除指定位置上的字元

                   public StringBuffer delete(int start,int end) 在原有字串緩衝區內容基礎上，刪除指定範圍內的多個字元

                   public StringBuffer replace(int start,int end,String str)在原有字串緩衝區內容基礎上，將指定範圍內的多個字元 用給定的字串替換

                   public StringBuffer reverse() 將字串緩衝區的內容 反轉  "abc"----"cba"

                   public String substring(int start) 從指定位置開始，到末尾結束，擷取該字串緩衝區，返回新字串

                   public String substring(int start,int end)  從指定位置開始，到指定位置結束，擷取該字串緩衝區，返回新字串

第13章    總結

13.1 知識點總結

l  正則表示式：用來定義匹配規則，匹配一系列符合某個句法規則的字串。

正則表示式的匹配規則

請參見1.2 正則表示式的匹配規則

正則表示式的常用方法：

public boolean matches(String regex) //判斷字串是否匹配給定的規則

public String[] split(String regex)     //根據給定正則表示式的匹配規則，拆分此字串

public String replaceAll(String regex,String replacement)  //將符合規則的字串內容，全部替換為新字串

 

l  Date: 日期/時間類

構造方法：

public Date()// 系統當前日期時間

public Date(long date) 得到一個1970年1月1日 0點這個時間基礎上，加上引數date 毫秒值對應的日期時間

    方法：

        public long getTime() 獲取日期所對應的毫秒值

 

l  DateFormat:是日期/時間格式化子類的抽象類, 使用其子類SimpleDateFormat 例項化

構造方法：

public SimpleDateFormat() 預設的格式化操作

    public SimpleDateFormat(String pattern) 按照指定的格式，進行日期格式化

                                     日期和時間模式

                                     y  年 

                                     M  年中的月份 

                                     d  月份中的天數

                                     H  一天中的小時數（0-23）

                                     m  小時中的分鐘數

                                 &