デザインパターン（IXを。コマンド・モード）を参照してください。栄光の王から

栄光の王からデザインモード（コマンドモード）を参照してください。

I.はじめに

栄光の王はチームスポーツゲームです。ある程度良いチーム情報交換、チームの勝利を助けます。、迅速な交換メカニズムを提供するために、栄光の王をスムーズにし、ゲームの利便性を確保するために、いくつかの簡単なチャットボタンがあります王の小さなマップの隣に（後退、攻撃、組み合わせ要求に始まった）、プレイヤーは適切なボタン迅速なチャットをクリックしてコマンドを発行することができますチームメイトとの通信に

II。コマンドモード

モードコマンド（Commandパターン）：コマンド・モードは、異なる要求を使用するためには、キューまたはその他のオブジェクトがパラメータログで、高い凝集モード、オブジェクトにカプセル化「要求」です。コマンドモードも取り消し可能操作がサポートされています。

• コマンドモードの使用シナリオ
  1. フィードバック機構 - トリガー：DOSコマンドシミュレーション時間はもちろん、だけでなく、コマンドモードの使用、限り、あなたはそれがコマンドモードは、例えば、使用できるコマンドだと思うように、GUI開発、ボタンのクリックコマンドがあり、コマンド・モードを使用することができます治療の。
  2. 依頼者と実装者との間の結合は、コマンドを解決するため。
• 関連するコマンドモードの設計原理は以下のとおりです。

1. 各コマンドは、操作ある：つの要求は、要求、実行操作を行い、受信側は、要求を受信し、動作を行います。
2. 依頼者とオープンのない受信者は、その要求当事者が要求を受信する1のインターフェースを知る必要がないこと、要求が受信されたかを知っていないと、操作が行われているかどうか、それが行われた場合、どのように実行されます。
3. キーコマンドモードでは受信者だけ抽象コマンドインタフェースに関連付けられた特定のコマンドを達成するために、抽象コマンド・インターフェースの導入、およびプログラミングのための送信元抽象コマンド・インタフェースです。

• 図ジェネリッククラスコマンドモード：
  

• 関連するコマンドモードの役割は次のとおりです：
  抽象命令（コマンド）：インターフェイスメソッド宣言の実行にはコマンドを定義しています。
  特定の順序（ConcreteCommand）：;通常、受信者があり、操作コマンドを完了するための関数呼び出しの受信者は、実行される特定のコマンドは、メソッドを達成するために実行されるように、それは通常、「仮想」の実装です。
  受信機（レシーバー）：実際のオブジェクトは、コマンドを実行します。任意のクラスは、対応するコマンド機能要件を実現するために限り、達成することができ、受信者になることができます。
  呼び出し側（実行者は）：要求を実行するコマンドオブジェクトを必要とし、通常開催されたコマンドオブジェクトは、コマンドオブジェクトの多くを保持することができます。実際にクライアントトリガコマンドおよび要求コマンドは、コマンドオブジェクトの入り口を使用するのと同じである適切なアクションを実行する場所です。
  クライアント（クライアント）：コマンドは、クライアントを作成し、受信者のコマンドを設定します。
  ---

• コマンドモードの利点：
  1. クラス間のデカップリング：発信者と受信者のキャラクターの役割の間には依存関係はありませんあなたが最後に実行するために受信者を知っている必要はありません。これは、機能を実現することができたときに、呼び出し側は単純に実行する方法コマンド抽象クラスを呼び出します
  2. スケーラビリティ：コマンドサブクラスを簡単に拡張することができ、かつ高いレベルのクライアントモジュール実行者、発信者が深刻なカップリングコードを持っていません。
  3. 他のモードと組み合わせたコマンドモードが良くなります：コマンドモードは、Chain of Responsibilityパターンを組み合わせることができ、家族がタスクを解析するコマンド実現し、テンプレートメソッドパターンを結合し、拡張コマンドを発行サブクラスを低減することができます。

• コマンドモードを欠点：
  コマンドモードは長所と短所があり、参照してください。コマンドのサブクラスは：Nコマンドがある場合は、問題が出てきた、コマンドサブクラスすることができますいくつかではないが、N、この非常に大きなクラスの拡張

III。構造図

IV。図のデザインクラス

V.コードの実装

com.practice.ObserverModuleからパッケージを取り入れ栄光を参照してくださいデザインパターン（オブザーバーパターン）の王
Observerable（抽象ビューアインタフェース）

package com.practice.ObserverModule;
/***
 * 抽象被观察者接口
 * 声明了添加、删除、通知观察者方法
 *
 */

public interface Observerable {
    public void RegisterObserver(Observer o);
    public void RemoveObserver(Observer o);
    public void NotifyObserver();
}

InformMessageクラス（クラスオブザーバー）

package com.practice.ObserverModule;

import java.util.ArrayList;
import java.util.List;

/*
 * 被观察者
*实现了Observerable接口，对Observerable接口的三个方法进行了具体实现
 *
 */
public class InformMessage implements Observerable {
    private String message;
    private String heroName;
    private List<Observer> list;
    
    public InformMessage() {
        list = new ArrayList<Observer>();
    }
    
    public void NotifyObserver() {
        for(int i = 0;i < list.size(); i++) {
            Observer observer = list.get(i);
            observer.update(message);
        }
    }

    public void RegisterObserver(Observer o) {
        list.add(o);
        
    }

