JAVA簡單的複習資料

一、背景
Java： 1990年由 sun公司 James Gosling 等開發的Oak發展而來，後oracle收購，維護

1、命名（語義化並遵守相應規範
多個單詞合成一個識別字時，
        帕斯卡原則：每個單詞首字母大寫 eg：FirstName、LastName （大駝峰原則）
        駝峰原則：除第一個單詞之外，其他單詞首字母大寫 eg：myStudentCount（小駝峰原則）
識別符號命名規則：                                    // 識別符號：給類，介面，方法或者變數等等起的名字
                      字母、數字、下劃線、$組成（不能是保留字，不能以數字開頭，並且區分大小寫）
                     1、 專案名全部小寫
                     2、 包名全部小寫  // 倒置的域名
                     3、 類名（駝峰原則）
                     4、 變數名、方法名(駝峰原則)
                     5、 常量名(全大寫，下劃線連線)     eg：public static final String GAME_COLOR=”RED”;

注：命名語義化（方法用動詞，其他用名詞，通過名字基本確定要說什麼。eg：eat()吃的方法 Appple表示蘋果類 ）

2、註釋
    單行：        // 註釋文字
    多行：        /* 註釋文字 */
    文件註釋：  /** 註釋文字 */  可生成說明文件

注：功能說明的註釋用文件註釋（可以生成說明文件）eg：類說明，成員變數成員方法的說明

3、常用編輯快捷鍵
    Ctrl+A    全選
    Ctrl+C    複製
    Ctrl+V    貼上
    Ctrl+X    剪下
    Ctrl+Z    撤銷
    Ctrl+S    儲存
    
4、DOS命令
    d: 回車    碟符切換
    dir(directory):列出當前目錄下的檔案以及資料夾
    md (make directory) : 建立目錄
    rd (remove directory): 刪除目錄
    cd (change directory)改變指定目錄(進入指定目錄)
    cd.. : 退回到上一級目錄
    cd\: 退回到根目錄
    del (delete): 刪除檔案,刪除一堆字尾名一樣的檔案*.txt
    exit : 退出dos命令列
    cls : (clear screen)清屏

5、環境配置
    JAVA_HOME:     "D:\Program Files\Java\jdk1.8.0_91"                                       // JDK路徑
    path：         "%Java_Home%\bin;%Java_Home%\jre\bin;"                                 // 到bin，jdk和jdk下jre的bin
    classpath：  ".;%Java_Home%\bin;%Java_Home%\lib\dt.jar;%Java_Home%\lib\tools.jar"   
    注：配置環境變數的目的是為了讓java檔案和class檔案在任意目錄下都能正常執行
    
6、Class檔案反解可以使用軟體jd-gui

7、關鍵字
    (1)關鍵字:被Java賦予特定含義的單詞
    (2)特點:全部小寫
   注： goto和const作是保留字存但不是關鍵字，不能使用（保留字：高階程式曾定義過的字）

8、解釋與編譯
     解釋執行：解釋的同時執行程式，不生成目標程式            eg:java
     編譯執行：先編譯產生機器語言的目標程式，然後執行程式    eg:C    

注：java程式的執行：java程式碼生成中間二進位制位元組碼.class檔案；類載入器載入到虛擬機器(在虛擬機器中以class物件的形式存在)

9、JVM管理的記憶體區域：
            9.1. 程式計數器（Program Counter Register）：指示當前執行緒所執行的位元組碼執行到了第幾行，執行緒私有（一個執行緒就有一個程式計數器）
           9.2. 棧（Statck）：存放區域性變數         eg：基本型別的資料和物件的引用，但物件本身不存放在棧中，而是存放在堆中
         （每個執行緒對應著一個虛擬機器棧，一個執行緒的每個方法在執行的同時，都會建立一個棧幀，棧幀中儲存：
           區域性變數表、操作站、動態連結、方法出口等，當方法被呼叫時，棧幀在JVM棧中入棧，當方法執行完成時，棧幀出棧。
，因此虛擬機器棧也是執行緒私有的。）
            9.3. 堆（heap）：JVM記憶體中比重最大的一塊，所有執行緒共享，儲存物件的例項(new產生)
            9.4. 方法區（Method Area）:也叫靜態區，存放所有的class和static定義的靜態成員 
          （各個執行緒共享的區域,用於儲存已經被虛擬機器載入的類資訊、final常量、靜態變數、編譯器即時編譯的程式碼等，常量池是方法區的一部分）

