UML & Strategy Pattern - University Of California, San Diego

Discussion 11/2/2016 UML & Strategy Pattern

UML – What and Why? “Universal Modeling Language” Emerged in the mid 90’s to standardize software design notation Language-independent visual representation of object-based software design Methods representing both structural and behavioral design of software* *These slides only cover structural UML.

UML Notation – Classes Name Access Level Type Can be followed by “ : Type “ to denote return type. This method is void.

UML Notation – Inheritance (Is-A)

Example (1.1) – Simple Animals Animals as OBJECTS (Instantiated Classes)

UML Notation – Interfaces * Key distinction between abstract classes and interfaces: abstract classes are realized via inheritance, interfaces are realized via implementation. Interfaces should be used used to define behaviors which classes implement.

Example (1.2) – Simple Animals Notice dashed line for implementation

UML Notation – Aggregation, Composition, and Association (Has-A) Aggregation (ClassA contains ClassB) Composition (ClassA contains ClassB) Association (Bi-Directional) Multiplicity * 1 n Any number Exactly 1 Exactly n 0.1 1.* n.m Zero OR 1 One or more Any value n through m

Example (2.1) – Airports & Universities Here a “route” is a path flown by a passenger (ex: San Diego to New York), where a route is an aggregation of direct flights. You could take a direct flight or have a connecting flight in Chicago. Each flight only has one plane for a specific gate and time, but a plane may have multiple flights. A university is composed of departments, which will cease to exist if the university is closed. In the previous example, a flight will still exist even if it is not encapsulated by a route.

Strategy Pattern Strategy Goals (1) Define a family of algorithms (2) Encapsulate each algorithm (3) Make algorithms interchangeable within family

Strategy – In UML

Example (3.1) Strategy Situations: Pitcher

Example (3.2) Strategy Situations: Audio Playback

In Java: Strategy & Concrete Strategies // encapsulates family of algorithms public interface Strategy { public void algorithm(); } // a strategy for implementing an algorithm public class ConcreteStrategyA implements Strategy { // implementation of the algorithm public void algorithm() { // do stuff one way System.out.println("using strategy A"); return; } } // a second strategy for implementing an algorithm public class ConcreteStrategyB implements Strategy { // implementation of the algorithm public void algorithm() { // do stuff another way System.out.println("using strategy B"); return; } }

In Java: Context public class Context { // interface to set strategy public void setStrategy(Strategy strategy) { s strategy; return; } // execute algorithm public void execute() { s.algorithm(); return; } // NOTE: set strategy before using private Strategy s; }

In Java: Client Code public class Test { // demo the strategy public static void main(String[] args) { Context c new Context(); // set and use strategy A c.setStrategy(new ConcreteStrategyA()); c.execute(); // set and use strategy B c.setStrategy(new ConcreteStrategyB()); c.execute(); // . and let's go back to strategy A c.setStrategy(new ConcreteStrategyA()); c.execute(); return; }

// a strategy for implementing an algorithm public class ConcreteStrategyA implements Strategy {// implementation of the algorithm public void algorithm() {// do stuff one way System.out.println("using strategy A"); return;}} // a second strategy for implementing an algorithm public class ConcreteStrategyB implements Strategy