Modo de comando do padrão de design java (13)

A vida só pode estar na estrada, os sonhos só podem estar na frente, não há problema com a mente e a estrada é honesta e a atitude certa pode tornar sua vida mais calma e confortável. Claro, a mentalidade é ajustada por você mesmo, contanto que você esteja disposto, você pode se dar uma mentalidade correta, enquanto você estiver disposto, você pode mantê-la.

Aprendizagem de padrões de design, vou postar um blog sobre 23 padrões de design em um futuro próximo , fique ligado ~ -
2021/1/16

definição

Em sistemas de software, " solicitantes de comportamento " e " implementadores de comportamento " geralmente apresentam um tipo de " acoplamento estreito ". Mas em algumas situações, como "gravar, desfazer / refazer, transação" e outro processamento de comportamento, esse tipo de acoplamento forte que não pode resistir a mudanças é inadequado. Nesse caso, como separar o "solicitante de comportamento" do "implementador de comportamento"? Abstraia um conjunto de comportamentos como objetos para obter um acoplamento fraco entre os dois. Este é o padrão de comando

Enciclopédia Baidu

Análise do modo de comando

• A essência do modo de comando é encapsular o comando e separar a responsabilidade de emitir o comando da responsabilidade de executá-lo.
• Cada comando é uma operação: a parte solicitante envia uma solicitação para realizar uma operação; a parte receptora recebe a solicitação e executa a operação.
• O modo de comando permite que a parte solicitante e a parte receptora sejam independentes, de modo que a parte solicitante não precise saber a interface da parte receptora, muito menos como a solicitação foi recebida e se a operação foi executada, quando, e como executado.
• O modo de comando torna a própria solicitação um objeto, que pode ser armazenado e transmitido como outros objetos.
• A chave para o modo de comando é a introdução de uma interface de comando abstrata, e o remetente é programado para a interface de comando abstrata.Apenas comandos específicos que implementam a interface de comando abstrata podem ser associados ao receptor.

Entendimento simples: Se você
quiser ir para a guerra, o general dará uma ordem ao soldado para executar a ordem. O general não lidará diretamente com o soldado e irá 'conectar' o general e o soldado através da ordem.

Análise de papel

• ICommand é usado para definir a interface de comando
• Soldados referem-se a soldados para implementar a interface de comando ICommand
• Admiral refere-se à integração geral da interface de comando ICommand para enviar comandos
• CommandContent refere - se ao conteúdo específico do comando

UML类图(1.1):

Requisitos do projeto

Por exemplo, agora existem:

• computador
• televisão
• Celular
• ar condicionado

Espere pelos eletrodomésticos, cada eletrodoméstico corresponde a um controle remoto, por exemplo, existem 4 tipos de eletrodomésticos, então existem 4 tipos de controles remotos, o que é muito problemático, e o modo de comando pode combinar esses 4 tipos de casa eletrodomésticos em um controle remoto. Use um controle remoto para controlar esses quatro eletrodomésticos.

效果图(2.1):

Envie um comando por meio do controle remoto e o produto correspondente realizará a função correspondente, como clicar no botão TV para ligar a TV e outras operações

Código

ICommand (interface de comando):

public interface ICommand {
    
    
    //开始
    public void start();

    //撤回
    public void withdraw();
}

CommandContent (conteúdo específico do comando):

public class CommandContent {
    
    
    String type;
    
    //传递的是家电 比如说电视 
    public CommandContent(String type) {
    
    
        this.type = type;
    }
    public void on(){
    
    
        Log.i("命令模式",type+"  打开了~ ");
    }
    public void off(){
    
    
        Log.i("命令模式",type+"  关闭了~ ");
    }
}

TvOffCommand, interface de implementação específica (TV desligada):

public class TvOffCommand implements ICommand{
    
    

    CommandContent dispatchOrders;

    public TvOffCommand(CommandContent dispatchOrders) {
    
    
        this.dispatchOrders = dispatchOrders;
    }
    @Override
    public void start() {
    
    
  		  //如果点击关闭,执行关闭命令
        dispatchOrders.off();
    }
    @Override
    public void withdraw() {
    
    
  		  //点击撤销,执行打开命令 
        dispatchOrders.on();
    }
}

TvOnCommand, interface de implementação específica (TV on):

public class TvOnCommand implements ICommand{
    
    
    CommandContent dispatchOrders;

    public TvOnCommand(CommandContent dispatchOrders) {
    
    
        this.dispatchOrders = dispatchOrders;
    }
    @Override
    public void start() {
    
    
 		//如果点击打开,执行打开命令
        dispatchOrders.on();
    }
    @Override
    public void withdraw() {
    
    
 		  //点击撤销,执行关闭命令
        dispatchOrders.off();
    }
}

NoCommand (comando vazio, usado para a primeira inicialização, porque a primeira vez não é aberta nem fechada):

public class NoCommand implements ICommand{
    
    
    @Override
    public void start() {
    
    
    }