10、通過生命週期分析變數的位置：
        成員變數：建立物件就產生，物件銷燬銷燬 故與物件一起 在堆裡
        區域性變數：方法呼叫產生，跳出方法域銷燬，在方法對應的棧幀上

11、GC 垃圾收集（Garbage collection）：
       jvm上的垃圾回收主要針對堆區（執行緒共享），
       程式計數器、棧（虛擬機器棧、本地方法棧）隨執行緒而生滅，方法結束或者執行緒結束時，記憶體就回收了，沒有過多的垃圾回收問題（執行緒私有）

12 、 併發：使用者執行緒與GC執行緒同時執行；
         並行收集：多個GC執行緒並行工作，但此時使用者執行緒是暫停的；

13、縮寫：
    jvm  Java虛擬機器
    jdk  Java開發工具包（Java Developer's Kit）
    jre     Java執行環境（Java Runtime Environment）
    GC   垃圾收集（Garbage collection）
    
二、 基礎知識

常量：值不發生改變的量
字面值常量：
        A:字串常量 用""括起來的內容。舉例："helloworld"
        B:整數常量 舉例:1,200
        C:小數常量 舉例:12.5
        D:字元常量 用''括起來的內容。舉例：'a','A','0'
        E:布林常量 比較特殊，只有兩個值。舉例：true,false
        F:空常量 null(陣列部分講)
整數常量的表現形式：// x進製表示逢x進1
        A:二進位制
            由0,1組成。以0b開頭
        B:八進位制
            由0,1,2,3,4,5,6,7組成。以0開頭
        C:十進位制
            由0,1,2,3,4,5,6,7,8,9組成。預設是十進位制。
        D:十六進位制
            由0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F組成。以0x開頭。
            注意：字母不區分大小寫。
            
變數
    (1)變數：值會發生改變的量。
    (2)定義格式：
        A:資料型別 變數名 = 初始化值;
        B:資料型別 變數名;
                   變數名 = 初始化值;
資料型別
    (1)資料型別分類
        A:基本型別：4類8種
        B:引用型別：類，介面，陣列
    (2)基本型別-
        A:整數            佔用的記憶體空間
            byte                     1            -2^7 ~ 2^7-1，      即-128 ~ 127    末尾加B
            short                    2             -2^15 ~ 2^15-1， 即-32768 ~ 32767
            int                        4             -2^31 ~ 2^31-1， 即-2147483648 ~ 2147483647。 （21億 ，強轉超過範圍的資料，迴圈）
            long                     8              -2^63 ~ 2^63-1， 末尾加L。（也可以不加L）
        B:浮點數
            float        4  末尾加F。（也可以不加F）
            double        8 （預設）
        C:字元
            char        2  // 漢字 、字母 都是用unicode碼錶示的，都是char型別
        D:布林
            boolean        1
        無符號整數會用全部為來儲存，有符號的整數，最高位當做符號位 ，其餘為表示數值。0正1負
        
型別轉換
    注意：boolean型別不參與。
    隱式轉換：從小到大（參加計算就會發生隱式的型別轉換）
    byte,short,char --> int --> long --> float --> double        
    強制轉換：從大到小
        一般不建議這樣做，因為可能有精度的損失。
    格式：
        目標資料型別 變數名 = (目標資料型別)(被轉換的資料);
        
注：
    1、int範圍比float 和double都大，隱式轉換可能會精度丟失】
    2、（byte in = 5; s+=5;  這種形式s計算產生的int會被強制轉換為byte）
    
算術運算子
    (1)+,-,*,/,%,++,--
    (2)+:
        正號
        加法
        字串連線符
    (3)%和/的區別
        %：餘數
        /：商
        整數相除，結果是整數。想得到小數，可以乘以或者除以1.0

        %的結果的符號和前面的那個數一致。
    (4)++,--
        A:單獨使用
            放在資料的前面和後面效果一樣。
        B:參與操作使用
            放在資料的前面，先資料變化，再參與運算。
            放在資料的後面，先參與運算，再資料變化。
        C:++,--的練習題。

賦值運算子
    (1)=,+=,-=,*=,/=,%=,...
    (2)基本用法
        int a = 10;
        把10賦值給int型別的變數a。
    (3)複合用法
        int a = 10;
        a += 20;
        值等價於：a = a + 20;
        把左邊和右邊的結果賦值給左邊，並強制轉換為左邊的型別。
        即：
        short s = 1; s = s + 1;   錯
        short s = 1, s +=1;       對

