[转]面向对象（1、三大特征；2、六大原则）
目錄
一、面向?qū)ο蟮母攀?#xff1a;
二、封裝：
1、封裝概述
2、封裝原則
3、封裝好處
4、封裝壞處
5、封裝代碼展示
三、繼承：
1、概念：
2、實現(xiàn)格式：
3、特點：
4、好處：
5、弊端：
6、應(yīng)用場景
7、繼承中變量的訪問特點：
8、關(guān)鍵字
9、方法重寫
10、 Java繼承中的注意事項：
11、代碼演示:
（貓狗類繼承動物類的案例，大家就自己試試吧？給大家演示一個完整例題。）
四、多態(tài)：
1、概念：
2、前提條件：
3、多態(tài)中成員變量的訪問特點是什么？
4、多態(tài)中成員方法的訪問特點是什么？
5、好處與弊端
6、類形態(tài)的轉(zhuǎn)換
7、形式分類：
8、多態(tài)的優(yōu)點：
9、什么是虛擬方法調(diào)用？
五、補充之六大原則：
1、單一職責(zé)原則 （SRP）(Single Responsibility Principle)
2、開放封閉原則OCP(Open－Close Principle)
3、里式替換原則LSP(the Liskov Substitution Principle LSP)
4、依賴倒置原則DIP(the Dependency Inversion Principle DIP)
5、接口分離原則ISP(the Interface Segregation Principle ISP)
6、迪米特法則（Law of Demeter,簡稱LoD）
一、面向?qū)ο蟮母攀?#xff1a;
面向?qū)ο蠛唵蝸碚f就是將功能封裝到對象（數(shù)據(jù)和操作結(jié)合）里，我們面向?qū)ο?#xff0c;讓對象去完成這些功能。
什么是對象？萬物皆對象，客觀存在的事物皆是對象。
面向?qū)ο?Object Oriented,OO)是軟件開發(fā)的方法。而面向?qū)ο蟮母拍詈蛻?yīng)用已超脫于程序設(shè)計和軟件開發(fā)，擴(kuò)展到如數(shù)據(jù)庫系統(tǒng)、交互式界面、應(yīng)用結(jié)構(gòu)、應(yīng)用平臺、分布式系統(tǒng)、網(wǎng)絡(luò)管理結(jié)構(gòu)、CAD技術(shù)、人工智能等領(lǐng)域。
面向?qū)ο笫且环N對現(xiàn)實世界理解和抽象的方法，是計算機(jī)編程技術(shù)發(fā)展到一定階段后的產(chǎn)物。
JAVA是一門面向?qū)ο蟮恼Z言，那么其面向?qū)ο笾饕幸韵聨讉€特性和原則：
三大特性：封裝、繼承、多態(tài)。
六大原則：SPR,CCP,LSP,DIP,ISP,LoD
今天我們主要來說一下面向?qū)ο蟮娜筇匦浴?/p>
二、封裝：
1、封裝概述
是面向?qū)ο笕筇卣髦?#xff08;封裝，繼承，多態(tài)）
是面向?qū)ο缶幊陶Z言對客觀世界的模擬，客觀世界里成員變量都是隱藏在對象內(nèi)部的，外界是無法直接操作的。
2、封裝原則
將類的某些信息隱藏在類內(nèi)部，不允許外部程序直接訪問，而是通過該類提供的方法來實現(xiàn)對隱藏信息的操作和訪問
成員變量private，提供對應(yīng)的getXxx()/setXxx()方法
3、封裝好處
通過方法來控制成員變量的操作，提高了代碼的安全性
把代碼用方法進(jìn)行封裝，提高了代碼的復(fù)用性。
4、封裝壞處
如果封裝的方法出現(xiàn)問題，或者修改，對于其所引用的對象，則需要大量的修改。
5、封裝代碼展示
package sort; public class Customer { private String name; private String id_card; private String number; private String home_address; public Customer() { super(); } public Customer(String name, String id_card, String number, String home_address) { this.name = name; this.id_card = id_card; this.number = number; this.home_address = home_address; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId_card() { return id_card; } public void setId_card(String id_card) { this.id_card = id_card; } public String getNumber() { return number; } public void setNumber(String number) { this.number = number; } public String getHome_address() { return home_address; } public void setHome_address(String home_address) { this.home_address = home_address; } public String say() { String info = "姓名：" + name + "\n身份證號：" + id_card + "\n電話：" + number + "\n家庭住址：" + home_address; return info; }}成員屬性，構(gòu)造方法（構(gòu)造器），get/set方法，命令方法。一個簡單完整的封裝就可以了。
封裝可以使我們?nèi)菀椎匦薷念惖膬?nèi)部實現(xiàn)，而無需修改使用了該類的客戶代碼。就可以對成員變量進(jìn)行更精確的控制。
比如：
public String getSexName() { if("0".equals(sex)){ sexName = "女"; }else if("1".equals(sex)){ sexName = "男"; }else{ sexName = "人妖"; } return sexName; }三、繼承
1、概念：
繼承也是面向?qū)ο笕筇卣髦弧?br /> 可以使得子類具有父類的屬性和方法，還可以在子類中重新定義，
以及追加屬性和方法。
2、實現(xiàn)格式：
通過extends關(guān)鍵字實現(xiàn)繼承
?? ?格式： class 子類 extends 父類 { }
3、特點：
子類可以有父類的內(nèi)容，子類還可以有自己特有的內(nèi)容
4、好處：
提高了代碼的復(fù)用性(多個類相同的成員可以放到同一個類中)
提高了代碼的維護(hù)性(如果方法的代碼需要修改，修改一處即可)
5、弊端：
繼承讓類與類之間產(chǎn)生了關(guān)系，類的耦合性增強了，當(dāng)父類發(fā)生變化時子類實現(xiàn)也不得不跟著變化，削弱了子類的獨立性。
6、應(yīng)用場景
使用繼承，需要考慮類與類之間是否存在is..a的關(guān)系，不能盲目使用繼承
is..a的關(guān)系：誰是誰的一種，例如：老師和學(xué)生是人的一種，那人就是父類，學(xué)生和老師就是子類。
例如：假設(shè)我有兩個類A和B，如果滿足A是B的一種，或者B是A的一種，就說明他們存在繼承關(guān)系，這個時候就可以考慮使用繼承來體現(xiàn)，否則就不能濫用繼承。
7、繼承中變量的訪問特點：
在子類方法中訪問一個變量，采用的是就近原則。
子類局部范圍找
子類成員范圍找
父類成員范圍找
如果都沒有就報錯(不考慮父親的父親…)
8、關(guān)鍵字
this關(guān)鍵字：this：代表本類對象（成員變量）的引用。
super關(guān)鍵字：super：代表父類存儲空間的標(biāo)識(可以理解為父類對象引用)。
this和super的使用區(qū)別（三種訪問方法）：
成員變量：
?? ?this.成員變量 ? ?- ? 訪問本類成員變量
?? ?super.成員變量 - ? 訪問父類成員變量
成員方法：
?? ?this.成員方法?? ?- 訪問本類成員方法
?? ?super.成員方法 - 訪問父類成員方法
構(gòu)造方法：
?? ?this(…)?? ?- ?訪問本類構(gòu)造方法
?? ?super(…)?? ?- ?訪問父類構(gòu)造方法
9、方法重寫
概念:子類出現(xiàn)了和父類中一模一樣的方法聲明（方法名一樣，參數(shù)列表也必須一樣）.
應(yīng)用場景：當(dāng)子類需要父類的功能，而功能主體子類有自己特有內(nèi)容時，可以重寫父類中的方法，這樣，即沿襲了父類的功能，又定義了子類特有的內(nèi)容。
@Override：注解：用來檢測當(dāng)前的方法，是否是重寫的方法，起到【校驗】的作用。
方法重寫的注意事項：
1. 私有方法不能被重寫(父類私有成員子類是不能繼承的)
2. 子類方法訪問權(quán)限不能更低(public > 默認(rèn) > 私有)
10、 Java繼承中的注意事項：
java中，類支持單繼承，不支持多繼承，支持多層繼承。
錯誤范例：class A extends B, C { }
Java中類支持多層繼承
正確范例：
?? ?class A {} ??
?? ?class B extends A{ } ??
?? ?class C extends B{ }
11、代碼演示:
（貓狗類繼承動物類的案例，大家就自己試試吧？給大家演示一個完整例題。）
1、這是一個封裝類
package inherit01; /*(1)定義一個ManKind類，包括?成員變量int sex和int salary；?方法void manOrWoman()：根據(jù)sex的值顯示“man”(sex==1)或者“woman”(sex==0)；?方法void employeed()：根據(jù)salary的值顯示“no job”(salary==0)或者“ job”(salary!=0)。 */ public class ManKind { public int sex; public int salary; public ManKind() { } public ManKind(int sex, int salary) { this.sex = sex; this.salary = salary; } public int getSex() { return sex; } public void setSex(int sex) { this.sex = sex; } public int getSalary() { return salary; } public void setSalary(int salary) { this.salary = salary; } public void manOrWoman(int sex){ if(sex == 1){ System.out.println("man"); }else if(sex == 0){ System.out.println("woman"); } } public void employeed(int salary){ if(salary == 0){ System.out.println("no job"); }else { System.out.println("job"); } }}2、這是繼承了上一個封裝的類
package inherit01; /*(2)定義類Kids繼承ManKind，并包括?成員變量int yearsOld；?方法printAge()打印yearsOld的值。 */public class Kids extends ManKind{ public int yearsOld; public Kids() { } public Kids(int yearsOld) { this.yearsOld = yearsOld; } public int getYearsOld() { return yearsOld; } public void setYearsOld(int yearsOld) { this.yearsOld = yearsOld; } public void printAge(int yearsOld){ System.out.println("yearsOld: "+yearsOld); }}?最后定義一個測試類
package inherit01;/*(3)定義類KidsTest，在類的main方法中實例化Kids的對象someKid，用該對象訪問其父類的成員變量及方法。 */public class KidsTest { public static void main(String[] args) { Kids someKid=new Kids(); someKid.setSex(1); someKid.setSalary(6666); someKid.setYearsOld(25); someKid.manOrWoman(someKid.getSex()); someKid.employeed(someKid.salary); someKid.printAge(someKid.yearsOld); }}四、多態(tài)
1、概念：
同一個對象，在不同時刻表現(xiàn)出來的不同形態(tài)。（多態(tài)性：多態(tài)性是對象多種表現(xiàn)形式的體現(xiàn)）
（例如：我們可以說貓是貓，貓 cat = new cat（）； ? ? ? ? 我們也可以說貓是動物：動物 animal = new 貓（）； ? ? ? ?這時，貓在不同時刻表現(xiàn)出來了不同的形態(tài)，這就是多態(tài)。）
2、前提條件：
要有繼承/實現(xiàn)關(guān)系
要有方法重寫
要有父（類/接口）引用指向子（子/實現(xiàn)）類對象
3、多態(tài)中成員變量的訪問特點是什么？
（編譯看左邊、運行看左邊）
舉例：比如還是貓，我們創(chuàng)建對象，Animal a=new Cat（）； ? ?當(dāng)我們編譯（sout（a.屬性）），這時我們會發(fā)現(xiàn)，這里的屬性，尋找的是Animal類中的屬性，而不是Cat中的屬性。 ? ? ? 同理，運行時（即控制臺輸出時的值），我們會發(fā)現(xiàn)也看的Animal類中的數(shù)據(jù)屬性。
4、多態(tài)中成員方法的訪問特點是什么？
（編譯看左邊、運行看右邊）
同上，編譯時看創(chuàng)建對象的左邊，即Animal父類，而不是貓Cat類。而此時的運行，卻是看右邊的方法里數(shù)據(jù)內(nèi)容了。
（為什么成員變量和成員方法的訪問不一樣呢？因為成員方法有重寫，而成員變量沒有。）
5、好處與弊端
好處：提高了代碼的擴(kuò)展性。
? ? ? ?定義方法時，如果將父類型作為參數(shù)，在使用方法時，可以傳遞任意子類對象。
弊端：不能使用子類特有的成員，不能使用子類的特有功能，比如特有的方法。
6、類形態(tài)的轉(zhuǎn)換
向上轉(zhuǎn)型：父類引用指向子類對象其實就是向上轉(zhuǎn)型。例如：
? ? ? ?Animal a = new Dog(); ? Animal是父類， Animal a中的a就是父類引用，new Dog就是子類對象。
向下轉(zhuǎn)型：將父類型的引用轉(zhuǎn)換成具體的子類對象。轉(zhuǎn)換格式：
? ? ? ?子類 對象名 = (子類)父類引用; ? ?例如：Cat c= （Cat）a；
7、形式分類：
（1）：具體類多態(tài)（幾乎是不用的）
（2）：抽象類多態(tài)
（3）：接口多態(tài)
8、多態(tài)的優(yōu)點：
（1）. 消除類型之間的耦合關(guān)系
（2）. 可替換性
（3）. 可擴(kuò)充性
（4）. 接口性
（5）. 靈活性
（6）. 簡化性
9、什么是虛擬方法調(diào)用？
1.子類中定義了與父類同名同參數(shù)的方法，在多態(tài)情況下，將此時父類的方法稱為虛擬方法，父類根據(jù)賦給它的不同子類對象，動態(tài)調(diào)用屬于子類的該方法。這樣的方法調(diào)用在編譯期是無法確定的。
2.多態(tài)是運行時行為，不是編譯時行為。
10、代碼演示
（1）.我們定義一個父類：Animal
public class Animal { public void eat() { System.out.println("動物吃東西"); } }
? ? （2）.我們再定義一個子類繼承父類：Cat extends Animal
（3）最后我們再定義一個測試類，實現(xiàn)多態(tài)
多態(tài)： 同一個對象，在不同時刻表現(xiàn)出來的不同形態(tài) 舉例：貓 我們可以說貓是貓：貓 cat = new 貓(); 我們也可以說貓是動物：動物 animal = new 貓(); 這里貓在不同的時刻表現(xiàn)出來了不同的形態(tài)，這就是多態(tài) 多態(tài)的前提和體現(xiàn) 有繼承/實現(xiàn)關(guān)系 有方法重寫 有父類引用指向子類對象 */public class AnimalDemo { public static void main(String[] args) { //有父類引用指向子類對象 Animal a = new Cat(); }}五、補充之六大原則：
總述：面向?qū)ο蟮牧笤瓌t
六大原則指的是單一職責(zé)原則、開閉式原則、里氏替換原則、依賴倒置原則、接口隔離原則以及迪米特原則。
1、單一職責(zé)原則 （SRP）(Single Responsibility Principle)
就一個類而言，應(yīng)該只有一個引起它變化的原因。簡單來說，一個類應(yīng)該是一組相關(guān)性很高的函數(shù)和數(shù)據(jù)的封裝。因為單一職責(zé)的劃分界限并不是那么清晰，每個人的理解不一樣，這就導(dǎo)致了不同的人劃分的類承擔(dān)的職責(zé)也不一樣，就圖片加載的例子來說，可能有的人就認(rèn)為整個圖片加載是一組相關(guān)性很高的功能，于是將其放入在一個類中處理。一般來說，我們首先需要具備單一職責(zé)原則的思想，如果發(fā)現(xiàn)一個類承擔(dān)了太多的功能，這個時候就要考慮將某些功能劃分到其他類中去處理，具體的劃分細(xì)節(jié)要平開發(fā)者的個人經(jīng)驗。
2、開放封閉原則OCP(Open－Close Principle)
軟件中的對象應(yīng)該對擴(kuò)展是開放的，但是，對修改是關(guān)閉的。軟件開發(fā)過程中，需求是不斷變化的，因為變化、升級和維護(hù)等原因需要對原有的軟件代碼進(jìn)行修改，而一旦對原有的代碼進(jìn)行修改，就有可能影響到原有的模塊，引起bug，因此，在軟件開發(fā)過程中，我們應(yīng)該盡可能通過擴(kuò)展的方式實現(xiàn)變化，而不是修改原有的代碼，當(dāng)然，這是一種理想的情況，在實際的軟件開發(fā)中，完全通過擴(kuò)展的方式實現(xiàn)變化是不現(xiàn)實的。
3、里式替換原則LSP(the Liskov Substitution Principle LSP)
所有引用基類的地方都必須能夠透明的使用其子類。通過建立抽象，讓高層次模塊依賴于抽象類，在運行時在替換成具體的實現(xiàn)類，保證了系統(tǒng)的擴(kuò)展性和靈活性。
4、依賴倒置原則DIP(the Dependency Inversion Principle DIP)
依賴倒置原則指的是高層次模塊不應(yīng)該依賴于低層次模塊的具體實現(xiàn)，兩者都應(yīng)該依賴其抽象，具體如下：
1、高層次模塊不應(yīng)該依賴低層次模塊的具體實現(xiàn)，兩者都應(yīng)該依賴其抽象；
2、抽象不應(yīng)該依賴細(xì)節(jié)；
3、細(xì)節(jié)應(yīng)該依賴抽象。
在面向?qū)ο笳Z言中，抽象指的是接口或者抽象類，兩者都不能被實例化，而細(xì)節(jié)指的是具體的實現(xiàn)類。其實一句話就可以概括，面向接口編程，或者說面向抽象編程，試想一下，如果類和類之間之間依賴細(xì)節(jié)，那么這兩個類將會緊緊的耦合在一起，這就意味著，修改了其中一個類，很可能需要對另外一個類也需要進(jìn)行修改，并且這樣也大大限制了系統(tǒng)的可擴(kuò)展性。依賴倒置原則提供了一種解耦方式，通過抽象讓類和類之間不再依賴細(xì)節(jié)，而是在具體運行時再進(jìn)行替換。
5、接口分離原則ISP(the Interface Segregation Principle ISP)
類間的依賴關(guān)系應(yīng)該建立在最小的接口之上。接口隔離原則將非常龐大、臃腫的接口拆分成更小更具體的接口。
一個接口定義的過于臃腫，則代表它的每一個實現(xiàn)類都要考慮所有的實現(xiàn)邏輯。如果一個類實現(xiàn)了某個接口，也就是說這個類承載了這個接口所有的功能，維護(hù)這些功能成為了自己的職責(zé)。這就無形中增加了一個類的負(fù)擔(dān)。
這里有一點需要說明，接口定義要小，但是要有限度，對接口細(xì)化可以增加靈活性，但是過度細(xì)化則會使設(shè)計復(fù)雜化。同時接口的使用率不高，提高了代碼的維護(hù)成本。這種極端的體現(xiàn)就是每個接口只含有一個方法，這顯然是不合適的。
6、迪米特法則（Law of Demeter,簡稱LoD）
一個對象應(yīng)該對其他對象有最小的了解。迪米特原則也稱作最小知道原則，即類和類直接應(yīng)該建立在最小的依賴之上，一個類應(yīng)該對其依賴的類有最小的了解，即只需要知道其所需要的方法即可，至于其內(nèi)部具體是如何實現(xiàn)的則不用關(guān)心。迪米特原則的目的是減少類和類之間的耦合性，類和類之間的耦合性越大，當(dāng)一個類發(fā)生修改后，會其他類造成的影響也越大。
以上，就是今天小知識課堂的全部了，咚咚咚（敲黑板），下課。
---------------------
作者：IT_ZI-O
來源：CSDN
原文：https://blog.csdn.net/Lee0620/article/details/120270751?utm_medium=distribute.pc_category.none-task-blog-hot-10.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-10.nonecase
版權(quán)聲明：本文為作者原創(chuàng)文章，轉(zhuǎn)載請附上博文鏈接！
內(nèi)容解析By：CSDN,CNBLOG博客文章一鍵轉(zhuǎn)載插件
總結(jié)
以上是生活随笔為你收集整理的[转]面向对象（1、三大特征；2、六大原则）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 用python快速合并代码（方便软著申请
- 下一篇： 中台基础指标列表