No sistema de desenvolvimento de software, muitas vezes há existe um acoplamento estreito entre "método solicitante" e "abordagem implementadores." Esta não é propício para a expansão e manutenção da funcionalidade do software. Por exemplo, querer realizar "desfazer, refazer, ficha" e de processamento é muito inconveniente, por isso "o solicitante eo método de implementação do método é como dissociar?" Se torna muito importante, o modo de comando pode ser uma boa solução este problema.
Na vida real, existem muitos exemplos, por exemplo, o controle remoto da TV (comando remetente) para a TV através do botão de controlo remoto (comando específico) (receptores de comando), bem como "teclas de função" e no teclado do computador.
A definição e as características do modo de comando
modo de comando definido (de comando) são como se segue: encapsular um pedido de um objecto, de modo que a execução do pedido e Responsabilidade solicitando separados. Tal comunicação entre o objeto de comando tão fácil de comando objetos para armazenamento, transferência, recall, e aumentou gestão.
A principal vantagem do modo de comando é a seguinte.
- Reduzir o sistema de acoplamento. operação no modo de comando pode chamar o objeto eo objeto que implementa o desacoplamento da operação.
- Adicionar ou comando de exclusão é muito conveniente. Usando o modo de comando aumenta com o comando de exclusão não afeta as outras classes, que atendem o "princípio de abertura e fechamento" para estender mais flexível.
- Macros podem ser alcançados. Modo de comando pode ser modo combinado em combinação, uma pluralidade de combinações de comando montada em um comando, isto é, um comando de macro.
- Facilitar a realização de operações de desfazer e refazer. Modo de comando pode ser descrito mais tarde com o modo de nota em conjunto com a recuperação de implementar um comando desfazer.
Suas desvantagens são: o comando pode ter numerosa classe específica. Porque a operação de contagem para cada necessidade específica para projetar uma classe comando específico, isso vai aumentar a complexidade do sistema.
Arquitetura e Implementação do modo de comando
A operação do sistema de comando relacionadas pode ser captada para o chamador associado à separação implementador, tem a seguinte estrutura.
1. Estrutura Modelo
modo de comando inclui o seguinte papel importante.
- Abstract comando classe (Command) Papel: declarar uma interface para executar o comando, método abstrato tem que executar comandos execute ().
- papel comando específico (Concrete Command) papel: é uma realização concreta da classe classe Command abstrato, que tem receptores de objeto e função chamando o destinatário para completar o comando de operação a ser executada.
- Realização / Receiver (Receptor) papel: executar a função de comando de operações relacionado é para perceber quem as ordens específicas de objetos de negócios.
- Os / solicitante (Invoker) papéis de chamadas: o pedido do remetente, ele geralmente tem um monte de objeto de comando, e para implementar a solicitação relevante acessando o objeto de comando, ele não acessa diretamente o destinatário.
A estrutura mostrada na Figura 1.
Modo 2. de realização
código de modo de comando é a seguinte:
package command;
public class CommandPattern
{
public static void main(String[] args)
{
Command cmd=new ConcreteCommand();
Invoker ir=new Invoker(cmd);
System.out.println("客户访问调用者的call()方法...");
ir.call();
}
}
//调用者
class Invoker
{
private Command command;
public Invoker(Command command)
{
this.command=command;
}
public void setCommand(Command command)
{
this.command=command;
}
public void call()
{
System.out.println("调用者执行命令command...");
command.execute();
}
}
//抽象命令
interface Command
{
public abstract void execute();
}
//具体命令
class ConcreteCommand implements Command
{
private Receiver receiver;
ConcreteCommand()
{
receiver=new Receiver();
}
public void execute()
{
receiver.action();
}
}
//接收者
class Receiver
{
public void action()
{
System.out.println("接收者的action()方法被调用...");
}
}resultados operacionais do programa são os seguintes:
客户访问调用者的call()方法...
调用者执行命令command...
接收者的action()方法被调用...Exemplos de aplicação do modo de comando
[Exemplo 1] Exemplos conseguir ir ao cliente a um restaurante para comer o pequeno almoço com o modo de comando.
Análise: Os clientes podem optar por ir a um restaurante tendo o pequeno-almoço de arroz, macarrão de arroz e wonton, etc., os clientes podem optar por vários garçom no café da manhã, o garçom pedido do cliente com o chef relevante para fazer. O ponto aqui é equivalente pequeno-almoço "ordem", o garçom é equivalente a "chamador", o equivalente chef do "receptor", é conseguido com o modo de comando apropriado.
Primeiro, definir uma classe pequeno-almoço (café da manhã), que é uma classe abstrata Command, método abstrato cozinhar (), explicar o que fazer e, em seguida, definir subclasses como rolos de arroz (ChangFen), classe ravioli (Huntun) e classe Pho ( HeFen), que é uma classe de comando específico que implementa a cozinhar () da classe pequeno-almoço, mas eles não especificamente, mas ao chef para fazer concreto; classe concreta cozinheiros chefe têm rolos de arroz (ChangFenChef), ravioli eclipse chef ( HunTunChef) e cozinheiro Pho (HeFenChef), que é o receptor do comando, uma vez que o presente exemplo da FIG cozinhar para cozinhar visor ( representações a ser exibido aqui para baixar ), de modo a cozinhar cada sub-classe é definida como Jframe classe e, finalmente, a definição de garçom classe (garçom), que recebe o pedido do cliente para cozinhar, cozinhar e emitir o comando. classe cliente por classe atendente la carte, Fig. 2 é um diagrama de configuração da FIG.
Código é a seguinte:
package command;
import javax.swing.*;
public class CookingCommand
{
public static void main(String[] args)
{
Breakfast food1=new ChangFen();
Breakfast food2=new HunTun();
Breakfast food3=new HeFen();
Waiter fwy=new Waiter();
fwy.setChangFen(food1);//设置肠粉菜单
fwy.setHunTun(food2); //设置河粉菜单
fwy.setHeFen(food3); //设置馄饨菜单
fwy.chooseChangFen(); //选择肠粉
fwy.chooseHeFen(); //选择河粉
fwy.chooseHunTun(); //选择馄饨
}
}
//调用者：服务员
class Waiter
{
private Breakfast changFen,hunTun,heFen;
public void setChangFen(Breakfast f)
{
changFen=f;
}
public void setHunTun(Breakfast f)
{
hunTun=f;
}
public void setHeFen(Breakfast f)
{
heFen=f;
}
public void chooseChangFen()
{
changFen.cooking();
}
public void chooseHunTun()
{
hunTun.cooking();
}
public void chooseHeFen()
{
heFen.cooking();
}
}
//抽象命令：早餐
interface Breakfast
{
public abstract void cooking();
}
//具体命令：肠粉
class ChangFen implements Breakfast
{
private ChangFenChef receiver;
ChangFen()
{
receiver=new ChangFenChef();
}
public void cooking()
{
receiver.cooking();
}
}
//具体命令：馄饨
class HunTun implements Breakfast
{
private HunTunChef receiver;
HunTun()
{
receiver=new HunTunChef();
}
public void cooking()
{
receiver.cooking();
}
}
//具体命令：河粉
class HeFen implements Breakfast
{
private HeFenChef receiver;
HeFen()
{
receiver=new HeFenChef();
}
public void cooking()
{
receiver.cooking();
}
}
//接收者：肠粉厨师
class ChangFenChef extends JFrame
{
private static final long serialVersionUID = 1L;
JLabel l=new JLabel();
ChangFenChef()
{
super("煮肠粉");
l.setIcon(new ImageIcon("src/command/ChangFen.jpg"));
this.add(l);
this.setLocation(30, 30);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}
//接收者：馄饨厨师
class HunTunChef extends JFrame
{
private static final long serialVersionUID=1L;
JLabel l=new JLabel();
HunTunChef()
{
super("煮馄饨");
l.setIcon(new ImageIcon("src/command/HunTun.jpg"));
this.add(l);
this.setLocation(350, 50);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}
//接收者：河粉厨师
class HeFenChef extends JFrame
{
private static final long serialVersionUID=1L;
JLabel l=new JLabel();
HeFenChef()
{
super("煮河粉");
l.setIcon(new ImageIcon("src/command/HeFen.jpg"));
this.add(l);
this.setLocation(200, 280);
this.pack();
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void cooking()
{
this.setVisible(true);
}
}Os resultados da execução do programa mostrado na FIG.
Cenários de comando de modo
modo de comando é normalmente usado na cena.
- Quando o sistema exige que o chamador precisa ser dissociado do pedido receptor, o modo de comando para que o chamador não diretamente interagem e receptor.
- Quando o sistema precisa pedido aleatório ordem ou frequência adicionar ou comando de exclusão, o modo de comando é mais conveniente para implementar essas funções.
- Quando o sistema precisa para executar um conjunto de operações, modo de comando pode ser definida para alcançar esta função macros.
- Quando o sistema tem de suportar comando Anular (Undo) e operação operação de recuperação (refazer), um objecto de comando podem ser armazenados, usando o modo de nota é alcançado.
modo de comando estendido
No desenvolvimento de software, às vezes na frente do modo de comando e aprender combinação modo utilizado em combinação, o que constitui um modo de macro, também chamado modo de comando combinado. Macro comando que compreende um conjunto de comandos, que actua como um duplo papel e comando chamador específico, a chamada recursiva que contém todos os comandos que, quando executado, a sua estrutura específica é mostrado na Figura 3.
Código é a seguinte:
package command;
import java.util.ArrayList;
public class CompositeCommandPattern
{
public static void main(String[] args)
{
AbstractCommand cmd1=new ConcreteCommand1();
AbstractCommand cmd2=new ConcreteCommand2();
CompositeInvoker ir=new CompositeInvoker();
ir.add(cmd1);
ir.add(cmd2);
System.out.println("客户访问调用者的execute()方法...");
ir.execute();
}
}
//抽象命令
interface AbstractCommand
{
public abstract void execute();
}
//树叶构件: 具体命令1
class ConcreteCommand1 implements AbstractCommand
{
private CompositeReceiver receiver;
ConcreteCommand1()
{
receiver=new CompositeReceiver();
}
public void execute()
{
receiver.action1();
}
}
//树叶构件: 具体命令2
class ConcreteCommand2 implements AbstractCommand
{
private CompositeReceiver receiver;
ConcreteCommand2()
{
receiver=new CompositeReceiver();
}
public void execute()
{
receiver.action2();
}
}
//树枝构件: 调用者
class CompositeInvoker implements AbstractCommand
{
private ArrayList<AbstractCommand> children = new ArrayList<AbstractCommand>();
public void add(AbstractCommand c)
{
children.add(c);
}
public void remove(AbstractCommand c)
{
children.remove(c);
}
public AbstractCommand getChild(int i)
{
return children.get(i);
}
public void execute()
{
for(Object obj:children)
{
((AbstractCommand)obj).execute();
}
}
}
//接收者
class CompositeReceiver
{
public void action1()
{
System.out.println("接收者的action1()方法被调用...");
}
public void action2()
{
System.out.println("接收者的action2()方法被调用...");
}
}resultados operacionais do programa são os seguintes:
客户访问调用者的execute()方法...
接收者的action1()方法被调用...
接收者的action2()方法被调用...Claro que, a mesma nota pode comandar Modo (Amnésia) usados em combinação, de modo que torna-se um modo de comando revogável, que será descrito mais tarde.
