OPP--物件導向知識點，opp--物件導向

OPP--物件導向知識點，opp--物件導向

第一天

1.什麼是類？什麼是對象？

  1)現實世界是由很多很多個物件組成的

    基於對象抽出了類

  2)對象:真真正正存在的單個的個體

    類:代表一類個體(類型、類別)

  3)類中可以包含:

    3.1)所有對象所共有的屬性(靜)----變數

    3.2)所有對象所共有的行為(動)----方法

  4)一個類可以建立多個對象

    同一個類建立的多個對象，結構相同，資料不同

  5)類是對象的模板，對象是類的具體的執行個體

2.如何建立類？如何建立對象？

3.參考型別畫等號:

  1)指向同一個對象

  2)對其中一個引用的修改會影響另外一個

    eg:房門鑰匙

  基本類型畫等號:

  1)賦值

  2)對其中一個值的修改不會影響另外一個

    eg:身份證複印件

4.null:空，即不指向任何對象

       若引用的值為null，則該引用不能再進行任何操作了

       若操作則null 指標異常(NullPointerException)

補充

1. 1)找對象:一堆小格子

2)抽類:格子類Cell

3)設計類中的成員變數和方法:

4)建立對象:

2. 面向過程是一種以過程為核心的編程思想，即分析出解決問題所需要的步驟，然後使用方法將這些步驟一步一步的實現，使用的時候，在main方法中一個一個依次調用就可以了。

3. 請描述類和對象的關係

參考答案

對象是一個客觀存在的實體，是物件導向編程過程中分析與解決問題的出發點與基礎。對象的實質就是記憶體中的一塊資料存放區地區，其資料結構由定義它的類來決定。

類是用於構建對象的模板，對象通過類的執行個體化產生，一個類可以建立多個對象，每個對象擁有自己的資料和行為。

3 請描述參考型別和基本類型的區別

參考答案

除8種基本類型之外，用類名（介面、數組）聲明的變數稱為參考型別變數，簡稱“引用”。引用的功能在於訪問對象。

基本類型變數本身就包含了其執行個體資料，而參考型別變數中儲存的是某個對象在記憶體中的地址資訊。當一個參考型別變數指向該類的對象時，就可以通過這個變數訪問對象。

第二天

1.方法的簽名:方法名+參數列表

2.方法的重載:

  1)同一個類中，方法名稱相同，參數列表不同

  2)編譯器在編譯時間自動根據方法的簽名綁定調用不同的方法

3.構造方法:建構函式、構造器、構建器

  1)給成員變數賦初值

  2)與類同名，沒有傳回值類型

  3)在建立(new)對象時被自動調用

  4)若自己不寫構造，則系統預設提供一個無參構造方法

    若自己寫了構造，則不再預設提供

  5)構造方法可以重載

4.this:指代當前對象，哪個對象調指的就是哪個對象

       方法中訪問成員變數之前，預設有個this.

  this用法:

  1)this.成員變數名----訪問成員變數

  2)this.方法名()------調用方法

  3)this()-------------調用構造方法

5.參考型別數組

  1)

1     Cell[] cells = new Cell[4];2     cells[0] = new Cell(2,5);3     cells[1] = new Cell(3,6);4     cells[2] = new Cell(4,7);5     cells[3] = new Cell(5,8);

2)

1      Cell[] cells = new Cell[]{2       new Cell(2,5),3       new Cell(3,6),4       new Cell(4,7),5       new Cell(5,8)6      }

  3)

1     int[][] arr = new int[3][];2     arr[0] = new int[2];3     arr[1] = new int[3];4     arr[2] = new int[2];5     arr[1][0] = 100; //arr中第2個元素中的第1個元素賦值為100

4)

1 int[][] arr = new int[3][4]; //3行4列2     for(int i=0;i<arr.length;i++){3       for(int j=0;j<arr[i].length;j++){4         arr[i][j] = 100;5       }6     }

1)找對象:T對象,J,O,I,S,Z,L

2)抽類:T類，J類，L類，O,S,Z,I類

3)設計類中的成員變數和方法:

4)建立對象測試:

知識點補充：

1.一個檔案中可以包含多個類

 public修飾的類只能有一個

 public修飾的類的名字必須與檔案名稱相同

第三天

1.記憶體管理:理解

  1)堆:

    1.1)儲存所有new出來的對象

    1.2)成員變數的生命週期:

          建立對象時存在堆中，對象被回收時一併消失

    1.3)沒有任何引用所指向的對象即為垃圾，

        記憶體回收行程(GC)不定時查看，看到垃圾則自動回收

    1.4)記憶體泄露:無用的對象沒有被及時的回收

          建議:若對象不再使用，及時將引用設定為null

  2)棧:

    2.1)儲存正在調用的方法中的所有局部變數

    2.2)調用方法時在棧中為該方法分配一塊對應的棧幀，

        棧幀中儲存方法中的局部變數，

               方法執行結束時棧幀被消除，局部變數一併消失

    2.3)局部變數的生命週期:

          方法被調用時存在棧中，方法結束時棧幀被消除時一併消失

  3)方法區:

    3.1)儲存.class位元組碼檔案以及所有方法

    3.2)方法只有一份，通過this來區分具體的引用