關係運算子
    (1)==,!=,>,>=,<,<=
    (2)注意：
        A:無論表示式簡單還是複雜，結果肯定是boolean型別
        B:千萬不要把"=="寫成"="

邏輯運算子
    (1)&,|,^,!,&&,||
    (2)單用法
        &:有false則false
        |:有true則true
        ^:異或     （同真異假：同或    同假異真：異或）
        !:偶數個，值不變；奇數個，值相反。
    (3)雙用法:
        &&,||和&,|的區別

        &&具有短路效果，左邊為false，右邊不執行。
        ||具有短路效果，左邊為true，右邊不執行。

位運算子
    (1)&,|,^,~,>>,>>>,<<
        做位運算，需要把資料轉換為二進位制。
    (2)^的特點：
        針對同一個資料異或兩次，值不變。
    請用最有效率的方式計算2乘以8的值：2*8   2<<3（小數點位置不變左移3位）

三元運算子
    (1)格式：
        關係表示式?表示式1:表示式2;
    (2)執行流程：
        A:計算關係表示式的值
        B:如果是true，表示式1就是結果
          如果是false，表示式2就是結果

Scanner類         //  鍵盤錄入資料
    (1)導包： import java.util.Scanner;
    (2)建立鍵盤錄入物件：Scanner sc = new Scanner(System.in);  //system.in標準輸入流   hashnext()  / hashnextInt()
    (3)獲取資料  int i = sc.nextInt();

if語句
    (1)三種格式
        A:格式1
            if(關係表示式) {
                語句體;
            }

            執行流程：
                a:計算關係表示式的值
                b:如果是true，就執行語句體
                  如果是false，就不執行語句體
                c:繼續向下執行

        B:格式2
            if(關係表示式) {
                語句體1;
            }else {
                語句體2;
            }

            執行流程：
                a:計算關係表示式的值
                b:如果是true，就執行語句體1
                  如果是false，就執行語句體2
                c:繼續向下執行

        C:格式3
            if(關係表示式1) {
                語句體1;
            }else if(關係表示式2) {
                語句體2;
            }else if(關係表示式3) {
                語句體3;
            }
            ...
            else {
                語句體n+1;
            }

            執行流程：
                a:計算關係表示式1的值
                b:如果是true，就執行語句體1
                  如果是false，就計算關係表示式2的值
                c:如果是true，就執行語句體2
                  如果是false，就計算關係表示式3的值
                  ...

switch語句
    (1)格式：
        switch(表示式) {
            case 值1:
                語句體1;
                break;
            case 值2:
                語句體2;
                break;
            case 值3:
                語句體3;
                break;
            ...
            default:
                語句體n+1;
                break;
        }

注：表示式的取值
                byte,short,int,char   // 計算轉換為int的4個基本資料型別
                JDK5以後可以是列舉
                JDK7以後可以是String
for迴圈語句
    for語句基本格式
        for(初始條件表示式;判斷條件表示式;控制條件表示式) {
            迴圈體；
        }
    for迴圈的執行流程
        A:執行初始條件表示式
        B:判斷控制變數的值
            如果判斷為true，則執行下一步；為false，則結束
        C:執行迴圈體
        D:執行控制條件表示式，控制變數
        E:再回到B
while迴圈
    while語句基本格式
        while(判斷條件表示式) {
            語句體；
        }

do...while迴圈
    do...while語句基本格式
        do {
            語句體
        }while(判斷條件表示式)

注：
    A:三種迴圈的比較
        for迴圈和while迴圈中的迴圈體可以一次不執行，do...while迴圈中迴圈體
        至少執行一次
    B:三種迴圈的使用
        a:可以相互等價轉換，相互改寫
        b:當迴圈變數需要保留下來供以後計算，則使用while迴圈在迴圈體前面定義
          控制變數；否則建議優先使用for迴圈，提高程式執行效率；其次是while循
          環，最後是do...while迴圈
    C:for迴圈適用於知道一定範圍，while迴圈更常用於迴圈次數不一定
    break 跳出迴圈
    continue 進行下次迴圈  
    兩個關鍵字都可以跳轉標記

