目錄
一、設計模式概述
1.1、23種設計模式有哪些？
1.2、軟件設計模式的概念
1.3、學習設計模式的必要性
1.4、設計模式分類
二、UML圖
2.1、類圖概述
2.2、類圖的作用
2.3、類圖表示法
類的表示方式
類與類之間關系的表示方式
關聯關系
聚合關系
組合關系
依賴關系
繼承關系
實現關系
三、軟件設計原則
3.1、開閉原則
3.2、里氏代換原則
3.3、依賴倒轉原則
3.4、接口隔離原則
3.5、迪米特法則
3.6、合成復用原則
一、設計模式概述
1.1、23種設計模式有哪些？
1.2、軟件設計模式的概念
軟件設計模式（Software Design Pattern），又稱設計模式，是一套被反復使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。它描述了在軟件設計過程中的一些不斷重復發(fā)生的問題，以及該問題的解決方案。也就是說，它是解決特定問題的一系列套路，是前輩們的代碼設計經驗的總結，具有一定的普遍性，可以反復使用。
1.3、學習設計模式的必要性
設計模式的本質是面向對象設計原則的實際運用，是對類的封裝性、繼承性和多態(tài)性以及類的關聯關系和組合關系的充分理解。
正確使用設計模式具有以下優(yōu)點：
-
可以提高程序員的思維能力、編程能力和設計能力。
-
使程序設計更加標準化、代碼編制更加工程化，使軟件開發(fā)效率大大提高，從而縮短軟件的開發(fā)周期。
-
使設計的代碼可重用性高、可讀性強、可靠性高、靈活性好、可維護性強。
1.4、設計模式分類
-
創(chuàng)建型模式
用于描述“怎樣創(chuàng)建對象”，它的主要特點是“將對象的創(chuàng)建與使用分離”。GoF（四人組）書中提供了單例、原型、工廠方法、抽象工廠、建造者等 5 種創(chuàng)建型模式。
-
結構型模式
用于描述如何將類或對象按某種布局組成更大的結構，GoF（四人組）書中提供了代理、適配器、橋接、裝飾、外觀、享元、組合等 7 種結構型模式。
-
行為型模式
用于描述類或對象之間怎樣相互協作共同完成單個對象無法單獨完成的任務，以及怎樣分配職責。GoF（四人組）書中提供了模板方法、策略、命令、職責鏈、狀態(tài)、觀察者、中介者、迭代器、訪問者、備忘錄、解釋器等 11 種行為型模式。
二、UML圖
統(tǒng)一建模語言（Unified Modeling Language，UML）是用來設計軟件的可視化建模語言。它的特點是簡單、統(tǒng)一、圖形化、能表達軟件設計中的動態(tài)與靜態(tài)信息。
UML 從目標系統(tǒng)的不同角度出發(fā)，定義了用例圖、類圖、對象圖、狀態(tài)圖、活動圖、時序圖、協作圖、構件圖、部署圖等 9 種圖。
2.1、類圖概述
類圖(Class diagram)是顯示了模型的靜態(tài)結構，特別是模型中存在的類、類的內部結構以及它們與其他類的關系等。類圖不顯示暫時性的信息。類圖是面向對象建模的主要組成部分。
2.2、類圖的作用
-
在軟件工程中，類圖是一種靜態(tài)的結構圖，描述了系統(tǒng)的類的集合，類的屬性和類之間的關系，可以簡化了人們對系統(tǒng)的理解；
-
類圖是系統(tǒng)分析和設計階段的重要產物，是系統(tǒng)編碼和測試的重要模型。
2.3、類圖表示法
類的表示方式
在UML類圖中，類使用包含類名、屬性(field) 和方法(method) 且?guī)в蟹指罹€的矩形來表示，比如下圖表示一個Employee類，它包含name,age和address這3個屬性，以及work()方法。
屬性/方法名稱前加的加號和減號表示了這個屬性/方法的可見性，UML類圖中表示可見性的符號有三種：
-
+：表示public
-
-：表示private
-
#：表示protected
屬性的完整表示方式是： 可見性 名稱 ：類型 [ = 缺省值]
方法的完整表示方式是： 可見性 名稱(參數列表) [ ： 返回類型]
注意：
1、中括號中的內容表示是可選的。
2、也有將類型放在變量名前面，返回值類型放在方法名前面。
上圖Demo類定義了三個方法：
-
method()方法：修飾符為public，沒有參數，沒有返回值。
-
method1()方法：修飾符為private，沒有參數，返回值類型為String。
-
method2()方法：修飾符為protected，接收兩個參數，第一個參數類型為int，第二個參數類型為String，返回值類型是int。
類與類之間關系的表示方式
關聯關系
關聯關系是對象之間的一種引用關系，用于表示一類對象與另一類對象之間的聯系，如老師和學生、師傅和徒弟、丈夫和妻子等。關聯關系是類與類之間最常用的一種關系，分為一般關聯關系、聚合關系和組合關系。我們先介紹一般關聯。
關聯又可以分為單向關聯，雙向關聯，自關聯。
1、單向關聯
在UML類圖中單向關聯用一個帶箭頭的實線表示。上圖表示每個顧客都有一個地址，這通過讓Customer類持有一個類型為Address的成員變量類實現。
2、雙向關聯
從上圖中我們很容易看出，所謂的雙向關聯就是雙方各自持有對方類型的成員變量。
在UML類圖中，雙向關聯用一個不帶箭頭的直線表示。上圖中在Customer類中維護一個List<Product>，表示一個顧客可以購買多個商品；在Product類中維護一個Customer類型的成員變量表示這個產品被哪個顧客所購買。
3、自關聯
自關聯在UML類圖中用一個帶有箭頭且指向自身的線表示。上圖的意思就是Node類包含類型為Node的成員變量，也就是“自己包含自己”。
聚合關系
聚合關系是關聯關系的一種，是強關聯關系，是整體和部分之間的關系。
聚合關系也是通過成員對象來實現的，其中成員對象是整體對象的一部分，但是成員對象可以脫離整體對象而獨立存在。例如，學校與老師的關系，學校包含老師，但如果學校停辦了，老師依然存在。
在 UML 類圖中，聚合關系可以用帶空心菱形的實線來表示，菱形指向整體。下圖所示是大學和教師的關系圖：
組合關系
組合表示類之間的整體與部分的關系，但它是一種更強烈的聚合關系。
在組合關系中，整體對象可以控制部分對象的生命周期，一旦整體對象不存在，部分對象也將不存在，部分對象不能脫離整體對象而存在。例如，頭和嘴的關系，沒有了頭，嘴也就不存在了。
在 UML 類圖中，組合關系用帶實心菱形的實線來表示，菱形指向整體。下圖所示是頭和嘴的關系圖：
依賴關系
依賴關系是一種使用關系，它是對象之間耦合度最弱的一種關聯方式，是臨時性的關聯。在代碼中，某個類的方法通過局部變量、方法的參數或者對靜態(tài)方法的調用來訪問另一個類（被依賴類）中的某些方法來完成一些職責。
在 UML 類圖中，依賴關系使用帶箭頭的虛線來表示，箭頭從使用類指向被依賴的類。下圖所示是司機和汽車的關系圖，司機駕駛汽車：
繼承關系
繼承關系是對象之間耦合度最大的一種關系，表示一般與特殊的關系，是父類與子類之間的關系，是一種繼承關系。
在 UML 類圖中，泛化關系用帶空心三角箭頭的實線來表示，箭頭從子類指向父類。在代碼實現時，使用面向對象的繼承機制來實現泛化關系。例如，Student 類和 Teacher 類都是 Person 類的子類，其類圖如下圖所示：
實現關系
實現關系是接口與實現類之間的關系。在這種關系中，類實現了接口，類中的操作實現了接口中所聲明的所有的抽象操作。
在 UML 類圖中，實現關系使用帶空心三角箭頭的虛線來表示，箭頭從實現類指向接口。例如，汽車和船實現了交通工具，其類圖如圖 9 所示。
三、軟件設計原則
在軟件開發(fā)中，為了提高軟件系統(tǒng)的可維護性和可復用性，增加軟件的可擴展性和靈活性，程序員要盡量根據6條原則來開發(fā)程序，從而提高軟件開發(fā)效率、節(jié)約軟件開發(fā)成本和維護成本。
3.1、開閉原則
對擴展開放，對修改關閉。在程序需要進行拓展的時候，不能去修改原有的代碼，實現一個熱插拔的效果。簡言之，是為了使程序的擴展性好，易于維護和升級。
想要達到這樣的效果，我們需要使用接口和抽象類。
因為抽象靈活性好，適應性廣，只要抽象的合理，可以基本保持軟件架構的穩(wěn)定。而軟件中易變的細節(jié)可以從抽象派生來的實現類來進行擴展，當軟件需要發(fā)生變化時，只需要根據需求重新派生一個實現類來擴展就可以了。
下面以 搜狗輸入法 的皮膚為例介紹開閉原則的應用。
【例】搜狗輸入法 的皮膚設計。
分析：搜狗輸入法 的皮膚是輸入法背景圖片、窗口顏色和聲音等元素的組合。用戶可以根據自己的喜愛更換自己的輸入法的皮膚，也可以從網上下載新的皮膚。這些皮膚有共同的特點，可以為其定義一個抽象類（AbstractSkin），而每個具體的皮膚（DefaultSpecificSkin和HeimaSpecificSkin）是其子類。用戶窗體可以根據需要選擇或者增加新的主題，而不需要修改原代碼，所以它是滿足開閉原則的。
代碼實現：
/**
* @version v1.0
* @ClassName: AbstractSkin
* @Description: 抽象皮膚類
* @Author: 黑馬程序員
*/
public abstract class AbstractSkin {
//顯示的方法
public abstract void display();
}/**
* @version v1.0
* @ClassName: DefaultSkin
* @Description: 默認皮膚類
* @Author: 黑馬程序員
*/
public class DefaultSkin extends AbstractSkin {
public void display() {
System.out.println("默認皮膚");
}
}
/**
* @version v1.0
* @ClassName: HeimaSkin
* @Description: 黑馬程序員皮膚
* @Author: 黑馬程序員
*/
public class HeimaSkin extends AbstractSkin {
public void display() {
System.out.println("黑馬皮膚");
}
}/**
* @version v1.0
* @ClassName: SougouInput
* @Description: 搜狗輸入法
* @Author: 黑馬程序員
*/
public class SougouInput {
private AbstractSkin skin;
public void setSkin(AbstractSkin skin) {
this.skin = skin;
}
public void display() {
skin.display();
}
}/**
* @version v1.0
* @ClassName: Client
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class Client {
public static void main(String[] args) {
//1,創(chuàng)建搜狗輸入法對象
SougouInput input = new SougouInput();
//2,創(chuàng)建皮膚對象
//DefaultSkin skin = new DefaultSkin();
HeimaSkin skin = new HeimaSkin();
//3,將皮膚設置到輸入法中
input.setSkin(skin);
//4,顯示皮膚
input.display();
}
}
3.2、里氏代換原則
里氏代換原則是面向對象設計的基本原則之一。
里氏代換原則：任何基類可以出現的地方，子類一定可以出現。通俗理解：子類可以擴展父類的功能，但不能改變父類原有的功能。換句話說，子類繼承父類時，除添加新的方法完成新增功能外，盡量不要重寫父類的方法。
如果通過重寫父類的方法來完成新的功能，這樣寫起來雖然簡單，但是整個繼承體系的可復用性會比較差，特別是運用多態(tài)比較頻繁時，程序運行出錯的概率會非常大。
下面看一個里氏替換原則中經典的一個例子
【例】正方形不是長方形。
在數學領域里，正方形毫無疑問是長方形，它是一個長寬相等的長方形。所以，我們開發(fā)的一個與幾何圖形相關的軟件系統(tǒng)，就可以順理成章的讓正方形繼承自長方形。
代碼實現：
/**
* @version v1.0
* @ClassName: Rectangle
* @Description: 長方形類
* @Author: 黑馬程序員
*/
public class Rectangle {
private double length;
private double width;
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
}/**
* @version v1.0
* @ClassName: Square
* @Description: 正方形類
* @Author: 黑馬程序員
*/
public class Square extends Rectangle {
@Override
public void setLength(double length) {
super.setLength(length);
super.setWidth(length);
}
@Override
public void setWidth(double width) {
super.setLength(width);
super.setWidth(width);
}
}/**
* @version v1.0
* @ClassName: RectangleDemo
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class RectangleDemo {
public static void main(String[] args) {
//創(chuàng)建長方形對象
Rectangle r = new Rectangle();
//設置長和寬
r.setLength(20);
r.setWidth(10);
//調用resize方法進行擴寬
resize(r);
printLengthAndWidth(r);
System.out.println("==================");
//創(chuàng)建正方形對象
Square s = new Square();
//設置長和寬
s.setLength(10);
//調用resize方法進行擴寬
resize(s);
printLengthAndWidth(s);
}
//擴寬方法
public static void resize(Rectangle rectangle) {
//判斷寬如果比長小，進行擴寬的操作
while(rectangle.getWidth() <= rectangle.getLength()) {
rectangle.setWidth(rectangle.getWidth() + 1);
}
}
//打印長和寬
public static void printLengthAndWidth(Rectangle rectangle) {
System.out.println(rectangle.getLength());
System.out.println(rectangle.getWidth());
}
}我們運行一下這段代碼就會發(fā)現，假如我們把一個普通長方形作為參數傳入resize方法，就會看到長方形寬度逐漸增長的效果，當寬度大于長度,代碼就會停止，這種行為的結果符合我們的預期；假如我們再把一個正方形作為參數傳入resize方法后，就會看到正方形的寬度和長度都在不斷增長，代碼會一直運行下去，直至系統(tǒng)產生溢出錯誤。所以，普通的長方形是適合這段代碼的，正方形不適合。 我們得出結論：在resize方法中，Rectangle類型的參數是不能被Square類型的參數所代替，如果進行了替換就得不到預期結果。因此，Square類和Rectangle類之間的繼承關系違反了里氏代換原則，它們之間的繼承關系不成立，正方形不是長方形。
如何改進呢？此時我們需要重新設計他們之間的關系。抽象出來一個四邊形接口(Quadrilateral)，讓Rectangle類和Square類實現Quadrilateral接口
改造代碼后：
/**
* @version v1.0
* @ClassName: Quadrilateral
* @Description: 四邊形接口
* @Author: 黑馬程序員
*/
public interface Quadrilateral {
//獲取長
double getLength();
//獲取寬
double getWidth();
}/**
* @version v1.0
* @ClassName: Rectangle
* @Description: 長方形類
* @Author: 黑馬程序員
*/
public class Rectangle implements Quadrilateral {
private double length;
private double width;
public void setLength(double length) {
this.length = length;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public double getWidth() {
return width;
}
}/**
* @version v1.0
* @ClassName: Square
* @Description: 正方形
* @Author: 黑馬程序員
*/
public class Square implements Quadrilateral {
private double side;
public double getSide() {
return side;
}
public void setSide(double side) {
this.side = side;
}
public double getLength() {
return side;
}
public double getWidth() {
return side;
}
}/**
* @version v1.0
* @ClassName: RectangleDemo
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class RectangleDemo {
public static void main(String[] args) {
//創(chuàng)建長方形對象
Rectangle r = new Rectangle();
r.setLength(20);
r.setWidth(10);
//調用方法進行擴寬操作
resize(r);
printLengthAndWidth(r);
}
//擴寬的方法
public static void resize(Rectangle rectangle) {
//判斷寬如果比長小，進行擴寬的操作
while(rectangle.getWidth() <= rectangle.getLength()) {
rectangle.setWidth(rectangle.getWidth() + 1);
}
}
//打印長和寬
public static void printLengthAndWidth(Quadrilateral quadrilateral) {
System.out.println(quadrilateral.getLength());
System.out.println(quadrilateral.getWidth());
}
}3.3、依賴倒轉原則
高層模塊不應該依賴低層模塊，兩者都應該依賴其抽象；抽象不應該依賴細節(jié)，細節(jié)應該依賴抽象。簡單的說就是要求對抽象進行編程，不要對實現進行編程，這樣就降低了客戶與實現模塊間的耦合。
下面看一個例子來理解依賴倒轉原則
【例】組裝電腦
現要組裝一臺電腦，需要配件cpu，硬盤，內存條。只有這些配置都有了，計算機才能正常的運行。選擇cpu有很多選擇，如Intel，AMD等，硬盤可以選擇希捷，西數等，內存條可以選擇金士頓，海盜船等。
類圖如下：
代碼實現：
/**
* @version v1.0
* @ClassName: HardDisk
* @Description: 硬盤接口
* @Author: 黑馬程序員
*/
public interface HardDisk {
//存儲數據
public void save(String data);
//獲取數據
public String get();
}/**
* @version v1.0
* @ClassName: Cpu
* @Description: cpu接口
* @Author: 黑馬程序員
*/
public interface Cpu {
//運行cpu
public void run();
}/**
* @version v1.0
* @ClassName: Memory
* @Description: 內存條接口
* @Author: 黑馬程序員
*/
public interface Memory {
public void save();
}/**
* @version v1.0
* @ClassName: XiJieHardDisk
* @Description: 希捷硬盤
* @Author: 黑馬程序員
*/
public class XiJieHardDisk implements HardDisk {
//存儲數據的方法
public void save(String data) {
System.out.println("使用希捷硬盤存儲數據為：" + data);
}
//獲取數據的方法
public String get() {
System.out.println("使用希捷希捷硬盤取數據");
return "數據";
}
}/**
* @version v1.0
* @ClassName: IntelCpu
* @Description: Intel cpu
* @Author: 黑馬程序員
*/
public class IntelCpu implements Cpu {
public void run() {
System.out.println("使用Intel處理器");
}
}/**
* @version v1.0
* @ClassName: KingstonMemory
* @Description: 金士頓內存條類
* @Author: 黑馬程序員
*/
public class KingstonMemory implements Memory {
public void save() {
System.out.println("使用金士頓內存條");
}
}/**
* @version v1.0
* @ClassName: Computer
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class Computer {
private HardDisk hardDisk;
private Cpu cpu;
private Memory memory;
public HardDisk getHardDisk() {
return hardDisk;
}
public void setHardDisk(HardDisk hardDisk) {
this.hardDisk = hardDisk;
}
public Cpu getCpu() {
return cpu;
}
public void setCpu(Cpu cpu) {
this.cpu = cpu;
}
public Memory getMemory() {
return memory;
}
public void setMemory(Memory memory) {
this.memory = memory;
}
//運行計算機
public void run() {
System.out.println("運行計算機");
String data = hardDisk.get();
System.out.println("從硬盤上獲取的數據是：" + data);
cpu.run();
memory.save();
}
}/**
* @version v1.0
* @ClassName: ComputerDemo
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class ComputerDemo {
public static void main(String[] args) {
//創(chuàng)建計算機的組件對象
HardDisk hardDisk = new XiJieHardDisk();
Cpu cpu = new IntelCpu();
Memory memory = new KingstonMemory();
//創(chuàng)建計算機對象
Computer c = new Computer();
//組裝計算機
c.setCpu(cpu);
c.setHardDisk(hardDisk);
c.setMemory(memory);
//運行計算機
c.run();
}
}
3.4、接口隔離原則
客戶端不應該被迫依賴于它不使用的方法；一個類對另一個類的依賴應該建立在最小的接口上。
下面看一個例子來理解接口隔離原則
【例】安全門案例
我們需要創(chuàng)建一個黑馬品牌的安全門，該安全門具有防火、防水、防盜的功能?？梢詫⒎阑穑浪?，防盜功能提取成一個接口，形成一套規(guī)范。類圖如下：
我們創(chuàng)建接口，具有防火防盜防水方法，再創(chuàng)建實現類實現此接口，勢必要重寫三個方法，這就違背了接口隔離原則，因為創(chuàng)建三個接口，防火接口、防水接口、防盜接口，實現類想重寫哪個就實現哪個接口。
上面的設計我們發(fā)現了它存在的問題，黑馬品牌的安全門具有防盜，防水，防火的功能?，F在如果我們還需要再創(chuàng)建一個傳智品牌的安全門，而該安全門只具有防盜、防水功能呢？很顯然如果實現SafetyDoor接口就違背了接口隔離原則，那么我們如何進行修改呢？看如下類圖：
/**
* @version v1.0
* @ClassName: AntiTheft
* @Description: 防盜接口
* @Author: 黑馬程序員
*/
public interface AntiTheft {
void antiTheft();
}/**
* @version v1.0
* @ClassName: Fireproof
* @Description: 防火接口
* @Author: 黑馬程序員
*/
public interface Fireproof {
void fireproof();
}/**
* @version v1.0
* @ClassName: Waterproof
* @Description: 防水接口
* @Author: 黑馬程序員
*/
public interface Waterproof {
void waterproof();
}/**
* @version v1.0
* @ClassName: HeiMaSafetyDoor
* @Description: 黑馬安全門
* @Author: 黑馬程序員
*/
public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof {
public void antiTheft() {
System.out.println("防盜");
}
public void fireproof() {
System.out.println("防火");
}
public void waterproof() {
System.out.println("防水");
}
}/**
* @version v1.0
* @ClassName: ItcastSafetyDoor
* @Description: 傳智安全門
* @Author: 黑馬程序員
*/
public class ItcastSafetyDoor implements AntiTheft,Fireproof {
public void antiTheft() {
System.out.println("防盜");
}
public void fireproof() {
System.out.println("防火");
}
}/**
* @version v1.0
* @ClassName: Client
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class Client {
public static void main(String[] args) {
//創(chuàng)建黑馬安全門對象
HeimaSafetyDoor door = new HeimaSafetyDoor();
//調用功能
door.antiTheft();
door.fireProof();
door.waterProof();
System.out.println("============");
//創(chuàng)建傳智安全門對象
ItcastSafetyDoor door1 = new ItcastSafetyDoor();
//調用功能
door1.antiTheft();
door1.fireproof();
}
}
3.5、迪米特法則
迪米特法則又叫最少知識原則。
只和你的直接朋友交談，不跟“陌生人”說話（Talk only to your immediate friends and not to strangers）。
其含義是：如果兩個軟件實體無須直接通信，那么就不應當發(fā)生直接的相互調用，可以通過第三方轉發(fā)該調用。其目的是降低類之間的耦合度，提高模塊的相對獨立性。
迪米特法則中的“朋友”是指：當前對象本身、當前對象的成員對象、當前對象所創(chuàng)建的對象、當前對象的方法參數等，這些對象同當前對象存在關聯、聚合或組合關系，可以直接訪問這些對象的方法。
下面看一個例子來理解迪米特法則
【例】明星與經紀人的關系實例
明星由于全身心投入藝術，所以許多日常事務由經紀人負責處理，如和粉絲的見面會，和媒體公司的業(yè)務洽淡等。這里的經紀人是明星的朋友，而粉絲和媒體公司是陌生人，所以適合使用迪米特法則。
類圖如下：
代碼如下：
/**
* @version v1.0
* @ClassName: Star
* @Description: 明星類
* @Author: 黑馬程序員
*/
public class Star {
// 明星姓名
private String name;
public Star(String name) {
this.name = name;
}
public String getName() {
return name;
}
}/**
* @version v1.0
* @ClassName: Fans
* @Description: 粉絲類
* @Author: 黑馬程序員
*/
public class Fans {
// 粉絲姓名
private String name;
public String getName() {
return name;
}
public Fans(String name) {
this.name = name;
}
}/**
* @version v1.0
* @ClassName: Company
* @Description: 媒體公司類
* @Author: 黑馬程序員
*/
public class Company {
// 公司名
private String name;
public String getName() {
return name;
}
public Company(String name) {
this.name = name;
}
}
/**
* @version v1.0
* @ClassName: Agent
* @Description: 經紀人類
* @Author: 黑馬程序員
*/
public class Agent {
private Star star;
private Fans fans;
private Company company;
public void setStar(Star star) {
this.star = star;
}
public void setFans(Fans fans) {
this.fans = fans;
}
public void setCompany(Company company) {
this.company = company;
}
//和粉絲見面的方法
public void meeting() {
System.out.println(star.getName() + "和粉絲" + fans.getName() + "見面");
}
//和媒體公司洽談的方法
public void business() {
System.out.println(star.getName() + "和" + company.getName() + "洽談");
}
}/**
* @version v1.0
* @ClassName: Client
* @Description: TODO(一句話描述該類的功能)
* @Author: 黑馬程序員
*/
public class Client {
public static void main(String[] args) {
//創(chuàng)建經紀人類
Agent agent = new Agent();
//創(chuàng)建明星對象
Star star = new Star("林青霞");
agent.setStar(star);
//創(chuàng)建粉絲對象
Fans fans = new Fans("李四");
agent.setFans(fans);
//創(chuàng)建媒體公司對象
Company company = new Company("黑馬媒體公司");
agent.setCompany(company);
agent.meeting();//和粉絲見面
agent.business();//和媒體公司洽談業(yè)務
}
}
3.6、合成復用原則
合成復用原則是指：盡量先使用組合或者聚合等關聯關系來實現，其次才考慮使用繼承關系來實現。
通常類的復用分為繼承復用和合成復用兩種。
繼承復用雖然有簡單和易實現的優(yōu)點，但它也存在以下缺點：
-
繼承復用破壞了類的封裝性。因為繼承會將父類的實現細節(jié)暴露給子類，父類對子類是透明的，所以這種復用又稱為“白箱”復用。
-
子類與父類的耦合度高。父類的實現的任何改變都會導致子類的實現發(fā)生變化，這不利于類的擴展與維護。
-
它限制了復用的靈活性。從父類繼承而來的實現是靜態(tài)的，在編譯時已經定義，所以在運行時不可能發(fā)生變化。
采用組合或聚合復用時，可以將已有對象納入新對象中，使之成為新對象的一部分，新對象可以調用已有對象的功能，它有以下優(yōu)點：
-
它維持了類的封裝性。因為成分對象的內部細節(jié)是新對象看不見的，所以這種復用又稱為“黑箱”復用。
-
對象間的耦合度低?？梢栽陬惖某蓡T位置聲明抽象。
-
復用的靈活性高。這種復用可以在運行時動態(tài)進行，新對象可以動態(tài)地引用與成分對象類型相同的對象。
下面看一個例子來理解合成復用原則
【例】汽車分類管理程序
汽車按“動力源”劃分可分為汽油汽車、電動汽車等；按“顏色”劃分可分為白色汽車、黑色汽車和紅色汽車等。如果同時考慮這兩種分類，其組合就很多。類圖如下：
從上面類圖我們可以看到使用繼承復用產生了很多子類，如果現在又有新的動力源或者新的顏色的話，就需要再定義新的類。我們試著將繼承復用改為聚合復用看一下。文章來源：http://www.zghlxwxcb.cn/news/detail-805786.html
文章來源地址http://www.zghlxwxcb.cn/news/detail-805786.html
到了這里，關于黑馬程序員 Java設計模式學習筆記（一）的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！
