LECTURE 20:IMPLEMENTING COMMANDS

Computer Science 313 – Advanced Programming Topics

Using a Design Pattern

Design patterns are tools Each pattern has reason for being

Choose matching pattern to design need Design & coding is simple if choosing

correctly Life sucks when forced; coding is

impossible Knowing pattern intent crucial for

good design Make use as simple as adding pattern to

client code

Command Pattern Intent

What is the intent of command pattern?

Decoupling Without Texts

Command pattern decouples (splits)What we want to do

Who does itWhen it is done

Decoupling Without Texts

Command pattern decouples (splits)What we want to do

Who does itWhen it is done

Command of Command Pattern Command declares method(s) defining

actions Limit to fewest methods undo included, if desired

Must be abstract type Interface is possible Can be abstract class Terms interchangable

for design purposes

Warning! Warning! Warning!

Warning! Warning! Warning! Caution is needed if Command is

abstract class All ConcreteCommands use fields being

declared Big hint suggesting Command Pattern

incorrect Abstracts what is executed from the code Should be casting as wide a net as

possible Requiring common details is a rather

limited net Consider using Strategy Pattern may

be better Add fields to Context class executing the

strategy Method in strategy passed field as

parameter

Command Interface Example

Should be short & simple Use additional methods if more are

needed Often methods void for maximum

usability Returns value to Receiver in other cases

public interface Command {public void execute();public void undo();

}

Invoker of Command Pattern Stores Command instance(s)

Only refers to interface May change object held Changes made externally

Starts action execution Any reason valid forwhy this happens

Actual execution maybe delayed

Invoker Class Example

Blindly calls execute for correct Command Select one if multiple Commands referred

to Simple class that does not care what

happens

public class Remote { Command[] btnCommands; void buttonWasPushed(int slot){ btnCommands[slot].execute(); }

}

Receiver in Command Pattern With ConcreteCommand, performs the

action Real work done by Receiver Uses Command to

make & order calls Independent of Invoker Lacks knowledge

of how it is called Also called

FUNCTOR or CALLBACK

Receiver Class Example

Has methods needed to execute action Can be written to split work across method

public class CDPlayer { boolean powered, trayOpen; public void turnOn() { powered = true; } public void closeTray() { trayOpen = false; }}

ConcreteCommand in Pattern Calls method(s) in Receiver to perform

action Includes fields it will need Also acts on own

Separates Invoker &Receiver Prevents from

needing the other State defines it &

its actions

ConcreteCommand Example

class LtCommand implements Command {Light bulb;public LtCommand(Light l) { bulb = l;}public void execute() { bulb.turnOn();}public void undo() { if (bulb.on()) { bulb.turnOff(); } else { bulb.turnOn(); }}

MultiCommand Example

Party mode combines multiple Receivers

class PartyCommand implements Command { Stereo stereo; public MultiCommand(Stereo s) { stereo = s; } public void execute() { stereo.turnOn(); stereo.closeTray(); }

ComplexCommand Example

Can also perform actions on its own

class OpenCommand implements Command { Application app; public void execute() { String name = askUser();

doc = new Document(); app.add(doc); doc.open();

}

MacroCommand Example

Define macros which compose Commands

class MacroCommand implements Command {ArrayList<Command> cmd;public void addCommand(Command c) { cmd.add(c);}public void execute() {

for (Command c : cmd) c.execute();}

}

Client in Command Pattern

Helps perform actual action Works with ConcreteCommand Sets the Invoker’sCommands

Not involved in execution of actions

Client Class Example

Creates Commands for program to use Gets references to the Receivers Sets Command for the Invokers

Command lc = new LtCommand(light);Command sc = new StereoCommand(s); Command mc = new MacroCommand();mc.addCommand(lc);mc.addCommand(sc);remote.setOnCommand(0, lc);remote.setOnCommand(1, sc); remote.setOnCommand(2, mc);

For Next Class

Read remainder of the chapter Complete command pattern lecture &

discussion How would we go about creating logs of Commands?

Why does CSC351 need this pattern & how is it good?

And what in the world could CSC310 need this work?

Midterm #1 in class on Friday Open-book, open-note exam (as usual) Have been given & should use pattern

reports No computers, slides, or friends, however