一維陣列
    (1)陣列:儲存同一種資料型別的多個元素的集合
        每個元素都有編號，從0開始。
        最大編號是陣列的長度-1
    (2)陣列的格式：
        A:資料型別[] 陣列名;
        B:資料型別 陣列名[];
    (3)陣列的初始化：
        A:動態初始化 只給長度，不給元素
            int[] arr = new int[3];
        B:靜態初始化 不給長度，給元素
            int[] arr = new int[]{1,2,3};
            簡化版：int[] arr = {1,2,3};
    (4)兩個常見小問題
        A:陣列越界
        B:空指標異常
    (5)陣列常見操作    獲取陣列長度：陣列名.length
    
二維陣列
    (1)二維陣列：元素是一維陣列的陣列。
    (2)格式：
        A:資料型別[][] 變數名 = new 資料型別[m][n];
        B:資料型別[][] 變數名 = new 資料型別[m][];
        C:資料型別[][] 變數名 = new 資料型別[][]{{元素...},{元素...},{元素...}};
          資料型別[][] 變數名 = {{元素...},{元素...},{元素...}};

        
類與物件
        類：具有共性的事物的抽象
        屬性：外在特徵
        行為：內在行為
        物件：是該類事物的具體個體。   
類的組成
    (1)成員變數
        定義在類中，方法外，有預設值
    (2)成員方法
eg：       class Student {
                String name;
                int age;

                public void study() {}
            }

類的使用
    (1)建立物件
        格式：類名 物件名 = new 類名();
    (2)使用成員
        成員變數：物件名.變數名;
        成員方法：物件名.方法名(...);

成員變數和區域性變數的區別
    (1)在類中的位置不同
        A:成員變數 類中，方法外
        B:區域性變數 方法的形式引數，或者方法體中
    (2)在記憶體中的位置不同
        A:成員變數 在堆中
        B:區域性變數 在棧中
    (3)生命週期不同
        A:成員變數 隨著物件的存在而存在，隨著物件的消失而消失
        B:區域性變數 隨著方法的呼叫而存在，隨著方法的呼叫完畢而消失
    (4)初始化值不同
        A:成員變數 有預設初始化值
        B:區域性變數 沒有預設值，必須先宣告，賦值，最後才能使用

值傳遞：
    (1)基本型別  基本型別作為形式引數，傳遞的是該基本型別的值  --值傳遞
    (2)引用型別  引用型別作為形式引數，傳遞的是該引用型別的值（是指向其對應物件的地址） --地址傳遞

匿名物件
    (1)匿名物件：沒有名字的物件。是物件的簡化書寫方式。
    (2)使用場景
        A:呼叫方法，僅僅只呼叫一次
        B:作為實際引數傳遞

封裝
    (1)隱藏實現細節，提供公共的訪問方式
    (2)好處：
        A:隱藏實現細節，提供公共的訪問方式
        B:提高了程式碼的複用性
        C:提高了程式碼的安全性
    (3)使用原則
        A:把成員變數隱藏
        B:給出該成員變數對應的公共訪問方式

this關鍵字
    (1)this：代表本類的物件
    (2)應用場景：
        解決了區域性變數隱藏成員變數的問題。
        其他用法和super一起講。

構造方法
    (1)作用：建立物件
    (2)特點：
        A:方法名和類名相同
        B:沒有返回值型別
        C:沒有返回值
    (3)注意事項
        A:如果我們沒寫構造方法，系統將預設給出無參構造方法
        B:如果我們寫了構造方法，系統將不再給出預設無參構造方法
        注：無參的構造方法，可以沒有，但是開發過程中一定要寫，spring框架ioc通過無引數構造方法建立物件
    (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 void setName(String name) {
                this.name = name;
            }

            public String getName() {
                return name;
            }

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

            public int getAge() {
                return age;
            }

            public void show() {
                System.out.println("姓名是："+name+",年齡是："+age);
            }
        }

建立物件：
    (1)載入相應的類（靜態成員這個時候分配空間，分配在方法區上的靜態共享區），先載入父類後載入當前類
    (2)在堆中分配空間（呼叫本來構造方法，構造方法第一行是super()，所以會先初始化父類相關屬性方法）（new）
    (3)賦值給對應的形參，形參儲存在相應執行緒線開闢的棧幀中