    public void RemoveObserver(Observer o) {
        if(!list.isEmpty())
            list.remove(o);
    }

    public void setInformation(String name,Observer o,String message) {
        this.message = message;
        this.heroName = name;
        System.out.println("英雄[" + heroName + "]发出消息:" + message);
        RemoveObserver(o);
        NotifyObserver();
        list.add(o);
    }
}

Observerクラス（抽象クラスオブザーバー）

package com.practice.ObserverModule;

/*
 * 抽象观察者
 * 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
 */

public interface Observer {
    public void update(String message);
}

クラス・ヒーロー（観察に基づきます）

package com.practice.ObserverModule;
/**
 * 观察者
 * 实现了update方法
 *
 */
public class Hero implements Observer{
    private String name;
    private String message;
    
    public Hero(String heroName) {
        this.name = heroName;
    }
    
    public void update(String message) {
        this.message = message;
        read();
    }
    
    public void read() {
        System.out.println(name + "收到消息:" + message);
    }
}

GameInformクラス（クラス受信）

package com.practice.OrderModule;

/*
 * 接收类
 */

public class GameInform {
    public String Attack() {
        return "发起进攻";
    }
    
    public String Retreat() {
        return "开始撤退";
    }
    
    public String Gather() {
        return "请求集合";
    }
}

Commandクラス（抽象クラスコマンドの役割）

package com.practice.OrderModule;

/*
 * 抽象命令角色类
 */

public interface Command {
    public String execute();
}

AttackCommandクラス（クラスの特定の役割）

package com.practice.OrderModule;

/*
 * 具体角色类
 */

public class AttackCommand implements Command{
    private GameInform gameInform;
    
    public AttackCommand(GameInform gameInform) {
        this.gameInform = gameInform;
    }
    
    public String execute() {
        return gameInform.Attack();
    }
}

RetreatCommandクラス（クラスの特定の役割）

package com.practice.OrderModule;

/*
 * 具体角色类
 */

public class RetreatCommand implements Command{
    private GameInform gameInform;
    
    public RetreatCommand(GameInform gameInform) {
        this.gameInform = gameInform;
    }
    
    public String execute() {
        return gameInform.Retreat();
    }

}

GatherCommandクラス（クラスの特定の役割）

package com.practice.OrderModule;

/*
 * 具体角色类
 */

public class GatherCommand implements Command{
    private GameInform gameInform;
    
    public GatherCommand(GameInform gameInform) {
        this.gameInform = gameInform;
    }
    
    public String execute() {
        return gameInform.Gather();
    }
}

キーパッドのクラス（クラスの役割要求）

package com.practice.OrderModule;

/*
 * 请求角色类
 */

public class Keypad {
    private Command AttackCommand;
    private Command RetreatCommand;
    private Command GatherCommand;
    
    public void setAttackCommand(Command AttackCommand) {
        this.AttackCommand = AttackCommand;
    }
    
    public void setRetreatCommand(Command RetreatCommand) {
        this.RetreatCommand = RetreatCommand;
    }
    
    public void setGatherCommand(Command GatherCommand) {
        this.GatherCommand = GatherCommand;
    }
    
    public String Attack() {
        return AttackCommand.execute();
    }
    
    public String Retreat() {
        return RetreatCommand.execute();
    }
    
    public String Gather() {
        return GatherCommand.execute();
    }
}

テストクラス（クラス試験）

package com.practice.Test;

import com.practice.ObserverModule.Hero;
import com.practice.ObserverModule.InformMessage;
import com.practice.ObserverModule.Observer;
import com.practice.OrderModule.AttackCommand;
import com.practice.OrderModule.Command;
import com.practice.OrderModule.GameInform;
import com.practice.OrderModule.GatherCommand;
import com.practice.OrderModule.Keypad;
import com.practice.OrderModule.RetreatCommand;

public class Test {
    public static void main(String [] args) {
        //首先创建被观察者对象
        InformMessage HeroGlory = new InformMessage();
        //创建接收者对象
        GameInform gameInform = new GameInform();
        
        //将接收者对象传入命令对象
        Command attackCommand = new AttackCommand(gameInform);
        Command retreatCommand = new RetreatCommand(gameInform);
        Command gatherCommand = new GatherCommand(gameInform);
        
        //创建请求者对象
        Keypad keypad = new Keypad();
        //把命令传给请求者
        keypad.setAttackCommand(attackCommand);
        keypad.setRetreatCommand(retreatCommand);
        keypad.setGatherCommand(gatherCommand);
        
        //创建观察者对象
        Observer HanXin = new Hero("韩信");
        Observer HouYi = new Hero("后羿");
        Observer DianWei = new Hero("典韦");
        Observer DaJi = new Hero("妲己");
        Observer LiuShan = new Hero("刘禅");
        
        //添加观察者
        HeroGlory.RegisterObserver(HanXin);
        HeroGlory.RegisterObserver(HouYi);
        HeroGlory.RegisterObserver(DianWei);
        HeroGlory.RegisterObserver(DaJi);
        HeroGlory.RegisterObserver(LiuShan);
        
        //1.更新消息 2.调用请求
        HeroGlory.setInformation("妲己",DaJi,keypad.Retreat());
        
        System.out.println("---------------------------------------------------");
        HeroGlory.setInformation("后羿",HouYi,keypad.Gather());
    }
}

業績