java real football_Java学习--设计模式之行为型模式（三）
一、空對象模式(Null Object Pattern)
1、概念
在空對象模式(Null Object Pattern)中，一個空對象取代 NULL 對象實例的檢查。Null 對象不是檢查空值，而是反應一個不做任何動作的關系。這樣的 Null 對象也可以在數據不可用的時候提供默認的行為。在空對象模式中，我們創建一個指定各種要執行的操作的抽象類和擴展該類的實體類，還創建一個未對該類做任何實現的空對象類，該空對象類將無縫地使用在需要檢查空值的地方。
2、實例
我們將創建一個定義操作(在這里，是客戶的名稱)的?AbstractCustomer?抽象類，和擴展了?AbstractCustomer?類的實體類。工廠類?CustomerFactory?基于客戶傳遞的名字來返回?RealCustomer?或?NullCustomer?對象。演示類?NullPatternDemo，我們的演示類使用?CustomerFactory?來演示空對象模式的用法。
(1)、創建一個抽象類
public abstract classAbstractCustomer {protectedString name;public abstract booleanisNil();public abstractString getName();
}
(2)、擴展一個執行操作的實體類
public class RealCustomer extendsAbstractCustomer {publicRealCustomer(String name) {this.name =name;
}
@OverridepublicString getName() {returnname;
}
@Overridepublic booleanisNil() {return false;
}
}
(3)、擴展一個不做任何實現的空對象類
public class NullCustomer extendsAbstractCustomer {
@OverridepublicString getName() {return "Not Available in Customer Database";
}
@Overridepublic booleanisNil() {return true;
}
}
(4)、創建?CustomerFactory?類
public classCustomerFactory {public static final String[] names = {"Rob", "Joe", "Julie"};public staticAbstractCustomer getCustomer(String name){for (int i = 0; i < names.length; i++) {if(names[i].equalsIgnoreCase(name)){return newRealCustomer(name);
}
}return newNullCustomer();
}
}
(5)、使用?CustomerFactory，基于客戶傳遞的名字，來獲取?RealCustomer?或?NullCustomer?對象
public classNullPatternDemo {public static voidmain(String[] args) {
AbstractCustomer customer1= CustomerFactory.getCustomer("Rob");
AbstractCustomer customer2= CustomerFactory.getCustomer("Bob");
AbstractCustomer customer3= CustomerFactory.getCustomer("Julie");
AbstractCustomer customer4= CustomerFactory.getCustomer("Laura");
System.out.println("Customers");
System.out.println(customer1.getName());
System.out.println(customer2.getName());
System.out.println(customer3.getName());
System.out.println(customer4.getName());
}
}
(5)、演示結果
1 Customers2 Rob3 Not Available in Customer Database4 Julie5 Not Available in Customer Database
二、策略模式(Strategy Pattern)
1、概念
在策略模式(Strategy Pattern)中，一個類的行為或其算法可以在運行時更改。這種類型的設計模式屬于行為型模式。
2、簡介
意圖：定義一系列的算法,把它們一個個封裝起來, 并且使它們可相互替換。
主要解決：在有多種算法相似的情況下，使用 if...else 所帶來的復雜和難以維護。
何時使用：一個系統有許多許多類，而區分它們的只是他們直接的行為。
如何解決：將這些算法封裝成一個一個的類，任意地替換。
關鍵代碼：實現同一個接口。
優點：
(1)、算法可以自由切換。
(2)、避免使用多重條件判斷。
(3)、擴展性良好。
缺點：
(1)、策略類會增多。
(2)、所有策略類都需要對外暴露。
使用場景：
(1)、如果在一個系統里面有許多類，它們之間的區別僅在于它們的行為，那么使用策略模式可以動態地讓一個對象在許多行為中選擇一種行為。
(2)、一個系統需要動態地在幾種算法中選擇一種。
(3)、如果一個對象有很多的行為，如果不用恰當的模式，這些行為就只好使用多重的條件選擇語句來實現。
注意事項：如果一個系統的策略多于四個，就需要考慮使用混合模式，解決策略類膨脹的問題。
3、實例
我們將創建一個定義活動的?Strategy?接口和實現了?Strategy?接口的實體策略類。Context?是一個使用了某種策略的類。演示類?StrategyPatternDemo，我們的演示類使用?Context?和策略對象來演示 Context 在它所配置或使用的策略改變時的行為變化。
(1)、創建一個接口
public interfaceStrategy {public int doOperation(int num1, intnum2);
}
(2)、創建接口的實現類
public class OperationAdd implementsStrategy{
@Overridepublic int doOperation(int num1, intnum2) {return num1 +num2;
}
}
public class OperationSubstract implementsStrategy{
@Overridepublic int doOperation(int num1, intnum2) {return num1 -num2;
}
}
public class OperationMultiply implementsStrategy{
@Overridepublic int doOperation(int num1, intnum2) {return num1 *num2;
}
}
(3)、創建 Context 類
public classContext {privateStrategy strategy;publicContext(Strategy strategy){this.strategy =strategy;
}public int executeStrategy(int num1, intnum2){returnstrategy.doOperation(num1, num2);
}
}
(4)、使用?Context?來查看當它改變策略?Strategy?時的行為變化。
public classStrategyPatternDemo {public static voidmain(String[] args) {
Context context= new Context(newOperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context= new Context(newOperationSubstract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context= new Context(newOperationMultiply());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
(5)、演示結果
1 10 + 5 = 15
2 10 - 5 = 5
3 10 * 5 = 50
三、模板模式(Template Pattern)
1、概念
在模板模式(Template Pattern)中，一個抽象類公開定義了執行它的方法的方式/模板。它的子類可以按需要重寫方法實現，但調用將以抽象類中定義的方式進行。這種類型的設計模式屬于行為型模式。
2、簡介
意圖：定義一個操作中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。
主要解決：一些方法通用，卻在每一個子類都重新寫了這一方法。
何時使用：有一些通用的方法。
如何解決：將這些通用算法抽象出來。
關鍵代碼：在抽象類實現，其他步驟在子類實現。
優點：
(1)、封裝不變部分，擴展可變部分。
(2)、提取公共代碼，便于維護。
(3)、行為由父類控制，子類實現。
缺點：每一個不同的實現都需要一個子類來實現，導致類的個數增加，使得系統更加龐大。
使用場景：
(1)、有多個子類共有的方法，且邏輯相同。
(2)、重要的、復雜的方法，可以考慮作為模板方法。
注意事項：為防止惡意操作，一般模板方法都加上 final 關鍵詞。
3、實例
我們將創建一個定義操作的?Game?抽象類，其中，模板方法設置為 final，這樣它就不會被重寫。Cricket?和?Football?是擴展了?Game?的實體類，它們重寫了抽象類的方法。演示類 TemplatePatternDemo，我們的演示類使用?Game?來演示模板模式的用法。
(1)、創建一個抽象類，將他的模板方法設置為 final
public abstract classGame {abstract voidinitialize();abstract voidstartPlay();abstract voidendPlay();//模板
public final voidplay(){//初始化游戲
initialize();//開始游戲
startPlay();//結束游戲
endPlay();
}
}
(2)、創建實體游戲類
public class Cricket extendsGame {
@OverridevoidendPlay() {
System.out.println("Cricket Game Finished!");
}
@Overridevoidinitialize() {
System.out.println("Cricket Game Initialized! Start playing.");
}
@OverridevoidstartPlay() {
System.out.println("Cricket Game Started. Enjoy the game!");
}
}
public class Football extendsGame {
@OverridevoidendPlay() {
System.out.println("Football Game Finished!");
}
@Overridevoidinitialize() {
System.out.println("Football Game Initialized! Start playing.");
}
@OverridevoidstartPlay() {
System.out.println("Football Game Started. Enjoy the game!");
}
}
(3)、使用?Game?的模板方法 play() 來演示游戲的定義方式。
public classTemplatePatternDemo {public static voidmain(String[] args) {
Game game= newCricket();
game.play();
System.out.println();
game= newFootball();
game.play();
}
}
(4)、演示結果
1 Cricket Game Initialized!Start playing.2 Cricket Game Started. Enjoy the game!
3 Cricket Game Finished!
4
5 Football Game Initialized!Start playing.6 Football Game Started. Enjoy the game!
7 Football Game Finished!
四、訪問者模式(Visitor Pattern)
1、概念
在訪問者模式(Visitor Pattern)中，我們使用了一個訪問者類，它改變了元素類的執行算法。通過這種方式，元素的執行算法可以隨著訪問者改變而改變。這種類型的設計模式屬于行為型模式。根據模式，元素對象已接受訪問者對象，這樣訪問者對象就可以處理元素對象上的操作。
2、簡介
意圖：主要將數據結構與數據操作分離。
主要解決：穩定的數據結構和易變的操作耦合問題。
何時使用：需要對一個對象結構中的對象進行很多不同的并且不相關的操作，而需要避免讓這些操作"污染"這些對象的類，使用訪問者模式將這些封裝到類中。
如何解決：在被訪問的類里面加一個對外提供接待訪問者的接口。
關鍵代碼：在數據基礎類里面有一個方法接受訪問者，將自身引用傳入訪問者。
應用實例：您在朋友家做客，您是訪問者，朋友接受您的訪問，您通過朋友的描述，然后對朋友的描述做出一個判斷，這就是訪問者模式。
優點：
(1)、符合單一職責原則。
(2)、優秀的擴展性。
(3)、靈活性。
缺點：
(1)、具體元素對訪問者公布細節，違反了迪米特原則。
(2)、具體元素變更比較困難。
(3)、違反了依賴倒置原則，依賴了具體類，沒有依賴抽象。
使用場景：
(1)、對象結構中對象對應的類很少改變，但經常需要在此對象結構上定義新的操作。
(2)、需要對一個對象結構中的對象進行很多不同的并且不相關的操作，而需要避免讓這些操作"污染"這些對象的類，也不希望在增加新操作時修改這些類。
注意事項：訪問者可以對功能進行統一，可以做報表、UI、攔截器與過濾器。
3、實例
我們將創建一個定義接受操作的?ComputerPart?接口。Keyboard、Mouse、Monitor?和?Computer?是實現了?ComputerPart?接口的實體類。我們將定義另一個接口?ComputerPartVisitor，它定義了訪問者類的操作。Computer?使用實體訪問者來執行相應的動作。演示類?VisitorPatternDemo，我們的演示類使用?Computer、ComputerPartVisitor?類來演示訪問者模式的用法。
(1)、定義一個表示元素的接口
public interfaceComputerPart {public voidaccept(ComputerPartVisitor computerPartVisitor);
}
(2)、擴展不同訪問的實體類
public class Keyboard implementsComputerPart {
@Overridepublic voidaccept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public class Monitor implementsComputerPart {
@Overridepublic voidaccept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public class Mouse implementsComputerPart {
@Overridepublic voidaccept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public class Computer implementsComputerPart {
ComputerPart[] parts;publicComputer(){
parts= new ComputerPart[] {new Mouse(), new Keyboard(), newMonitor()};
}
@Overridepublic voidaccept(ComputerPartVisitor computerPartVisitor) {for (int i = 0; i < parts.length; i++) {
parts[i].accept(computerPartVisitor);
}
computerPartVisitor.visit(this);
}
}
(3)、定義一個表示訪問者的接口
public interfaceComputerPartVisitor {public voidvisit(Computer computer);public voidvisit(Mouse mouse);public voidvisit(Keyboard keyboard);public voidvisit(Monitor monitor);
}
(4)、創建實現了上述類的實體訪問者
public class ComputerPartDisplayVisitor implementsComputerPartVisitor {
@Overridepublic voidvisit(Computer computer) {
System.out.println("Displaying Computer.");
}
@Overridepublic voidvisit(Mouse mouse) {
System.out.println("Displaying Mouse.");
}
@Overridepublic voidvisit(Keyboard keyboard) {
System.out.println("Displaying Keyboard.");
}
@Overridepublic voidvisit(Monitor monitor) {
System.out.println("Displaying Monitor.");
}
}
(5)、使用?ComputerPartDisplayVisitor?來顯示?Computer?的組成部分。
public classVisitorPatternDemo {public static voidmain(String[] args) {
ComputerPart computer= newComputer();
computer.accept(newComputerPartDisplayVisitor());
}
}
(6)、演示結果
1 Displaying Mouse.2 Displaying Keyboard.3 Displaying Monitor.4 Displaying Computer.
行為型模式的介紹就到這里了，如有誤，還請各位大佬指正；
總結
以上是生活随笔為你收集整理的java real football_Java学习--设计模式之行为型模式（三）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： mysql 分时统计_mysql中数据统
- 下一篇： java如何做测试数据库_如何模拟用于测