面向物件

1、面向物件思想：

(1)概述：面向物件是相對於面向過程而言的，面向過程強調的是功能，面向物件強調的是將功能封裝進物件，強調具備功能的物件；

(2)思想特點：

A:是符合人們思考習慣的一種思想；

B:將複雜的事情簡單化了；

C:將程式設計師從執行者變成了指揮者；

比如我要達到某種結果，我就尋找能幫我達到該結果的功能的物件，如我要洗衣服我就買洗衣機，至於怎麼洗我不管。

(3)特徵：

封裝：隱藏物件的屬性和實現細節，僅對外提供公共訪問方式

繼承: 多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行為，只要繼承那個類即可。

多型: 一個物件在程式不同執行時刻代表的多種狀態，父類或者介面的引用指向子類物件

2、類和物件：

類：對現實世界中某類事物的描述,是抽象的，概念上的定義。

物件：事物具體存在的個體。

3、成員變數和區域性變數的區別

（1）作用域：

　　成員變數：針對整個類有效。

　　區域性變數：只在某個範圍內有效。（一般指的是方法或語句體內）

（2）儲存位置：

　　成員變數：隨著物件的建立而存在，隨著物件的消失而消失，儲存在堆記憶體中。

　　區域性變數：在方法被呼叫，或者語句體被執行的時候存在，儲存在棧記憶體中。當方法呼叫完或者語句結束後，自動釋放。

（3）初始值：

　　成員變數：有預設初始值。

　　區域性變數：沒有預設初始值，使用前必須賦值。

4、匿名物件

（1）匿名物件就是沒有名字的物件，是物件的一種簡寫形式。

（2）應用場景

　　A:只調用一次類中的方法。

　　B:可以作為實際引數在方法傳遞中使用。

5、封裝

隱藏物件的屬性和實現細節，僅對外提供公共訪問方式

優點：將物件隔離、方便使用、提高複用性、提高安全性

6、關鍵字private：

（1）私有的意思，許可權修飾符

（2）用來修飾成員變數和成員方法

（3）用private修飾的成員只在本類中有效

（4）私有是封裝的一種體現

7、構造方法：

（1）特點：

　　方法名和類名相同

　　沒有返回值

　　沒有返回值型別

（2）作用：建構函式是用於建立物件，並對其進行初始化賦值，物件一建立就自動呼叫相對的建構函式

（3）構造方法的注意事項：

　　A：如果一個自定義類沒有構造方法，系統會預設給出一個無參構造方法。

　　B：如果一個自定義類提供了構造方法，那麼系統將不再給出無參構造方法。這個時候你可以不使用無參構造方法，如果要使用

　　     那麼必須手動給出無參構造方法；

　　建議：一般情況下，我們的自定義類都要手動給出無參構造方法。

（4）構造方法和成員方法的區別

　　A：格式區別

　　　　構造方法和類目相同，並且沒有返回型別，也沒有返回值。

　　　　普通成員方法可以任意起名，必須有返回型別，可以沒有返回值。

　　B：作用區別

　　　　構造方法用於建立物件，並進行初始化值。

　　　　普通成員方法是用於完成特定功能的。

　　C：呼叫區別

　　　　構造方法是在建立物件時被呼叫，一個物件建立，只調用一次相應建構函式。

　　　　普通成員方法是由建立好的物件呼叫，可以呼叫多次

8、構造程式碼塊：

（1）作用：給物件進行初始化，物件一建立就執行，而且優先於建構函式執行

（2）構造程式碼塊和建構函式的區別：

　　構造程式碼塊是給所有不同物件的共性進行統一初始化

　　建構函式是給對應的物件進行初始化

9、this關鍵字

（1）this關鍵字代表本類物件的一個引用，誰呼叫this所在的方法，this就代表誰

（2）this的使用場景

　　A：用於區分同名成員變數和區域性變數；

　　B：在定義函式時，該函式內部要用到呼叫該函式的物件時，因此此時物件還沒建立，故this代表此物件

　　C：建構函式間呼叫    這個時候，this（引數）必須作為第一條語句存在。

10、Person p = new Person（）；在記憶體中做了哪些事情？

　　（1）將Person.class檔案載入進記憶體中。

　　（2）如果p定義在主方法中，那麼，就會在棧空間開闢一個變數空間p。

