Implémenter une interface comme démontré simplement et clairement par dfa est propre et élégant (et de manière "officiellement" prise en charge). C'est à cela que sert le concept d'interface.
En C #, nous pourrions utiliser des délégués pour les programmeurs qui aiment utiliser des pointeurs de fonction en c, mais la technique de DFA est la manière d'utiliser.
Vous pourriez aussi avoir un tableau
Command[] commands =
{
new CommandA(), new CommandB(), new CommandC(), ...
}
Ensuite, vous pouvez exécuter une commande par index
commands[7].exec();
Plagier à partir de DFA, mais ayant une classe de base abstraite au lieu d'une interface. Notez la cmdKey qui sera utilisée plus tard. Par expérience, je me rends compte que souvent une commande d'équipement a aussi des sous-commandes.
abstract public class Command()
{
abstract public byte exec(String subCmd);
public String cmdKey;
public String subCmd;
}
Construisez vos commandes ainsi,
public class CommandA
extends Command
{
public CommandA(String subCmd)
{
this.cmdKey = "A";
this.subCmd = subCmd;
}
public byte exec()
{
sendWhatever(...);
byte status = receiveWhatever(...);
return status;
}
}
Vous pouvez ensuite étendre HashMap ou HashTable générique en fournissant une fonction de succion de paire clé-valeur:
public class CommandHash<String, Command>
extends HashMap<String, Command>
(
public CommandHash<String, Command>(Command[] commands)
{
this.commandSucker(Command[] commands);
}
public commandSucker(Command[] commands)
{
for(Command cmd : commands)
{
this.put(cmd.cmdKey, cmd);
}
}
}
Ensuite, construisez votre magasin de commandes:
CommandHash commands =
new CommandHash(
{
new CommandA("asdf"),
new CommandA("qwerty"),
new CommandB(null),
new CommandC("hello dolly"),
...
});
Maintenant, vous pouvez envoyer des contrôles objectivement
commands.get("A").exec();
commands.get(condition).exec();