JAVA（一）JAVA基礎/物件導向基礎/高階物件導向

Leo.cheng發表於2014-02-08
Java物件
成鵬致遠 | lcw.cnblog.com |2014-01-23

JAVA基礎

1.開發環境搭建

  1. JAVA程式的執行流程
    1. JAVA命令->要使用一個*.class檔案(類檔案)->通過classpath找到*.class檔案所儲存的真實目錄，之後再進行載入執行
  2. 小結
    1. Path的主要功能是設定JDK的可執行命令
    2. classpath主要是在執行時候起作用，告訴JVM類的儲存路徑，一般設定成“.”
    3. 【注意】classpath只在java命令的時候起作用，而對於javac不起任何作用

2.簡單JAVA程式

  1. 使用Public class和class宣告的區別
    1. public class檔名稱必須與類名稱一致
    2. class檔名稱可以與類名稱不一致
  2. 在整個java中只允許有一個public class宣告，但是允許有其他的class宣告
  3. 在使用一個java檔案中允許有多個class定義，編譯之後會自動劃分不同的class
  4. 【注意】在編寫java程式的時候類名稱的編寫要採用一定的格式：所有單詞的首字母必須大寫
  5. 小結
    1. public class及class的宣告：一個java檔案中只能有一個public class的宣告，但是允許有多個class，使用的時候直接要使用主方法所在的類
    2. 關鍵字的表示
    3. 識別符號的命名規則：最好永遠以字母開頭，不使用偏門的字元
    4. 常量就是不可改變的數值，變數的內容是可以改變的

3.java基礎程式設計

  1. 資料型別
    1. 基本資料型別
    2. 數值型
      1. 整數型別（byte、short、int、long）
      2. 浮點型別（float、double）
    3. 字元型（char）
    4. 布林型（boolean）
    5. 引用資料型別
      1. 類（class）
      2. 介面（interface）
      3. 陣列
  2. 分為兩大型別
    1. 基本資料型別：類似於普通的值
    2. 引用資料型別：傳遞的是記憶體的地址
  3. 浮點型別實際上就是表示小數
  4. Double型別可以裝全宇宙的資料
  5. 對於資料來說，設定內容的時候應該放在整個允許的範圍之中。如果超過了此範圍，則肯定會出現數值不正確的情況
  6. 字元型別
    1. 字元型別在記憶體中佔有2個位元組，可以用來儲存英文字母等字元。
    2. 計算機處理字元型別時，是把這些字元當成不同的整數來看待，因此，嚴格來說，字元型別也算是整數型別的一種
  7. 所有資料型別都會像字串轉換
  8. 小結
    1. Java中的資料型別劃分
    2. 八種基本資料型別，包括長度的，常量的預設值
    3. String，任何型別都會向String進行轉換

4.運算子、表示式與語句

  1. 小結　
    1. 清楚的掌握JAVA中的賦值、計算、關係運算子
    2. 瞭解一下位的運算
    3. 使用括號可以輕易的改變運算的優先順序

5.判斷與迴圈語句筆記

  1. 在使用switch進行表示式的時候一定要注意：在表示式中只能使用數字或字元或列舉
  2. 小結
    1. 任何語言都會包含三種功能：順序、選擇、迴圈
    2. 選擇結構：if/if..else/if..else if..else/switch
    3. 迴圈：while/do..while/for
    4. 兩種中斷關鍵字：break/continue