　　（3）在堆記憶體給物件分配空間。

　　（4）對物件中的成員進行預設初始化。

　　（5）對物件中的成員進行顯示初始化。

　　（6）呼叫構造程式碼塊對物件進行初始化。（如果沒有就不執行）

　　（7）呼叫構造方法對物件進行初始化。物件初始化完畢。

　　（8）將物件的記憶體地址賦值給p變數，讓p變數指向該物件。

11、static關鍵字：
(1)靜態的意思，用來修飾成員變數和成員函式
(2)靜態的特點:
　　隨著類的載入而載入
　　優先於物件存在
　　對所有物件共享
　　可以被類名直接呼叫
(3)靜態的注意事項
　　A:靜態方法只能訪問靜態成員
　　為什麼：因為靜態的內容是隨著類的載入而載入，它是先進記憶體的。
　　B:靜態方法中不能使用this,super關鍵字
　　C:主方法是靜態的
　　public static void main(String[] args)
　　public:公共的意思，是最大許可權修飾符。
　　static:由於jvm呼叫main方法的時候，沒有建立物件。
　　只能通過類名呼叫。所以，main必須用static修飾。
　　void:由於main方法是被jvm呼叫，不需要返回值。用void修飾。
　　main:main是主要的意思，所以jvm採用了這個名字。是程式的入口。

　　String[]:字串陣列
　　args:陣列名

　　在執行的時候，通過java命令給args陣列賦值。
　　格式：java MainTest hello world itcast
(4)靜態變數和成員變數的區別
　　A：呼叫方式
　　　　靜態變數也稱為類變數，可以直接通過類名呼叫。也可以通過物件名呼叫。這個變數屬於類。
　　　　成員變數也稱為例項變數，只能通過物件名呼叫。這個變數屬於物件。
　　B：儲存位置
　　　　靜態變數儲存在方法區長中的靜態區。
　　　　成員變數儲存在堆記憶體。
　　C：生命週期
　　　　靜態變數隨著類的載入而存在，隨著類的消失而消失。生命週期長。
　　　　成員變數隨著物件的建立而存在，隨著物件的消失而消失。
　　D：與物件的相關性
　　　　靜態變數是所有物件共享的資料。
　　　　成員變數是每個物件所特有的資料。
(5)靜態的優點和弊端
　　優點：
　　對物件的共享資料進行單獨空間的儲存，節省記憶體，沒有必要每個物件都儲存一份可直接被類名呼叫
　　弊端：
　　　　生命週期過長，隨著類的消失而消失
　　　　訪問出現許可權，即靜態雖好但只能訪問靜態
(6)什麼使用使用靜態呢？
　　A:當所有物件共享某個資料的時候，就把這個成員變數定義為靜態修飾的。
　　B:當某個方法沒有訪問該類中的非靜態成員，就可以把這個方法定義為靜態修飾。

　　靜態的生命週期比較長，所以一般不推薦使用。
(7)靜態程式碼塊
　　A:它只執行一次，它比main還先執行。
　　B:執行順序
　　　　靜態程式碼塊--構造程式碼塊--構造方法

12、單例設計模式

（1）設計模式：

　　解決某類問題行之有效的方法，是一種思想，是規律的總結

（2）用來保證某個類在記憶體中只有一個物件

（3）保證唯一性的思想及步驟：

　　A：為了避免其他程式建立該類物件，先禁止其他程式建立該物件，即將建構函式私有化

　　B：為了其他程式訪問到該類物件，須在本類中建立一個該類私有物件

　　C：為了方便其他程式訪問到該類物件，可對外提供一個公共訪問方式

（4）單例設計模式的兩種方式

　　A：餓漢式 當類載入的時候，就建立物件。

class Student{
   private Student(){}
   private static final Student s = new Student();
   public static Student getInstance(){
         return s;  
    }  
}

 

　　B：懶漢式 當使用的時候才去建立物件。

class Student{
     private Student(){}
     private static final Student s = null;
     private static Student getInstance(){
          if(s == null){
                return new Student();
        }
    }
}

 

餓漢式和懶漢式的區別：

 　　餓漢式：類一載入進記憶體就建立好物件；

　　 懶漢式：類才載入進記憶體的時候，物件還沒有存在，只有呼叫了getInstance（）方法時，物件才開始建立。

