Anti-If in Java ME

In Java Micro Edition l'Event Handling dei comandi utente sulla GUI viene implementato con due classi: il Command e il suo CommandListener. Il ruolo di ciascuna é ben descritto nel Javadoc della classe Command.

The Command class is a construct that encapsulates the semantic information of an action. The behavior that the command activates is not encapsulated in this object. This means that command contains only information about "command" not the actual action that happens when command is activated. The action is defined in a CommandListener associated with the Displayable.

La scelta architetturale della piattaforma MIDP é stata quindi una separazione fra l'esecuzione di un comando e l'azione che ne deve conseguire.

Se cercate degli esempi di programmazione di questo meccanismo, a cominciare da uno della stessa Oracle ™, il codice appare quasi sempre come segue.

public class LCDUICommandByEqualsMIDlet extends MIDlet implements CommandListener {

    private Command exitCommand = new Command("Exit",Command.EXIT, 1);
    private Command sayYesCommand = new Command("Say Yes", Command.SCREEN, 2);
    private Command sayNoCommand = new Command("Say No", Command.SCREEN, 3);
    private Command sayMaybeCommand = new Command("Say Maybe", Command.SCREEN, 4);

    ...
    
    protected void startApp() throws MIDletStateChangeException {
        Form form = new Form("Command-By-Equals-MIDlet - LCDUI Version");
        
        form.addCommand(exitCommand);
        form.addCommand(sayMaybeCommand);
        form.addCommand(sayNoCommand);
        form.addCommand(sayYesCommand);
        
        form.setCommandListener(this);
        
        Display.getDisplay(this).setCurrent(form);
    }

    ...

    public void commandAction(Command command, Displayable displayable) {
        if(command == exitCommand) {
            notifyDestroyed();
        } else
        if(command == sayYesCommand) {
            ...
        } else
        if(command == sayNoCommand) {
            ...
        } else
        if(command == sayMaybeCommand) {
            ...
        }
    }
}

Sembra evidente, in caso di aggiunta di comandi alla GUI, il pericolo di una proliferazione degli IF, che rendono il codice poco leggibile e complesso.

Adottando la libreria Oracle ™ LWUIT (Lightweight UI Toolkit), oltre a beneficiare di widget grafici piú avanzati di quelli messi a disposizione dal package LCDUI standard, é possibile sbarazzarsi anche degli IF per la determinazione dei comandi invocati. Vediamo come.

Il Command LWUIT, unisce al concetto di comando MIDP, quello di Action di Swing. Espone, infatti, il metodo actionPerformed(ActionEvent evt) che viene invocato in callback quando viene cliccato il relativo bottone sulla GUI. Questo significa che la risoluzione del comando viene realizzata senza doverla esplicitamente programmare.

Sfruttando questo comportamento si puó impostare una superclasse astratta come segue:

public abstract class AntiIfCommand extends Command {

    public AntiIfCommand(String command) {
        super(command);
    }
    
    public void actionPerformed(ActionEvent evt) {
        execute();
    }

    public abstract void execute();
}

Quindi estenderla per implementare i comportamenti voluti all'atto del click dell'utente. Ad esempio, un ipotetico ExitCommand:

public class ExitCommand extends AntiIfCommand {

    private final MIDlet midlet;

    public ExitCommand(MIDlet midlet) {
        super("Exit");
        this.midlet = midlet;
    }

    public void execute() {
           midlet.notifyDestroyed();
    }

}

Oppure, un altro comando:

public class SayYesCommand extends AntiIfCommand {

    public SayYesCommand() {
        super("Say Yes");
    }

    public void execute() {
        sayYes();
    }

    private void sayYes() {
        Dialog.show("Yes Command", "Yes! :)", OK, null);
    }

}

Realizzando i comandi in questa maniera il MIDlet, cambia come segue:

public class LWUITCommandByOopMIDlet extends MIDlet {

    ...

    protected void startApp() throws MIDletStateChangeException {
        Form form = new Form("Command-By-OOP-MIDlet");
        
        form.addCommand(new ExitCommand(this));
        form.addCommand(new SayMaybeCommand());
        form.addCommand(new SayNoCommand());
        form.addCommand(new SayYesCommand());
        
        form.show();
    }

    ...
}

Questa versione del MIDlet, come si puó notare, non implementa alcun listener di eventi; di conseguenza, il codice non viene complicato da nessuna sequenza di IF.

Per chi se lo stesse chiedendo, ho dato una breve occhiata anche ai risultati prodotti da Metrics sulle due versioni del codice. La prima versione del MIDlet presentava degli warning su complessitá ciclomatica, linee di codice per metodo e numero livelli.
Nella versione No-If non ci sono warning sollevati. :)

Potete trovare qui alcuni gist piú completi.