2.繼承:

  1)有利於代碼的重用(避免代碼重複)

  2)通過extends實現繼承

  3)父類/基類:所有子類所共有的特徵和行為

    子類/衍生類別/:子類所特有的特徵和行為

  4)子類繼承父類後，具有:

      父類共有的+子類特有的

  5)一個父類可以有多個子類，

    一個子類只能有一個父類---單一繼承

  6)繼承具有傳遞性

  7)java規定:構造子類之前必須先構造父類

    子類構造中若沒有調用父類構造，則預設添加super()來調用父類的無參構造

    若子類構造中調了父類構造，則不再預設提供

    super()必須位於子類構造的第一句

3.super:指代當前對象的父類對象

  用法:

  1)super.成員變數名---訪問父類的成員變數

  2)super.方法名()-----調用父類的方法

  3)super()------------調用父類的構造方法

4.向上造型

  1)父類型的引用指向子類的對象

  2)能點出來什麼，看引用的類型

知識點補充：

1.成員變數:

1)類中，方法外

2)new時存在堆中，對象被回收時一併被清除

3)有預設值

局部變數:

1)方法中

2)方法被調用時存在棧中，調用結束棧幀被清除時一併消失

3)沒有預設值

成員變數:有幾個對象就有幾份(堆)

成員方法:只有一份(方法區)

2. 在JAVA中，有java程式、虛擬機器、作業系統三個層次，其中java程式與虛擬機器互動，而虛擬機器與作業系統互動。編譯好的java位元組碼檔案運行在JVM中。

程式中無論代碼還是資料，都需要儲存在記憶體中，而java程式所需記憶體均由JVM進行管理分配，開發人員只需關心JVM是如何管理記憶體的，而無需關注某種作業系統是如何管理記憶體的，這就保證了java程式的平台無關性。

JVM會將申請的記憶體從邏輯上劃分為三個地區：堆、棧、方法區。這三個地區分別用於儲存不同的資料。

3．GC線程會從棧中的引用變數開始跟蹤，從而判定哪些記憶體是正在使用的，若GC無法跟蹤到某一塊堆記憶體，那麼GC就認為這塊記憶體不再使用了，即為可回收的。但是，java程式員不用擔心記憶體管理，因為垃圾收集器會自動進行管理。

4. 構建T類和J類的父類Tetromino類，將公用的（T類和J類公有的）資訊存放在父類中， T類和J類繼承Tetromino父類。此時，子類即可以共用父類的資料。這個過程就是泛化的過程。

5.簡述JVM記憶體回收機制

記憶體回收機制是Java提供的自動釋放記憶體空間的機制。

記憶體回收行程（Garbage Collection，GC）是JVM內建的一個線程，用於回收沒有被引用的對象。

6 Java程式是否會出現記憶體泄露

會出現記憶體流失。一般來說記憶體流失有兩種情況。

一是在堆中分配的記憶體，在沒有將其釋放掉的時候，就將所有能訪問這塊記憶體的方式都刪掉；另一種情況則是在記憶體對象明明已經不需要的時候，還仍然保留著這塊記憶體和它的訪問方式（引用）。第一種情況，在Java中已經由於記憶體回收機制的引入，得到了很好的解決。所以，Java中的記憶體流失，主要指的是第二種情況。

7.Foo foo = new Foo();

foo.f();

以上代碼的記憶體實現原理為：

1.Foo類首先被裝載到JVM的方法區，其中包括類的資訊，包括方法和構造等。

2.在棧記憶體中分配引用變數foo。

3.在堆記憶體中按照Foo類型資訊分配執行個體變數記憶體空間；然後，將棧中引用foo指向foo對象堆記憶體的首地址。

4.使用引用foo調用方法，根據foo引用的類型Foo調用f方法。

8．當調用子類構造器來初始化子類對象時，父類構造器總會在子類構造器之前執行。子類構造器調用父類構造器分如下幾種情況。

A，子類構造器執行體的第一行使用super顯式調用父類構造器，系統將根據super調用裡傳入的實參列表調用父類對應的構造器。

B，子類構造器執行的第一行代碼使用this顯式調用本類中重載的構造器，系統將根據this調用裡傳入的實參列表調用本類中的另一個構造器。執行本類中另一個構造器時即會調用父類構造器。

C，子類構造器執行體中既沒有super調用，也沒有this調用，系統將會在執行子類構造器之前，隱式調用父類無參數的構造器。