　　 懶漢式是延遲載入，如果多執行緒同時操作懶漢式時就有可能出現執行緒安全問題，解決執行緒安全問題可以加同步來解決。

　　 但是加了同步之後，每一次都要比較鎖，效率會變慢，所以可以加雙重判斷來提高程式效率。

　　 注：開發中常用餓漢式，因為餓漢式簡單安全。懶漢式對現場的時候容易發生問題。

13、繼承

（1）把很多類中相同特徵和行為進行抽取，用一個類來描述，讓多個類和這個類產生關係。這樣的話，多個類就可以省略很多程式碼。

這個關係就是繼承。Java中用extends關鍵詞表示。

（2）繼承的體系結構

　　A：多個具體的物件，不斷的向上抽取共享的內容，最終形成一個體系，這個體系叫做繼承體系。

　　B：繼承體系的學習和使用原則

　　　　學習頂層的內容——因為他是整個體系的共性內容

　　　　建立子類使用——也就是使用底層的具體物件

（3）繼承的特點：

　　A：Java中只能單繼承，沒有多繼承。

　　B：Java中可以多重繼承。

（4）繼承的好處：

　　繼承的出現提高了程式碼的複用性。

　　繼承的出現讓類與類之間產生了關係，提供了多型的前提。

（5）子父類的成員關係

　　A：成員變數

　　　　在子類方法中使用一個變數時：

　　　　首先，在方法的區域性變數中找這個變數，有則使用。否則，在本類中找成員變數，有則使用。否則在父類中找成員變數，有則使用，否則報錯；

　　B：成員方法

　　　　在子類物件使用一個方法時：

　　　　首先。在子類中找這個方法，有則使用。否則。在父類中找這個方法，有則使用。否則報錯；

（6）重寫和過載的區別：

　　過載：在同一個類中，方法名相同，引數列表不同。過載可以改變返回型別。

　　重寫：在不同類中（子父類中），方法宣告相同（返回型別，方法名，引數列表均相同）。

　　　　　注意：重寫是子類方法的訪問許可權要大於等於父類方法的訪問許可權。靜態只能重寫靜態，但是這種情況一般不會出現。

14、final關鍵字

（1）最終的意思，可以修飾類、方法、變數。

（2）final修飾的類不能被繼承

　　  final修飾的方法不能被重寫

　　  final修飾的變數是一個常量，只能被賦值一次

　　  內部類只能訪問被final修飾的區域性變數

 15、抽象類

（1）多個類有相同的方法宣告，但是方法體不一樣。這個時候，我們考慮把方法什麼進行抽取，讓子類繼承後，自己

去實現方法體。沒有方法體的方法，我們需要用抽象標誌下。

（2）抽象類：該方法稱為抽象方法，包含抽象方法的類就是抽象類。

（3）抽象類的特點：

　　A：抽象類和抽象方法都要用abstract進行修飾

　　B：抽象類不能被例項化

　　C：抽象類中不一定有抽象方法，但是，有抽象方法的類一定是抽象類。

（4）抽象類中資料的特點

　　A：成員變數：抽象類中可以有變數，也可以有常量。

　　B：成員方法：抽象類中可以有抽象方法，也可以有非抽象方法。

　　C：構造方法：抽象類是一個類，所以它有構造方法。雖然本身不能例項化，但是可以給子類例項化使用。

（5）抽象類中的問題

　　A：抽象類中是否有構造方法？能不能被例項化？如果不能，為什麼有構造方法？

　　　　抽象類中有構造方法、抽象類不能被例項化、抽象類中的構造方法供子類例項化呼叫。

　　B：抽象關鍵字abstract不可以和哪些關鍵字共存？

　　　　a:private：私有時子類繼承不到，所有不能重寫。但是abstract修飾的方法，要求被重寫。兩者衝突。

　　　　b:final：final修飾的方法不能被重寫。而abstract修飾的方法，要求被重寫。兩者衝突。

　　　　c:static：假如一個抽象方法能通過static修飾，那麼這個方法就可以直接通過類名呼叫。而抽象方法是

　　　　　　沒有方法體的，這樣的呼叫無意義。所以不能用static修飾。

　　C：抽象類中可不可以沒有抽象方法？如果可以，這樣的類有什麼用？