    @Override
    public void withdraw() {
    
    
    }
}

CallCommand (chamador de comando):

public class CallCommand {
    
    

   	//开命令
    ICommand[] tvOnCommand;

    //关命令
    ICommand[] tvOffCommand;

    //记录当前存放的命令 用来撤回
    ICommand currentCommand;

	//默认可存放5条命令
    int number = 5;

	//初始化命令
    public CallCommand() {
    
    
        tvOnCommand = new ICommand[number];
        tvOffCommand = new ICommand[number];

        for (int i = 0; i < number; i++) {
    
    
          //先默认为空的命令
            tvOnCommand[i] = new NoCommand();
            tvOffCommand[i] = new NoCommand();
        }
    }

    /**
     * @param index        当前存放的下标
     * @param OnCommand  开始下标
     * @param OffCommand 结束下标
     */
    public void setTvOnCommand(int index, ICommand OnCommand, ICommand OffCommand) {
    
    
        this.tvOnCommand[index] = OnCommand;
        this.tvOffCommand[index] = OffCommand;
    }

    /**
     * @param index 命令下标
     */
    public void getOnCommand(int index) {
    
    
        this.tvOnCommand[index].start();
        //记录当前命令
        currentCommand =  this.tvOnCommand[index];
    }

    /**
     * @param index 命令下标
     */
    public void getOffCommand(int index) {
    
    
        this.tvOffCommand[index].start();
        //记录当前命令
        currentCommand =  this.tvOffCommand[index];
    }

    /**
     * 撤回
     */
    public void getWithdraw() {
    
    
        currentCommand.withdraw();
    }
}

Código de teste (cliente):

		//创建打开电视机命令具体内容
        CommandContent commandContent1 = new CommandContent("电视机");

        //初始化电视机开关命令
        TvOnCommand tvOnCommand = new TvOnCommand(commandContent1);
        TvOffCommand tvOffCommand = new TvOffCommand(commandContent1);

        //创建遥控器
        CallCommand callCommand = new CallCommand();
        //给遥控器初始化电视机开关命令
        callCommand.setTvOnCommand(0,tvOnCommand,tvOffCommand);

        //调用遥控器打开命令
        callCommand.getOnCommand(0);

        //调用遥控器关闭命令
        callCommand.getOffCommand(0);

        //调用遥控器撤回命令
        callCommand.getWithdraw();

Log图(3.1):

Vantagens:

• Reduza o grau de acoplamento entre objetos.
• Novos comandos podem ser facilmente adicionados ao sistema.
• Observe o princípio de abertura e fechamento (aberto para extensão, fechado para modificação), e pode ser bem estendido

Desvantagens:

• Se for uma função simples, causará muito código e muitas classes, e causará dificuldades de leitura se você não entender o modo de comando.
• Para cada comando, uma classe de comando específica precisa ser projetada.Portanto, alguns sistemas podem exigir um grande número de classes de comando específicas, o que afetará o uso do modo de comando.

Como expandir

Suponha que agora você precise adicionar um comando para trocar o telefone:

PhoneOnCommand (comando de abertura do telefone):

public class PhoneOnCommand implements ICommand{
    
    

    CommandContent dispatchOrders;

    public PhoneOnCommand(CommandContent dispatchOrders) {
    
    
        this.dispatchOrders = dispatchOrders;
    }
    @Override
    public void start() {
    
    
        dispatchOrders.on();
    }

    @Override
    public void withdraw() {
    
    
        dispatchOrders.off();
    }
}

PhoneOffCommand (comando para desligar o telefone):

public class PhoneOffCommand implements ICommand{
    
    

    CommandContent dispatchOrders;

    public PhoneOffCommand(CommandContent dispatchOrders) {
    
    
        this.dispatchOrders = dispatchOrders;
    }

    @Override
    public void start() {
    
    
        dispatchOrders.off();
    }

    @Override
    public void withdraw() {
    
    
        dispatchOrders.on();
    }
}

Código de teste (cliente):

	   //创建命令具体类容
        CommandContent commandContent2 = new CommandContent("手机");
        //创建手机命令
        PhoneOnCommand phoneOnCommand = new PhoneOnCommand(commandContent2);
        PhoneOffCommand phoneOffCommand = new PhoneOffCommand(commandContent2);

        //设置给遥控器命令
        callCommand.setTvOnCommand(1,phoneOnCommand,phoneOffCommand);

        //遥控器打开手机
        callCommand.getOnCommand(1);
        //遥控器关闭手机
        callCommand.getOffCommand(1);
        //遥控器打开手机
        callCommand.getOnCommand(1);
        //遥控器撤销
        callCommand.getWithdraw();

Log图(3.2):

Pode-se ver que o código original não foi alterado, mas o 'comando' foi modificado um pouco, e o método correspondente ainda pode ser ajustado;

Código completo

Acesse a página inicial do modo de design / Princípios de design

Originalidade não é fácil, seus gostos são o seu maior apoio para mim ~