static關鍵字
    (1)是一個狀態修飾符。靜態的意思
    (2)它可以修飾成員變數和成員方法
    (3)特點：
        A:隨著類的載入而載入
        B:優先於物件存在
        C:被所有物件共享
            這也是判斷我們是不是該使用靜態的條件
            舉例：飲水機和水杯例子。
        D:可以通過類名呼叫
            靜態修飾的內容，可以通過類名呼叫，也可以通過物件名呼叫
            在類中的位置可前可後，不影響呼叫（即靜態方法下面申明的靜態成員變數也可以被寫在上面的靜態方法使用）
    (4)方法訪問特點
        A:普通成員方法  可以訪問靜態的
        B:靜態成員方法  靜態只能訪問靜態的
        注：靜態中是不能有this的（載入時間不同）。
靜態成員變數和普通成員變數的區別(理解)
    (1)所屬不同
        靜態屬於類，稱為類變數，可以用類名直接呼叫
        非靜態屬於物件，稱為例項變數
    (2)記憶體空間不同
        靜態在方法區的靜態區
        非靜態在堆記憶體
    (3)生命週期不同
        靜態隨著類的載入而載入，隨著類的消失而消失
        非靜態隨著物件的建立而存在，隨著物件的消失而消失
    (4)呼叫不同
        靜態可以通過類名呼叫，也可以通過物件名呼叫。建議通過類名呼叫
        非靜態只能通過物件名呼叫

main方法是靜態的 public static void main(String[] args)

Math類
    (1)Math:針對數學進行運算的類
    (2)特點：沒有構造方法，因為它的成員都是靜態的
    (3)產生隨機數：
        public static double random(): 產生隨機數，範圍[0.0,1.0)
    (4)產生1-100之間的隨機數
        int number = (int)(Math.random()*100)+1;
程式碼塊
    (1)在java中用{}起來的程式碼
    (2)分類：
        區域性程式碼塊：在方法中。限定變數生命週期，及早釋放，提高記憶體使用率
        構造程式碼塊：在類中方法外。
                把多個構造中的相同程式碼用一個構造程式碼塊體現，每次建立物件都會自動呼叫。
        靜態程式碼塊：在類中方法外，用static修飾。
                對類中的資料進行初始化。僅僅執行一次。
    
        
繼承
    (1)把多個類中相同的屬性和行為提取出來，定義到一個類中，
       然後讓這多個類和這一個類產生一個關係，這多個類就具備這一個類的屬性和行為了。
       這種關係叫：繼承。
    (2)繼承如何表示的呢?
        格式：class 子類名 extends 父類名 {}
    (3)java中的繼承特點：
        A:java中只能單繼承
        B:java中可以多層繼承。(繼承體系)
    (4)java中的繼承的好處和弊端
        A:好處    
            a:提高了程式碼的複用性
            b:提高了程式碼的可維護性
            c:讓類與類之間產生了一個關係，是多型的前提
        B:弊端
            讓類與類的耦合增強了。這樣一個類的改動會直接影響另一個類。
            設計原則：高內聚，低耦合。
    (5)java中的繼承的注意事項：
        A:私有成員不能被繼承
        B:構造方法不能被繼承，想訪問，通過super關鍵字
        C:不能為了部分功能而去使用繼承
    (6)繼承中的成員關係：
        A:成員變數
            不同名：特別簡單，一看就知道用的是誰。
            同名：就近原則
                訪問自己的用this
                訪問父親的用super
        B:構造方法
            a:子類的所有構造方法預設都是訪問父類的無參構造方法
            b:如果父類沒有無參構造方法，怎麼辦呢?
                通過super(...)訪問父類帶參構造方法
                通過this(...)訪問本類其他構造方法。(一定要有一個訪問了父類的構造方法)
                注意：super或者this同時只能出現一個，並且只能在語句的第一條語句。
            為什麼呢?
                因為子類可能會訪問父類的資料，所以，在子類初始化之前，要先把父類資料初始化完畢。
        C:成員方法
            不同名：特別簡單，一看就知道用的是誰。
            同名：就近原則
                訪問自己的用this
                訪問父親的用super
    (7)this和super的區別及應用場景
        A:區別
            this：本類物件的引用
            super：父類儲存空間的標識。可以理解為父類物件的引用。

        B:應用場景
            a:成員變數
                this.變數 本類的成員變數
                super.變數 父類的成員變數
            b:構造方法
                this(...) 本類的構造方法
                super(...) 父類的構造方法
            c:成員方法
                this.方法名(...) 本類的成員方法
                super.方法名(...) 父類的成員方法
    