　　　　抽象類可以沒有抽象方法。抽象類中沒有抽象方法的作用，只是為了不讓別的類建立該類抽象類物件，這個在awt中有體現。

16、介面interface

（1）當一個類中的方法都是抽象的時候，Java提供了另一種表示方式，叫介面。用interface關鍵字表示。類與介面關係用implements表示。

（2）介面的成員特點

　　A：成員變數：是常量，預設修飾 public static final

　　B：成員方法：都是抽象的，預設修飾public abstract

（3）關係

　　A：類與類的關係

　　　　是繼承關係。類可以多實現介面。

　　B：類與介面的關係

　　　　是實現的關係。類可以多實現介面。

　　C：介面和介面的關係

　　　　是繼承關係。介面可以多繼承介面。

（4）介面的特點

　　A：是對外暴露的規則

　　B：是功能的擴充套件

　　C：介面的出現降低耦合性。

　　　　耦合（類與類之間的關係） 內聚（類完成功能的能力）

　　　　編碼規範：低耦合，高內聚。

　　D：介面可以多實現。

（5）介面和抽象類的區別

　　A：抽象類只能被單繼承，介面可以多實現，介面的出現避免了多繼承的侷限性。

　　B：抽象類的資料特點：

　　　　　　成員變數：可以是變數，也可以是常量

　　　　　　成員方法：可以是抽象方法，也可以是非抽象方法

　　　　　　構造方法：有構造方法

　　　　介面中的資料特點：

　　　　　　成員變數：是常量。預設修飾public static final

　　　　　　成員方法：都是抽象方法。預設修飾public abstract

　　　　　　構造方法：沒有構造方法

　　C：抽象類中定義的是繼承體系中的共性功能、介面中定義的是繼承體系的擴充套件功能。

　　D：抽象類被繼承是“is a”關係；

　　　　介面被實現是“like a”關係；

17、多型：

（1）同一個物件，在程式不同時刻的多種執行狀態。

（2）多型的前提

　　A：存在著繼承或者實現的關係

　　B：有方法的重寫

　　C：父類（介面）引用指向子類（實現）物件

（3）多型的好處和弊端

　　好處：多型的存在是提高了程式的擴充套件性和後期可維護性

　　弊端：雖然可以預先使用，但是隻能訪問父類中已有的功能，執行的是後期子類的功能內容。不能預先使用子類中定義的特有功能。

（4）多型中物件呼叫成員的特點

　　Fu f = new zi（）；

　　A：成員變數

　　　　編譯看左邊，執行看左邊

　　B：成員方法

　　　　編譯看左邊，執行看右邊

　　C：靜態方法

　　　　編譯看左邊，執行看左邊

（5）多型的思想

　　指揮同一批物件做事情。

18、instanceof關鍵字

　　A：用於判斷某個物件是否是某種型別。

　　B：格式  物件名  instanceof 子類（實現）名

19.==和equals的用法：

（1）==怎麼用？

　　可以用於比較基本資料型別，比較的就是基本資料型別的值是否相等。

　　可以用於比較引用資料型別，比較的是物件的地址是否相等。

（2）equals怎麼用？

　　equals只能用於比較引用資料型別。自定義類中如果重寫了equals方法，那麼就是按照你自己的需求來比較。

20、匿名內部類

（1）前提：繼承一個類或者實現一個介面

（2）格式：

　　new 父類名或者介面名（）{

　　重寫父類方法或者實現介面中的方法。

　　也可以自定義其他方法。

}

（3）什麼時候定義匿名內部類？

　　匿名內部類只是為了簡化書寫，匿名內部類有侷限，通常定義匿名內部類時，該類方法不超過3個

（4）匿名內部類的好處和弊端：

　　好處：簡化程式碼書寫

　　弊端：不能直接呼叫自己特有的方法，不能執行強轉換動作，如果該類裡面放方法較多，不允許使用匿名內部類

