面向對象設計的七大原則
一、單一設計原則（Single Responsibility Principle）
1.1 定義
通俗的說，即一個類應該只負責一項職責。如類A負責兩個不一樣職責：職責1，職責2。當職責1需求變動而改變A時，可能形成職責2執行錯誤，因此須要將類A的粒度分解成A1,A2。java
1.2 應用實例
1） 方案一編程
public class SingleResponsibility1 {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run("摩托車");
vehicle.run("汽車");
vehicle.run("飛機");
}
}
// 方式1
// 1. 在方式1 的run方法中，違反了單一職責原則
// 2. 解決的方案很是的簡單，根據交通工具運行方法不一樣，分解成不一樣類便可
class Vehicle {
public void run(String vehicle) {
System.out.println(vehicle + " 在公路上運行....");
}
}
複製代碼
2）方案二設計模式
public class SingleResponsibility2 {
public static void main(String[] args) {
RoadVehicle roadVehicle = new RoadVehicle();
roadVehicle.run("摩托車");
roadVehicle.run("汽車");
AirVehicle airVehicle = new AirVehicle();
airVehicle.run("飛機");
}
}
//方案2的分析
//1. 遵照單一職責原則
//2. 可是這樣作的改動很大，即將類分解，同時修改客戶端
//3. 改進：直接修改Vehicle 類，改動的代碼會比較少=>方案3
class RoadVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "公路運行");
}
}
class AirVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "天空運行");
}
}
class WaterVehicle {
public void run(String vehicle) {
System.out.println(vehicle + "水中運行");
}
}
複製代碼
3） 方案3bash
public class SingleResponsibility3 {
public static void main(String[] args) {
Vehicle2 vehicle2 = new Vehicle2();
vehicle2.run("汽車");
vehicle2.runWater("輪船");
vehicle2.runAir("飛機");
}
}
//方式3的分析
//1. 這種修改方法沒有對原來的類作大的修改，只是增長方法
//2. 這裏雖然沒有在類這個級別上遵照單一職責原則，可是在方法級別上，仍然是遵照單一職責
class Vehicle2 {
public void run(String vehicle) {
//處理
System.out.println(vehicle + " 在公路上運行....");
}
public void runAir(String vehicle) {
System.out.println(vehicle + " 在天空上運行....");
}
public void runWater(String vehicle) {
System.out.println(vehicle + " 在水中行....");
}
//方法2.
//..
//..
//...
}
複製代碼
1.3 注意事項和細節
- 下降類的複雜度，一個類負責一項職責。
- 提升類的可讀性，可維護性。
- 下降變動引發的風險。
- 一般狀況下，咱們應當遵照單一職責原則，只有邏輯足夠簡單，才能夠在代碼級違反單一職責原則；只有類中方法數量足夠少，能夠在方法級別保持單一職責原則。
二、接口隔離原則（Interface Segregation Principle）
2.1 定義
客戶端不該該依賴它不須要的接口，即一個類對另外一個類的依賴應該創建在最小的接口。微信
2.2 應用實例
interface Interface1 {
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
}
class B implements Interface1 {
public void operation1() {
System.out.println("B 實現了 operation1");
}
public void operation2() {
System.out.println("B 實現了 operation2");
}
public void operation3() {
System.out.println("B 實現了 operation3");
}
public void operation4() {
System.out.println("B 實現了 operation4");
}
public void operation5() {
System.out.println("B 實現了 operation5");
}
}
class D implements Interface1 {
public void operation1() {
System.out.println("D 實現了 operation1");
}
public void operation2() {
System.out.println("D 實現了 operation2");
}
public void operation3() {
System.out.println("D 實現了 operation3");
}
public void operation4() {
System.out.println("D 實現了 operation4");
}
public void operation5() {
System.out.println("D 實現了 operation5");
}
}
class A { //A 類經過接口Interface1 依賴(使用) B類，可是隻會用到1,2,3方法
public void depend1(Interface1 i) {
i.operation1();
}
public void depend2(Interface1 i) {
i.operation2();
}
public void depend3(Interface1 i) {
i.operation3();
}
}
class C { //C 類經過接口Interface1 依賴(使用) D類，可是隻會用到1,4,5方法
public void depend1(Interface1 i) {
i.operation1();
}
public void depend4(Interface1 i) {
i.operation4();
}
public void depend5(Interface1 i) {
i.operation5();
}
}
複製代碼
上面代碼問題：類A經過接口Interface1依賴類B，類C經過接口Interface1依賴D，若是接口Interface1對於類A和類C來講不是最小接口，那麼類B和類D必須去實現他們不須要的方法。框架
改進方案：將接口Interface1拆分爲獨立的幾個接口，類A和類C分別與他們須要的接口創建依賴關係。也就是採用接口隔離原則。ide
// 接口1
interface Interface1 {
void operation1();
}
// 接口2
interface Interface2 {
void operation2();
void operation3();
}
// 接口3
interface Interface3 {
void operation4();
void operation5();
}
class B implements Interface1, Interface2 {
public void operation1() {
System.out.println("B 實現了 operation1");
}
public void operation2() {
System.out.println("B 實現了 operation2");
}
public void operation3() {
System.out.println("B 實現了 operation3");
}
}
class D implements Interface1, Interface3 {
public void operation1() {
System.out.println("D 實現了 operation1");
}
public void operation4() {
System.out.println("D 實現了 operation4");
}
public void operation5() {
System.out.println("D 實現了 operation5");
}
}
class A { // A 類經過接口Interface1,Interface2 依賴(使用) B類，可是隻會用到1,2,3方法
public void depend1(Interface1 i) {
i.operation1();
}
public void depend2(Interface2 i) {
i.operation2();
}
public void depend3(Interface2 i) {
i.operation3();
}
}
class C { // C 類經過接口Interface1,Interface3 依賴(使用) D類，可是隻會用到1,4,5方法
public void depend1(Interface1 i) {
i.operation1();
}
public void depend4(Interface3 i) {
i.operation4();
}
public void depend5(Interface3 i) {
i.operation5();
}
}
複製代碼
2.3 注意事項和細節
- 接口儘可能小，可是要有限度。對接口進行細化能夠提升程序設計靈活是不掙的事實，可是若是太小，則會形成接口數量過多，使設計複雜化。因此必定要適度。
- 爲依賴接口的類定製服務，只暴露給調用的類它須要的方法，它不須要的方法則隱藏起來。只有專一地爲一個模塊提供定製服務，才能創建最小的依賴關係。
- 提升內聚，減小對外交互，使接口用最小的方法去完成最多的事情。
2.4 單一職責原理VS接口隔離原則
- 單一職責原則注重的是職責；而接口隔離原則注重對接口依賴的隔離。
- 單一職責原則主要是約束類，其次纔是接口和方法，它針對的是程序中的實現和細節；而接口隔離原則主要約束接口，主要針對抽象，針對程序總體框架的構建。
三、依賴倒轉原則（Dependence Inversion Principle）
3.1 定義
- 高層模塊（調用者）不該該依賴低層模塊（被調用者），兩者都應該依賴其抽象。
- 抽象不該該依賴細節，細節應該依賴抽象。
- 依賴倒轉（倒置）的中心思想是面向接口編程。
- 依賴倒轉原則是基於這樣的設計理念：相對於細節的多變性，抽象的東西要穩定的多。以抽象爲基礎搭建的框架比細節爲基礎的框架要穩定的多。在java中，抽象指的是接口和抽象類，細節就是具體的實現類。
- 使用接口和抽象類的目的是制定好規範，而不涉及任何具體的操做，把展示細節的任務交給它們的實現類去完成。
3.2 應用實例
public class DependecyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
}
}
class Email {
public String getInfo() {
return "電子郵件信息: hello,world";
}
}
//完成Person接收消息的功能
//方式1分析
//1. 簡單，比較容易想到
//2. 若是咱們獲取的對象是 微信，短信等等，則新增類，同時Perons也要增長相應的接收方法
//3. 解決思路：引入一個抽象的接口IReceiver, 表示接收者, 這樣Person類與接口IReceiver發生依賴
// 由於Email, WeiXin 等等屬於接收的範圍，他們各自實現IReceiver 接口就ok, 這樣咱們就符號依賴倒轉原則
class Person {
public void receive(Email email ) {
System.out.println(email.getInfo());
}
}
複製代碼
依賴倒轉改進方案：函數
public class DependecyInversion {
public static void main(String[] args) {
//客戶端無需改變
Person person = new Person();
person.receive(new Email());
person.receive(new WeiXin());
}
}
//定義接口
interface IReceiver {
public String getInfo();
}
class Email implements IReceiver {
public String getInfo() {
return "電子郵件信息: hello,world";
}
}
//增長微信
class WeiXin implements IReceiver {
public String getInfo() {
return "微信信息: hello,ok";
}
}
//方式2
class Person {
//這裏咱們是對接口的依賴
public void receive(IReceiver receiver ) {
System.out.println(receiver.getInfo());
}
}
複製代碼
3.3 傳遞依賴關係的方式
3.3.1 三種方式工具
- 接口傳遞。
- 構造方式傳遞。
- setter方法傳遞。
3.3.2 應用案例優化
public class DependencyPass {
public static void main(String[] args) {
// TODO Auto-generated method stub
ChangHong changHong = new ChangHong();
// OpenAndClose openAndClose = new OpenAndClose();
// openAndClose.open(changHong);
//經過構造器進行依賴傳遞
// OpenAndClose openAndClose = new OpenAndClose(changHong);
// openAndClose.open();
//經過setter方法進行依賴傳遞
OpenAndClose openAndClose = new OpenAndClose();
openAndClose.setTv(changHong);
openAndClose.open();
}
}
// 方式1： 經過接口傳遞實現依賴
// 開關的接口
// interface IOpenAndClose {
// public void open(ITV tv); //抽象方法,接收接口
// }
//
// interface ITV { //ITV接口
// public void play();
// }
//
// class ChangHong implements ITV {
//
// @Override
// public void play() {
// // TODO Auto-generated method stub
// System.out.println("長虹電視機，打開");
// }
//
// }
//// 實現接口
// class OpenAndClose implements IOpenAndClose{
// public void open(ITV tv){
// tv.play();
// }
// }
// 方式2: 經過構造方法依賴傳遞
// interface IOpenAndClose {
// public void open(); //抽象方法
// }
// interface ITV { //ITV接口
// public void play();
// }
// class OpenAndClose implements IOpenAndClose{
// public ITV tv; //成員
// public OpenAndClose(ITV tv){ //構造器
// this.tv = tv;
// }
// public void open(){
// this.tv.play();
// }
// }
// 方式3 , 經過setter方法傳遞
interface IOpenAndClose {
public void open(); // 抽象方法
public void setTv(ITV tv);
}
interface ITV { // ITV接口
public void play();
}
class OpenAndClose implements IOpenAndClose {
private ITV tv;
public void setTv(ITV tv) {
this.tv = tv;
}
public void open() {
this.tv.play();
}
}
class ChangHong implements ITV {
@Override
public void play() {
// TODO Auto-generated method stub
System.out.println("長虹電視機，打開");
}
}
複製代碼
3.4 注意事項和細節
- 底層模塊儘可能都要有抽象類和接口，或者二者都有，程序穩定性更好。
- 變量的聲明類型儘可能是抽象類或接口，這樣咱們的變量引用和實際對象間，就存在一個緩衝層，利於程序擴展和優化。
- 繼承是遵循里氏替換原則。
四、里氏替換原則（Liskov Substition Principle）
4.1 OO（Object Oriented）中繼承性說明
- 繼承性包含這樣一層含義：父類中凡事已經實現好的方法，其實是在設定規範和契約，雖然它不強制要求全部的子類必須遵循這些契約，可是子類對這些已經實現的方法任意修改，就會對整個繼承體系形成破壞。
- 繼承在給程序設計帶來便利的同時，也帶來了弊端。好比使用繼承會給程序帶來侵入性，程序的可移植性下降，增長對象間的耦合性，若是一個類被其餘的類繼承，則當這個類須要修改時，必須考慮到全部的子類，而且父類修改後，全部涉及到子類的功能都有可能產生故障。
4.2 定義
- 若是對每一個類型爲T1的對象o1，都有類型爲T2的對象o2，使得以T1定義的全部程序p在全部的對象o1都代換成o2，程序P的行爲沒有發生變化，那麼類型T2是類型T1的子類型。換句話說，全部引用基類的地方必須能透明地使用其子類的對象。
- 在使用繼承時，遵循里氏替換原則，在子類中儘可能不要重寫父類的方法。
- 里氏替換原則告訴咱們，繼承實際上讓兩個類耦合性加強了，在適合的狀況下，能夠經過聚合，組合，依賴來解決問題。
4.3 應用案例
public class Liskov {
public static void main(String[] args) {
// TODO Auto-generated method stub
A a = new A();
System.out.println("11-3=" + a.func1(11, 3));
System.out.println("1-8=" + a.func1(1, 8));
System.out.println("-----------------------");
B b = new B();
System.out.println("11-3=" + b.func1(11, 3));//這裏本意是求出11-3
System.out.println("1-8=" + b.func1(1, 8));// 1-8
System.out.println("11+3+9=" + b.func2(11, 3));
}
}
// A類
class A {
// 返回兩個數的差
public int func1(int num1, int num2) {
return num1 - num2;
}
}
// B類繼承了A
// 增長了一個新功能：完成兩個數相加,而後和9求和
class B extends A {
//這裏，重寫了A類的方法, 多是無心識
public int func1(int a, int b) {
return a + b;
}
public int func2(int a, int b) {
return func1(a, b) + 9;
}
}
複製代碼
解決方法：原來的父類和子類都繼承一個更通俗的基類。
public class Liskov {
public static void main(String[] args) {
// TODO Auto-generated method stub
A a = new A();
System.out.println("11-3=" + a.func1(11, 3));
System.out.println("1-8=" + a.func1(1, 8));
System.out.println("-----------------------");
B b = new B();
//由於B類再也不繼承A類，所以調用者，不會再func1是求減法
//調用完成的功能就會很明確
System.out.println("11+3=" + b.func1(11, 3));//這裏本意是求出11+3
System.out.println("1+8=" + b.func1(1, 8));// 1+8
System.out.println("11+3+9=" + b.func2(11, 3));
//使用組合仍然可使用到A類相關方法
System.out.println("11-3=" + b.func3(11, 3));// 這裏本意是求出11-3
}
}
//建立一個更加基礎的基類
class Base {
//把更加基礎的方法和成員寫到Base類
}
// A類
class A extends Base {
// 返回兩個數的差
public int func1(int num1, int num2) {
return num1 - num2;
}
}
// B類繼承了A
// 增長了一個新功能：完成兩個數相加,而後和9求和
class B extends Base {
//若是B須要使用A類的方法,使用組合關係
private A a = new A();
//這裏，重寫了A類的方法, 多是無心識
public int func1(int a, int b) {
return a + b;
}
public int func2(int a, int b) {
return func1(a, b) + 9;
}
//咱們仍然想使用A的方法
public int func3(int a, int b) {
return this.a.func1(a, b);
}
}
複製代碼
4.4 注意事項和細節
里氏替換原則通俗的來說就是：子類能夠擴展父類的功能，但不能改變父類原有的功能。它包含如下4層含義：
- 子類能夠實現父類的抽象方法，但不能覆蓋父類的非抽象方法。
- 子類中能夠增長本身特有的方法。
- 當子類的方法重載父類的抽象方法時，方法的前置條件（即方法的形參）要比父類方法的輸入參數更寬鬆。
- 放子類的方法實現父類的抽象方法時，方法的後置條件（即方法的返回值）要比父類更嚴格。
五、開閉原則（Open Closed Priciple）
5.1 定義
- 開閉原則是編程中最基礎、最重要的設計原則。
- 一個軟件實體如類、模塊和函數應該對擴展開發（對提供方），對修改關閉（對使用方）。用抽象構建框架，用實現擴展細節。
- 當軟件須要變化時，儘可能經過擴展軟件實體的行爲來實現變化，而不是經過修改已有的代碼來實現變化。
- 編程中遵循其它原則，以及使用設計模式的目的就是遵循開閉原則。
5.2 應用實例
public class Ocp {
public static void main(String[] args) {
//使用看看存在的問題
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Triangle());
}
}
//這是一個用於繪圖的類 [使用方]
class GraphicEditor {
//接收Shape對象，而後根據type，來繪製不一樣的圖形
public void drawShape(Shape s) {
if (s.m_type == 1)
drawRectangle(s);
else if (s.m_type == 2)
drawCircle(s);
else if (s.m_type == 3)
drawTriangle(s);
}
//繪製矩形
public void drawRectangle(Shape r) {
System.out.println(" 繪製矩形 ");
}
//繪製圓形
public void drawCircle(Shape r) {
System.out.println(" 繪製圓形 ");
}
//繪製三角形
public void drawTriangle(Shape r) {
System.out.println(" 繪製三角形 ");
}
}
//Shape類，基類
class Shape {
int m_type;
}
class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
}
class Circle extends Shape {
Circle() {
super.m_type = 2;
}
}
//新增畫三角形
class Triangle extends Shape {
Triangle() {
super.m_type = 3;
}
}
複製代碼
改進方法：把建立Shape類作成抽象類，並提供一個抽象的draw方法，讓子類去實現便可，這樣咱們有新的圖形種類時，只須要讓新的圖形類繼承Shape，並實現draw方法便可，使用方的代碼不須要修改 --> 知足了開閉原則。
public class Ocp {
public static void main(String[] args) {
//使用看看存在的問題
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Triangle());
graphicEditor.drawShape(new OtherGraphic());
}
}
//這是一個用於繪圖的類 [使用方]
class GraphicEditor {
//接收Shape對象，調用draw方法
public void drawShape(Shape s) {
s.draw();
}
}
//Shape類，基類
abstract class Shape {
public abstract void draw();//抽象方法
}
class Rectangle extends Shape {
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 繪製矩形 ");
}
}
class Circle extends Shape {
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 繪製圓形 ");
}
}
//新增畫三角形
class Triangle extends Shape {
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 繪製三角形 ");
}
}
//新增一個圖形
class OtherGraphic extends Shape {
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 繪製其它圖形 ");
}
}
複製代碼
六、迪米特法則（Demeter Principle）
6.1 定義
- 一個對象應該對其餘對象保持最少的瞭解。
- 類與類關係越密切，耦合度越大。
- 迪米特法則又叫最小知道原則，即一個類對本身依賴的類知道的越少越好。也就是說，對於被依賴的類無論多麼複雜，都儘可能將邏輯封裝在類的內部。對外除了提供的public方法，不對外泄露任何信息。
- 迪米特法則還有個更簡單的定義：只與直接的朋友通訊。
- 直接的朋友：每一個對象都會與其餘對象有耦合關係，只要兩個對象之間有耦合關係，咱們就說這兩個對象之間是朋友關係。耦合的方式不少，依賴，關聯，組合，聚合等。其餘，咱們稱出現成員變量，方法參數，方法返回值中的類爲直接的朋友，而出如今局部變量中的類不是直接的朋友。也就是說，陌生的類最好不要以局部變量的形式出如今類的內部。
6.2 應用實例
//客戶端
public class Demeter1 {
public static void main(String[] args) {
//建立了一個 SchoolManager 對象
SchoolManager schoolManager = new SchoolManager();
//輸出學院的員工id 和 學校總部的員工信息
schoolManager.printAllEmployee(new CollegeManager());
}
}
//學校總部員工類
class Employee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
//學院的員工類
class CollegeEmployee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
//管理學院員工的管理類
class CollegeManager {
//返回學院的全部員工
public List<CollegeEmployee> getAllEmployee() {
List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
for (int i = 0; i < 10; i++) { //這裏咱們增長了10個員工到 list
CollegeEmployee emp = new CollegeEmployee();
emp.setId("學院員工id= " + i);
list.add(emp);
}
return list;
}
}
//學校管理類
//分析 SchoolManager 類的直接朋友類有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一個陌生類，這樣違背了 迪米特法則
class SchoolManager {
//返回學校總部的員工
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<Employee>();
for (int i = 0; i < 5; i++) { //這裏咱們增長了5個員工到 list
Employee emp = new Employee();
emp.setId("學校總部員工id= " + i);
list.add(emp);
}
return list;
}
//該方法完成輸出學校總部和學院員工信息(id)
void printAllEmployee(CollegeManager sub) {
//分析問題
//1. 這裏的 CollegeEmployee 不是 SchoolManager的直接朋友
//2. CollegeEmployee 是以局部變量方式出如今 SchoolManager
//3. 違反了 迪米特法則
//獲取到學院員工
List<CollegeEmployee> list1 = sub.getAllEmployee();
System.out.println("------------學院員工------------");
for (CollegeEmployee e : list1) {
System.out.println(e.getId());
}
//獲取到學校總部員工
List<Employee> list2 = this.getAllEmployee();
System.out.println("------------學校總部員工------------");
for (Employee e : list2) {
System.out.println(e.getId());
}
}
}
複製代碼
改進方法：
//客戶端
public class Demeter1 {
public static void main(String[] args) {
System.out.println("~~~使用迪米特法則的改進~~~");
//建立了一個 SchoolManager 對象
SchoolManager schoolManager = new SchoolManager();
//輸出學院的員工id 和 學校總部的員工信息
schoolManager.printAllEmployee(new CollegeManager());
}
}
//學校總部員工類
class Employee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
//學院的員工類
class CollegeEmployee {
private String id;
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
//管理學院員工的管理類
class CollegeManager {
//返回學院的全部員工
public List<CollegeEmployee> getAllEmployee() {
List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
for (int i = 0; i < 10; i++) { //這裏咱們增長了10個員工到 list
CollegeEmployee emp = new CollegeEmployee();
emp.setId("學院員工id= " + i);
list.add(emp);
}
return list;
}
//輸出學院員工的信息
public void printEmployee() {
//獲取到學院員工
List<CollegeEmployee> list1 = getAllEmployee();
System.out.println("------------學院員工------------");
for (CollegeEmployee e : list1) {
System.out.println(e.getId());
}
}
}
//學校管理類
//分析 SchoolManager 類的直接朋友類有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一個陌生類，這樣違背了 迪米特法則
class SchoolManager {
//返回學校總部的員工
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<Employee>();
for (int i = 0; i < 5; i++) { //這裏咱們增長了5個員工到 list
Employee emp = new Employee();
emp.setId("學校總部員工id= " + i);
list.add(emp);
}
return list;
}
//該方法完成輸出學校總部和學院員工信息(id)
void printAllEmployee(CollegeManager sub) {
//分析問題
//1. 將輸出學院的員工方法，封裝到CollegeManager
sub.printEmployee();
//獲取到學校總部員工
List<Employee> list2 = this.getAllEmployee();
System.out.println("------------學校總部員工------------");
for (Employee e : list2) {
System.out.println(e.getId());
}
}
}
複製代碼
6.3 注意事項和細節
- 迪米特法則的核心是下降類之間的耦合。
- 因爲每一個類都減小了沒必要要的依賴，所以迪米特法則只是要求下降類間（對象間）耦合關係，並非要求徹底依賴關係。
七、合成複用原則（Composite Reuse Principle）
原則：儘可能使用合成/聚合的方式，而不是使用繼承。
特別聲明：一、如若文中有錯之處，歡迎大神指出。 二、文章是參考網上一些大神的文章，本身整理出來的，如如有侵權，可聯繫我刪除。
相關文章
- 1. 面向對象七大設計原則
- 2. 面向對象設計七大原則
- 3. 設計模式|面向對象設計的七大原則
- 4. 面向對象設計模式七大設計原則
- 5. 面向對象六大設計原則
- 6. 面向對象設計五大原則
- 7. 面向對象設計六大原則
- 8. 面向對象7大設計原則
- 9. 面向對象五大設計原則
- 10. unity開發程序設計原則（七大面向對象設計原則）
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • JDK13 GA發佈：5大特性解讀
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 面向對象七大設計原則
- 2. 面向對象設計七大原則
- 3. 設計模式|面向對象設計的七大原則
- 4. 面向對象設計模式七大設計原則
- 5. 面向對象六大設計原則
- 6. 面向對象設計五大原則
- 7. 面向對象設計六大原則
- 8. 面向對象7大設計原則
- 9. 面向對象五大設計原則
- 10. unity開發程序設計原則（七大面向對象設計原則）