OPP--面向對象知識點

2019-11-14 14:53:24

字體：大中小

來源：轉載

供稿：網友

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

1)現實世界是由很多很多對象組成的

基于對象抽出了類

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

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

3)類中可以包含:

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

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

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

同一個類創建的多個對象，結構相同，數據不同

5)類是對象的模板，對象是類的具體的實例

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

3.引用類型畫等號:

1)指向同一個對象

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

eg:房門鑰匙

基本類型畫等號:

1)賦值

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

eg:身份證復印件

4.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     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);

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      }

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

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)遵循"編譯期"綁定，根據引用的類型綁定方法

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 }