第四天

1.方法的重寫(override):

  1)發生在父子類中，方法名相同，參數列表相同，方法體不同

  2)重寫方法被調用時，看對象

2.重寫與重載的區別:----常見面試題

  1)重寫:

    1.1)父子類中，方法名相同，參數列表相同

    1.2)遵循"運行期"綁定，根據對象的類型調用方法

  2)重載(overload):

    2.1)同一個類中，方法名相同，參數列表不同

    2.2)遵循"編譯期"綁定，根據引用的類型Binder 方法

3.package:

  1)避免類的命名衝突

  2)類的完全限定名:包名.類名

  3)包名建議所有字母小寫

  import:

  1)同包中的類可以直接存取，

    不同包中類訪問兩種方式:

    1.1)通過import聲明類/引入類

    1.2)完全限定名----繁瑣

  2)文法: import 包名.類名;

4.存取控制修飾符:

  1)public:公開的，任何類

  2)private:私人的，本類

  3)protected:受保護的，本類、子類、同包類

  4)預設:什麼也不寫，本類、同包類

  說明:

    1)類的存取控制只能是public和預設

    2)類中的成員如上4種都可以

5.static:靜態

  1)靜態變數:

    1.1)由static修飾

    1.2)是屬於類的，存在方法區中，只有一份

    1.3)常常通過類名.來訪問

    1.4)何時用:所有對象的資料都一樣時使用

  2)靜態方法:

    2.1)由static修飾

    2.2)是屬於類的，存在方法區中，只有一份

    2.3)常常通過類名.來訪問

    2.4)靜態方法沒有隱式this傳遞，

        所以靜態方法中不能直接存取執行個體成員

    2.5)何時用:方法的操作僅與參數相關而與對象無關

  3)靜態塊:

    3.1)由static修飾

    3.2)類被載入時自動執行，類只被載入一次，

        靜態塊只執行一次

    3.3)何時用:常常用於載入靜態資源(圖片、音頻、視頻等)

6.final:最終的

  1)修飾變數:變數不能被改變

  2)修飾方法:方法不能被重寫

  3)修飾類:類不能被繼承

7.static final-----------自學

補充知識點：

1.執行個體變數多還是靜態變數多?

----------執行個體變數多

----------靜態方法不可能多

2. 靜態方法沒有隱式的this傳遞，

沒有this意味著沒有對象，

執行個體變數是屬於對象，必須通過對象點來訪問

所以靜態方法中不能直接存取執行個體成員

3. 成員變數:

1)執行個體變數:屬於對象的，存在堆中，

           有幾個對象有幾份  通過對象點來訪問

2)靜態變數:屬於類的，存在方法區中，

           只有一份   通過類名點來訪問

4.重寫遵守"兩同兩小一大"原則:----等於時絕對正確

 * 1)兩同:

 *   1.1)方法名相同

 *   1.2)參數列表相同

 * 2)兩小:

 *   2.1)子類的傳回值類型小於或等於父類的

 *       2.1.1)void和基本類型時，必須相同

 *       2.1.2)參考型別時，小於或等於父類的

 *   2.2)子類拋出的異常小於或等於父類的-----異常之後

 * 3)一大:

 *   3.1)子類的存取權限大於或等於父類的-----修飾符之後

5.方法重載的要求是“兩同一個不同“的原則，

* 1)兩同:

*   1.1)方法名相同，

同一類中是指兩個方法可以是同一個類中聲明的，或者是繼承來的，抑或一個是聲明的，另一個是繼承來的

 *   1.2) 同一類

* 2)一不同:參數列表不同

6. 對於類的修飾可以使用public和預設。 其中，public修飾的類可以被任何一個類使用，而預設存取控制的類只可以被同一個包中的類使用。

而protected和private存取修飾詞是不可以修飾類的，但其可以修飾內部類（後面課程詳細介紹）。

7. 關於package和import語句，下面說法錯誤的是：

A. package 提供了一種命名機制，用於管理類名空間

B. 定義類時，除了定義類的名稱以外，必須要指定一個包名

C. import語句用於匯入所需要的類

D. 同時使用不同包中相同類名的類，包名不能省略

8. final關鍵字修飾成員變數，意為初始化後不可改變（對象一旦建立即不可改變），那麼該成員變數可以在聲明時賦初始值，也可以在構造方法或是靜態代碼塊中初始化。

第五天

1.static final常量:

  1)常量必須聲明同時初始化

  2)不能被改變、通過類名.來訪問

  3)常量名建議所有字母大寫，多個單詞用_分隔

  4)在編譯時間被直接替換為具體的值---效率高

2.抽象方法:

  1)由abstract修飾

  2)只有方法的定義，沒有方法的具體實現(連{}都沒有)