21、異常
(1)程式執行過程中的不正常現象就叫異常。
(2)導致程式執行不正常的現象有很多，所以，就有很多的異常物件。
　　而這些異常物件存在著共性的內容，所以，可以不斷的進行抽取。最終形成了異常的體系結構。
　　異常體系的根類是:Throwable
　　Throwable：
　　|--Error:重大的問題，我們處理不了。也不需要編寫程式碼處理。比如說記憶體溢位。
　　|--Exception:一般性的錯誤，是需要我們編寫程式碼進行處理的。
　　　　|--RuntimeException:執行時異常，這個我們也不需要處理。
　　　　　　　　　　　　其實就是為了讓他在執行時出問題，然後我們回來修改程式碼。
(3)異常的分類
　　異常有兩種：
　　編譯時被檢測異常：
　　　　該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。
　　　　該異常被標識，代表這可以被處理。
　　執行時異常(編譯時不檢測)
　　　　在編譯時，不需要處理，編譯器不檢查。
　　　　該異常的發生，建議不處理，讓程式停止。需要對程式碼進行修正。
(4)異常體系的特點：
　　異常體系中的所有類及其子類物件都具備可拋性。也就是說可以被throw和throws關鍵字所操作。
(5)main方法是如何處理異常的。
　　A:在main裡面編寫程式碼進行處理
　　B:交給jvm自己進行處理。採用的是jvm的預設處理方式。
　　    其實就是相當於呼叫了異常物件的printStackTrace()方法。
(6)Throwable類的學習
　　getMessage():獲取異常資訊，返回字串。
　　toString():獲取異常類名和異常資訊，返回字串。
　　printStackTrace():獲取異常類名和異常資訊，以及異常出現在程式中的位置。返回值void。
(7)異常的處理·
　　A:try...catch...finally
　　基本格式：
　　　　try
　　　　{
　　　　　　可能出現異常的程式碼
　　　　}
　　　　　　catch(異常物件)
　　　　{
　　　　　　異常處理程式碼
　　　　}
　　　　finally
　　　　{
　　　　　　釋放資源
　　　　}

　　變形格式：
　　　　try...catch
　　　　try...catch...catch...
　　　　try...catch...catch...finally
　　**多個異常同時被捕獲的時候，記住一個原則：
　　　　先逮小的，再逮大的。
　　**finally:永遠被執行，除非退出jvm。System.exit(0);
　　　　面試題2個。
　　　　***：final,finally,finalize區別。
　　　　　　final是最終的意思。它可以用於修飾類，成員變數，成員方法。
　　　　　　它修飾的類不能被繼承，它修飾的變數時常量，它修飾的方法不能被重寫。

　　　　　　finally:是異常處理裡面的關鍵字。
　　　　　　它其中的程式碼永遠被執行。特殊情況：在執行它之前jvm退出。System.exit(0);

　　　　　　finalize:是Object類中的一個方法。
　　　　　　它是於垃圾回收器呼叫的方式。

　　　　***：假如catch中有return語句， finally裡中的程式碼會執行嗎？
　　　　　　是在return前，還是在return後呢？
　　　　　　會，在return前執行finally裡面的程式碼。
(8)Exception和RuntimeException的區別
　　A:Exception:一般性的錯誤，是需要我們編寫程式碼進行處理的。
　　B:RuntimeException:執行時異常，這個我們也不需要處理。
　　　　其實就是為了讓他在執行時出問題，然後我們回來修改程式碼。
　　　　在用throws丟擲一個的時候，如果這個異常是屬於RuntimeException的體系的時候，
　　　　我們在呼叫的地方可以不用處理。(RuntimeException和RuntimeException的子類)

　　　　在用throws丟擲一個的時候，如果這個異常是屬於Exception的體系的時候，
　　　　我們在呼叫的地方必須進行處理或者繼續丟擲。
(9)自定義異常
　　定義類繼承Exception或者RuntimeException
　　1,為了讓該自定義類具備可拋性。
　　2，讓該類具備操作異常的共性方法。
　　class MyExcepiton extends Exception
　　{
　　　　MyExcepiton(){}

　　　　MyExcepiton(String message)
　　　　{
　　　　　　super(message);
　　　　}
　　}

　　class MyException extends RuntimeException
　　{
　　　　MyExcepiton(){}

　　　　MyExcepiton(String message)
　　　　{
　　　　　　super(message);
　　　　}
　　}
(10)throws和throw的區別
　　A：有throws的時候可以沒有throw。
　　　　有throw的時候，如果throw拋的異常是Exception體系，那麼必須有throws在方法上宣告。
　　B：throws用於方法的宣告上，其後跟的是異常類名，後面可以跟多個異常類，之間用逗號隔開
　　　　throw用於方法體中，其後跟的是一個異常物件名