方法重寫
    (1)描述：在子類中，出現了和父類中一模一樣的方法宣告的現象。
    (2)作用：可以使用父類功能，還可以增強該功能。
    (3)面試題：
        override和overload的區別?
        overload可以改變返回值型別嗎?
    (4)方法重寫的注意事項：
        A:父類私有方法不能被重寫
        B:子類重寫方法的訪問許可權不能比父類的方法低
        C:靜態只能重寫靜態。(其實這算不上重寫)

final關鍵字
    (1)final:最終的意思
    (2)作用：可以修飾類，修飾成員變數，修飾成員方法
    (3)特點：
        A:修飾類 類不能被繼承
        B:修飾成員變數 變數變成了常量
        C:修飾成員方法 方法不能被重寫
    

多型
    (1)多型：同一個物件，在不同時刻表現出來的多種狀態
        舉例：水，貓和動物
    (2)多型的前提：
        A:有繼承關係
        B:有方法重寫
        C:有父類引用指向子類物件
    (3)多型中的成員訪問特點：
        A:成員變數
            編譯看左邊，執行看左邊
        B:成員方法
            編譯看左邊，執行看右邊
        C:靜態方法
            編譯看左邊，執行看左邊

        為什麼：
            因為方法有重寫，而變數沒有。靜態方法沒有重寫一說。
            
多型
    (1)同一個事物在不同時刻表現出現的多種狀態。
        舉例：水，貓和動物
    (2)前提
        A:有繼承或者實現關係
        B:有方法重寫
            因為抽象類中的抽象方法以及介面中的方法都必須被子類重寫，呼叫才有意義。
        C:有父類或者父介面引用指向子類物件
    (3)多型中的成員訪問特點
        Fu f = new Zi();
        A:成員變數
            編譯看左邊，執行看左邊
        B:成員方法
            編譯看左邊，執行看右邊
        C:靜態方法
            編譯看左邊，執行看左邊
    (4)好處和弊端
        A:好處
            提高了程式碼的維護性
            提高了程式碼的擴充套件性
        B:弊端
            不能訪問子類特有功能
    (5)如何訪問子類特有功能
        A:建立子類物件
        B:向下轉型
    (6)多型中的轉型
        A:向上轉型
            子到父
        B:向下轉型
            父到子(加強制轉換)

抽象類 abstract修飾的類
    (1)有些時候，我們對事物不能用具體的東西來描述，這個時候就應該把事物定義為抽象類。
    (2)抽象類的特點：
        A:抽象類或者抽象方法必須用abstract修飾
        B:抽象類中不一定有抽象方法，但是有抽象方法的類一定是抽象類
        C:抽象類不能例項化
            可以按照多型的方式例項化。
        D:抽象類的子類
            a:要麼是抽象類
            b:要麼重寫抽象類中的所有抽象方法
    (3)抽象類的成員特點：
        A:成員變數
            可以是變數，也可以是常量
        B:構造方法
            有。
            不能例項化，有構造方法有什麼意義呢?
            用於子類訪問父類資料的初始化。
        C:成員方法
            可以是抽象的，也可以是非抽象的
    (4)兩個小問題
        A:如果你看到一個抽象類中居然沒有抽象方法,這個抽象類的意義何在?
          不讓別人建立
        B:abstract不能和哪些關鍵字共存?
            a:private 衝突
            b:final 衝突
            c:static 無意義
    
介面 關鍵字interface
    (1)有些時候，不是事物本身具備的功能，我們就考慮使用介面來擴充套件。
    (2)介面的特點：
        A:定義介面用關鍵字interface
            格式是：interface 介面名 {}
        B:類實現介面用關鍵字implements 
            格式是：class 類名 implements 介面名 {}
        C:介面不能例項化
        D:介面的子類
            a:要麼是抽象類
            b:要麼重寫介面中的所有方法
    (3)介面的成員特點
        A:成員變數
            只能是常量。
            預設修飾符：public static final
        B:成員方法
            只能是抽象方法。
            預設修飾符：public abstract 
        推薦：
            建議自己寫介面的時候，把預設修飾符加上。
    (4)類與介面的關係
        A:類與類
            繼承關係，只能單繼承，可以多層繼承。
        B:類與介面
            實現關係，可以單實現，也可以多實現。
            還可以在繼承一個類的同時實現多個介面。
        C:介面與介面
            繼承關係，可以單繼承，也可以多繼承。
    (5)抽象類和介面的區別?
        A:成員區別
        B:關係區別
        C:設計理念區別
            抽象類：父抽象類，裡面定義的是共性內容。
            介面：父介面，裡面定義的是擴充套件內容。
        