6.陣列與方法

  1. 陣列定義及使用
    1. 要使用Java的陣列，必須經過兩個步驟
      1. 宣告陣列
      2. 分配記憶體給該陣列
    2. 陣列宣告後實際上是在棧記憶體中儲存了陣列的名稱，接下來便是要在堆記憶體中配置陣列所需要的記憶體，其中“長度”是告訴編譯器，所宣告的陣列要存放多少個元素，而“new”則是命令編譯器根據括號裡的長度開闢空間
    3. 變數的命名規則，第一個單詞的首字母小寫，之後每個單詞的首字母大寫
    4. 【堆疊記憶體的解釋】陣列操作中，在棧記憶體中儲存的永遠是陣列的名稱，只開闢了棧記憶體空間的陣列是永遠無法使用的，必須有指向的堆記憶體才可以使用，要想開闢新的堆記憶體則必須使用new關鍵字，之後只是將此堆記憶體的使用權交給了聖潔的棧記憶體空間，而且一個堆記憶體空間可以同時被多個棧記憶體空間指向，即：一個人可以有多個名字，人就相當於堆記憶體，名字就相當於棧記憶體
    5. 小結
      1. 陣列的使用分為兩個步驟
        1. 宣告陣列：是要棧記憶體中宣告的
        2. 為陣列開闢空間：是使用關鍵字new在堆記憶體中完成
        3. 當然也可以一起完成：資料型別 陣列名稱[]=new 資料型別[長度]
      2. 可以通過陣列名稱.length的形式求出陣列的長度
      3. 陣列中有很多常見演算法及題目，只要控制好其下標就可以完成
      4. 陣列下標不能越界，越界之後程式會出現錯誤，如果開闢了3個空間，則下標：0~2
      5. 陣列的維數在開發中最多基本上就使用到二維，就相當於是一個表格
      6. 多維陣列因為其比較複雜，所以不建議使用過多
  2. 方法的宣告及使用
    1. 方法過載
      1. 方法的過載就是方法名稱相同，但引數的型別和引數的個數不同，通過傳遞引數的個數及型別不同以完成不同功能方法呼叫
      2. 方法過載一定是根據引數的型別或個數來判斷的
    2. 小結
  • 方法定義的時候如果需要返回值，則明確寫出返回值的型別
  • 在方法中可以進行過載：方法名稱相同，引數的型別或個數不同，稱為過載
  • 在方法中可以使用return來結束一個方法的操作
  • 方法自己呼叫自己，成為遞迴操作，遞迴操作中必須有明確的結束條件
  • 陣列的引用傳遞
    1. 小結
      1. 陣列的引用傳遞傳遞的就是堆記憶體的使用權，可以將一個陣列傳遞到方法之中，傳遞的時候不需要寫上“[]”，直接寫名字即可
      2. 方法中對陣列所做的修改都會被保留下來
      3. 在java中提供了一些對陣列操作支援的方法，這些方法慢慢都會有所介紹
  • Java新特性對陣列的支援
    1. 所有的可變引數接收之後都是以陣列的形式儲存下來的，所以直接按陣列的方式接收即可
    2. 小結
      1. 可變引數在開發中經常用到，尤其是在進行一些其他引用資料型別使用可變引數的時候
      2. foreach不光可以輸出陣列，在日後的類集中也是對其有輸出的能力的

    物件導向基礎

    1.物件導向大特徵

    1. 封裝：對外部不可見，可以保護程式中的某些內容
    2. 繼承：擴充套件類的功能
    3. 多型：方法的過載/物件的多型性

    2.類與物件

    1. 類屬於引用傳遞型別，從陣列中可以知道，引用資料型別必然存在棧記憶體->堆記憶體的引用關係，實際上在類與物件的使用上依然存在這樣的關係
    2. 宣告物件：在棧記憶體中宣告，與陣列一樣，陣列名稱就儲存在棧記憶體之中，只開闢了棧記憶體的物件是無法使用的，必然有其堆記憶體的引用才可以使用
    3. 物件是儲存在棧記憶體之中，屬性是儲存在堆記憶體之中，在程式中所有的方法是儲存在全域性程式碼區之中的，此區中的內容中所有物件共享的
    4. 【注意點】在使用物件的時候，物件必須被例項化之後才可以使用（例項化物件，並不單單指的是直接通過new關鍵字實現的，只要其有堆記憶體的空間指向，則就表示例項化成功），如果不例項化，則會出現執行時錯誤：空指標
    5. 所謂的引用資料型別，實際上傳遞的就是堆記憶體的使用權，可以同時為一個堆記憶體空間定義多個棧記憶體的引用操作
    6. .小結
      1. 掌握棧與堆記憶體的關係
      2. 物件儲存在棧記憶體之中，而具體的內容儲存在堆記憶體之中
      3. 物件間的引用傳遞，實際上傳遞的就是堆記憶體被單的使用權
      4. 垃圾的產生

    3.封裝性

    1. 為什麼要有封裝
      1. 封裝就是保護內容
      2. 保證某些屬性或方法可以不被外部看見
    2. 訪問封裝的內容
      1. 封裝的屬性肯定是要表示出一些實際的意義，那麼這些意義的內容肯定應該由外部設定，所以在整個JAVA中對於封裝性的訪問就給出了一個明確的原則，此原則必須遵守
      2. 被封裝的屬性如果需要被訪問，則需要編寫setter及getter方法完成（setter方法完成輸入驗證，getter方法只是把內容簡單的取回即可）
    3. 封裝的類圖表示
      1. 用“-”表示private
      2. 用“+”表示public
    4. 小結
      1. 封裝性的目的
      2. setter及getter方法的作用
      3. 封裝性在JAVA中有很多形式，private只是最基本的一種形式，也是一種比較覺的形式
      4. 類中的每一個屬性必須封裝

    4.構造方法與匿名物件

    1. 只要一有物件例項化則就會呼叫構造方法
    2. 構造方法宣告原則：
      1. 構造方法的名稱必須與類名稱一致
      2. 構造方法的宣告處不能有任何返回值型別的宣告
      3. 不能在構造方法中使用return返回一個值
    3. 構造方法的主要目的就是為類中的屬性初始化
    4. 構造方法本身與普通方法一樣，都是支援過載操作的，只要引數的型別或者個數不同，則就可以完成過載操作
    5. 匿名物件
      1. 匿名：沒有名字，在JAVA中如果一個物件只使用一次，則就可以將其定義成匿名物件
      2. 所謂的匿名物件就是比之前的物件少了一個棧記憶體的引用關係
    6. 小結
      1. 構造方法的定義及使用原則
      2. 物件在例項化時必須呼叫構造方法
      3. 每個類中都有至少一個構造方法
      4. 匿名物件：只開闢了堆記憶體的例項物件

    5.String類

    1. 字串判斷
      1. “==”使用的判斷相等，是判斷地址空間是否相等，判斷的是地址值
      2. 如果要想判斷其內容是否相等，則就必須使用String類中提供的eauals()方法完成，開發中比較常用
    2. 使用直接賦值的方式，可以有效的儉省記憶體
    3. 使用直接賦值的方式只需要一個例項化物件即可，而使用new String()的方式則意味著要開闢兩個記憶體物件，開發中最好使用直接賦值的方式完成
    4. 字串的內容不可改變
      1. 實際上字串內容的改變，改變的是記憶體地址的引用關係
    5. 小結
      1. String要使用直接賦值的方式，因為使用new會開闢兩個空間，造成記憶體浪費
      2. 一個字串就是String的匿名物件
      3. 字串的比較有兩種方式：“==”與“equals”

    6.String類的常用方法

    1. 字串與byte陣列的轉換
      1. byte陣列（位元組陣列），在一般的IO操作中會經常使用到
      2. 在String類中提供了以下的方法可以進行字串與位元組陣列間的轉換
        1. 字串->位元組陣列：public byte[] getBytes()
        2. 將一個位元組陣列變為字串
          1. 將全部位元組陣列變為String:public String(byte[] bytes)
          2. 將部分位元組陣列變為String:public String(byte[] bytes,int offset,int length)
      3. 在實際操作中，經常會使用到判斷一個字串中是否存在某些內容，可以使用：public int indexOf(String str)，沒有則返回-1
      4. 使用者輸入資訊時，可能出現多餘的空格，使用trim()去掉字串左右的空格，但是字串中間的空格是不可能去掉的

    7.引用傳遞及應用

    1. String是一個特殊的類，其內容不可改變
    2. 只要是符合了引用傳遞的語法，則可以向任意的地方傳遞

    8.this關鍵字

    1. 在大部分操作的時候，屬性最好都使用this.屬性的形式表示
    2. 如果在一個類中有多個構造方法的話，也可以利用this關鍵字互相呼叫
    3. 【注意】在使用this關鍵字呼叫其他構造方法的時候，有以下幾點限制
      1. this()呼叫構造方法的語句只能放在構造方法的首先
      2. 在使用this呼叫本類中其他構造的時候，至少有一個構造方法是不用this呼叫的，否則會出現構造方法的遞迴呼叫
    4. this表示當前物件，即當前正在呼叫方法的物件
    5. 可以使用this和引用傳遞進行兩個物件是否相等的判斷
    6. 小結
      1. this.屬性/this.方法()，實際上都表示當前的物件中的屬性或當前物件呼叫的方法
      2. this的核心：表示當前物件，當前下在操作本方法的物件稱為當前物件
      3. 使用this可以呼叫其他構造方法，但是此語句必須放在構造方法的首行

    9.static關鍵字

    1. 如果希望一個屬性被所有的物件所共同擁有，則可以將其宣告為static，宣告static型別的屬性或方法之後此屬性或方法也稱為類方法，可以由類名稱直接呼叫
    2. Java中到底有多少個記憶體區域
      1. 棧記憶體：可以儲存物件的名稱（儲存，訪問的堆記憶體的地址）
      2. 堆記憶體：儲存每個物件的具體屬性
      3. 全域性資料區：儲存static型別的屬性
      4. 全域性程式碼區：儲存所有方法的定義
    3. 【注意】使用static方法，不能呼叫非static的屬性或方法
      1. 這一點非常好理解，因為static屬性或方法可以在物件沒有例項化的時候就直接進行呼叫了
    4. static相關應用
      1. static屬性是所有物件共享的，可以使用static屬性統計一個類到底產生了多少個例項化物件
      2. 可以使用stsatic為物件進行自動的編號操作
    5. 小結
      1. 使用static宣告屬性與非static宣告屬性的區別
      2. 使用static宣告的屬性或方法可以直接由類名稱呼叫
      3. 使用static方法的時候一定要注意，只能訪問static宣告的屬性或方法，而非static宣告的屬性和方法是不能訪問，因為static可以在物件沒有例項時就直接呼叫，而其他的屬性或方法必須在物件例項化之後才可以呼叫

    10.程式碼塊

    1. 程式碼塊可以分為四種：普通程式碼塊、構造塊、靜態程式碼塊、同步程式碼塊（出現在多執行緒中）
    2. 普通程式碼塊：直接定義在方法中的程式碼塊稱為普通程式碼塊
    3. 構造塊：將程式碼塊直接定義在類中，則稱為構造塊
      1. 構造塊優先於構造方法執行，且執行多次。只要一有例項化物件產生，就執行構造塊中的內容
    4. 靜態程式碼塊：直接使用static關鍵字宣告的程式碼塊就稱為靜態程式碼塊
      1. 靜態塊優先於主方法執行，如果在普通類中定義的靜態塊，優先於構造塊執行，不管有多少個例項化物件產生，靜態程式碼塊只執行一次，靜態程式碼塊的主要功能就是為靜態屬性初始化

    11.構造方法私有化

    1. 被私有化構造方法的類，不能在外部直接例項化，只能在內部例項化
    2. 單態設計模式(單例設計模式：Singleton)：如果不希望一個類產生過多的物件的話，則就必須使用單態設計模式，而且使用單態設計模式在JAVA中經常碰到，因為在JAVA的支援的類庫中，大量的採用了些種設計模式
    3. 所謂的單態就是入口處（構造方法）限制了物件的例項化操作
    4. 小結
      1. 單態設計模式的核心就是將類的構造方法私有化，之後在類的內部產生例項化物件，並通過類的靜態方法返回例項化物件的引用

    12.物件陣列

    1. 【注意】在物件陣列的使用中，陣列一定要先開闢空間，但是因為其是引用資料型別，所以陣列裡面的每一個物件都是null值，則在使用的時候陣列中的每一個物件都必須分別進行例項化操作
    2. 陣列在使用的時候分為靜態初始化和動態初始化，物件陣列也一樣
    3. 小結
      1. 物件陣列中的每個元素都必須單獨例項化，否則內容就是null

    13.內部類

    1. 內部類存在的特點
      1. 缺點：正常的一個類操作時，在類中最好只定義屬性或方法。如果定義一個類的話，則肯定破壞了程式的一個結構
      2. 優點：內部類的最大優點，就是可以方便的訪問外部類中的私有屬性
    2. 如果一個內部類使用static關鍵字宣告，則此內部類就稱為外部類，可以直接通過外部類.內部類進行訪問，但是如果要想訪問外部類中的屬性，則此屬性必須是static訪問許可權的
    3. 一個內部類除了可以通過外部類訪問，也可以直接在其他類中呼叫，但是呼叫的格式：外部類.內部類 內部類物件 = 外部類例項.new 內部類()
    4. 一個內部類可以在任意的位置上定義
    5. 小結
      1. 內部類在實際的開發中非常有用處，而且經常使用的，一定要熟悉其語法及其優點
      2. 在JAVA系統中也會到處看見使用static宣告內部類的情況
      3. 【注意】使用static宣告的內部類是外部類，操作的時候要使用“外部類.內部類”的形式訪問

    物件導向（高階）

    1.繼承的基本實現

    1. 繼承：子類繼承父類，可以擴充套件已有類的功能
    2. 訪問限制
      1. 子類是不能直接訪問父類中的私有成員的
      2. 子類可以呼叫父類中的非私有方法，但是不能直接呼叫父類中的私有成員
    3. 小結
      1. 繼承的主要目的：擴充套件類的功能
      2. Java中一個子類只能繼承一個父類
      3. Java中不允許多重繼承，但是允許多層繼承

    2.繼承進一步研究

    1. 子類物件例項化過程
      1. 在繼承的操作中，對於子類物件的例項化也是有要求的：“子類物件在例項化之前必須首先呼叫父類中的構造方法之後再呼叫子類自己的構造方法”
    2. 方法的覆寫
      1. 在繼承的關係中也存在著方法的覆寫的概念，就是指子類定義了與父類中同名的方法
      2. 考慮到許可權，即：被子類覆寫的方法不能擁有比父類方法更加嚴格的訪問許可權
      3. 訪問許可權大小關係：private<default<public
      4. 所以，如果在父類中使用public定義的方法，子類的訪問許可權必須是public，否則程式會無法編譯
    3. 使用super只是更加明確的說，要從父類中查詢，就不從子類找了
    4. 【思考】如果現將父類的一個方法定義成private訪問許可權，在子類中將此方法宣告為default訪問許可權，那麼還叫做覆寫嗎？
      1. 此時，方法並沒有被覆寫，而是相當於在子類中又重新定義了一個新的方法出來
    5. 屬性的覆蓋，主要就是指在子類中宣告瞭父類同名的屬性
    6. super表示從子類呼叫父類中的指定操作
    7. 不管任何時候，子類例項化的時候永遠要先去呼叫父類中的構造方法，預設呼叫的是無參構造
    8. 【注意】對於this和super本身都可以呼叫構造方法，而且呼叫的時候都必須放在構造方法的首行，所以這兩個關鍵字肯定不能同時出現
    9. 小結
      1. 方法的覆寫與過載的區別，以及覆寫的實現，許可權：private<default<public
      2. 子類物件的例項化過程：先呼叫父類的構造，再呼叫子類的構造
      3. super與this關鍵字的區別

    3.final關鍵字

    1. final在java中表示的意思是最終的意思。也可以稱為完結器
    2. 可以使用final關鍵字宣告類、屬性、方法
      1. 使用final宣告的類不能有子類
      2. 使用final宣告的方法不能被子類所覆寫
      3. 使用final宣告的變數即成為常量，常量不可以修改
    3. 【注意】命令要求：使用final宣告的變數的字母全部採用大寫的形式
    4. 使用static final關鍵字聯合宣告的變數稱為全域性常量
    5. static宣告的內容是所有物件共同擁有的
    6. 小結
      1. 在一般的開發中，使用final定義的常量是最多的
      2. 使用static final可以宣告全域性常量　

    4.抽象類基本概念

    1. 抽象類的概念：包含一個抽象方法的類就稱為抽象類
    2. 抽象方法：只宣告未實現的方法稱為抽象方法，抽象方法使用abstract關鍵字宣告
    3. 抽象類的定義及使用規則
      1. 包含一個抽象方法的類必須是抽象類
      2. 抽象類和抽象方法都要使用abstract關鍵字宣告
      3. 抽象方法只需宣告而不需要實現
      4. 抽象類必須被子類繼承，子類（如果不是抽象類）必須覆寫抽象類中的全部抽象方法
      5. 從定義上，抽象類就是比普通類多一個抽象方法而已
      6. 抽象類的定義雖然跟普通類非常相似，但是卻不能直接例項化
      7. 抽象類必須有子類，子類必須覆寫抽象類中的全部抽象方法
      8. 抽象類類圖表示：類名稱採用斜體表示一個抽象類
      9. 【注意】
        1. 一個抽象類不能使用　final關鍵字宣告
        2. 抽象類中是允許存在構造方法的，因為抽象類依然使用的是類的繼承關係，而且抽象類中也存在各個屬性，所以子類在例項化之前肯定是先要對父類進行例項化的
    4. 小結
      1. 一定要掌握抽象類定義格式及使用規則
      2. 抽象類使用的時候一定要有子類，子類仍然使用extends關鍵字繼承一個抽象類，同樣會存在單繼承。一個子類不能同時繼承多個抽象類
      3. 抽象類中絕對不能使用final關鍵字宣告
      4. 抽象類中允許有構造方法，而且完全符合子類物件的例項化過程

    5.介面基本概念

    1. 介面可以理解為一種特殊的類，裡面全部是由全域性常量和公共的抽象方法所組成
    2. 如果一個類中完全是由全域性常量（static final宣告）和抽象方法組成，就可以將其定義成一個介面
    3. 介面的類圖表示：使用一個“○”表示
    4. 與抽象類一樣，介面要使用也必須通過子類，子類通過implements關鍵字實現介面
    5. 介面的使用中也必須有子類，子類必須覆寫全部抽象方法，implements關鍵字實現。一個子類可以同時實現多個介面。則子類如果不是抽象類的話，肯定要覆寫介面中的全部抽象方法
    6. 一個介面雖然不能繼承抽象類，但是在JAVA中一個介面可以同時繼承（extends）多個介面，實現介面的多繼承
    7. 小結
      1. 介面是一個特殊的類，只包含全域性常量和抽象方法
      2. 【注意】介面中的抽象方法可以不加入abstract，而抽象類中的抽象方法必須有abstract關鍵字宣告
      3. 一個類只能繼承一個父類，但是可以同時實現多個介面
      4. 一個介面可以同時繼承多個介面，以實現介面的多繼承
      5. 介面和抽象類一樣，都必須依靠子類
      6. 一個抽象類可以實現多個介面，但是一個介面不能繼承一個抽象類

    6.多型性

    1. 多型在java中物件導向主要有以下兩種主要體現
      1. 方法的過載與覆寫
      2. 物件的多型性
    2. 掌握物件多型性之後可以直接應用在抽象類和介面上
    3. 物件的多型性主要分為以下兩種型別
      1. 向上轉型：子類物件->父類物件
        1. 對於向上轉型，程式會自動完成，格式
        2. 物件向上轉型：父類 父類物件 = 子類例項
        3. 【注意】通過子類進行父類物件的例項化操作時，如果呼叫的方法被子類覆寫過，則肯定呼叫被覆寫過的方法，並且轉型之後，因為操作的是父類物件，所以是無法找到在類中定義的新方法
      2. 向下轉型：父類物件->子類物件
        1. 對於向下轉型時，必須明確的指明要轉型的子類型別，格式
        2. 物件向下轉型：子類 子類物件 = (子類)父類例項
        3. 向下轉型需要採用強制手段
    4. 如果兩個沒有關係的物件之間發生了轉換關係，則肯定會出現異常
    5. 小結
      1. 物件多型性的概念
        1. 向上轉型：自動完成
        2. 向下轉型：強制。發生向下轉型關係之前必須先發生向上的轉型關係
      2. 物件多型性可以解決方法接收引數的問題

    7.instansof關鍵字

    1. 在JAVA中可以使用instancdof關鍵字判斷一個物件到底是哪個類的例項
    2. 在開發中一定要注意，對於向下轉型操作最好增加驗證，以保證轉型時不會發生ClassCaseException
    3. 在程式的開發中重點的設計應該放在父類上，只要父類設計的足夠合理，則開發肯定會非常的方便
    4. 一個類永遠不要去繼承一個已經實現好的類，而只有繼承抽象類或實現介面
    5. 小結
      1. instanceof用於判斷一個物件是否某個類的例項
      2. 在物件向下轉型之前最好使用instanceof關鍵字進行驗證

    8.抽象類與介面的應用

    1. 在Java中可以通過物件的多型性，為抽象類和介面例項化，這樣再使用抽象類和介面的時候就可以呼叫本子類中所覆寫過的方法了
    2. 通過物件多型性可以發現，子類發生了向上轉型關係之後，所呼叫的全部方法都是被覆寫過的方法
    3. 抽象類應用：模板設計
    4. 介面類應用：制定標準
    5. 工廠設計模式
      1. 在JAVA開發中是常使用的一種設計模式
      2. JVM的工作原理：程式 -> JVM -> 作業系統
      3. 主方法：應該就表示一個客戶端，主方法的程式碼越少越好。此時，直接在主方法中指定要操作的子類，如果要更換子類，則肯定要修改客戶端，就表示跟特定的子類緊密耦合在一起了，此時應該產生一個過渡端，這個過渡端在程式中就稱為工廠設計
    6. 代理設計模式
      1. 所謂的代理設計就是提一個代理主題來操作真實主題，真實主題執行具體的業務操作，而代理主題負責其他相關業務的處理
      2. 就好比生活中經常使用到的代理上網，客戶通過網路代理連線網路，由代理伺服器完成使用者許可權，訪問許可權等與上網操作相關的操作
    7. 介面卡設計
      1. 在圖形介面上用得非常多
      2. 對於Java程式來說，如果一個類要實現一個介面，由肯定要覆寫此介面中的全部抽象方法，如果一個介面中定義的抽象方法過多，但是在子類中又用不到這麼多抽象方法的話，則會很麻煩
      3. 此時，就需要一箇中間的過渡，但是此過渡類又不希望被直接使用，所以將此過渡類定義成抽象類最合適
      4. 即一個介面首先被一個抽象類（此抽象類通常稱為介面卡類），並在此抽象類中實現若干方法（方法體為空），則以後的子類直接繼承此抽象類，就可以有選擇的覆寫所需要的方法
    8. 內部類擴充套件
      1. 一個抽象類中也可以包含一個介面
      2. 一個介面中也可以定義一個抽象類
      3. 從實際的個人的開發角度來講，此種設計並不是很常見，因為程式碼的結構有些混亂了
    9. 抽象類與介面之間的關係
      1. No 區別點 抽象類 介面
        1 定義 包含一個抽象方法的類 抽象方法和全域性常量的集合
        2 組成 構造方法、抽象方法、普通應運、常量、變數 常量、抽象方法
        3 使用 子類繼承抽象類（extends） 子類實現介面（implements）
        4 關係 抽象類可以實現多個介面 介面不能繼承抽象類，但允許繼承多個介面
        5 常見設計模式 模板設計 工廠設計、代理設計
        6 物件 都通過物件的多型性產生例項化物件
        7 侷限 抽象類有單繼承的侷限 介面沒有此侷限
        8 實際 作為一個模板 是作為一個標準或是表示一種能力
        9 選擇 如果抽象類和介面都可以使得的話，優先使用介面，因為避免單繼而的侷限
        10 特殊 一個抽象類中可以包含多個介面，一個介面可以包含多個抽象類  
    10. 【重要的提示】
      1. 在開發中，一個類永遠不要去繼承一個已經實現好的類，要麼繼承抽象類，要麼實現介面，如果介面和抽象類同時都可以使用的話，那麼優先使用介面，避免單繼承侷限
    11. 小結
      1. 抽象類和介面的例項化：通過物件多型性
      2. 抽象類表示一個模板，介面制定的是一個標準
      3. 常見的設計模式：模板設計，工廠設計、代理設計，介面卡設計

    9.Object類

    1. 在Java中所有的類都有一個公共的父類就是Object類
    2. 物件在列印的時候一定會呼叫toString()方法，是預設呼叫的
    3. equals()方法的主要功能是進行物件的比較操作
    4. String本身也是Object類的子類，所以已經覆寫了此方法
    5. Object類是所有類的父類，則所有類的物件都可以使用Object接收，但是Object不光可以接收物件，還可以接收任意的引用資料型別
    6. 小結
      1. Object類是所有類的父類，只要是引用資料型別都可以使用Object進行接收
      2. 物件在進行向下轉型之前一定要先發生向上轉型，要使用instanceof關鍵字判斷
      3. toString()：物件列印時呼叫
      4. equals()：物件比較時呼叫
      5. String類也是Object類的子類

    10.包裝類

    1. 一切皆物件，八種基本資料型別不是物件
    2. 把int包裝成一個類，這樣就可以以物件的形式操作基本資料型別
    3. Integer、Byte、Float、Double、Short、Long都屬於Number類的子類。Number類本身提供了一系列的返回以上六種基本資料型別的操作
    4. Character與Boolean都屬於Object的直接子類
    5. 裝箱與拆箱
      1. 將基本資料型別變為包裝類稱為裝箱
      2. 將包裝類的型別變為基本資料型別稱為拆箱
    6. 在JDK1.5版本之後對程式的包裝類功能進行了改變，增加了自動裝箱及自動拆箱的功能。而且也可以使用包裝類直接進行數字運算
    7. 在包裝類中，實際上還存在一個最大的特點，就是可以將字串變為指定的資料型別
    8. 包裝類在實際中用得最多的還在於字串變為基本資料型別的操作上
    9. 小結
      1. JAVA中有八種基本資料型別的包裝類，可以將基本資料型別以類的形式進行操作
      2. 基本資料型別變為包裝類的過程，稱為裝箱，將包裝類變為基本資料型別的過程，稱為拆箱
      3. 在JDK1.5之後提供了自動裝箱和自動拆箱的操作
      4. 實際上這八個類是JAVA中提供的類庫，可以發現裡面的寶座也是使用了所嘗過的全部基本概念
      5. 使用包裝類可以將字串進行基本資料型別的轉換

    11.匿名內部類

    1. 內部類：在一個類的內部還有另外一個類稱為內部類，那麼匿名內部類，如果一個類在整個操作中只使用一次的話，就可以將其定義成匿名內部類，匿名內部類是在抽象類及介面的基礎上發展起來的
    2. 小結
      1. 在實際的JAVA開發中經常會使用到各種開發的框架，在框架上會大量的引用匿名內部類
      2. 匿名內部類是在抽象類和介面的基礎之上發展起來的
     

     

    相關文章