3.抽象類別:

  1)由abstract修飾

  2)包含抽象方法的類必須是抽象類別

    若一個類中沒有抽象方法，也可以聲明為抽象類別---我願意

  3)抽象類別不能被執行個體化(new)

  4)抽象類別是需要被繼承的，子類:

    4.1)重寫父類的所有抽象方法--常用

    4.2)也聲明為抽象類別----不常用

  5)抽象類別的意義:

    5.1)封裝子類所共有的資料和行為--子類重用

    5.2)為所有子類提供了一種公用的類型--向上造型

    5.3)包含抽象方法，為所有子類提供統一的入口

4.介面:

  1)是一個標準、規範

    只要符合了這個標準、就能幹某件事---API

  2)由interface定義

  3)只能包含常量和抽象方法

  4)介面不能被執行個體化

  5)介面是需要被實現/繼承的，實作類別/子類:

      必須重寫介面中的所有抽象方法

  6)一個類可以實現多個介面，

    若又繼承又實現時，必須先繼承後實現

  7)介面可以繼承介面

補充知識點

1. 抽象類別中可以包含抽象方法和非抽象方法，而介面中的所有方法均為抽象的。

2. 介面裡不包含構造器；抽象類別裡可以包含構造器，抽象類別裡的構造器並不是用於建立對象，而是讓其子類調用這些構造器來完成屬於抽象類別的初始化操作

3. //示範介面的基礎文法

1 interface Inter1{ 2     public static final int NUM = 250;3     public abstract void show();4     double PI = 3.14159;            //預設public static final5     void say();                           //預設public abstract6 }

 

第六天

正課:

1.多態:多種形態

  1)多態的意義:

    1.1)同一類型的引用在指向不同的對象時，有不同的實現

          行為的多態: cut(),run()

    1.2)同一對象被造型為不同的類型時，有不同的功能

          對象的多態: 我,水

  2)向上造型:

    2.1)父類型的引用指向子類的對象

    2.2)能造型成的類型:父類、所實現的介面

    2.3)能點出來什麼，看引用的類型

  3)強制類型轉換，成功的條件只有兩個:

    3.1)引用所指向的對象，就是該類型

    3.2)引用所指向的對象，實現了該介面

  4)只要不符合如上兩個條件，

    則發生ClassCastException類型轉換異常

    一般在轉換之前先通過instanceof判斷:

      引用所指向的對象是否是該類型

2.成員內部類:單獨應用的幾率不太大

  1)類中套類，裡面的叫內部類Inner，外面的叫外部類Outer

  2)內部類通常只服務於外部類，對外不具備可見度

  3)通常在外部類中建立內部類的對象

  4)內部類中可以直接存取外部類的成員(包括私人的)

    內部類中有一個隱式的引用指向了建立它的外部類對象

      外部類名.this.

3.匿名內部類:

  1)想建立一個類(子類)的對象，並且該對象只建立一次，

    此時該類不必命名，稱之為匿名內部類

  2)內部類(成員、匿名)有獨立的.class

4.物件導向三大特徵:

  1)封裝:

    1.1)類:封裝的是對象的特徵和行為

    1.2)方法:封裝的具體的商務邏輯/實現

    1.3)存取控制修飾符:封裝的是訪問的許可權

  2)繼承:

    2.1)便於代碼的重用

    2.2)extends，父:共有的 子:特有的

  3)多態:

    3.1)意義:

        3.1.1)同一類型的引用指向不同對象時，有不同的實現

                       行為的多態

               3.1.2)同一對象被造型為不同的類型的，有不同的功能

                       對象的多態

    3.2)向上造型、強制轉換、instanceof

    3.3)兩種表現形式:

        3.3.1)重寫

               3.3.2)重載

知識點補充:

1.父類大，子類小

類型轉換:

1)自動類型轉換:從小到大

2)強制類型轉換:從大到小

2. 設計原則:

1)將公用的特徵和行為抽到父類中

2)若所有子類行為都一樣，設計為普通方法

  若所有子類行為不一樣，設計為抽象方法

3)符合既是也是的關係時，使用介面

3. 繼承要符合is a的關係

4.   1)建立了Inter2的一個子類，沒有名字

2)為該子類建立了一個對象，名為o3

3).大括弧中的為該子類的類體

Inter2 o3 = new Inter2(){};

知識點鞏固：

 1 1.public class Answer { 2  public static void main(String[] args) { 3    int score = 20; 4    Answer  ans= new Answer(); 5    ans.add(score); 6    System.out.println(" main： score = " + score); 7  } 8  void  add(int score) { 9    System.out.println(" add： score=" + score++);10  }11 }

解析：輸出add： score=20

main： score =20

原因是score只定義在main函數中，範圍也是main函數，程式調用ans.add函數時，往函數中傳給了參數score=20，但是這個函數沒有傳回值。Main函數中輸出的還是變數score=20