形式引數和返回值問題
    (1)形式引數：
        基本型別：需要的是對應的值
        引用型別：
            類：該類的物件
            抽象類：該類的子類物件
            介面：該介面的實現類物件
    (2)返回值問題：
        基本型別：返回的是對應的值
        引用型別：
            類：該類的物件
            抽象類：該類的子類物件
            介面：該介面的實現類物件
    (3)鏈式程式設計
        new A().b().c().d();

包
    (1)其實就是資料夾
    (2)對類進行分類管理
    (3)格式：
        package 包名;
    (4)注意事項
        A:package是程式中的第一條可執行語句
        B:在類中package是唯一的
        C:沒有package，預設是無包名
    (5)帶包的類的編譯和執行

導包(理解)
    (1)為了方便使用不同包下的類，需要導包
    (2)格式：
        import 包名.報名...類名;

        注意：可以匯入到*,但是不建議
    (3)package，import，class在類中有沒有順序關係呢?
        有。
        package --> import --> class

修飾符
    (1)4種許可權修飾符
                本類    同一個包下    不同包下的子類    不同包下的其他類
        private        Y
        預設        Y        Y
        protected    Y        Y        Y
        public        Y        Y        Y        Y
    (2)常見的修飾
        A:類    public
        B:成員變數    private
        C:構造方法    public
        D:成員方法    public

內部類
    (1)把類A定義在類B內部，類A就被稱為內部類
    (2)訪問特點：
        A:內部類可以直接訪問外部類的成員，包括私有
        B:外部類要想訪問內部類的成員，必須建立物件
    (3)內部類的分類：
        A:成員內部類
        B:區域性內部類
    (4)成員內部類
        A:private
        B:static
    (5)區域性內部類
        區域性內部類訪問區域性變數，必須加final修飾
    (6)匿名內部類
        A:沒有名字的內部類
        B:前提
            存在一個類或者介面
        C:格式
            new 類名或者介面名() {        // 一個匿名內部類一定是在new的後面，用其隱含實現一個介面或實現一個類，作用提供物件
                重寫方法();
            };

            本質：是一個匿名子類物件
    (7)開發中如何使用
        不用在定義一個新的類了。直接通過匿名內部類的格式就可以搞定

        interface Person {
            public abstract void show();
        }

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

        PersonDemo pd = new PersonDemo();
        pd.method(new Person(){
            public void show(){...}
        });
    (8)面試題
        補齊程式碼，在控制檯輸出HelloWorld

        interface Inter {
            public abstract void show();
        }

        class Outer {
            //補齊程式碼
            public static Inter method() {
                return new Inter(){
                    public void show() {
                        System.out.println("helloworld");
                    }
                };
            }
        }

        class OuterDemo {
            public static void main(String[] args) {
                Outer.method().show();
            }
        }

Eclipse的快捷鍵
        A:內容輔助鍵
            alt+/
            補全main：main + alt+/
            補全輸出語句：syso + alt+/
        B:常用快捷鍵
            a:格式化
                ctrl+shift+f
            b:導包
                ctrl+shift+o
            c:註釋
                ctrl+/
    
Eclipse中debug
        A:debug的作用
            a:除錯錯誤
            b:檢視程式的執行流程
        B:檢視程式的執行流程
            a:如何加斷點
                在程式碼區域的左邊雙擊即可
            b:在哪裡加斷點
                哪裡不會加哪裡。
                注意：不要加在類名上或者方法名上
            c:觀看哪些地方
                程式碼的執行流程
                變數的變化過程
                控制檯的輸出結果
            d:如何讓程式一步步執行
                按F6
            e:如何去除斷點
                再次雙擊
                找到debug介面，有一個breakpoints裡面的兩個x的地方
三種常用的debug，debug中改變變數值方法
            a:Variables介面      直接找到相應變數 右擊 然後選擇change value
            b:Expressions介面    Add new expression ，通過新增表示式的方式，修改變數的值
            c:Debug Shell介面    此處可以直接執行java程式碼，通過java程式碼，更改變數值（3種中最強大的一種，不僅可以改變值，還能夠臨時新增變數等）