2. 繼承 的關鍵字:extends
   3.格式:
   class 子類名 extends 父類名{
   ...
   }
   4.繼承的好處:
   1>提供了代碼復用性,解決了代碼的臃腫
   2>它是多態的前提(多態的前提是必須有繼承關系
   5.繼承的特點:
   子類繼承父類,是繼承了父類所有的東西(成員變量,成員方法,包括私 有),但是子類不能使用私有的東西,只能通過父類的公共的訪問間接的讓子類訪問它.

   6. 繼承的另外一個特點:
      1>在Java中,繼承只支持單繼承,不支持多繼承(子類名 extends 父類名1,父類名2,...)
      2>但是,Java是可以支持多層繼承...
      

      3>類和類之間的關系:繼承關系
      4>類和接口之間的關系:實現關系
      7.繼承中的註意事項:
      1>構造方法不能被繼承,但是通過super關鍵字去訪問
      2>私有的可以間接的去訪問
      3>什麽時候使用extends?
      假設:有一個A類
      class A{
      public void show1(){}
      public void show2(){}
      }

                                                  有一個B類
                                                      class B{
                                                              public void show1(){}
                                                              public void method(){}
                                                      }
          4>按照正常的情況:發現A類和B類中有共同的show1()方法,根據繼承的概念,---->讓B類繼承A類
                                                  class B extends A{
                                                                      public void method(){}
                                                              }
       
      

      沒有問題,但是繼承了A類,show1(),show2()也繼承過來了,可能show2()並不是我想要的功能;對於這種情況不要使用繼承
      5>繼承體現的是一種"is a"的關系:
      6>如果A是B的一種或者B是A的一種,這個可以使用繼承!
      在繼承中,成員變量的名稱問題
      註意事項:
      1> 當前子類繼承父類的時候,子類和父類中的成員變量名稱不一致的情況,非常簡單,分別輸出就可以了;
      2>當子類和父類中的成員變量名稱一致的情況:
      a)先到子類的局部位置找,如果找到了,就輸出
      b)沒有找到,到子類的成員位置找,有就輸出,
      c)在類的成員位置還沒有找到,直接父類的成員位置找,有就輸出
      

      d)如果還沒有,就保存了,不存在這個變量
      二:
      關於繼承的成員的問題?
      構造方法:
      1>子類繼承父類,都會默認的訪問父類的無參構造方法
      2>假設數據還沒有被初始化完畢,所以應該先讓父類進行初始化,然後 在讓子類初始化--->分層初始化
      ?問題思考?
      如果父類的無參構造沒有提供?怎麽辦?
      解答:如果沒有無參構造就會報錯
      解決方法:1>提供一個無參
      2>子類通過super()對父類的有參進行訪問對其進行初始化
      3>還可以在子類中通過this(),訪問本類中的有參構造,間接的去訪問父類帶參構造
      4>子類的構造方法必須有一個(有參構造/無參構造),讓父類進行初始化!
      三:
      繼承中成員方法的問題?
      1)子類繼承父類,訪問成員方法名不一致的情況,分別調用!
      2)當子類中的成員方名和父類中的成員方法名一致的情況:
      3)先在子類的成員位置找,如果有就調用
      4)如果沒有找到,在父類的成員位置找,有就調用
      四:
      關於繼承的用法:
      1)父類中被private修飾的,是可以繼承,但是只能間接的去訪問私有的..
      2)父類被private修飾 成員屬性,子類不不能直接訪問的
      五
      補充:
      1>子類繼續父類,父類先進行初始化,然後子類進行初始化,這就是繼承中分層初始化
      2>類名 對象名 = new 類名() ; 這句話,創建了對象,通過構造方法進行初始化(默認初始化,顯示初始化)

      一:
      1)多態的概念:
                     多態就是事物在同一個時刻,體現出來的不同狀態;
      2)多態的好處:
        1>可以提供代碼的復用性:繼承保證
          2>可以提高的代碼的擴展性:由多態保證...  (父類的引用指向子類對象)
      3)多態的弊端:
                  1>父類引用指向子類對象,
                  2>通過父類的引用調用子類特有功能,不能調用....
                  3>不能訪問子類特有功能
        4>將父類的引用強制轉換子類的引用  ,向下轉型使用不當,會出現一個異常:屬於運行時期異常:ClassCastException
                  二:
                     1):
                       方法重寫:
          1>由於子類繼承父類的時候,提供一摸一樣的方法聲明,然後會將父類該方法覆蓋掉(重寫,復寫)
         2>有時候(具體的需求),不需要子類重寫父類的功能,針對這種情況,Java提供了一個關鍵字:final  最終的,終態的意思
                      2)
                       final關鍵字:
                          1> final:表示最終,終態(不能被更改的)
                          2>它可以修飾類,那麽該類不能繼承
                          3>它可以修飾成員方法,成員方法不能被重寫
                          4>它可以修飾變量,此時這個變量是一個常量
                          5>常量的分類:
                                  字面值常量:
                                  字符串常量,字符常量,,,,
              3)
              1>final不僅可以修飾基本數據類型
        2>還可以引用類型
              3>如果final修飾的是一個基本數據類型:基本數據類型的值不能再改變了...
              4>如果final習俗的是一個引用類型數據:引用類型的地址值不能再改變了,但是堆內存中的成員變量的值可以變得

      5>final的初始化時機在使用之前進行初始化,賦值(在構造方法之前賦值) (非靜態的...)
      三:
      代碼塊敘述:
      1)用{}括起來的代碼,統稱為代碼;
      根據其位置以及聲明不同:分為??
      1>構造代碼塊:在一個類中的成員位置中,用{}括起來,
      作用:可以將多個構造方法中的相同的代碼放到構造代碼塊中,對對象進行初始化. 在每次執行構造方法之前,先執行構造代碼塊.
      2>靜態代碼塊:在一個類的成員位置,也是用{}包起來,但是他被static修飾
      作用:一般情況 它的作用給類進行初始化
      面試題?
      構造代碼塊,構造方法,靜態代碼的優先級?
      1>靜態代碼塊>構造代碼塊>構造方法
      註意:
      1>靜態代碼:只能執行一次
      2>構造代碼塊在每次執行構造方法之前都會被執行.

                      -------------------------------------------------------------------------------------
      
      一:
          抽象類概念:
                  Java中,如果一個類中有一個方法聲明(抽象方法)抽象功能,那麽這個類定義為抽象類

      1)
      關鍵字:abstract 抽象的意思
      2)
      抽象類的特點:
      抽象類不能直接實例化!(不能創建對象) 接口也不能實例化
      3)關於抽象類:
      1>如果一個類中有抽象方法,那麽這個類是一定是一個抽象類
      2.>抽象類必須有抽象方法嗎? 抽象類中不一定都是抽象方法
      4)
      抽象類的子類:
      1>如果子類是抽象類,沒有意義,因為都不能實例化,對象如何創建
      2>子類具體類,那麽子類必須實現父類中的抽象功能.
      5)
      6)抽象類的成員特點:
      1>成員變量:
      可以是變量,也是一個常量
      2>構造方法:可以有無參,可以有有參,作用:給對象進行初始化的.
      3>成員方法:可以有抽象方法,還可以有非抽象方法...
      二:
      abstract和哪些關鍵字是沖突的,不能共有?
      1>abstract 和private
      2>abstract 和final
      3>abstract和static

      一:
      1) 接口的概念:
      接口:體現的是事務的擴展×××(額外動作,後天經過學習等等)
      2)接口格式(標識符:類,接口:見名知意)
      interface 接口名{
      //抽象功能
      public abstract void jump() ;

                                                              }
          3)接口的特點:不能實例化
          4)接口的子實現類:實現類 (具體的實現類)
                                                                      class 類名+impl implements 接口名{
      
                                                                      }

      5)接口的子類如果是抽象類:沒有意義,不能實例化
      6)用處???
      接口多態(最多)
      抽象類多態(比較多)
      具體對象的創建(經常會使用)
      二:
      接口成員的特點:
      1)成員變量:是一個常量,不能更改,並且默認的修飾符
      public static final:
      2)構造方法:接口不存在構造方法
      3)成員方法:都是抽象方法
      默認的修飾符:public abstract
      4) 接口和接口之間的關系:繼承關系
      三:
      實際開發中,接口作為形式參數的問題?
      1>如果形式參數是接口:
      傳統的方式:
      1>提供給接口的子實現類
      2>內部類的方式(不需要提供子實現類)
      四:
      1)內部類的問題:
      內部類:在B類內部定義A類,A類就屬於B的內部類
      2)內部類訪問外部類的特點:
      它可以直接訪問外部了的成員,包括私有
      3)外部類如何訪問內部類的成員?
      通過創建內部類對象的方式間接訪問...
      4)內部類的分類:
      1>成員內部類:在外部類的成員位置
      2>局部內部類:在外部類的局部位置
      5)成員內部類:
      1>可以直接外部類的成員,包括私有
      2>外部類要訪問內部類(非靜態的內部類)的成員方法:
      3>格式:外部類名.內部類名 對象名 = 外部類對象.內部類對象
      6)
      關於成員內部類的修飾符:
      1>private: 作用:保證數據的安全性!
      2>static修飾:可以把靜態內部類看成是外部類的成員.
      3>特點:靜態成員內部類訪問外部類的數據,該數據必須static修飾 7)局部內部類:
      1>可以訪問外部類的成員包括私有...
      2>在外部類的局部位置去訪問內部類的show(),需要在局部位置創建內部了對象,通過對象去訪問
      8)面試題?
      為什麽這個局部變量必須用final修飾?
      因為生命周期的問題,方法中的局部變量,方法結束後這個變量就要被釋放掉,final保證這個變量始終指向一個對象.
      9)匿名內部類
      1>前提是有一個類或者接口
      2>這個類可以是具體類也可以是抽象類
      3> new 類名或者接口名{
      方法重寫();
      }

   4>匿名內部類的本質:是繼承了該類或者實現了該接口子類對象...
   面試題??
   匿名內部類面試題：
   按照要求，補齊代碼
   interface Inter { void show(); }
   class Outer { //補齊代碼 }
   class OuterDemo {
   public static void main(String[] args) {
   Outer.method().show();
   }
   }
   要求在控制臺輸出”HelloWorld”

                                       interface Inter3{
                                           void show() ;//public abstract 
                                       }
                                       class Outer7{
                                           //補齊代碼
                                           public static Inter3 method() {
   
                                               //返回的是接口:當前並不提供接口的子實現類,所以只能用匿名內部類
                                               return new Inter3() {
                                                   public void show() {
                                                       System.out.println("helloworld");
                                                   }
                                               };
                                           }
                                       }
                                       //測試類
                                       public class Test {
   
                                           public static void main(String[] args) {
                                       //      Outer.method().show();
                                               //Outer7.method() :當前這個method方法是靜態方法
                                               //Outer.method().show(); //Outer.method()---->返回一個對象.show()
                                               //由於show()方法是一個接口中的方法,返回值是一個接口類型
   
                                               Outer7.method().show();
                                           }
                                       }                                               
   
   10)形式參數的問題:
        1>形式參數是引用類型:
           a>引用類型:是一個抽象類
               b>形式參數是一個抽象類:此時這塊需要的是該抽象類的子類對象   (抽象類多態
   11)形式參數是引用類型
                                        1>形式參數是一個接口 
                                    2>形式參數的問題:
                                                                               形式參數是基本類型,對實際參數沒有影響(簡單)
                                                                               形式參數是引用類型:
                                                                                       類(普通類)
                                                                                           抽象類
                                                                                       接口
     12)返回值:
       1>如果返回值基本類型:用對應的基本類型去接收數據即可!
       2>引用類型:
                           類(具體類): 需要的是該類的對象
                           抽象類
                           接口
          3>如果返回值基本類型:用對應的基本類型去接收數據即可!
   4>引用類型:
       類(具體類): 需要的是該類的對象
       抽象類:那麽返回需要的結果是需要當前抽象類的子類對象 抽象類多態
       接口
           接口和抽象類的區別:

   區別問題????
   A) 成員的區別
   1>成員變量:
   抽象類:既可以常量,也可以是變量
   接口:只能是常量,默認的修飾符:public static final
   2>構造方法:
   抽象類:有構造方法,無參/有參 (給對象進行初始化的)
   接口:沒有構造方法
   3>成員方法:
   抽象類:可以有抽象方法,也可以有非抽象方法
   接口:只能是抽象方法 :默認的修飾符:public abstract

                                   B)類與類/類與接口關系的區別
                                       1>類與類之間的關系:
                                                   繼承關系,只支持單繼承,不支持多繼承,但是可以多層繼承
                                       2>類與接口的關系:
                                                   實現關系,一個類繼承另一個類的同時,還可以實現多個接口...
                                       3>接口與接口的關系:
                                                   是一種繼承關系,既可以單繼承,也可以多繼承...
                                                   接口1 extends 接口2,接口3...
                                   C)設計原則的 區別
                                       1>抽象類: 是有繼承關系---->體現的是一種"is a"的關系   (A是B的一種或者B是A的一種)
                                       2>接口:類和接口:實現關系--->體現的是一種" like a"的關系(擴展功能)  :跳高貓 像貓

繼承 多態 抽象類 接口等學習內容總結