Outline Design Patterns Singleton pattern Visitor pattern ObejctOriented

Outline Design Patterns Singleton pattern Visitor pattern

Obejct-Oriented Software Designing object-oriented software is hard – designing reusable object oriented software if even harder. Your design should be specific to the problem at hand, but also general enough to address future problems and requirements. Don’t solve every problem from first principles - Reuse solutions that have worked in the past.

Design patterns A general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design. It is a description or template for how to solve a problem. Patterns are formalized best practices that the programmer can use to solve common problems when designing.

Example 1 - problem Design problem: We want to ensure a class only has one instance, and provide a global point of access to it. Examples: - Log file - Printer spooler - File system access

Example 1 - Solution Singleton Pattern

Singleton pattern n The instance is held privately in the class. A getter is responsible of returning the instance. The constructor is private.

Singleton pattern Eager initialization public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} public static Singleton get. Instance() { return INSTANCE; } }

Singleton pattern Lazy initialization public class Singleton. Demo { private static Singleton. Demo instance = null; private Singleton. Demo() { } public static Singleton. Demo get. Instance(){ if (instance == null) { instance = new Singleton. Demo(); } return instance; } }

Example 2 Visitor pattern

Reminder: Polymorphic Variables

Reminder: Polymorphic Variables Animal animal; animal = new Dog(); Animal * animal. say(); \ “Woof” animal = new Cat(); + say() * animal. say(); \ “Miau” Cat + say() System. out. println(“Miau”) Dog + say() System. out. println(“Woof”)

What happens if a method accepts an argument? boolean b; Animal * Animal cat = new Cat(); + say() * Animal mouse = new Mouse(); + eats(mouse: Mouse) : bool * b = cat. eats(mouse); + eats(cat: Cat) : bool * //compilation error Cat Mouse + say() + eats(mouse : Mouse) : bool + eats(cat : Cat) : bool

polymorphism of No support for arguments • Java (and many other languages) supports only polymorphism of the receiver (the variable on which the method is invoked). • Polymorphism of the receiver is performed usingle dispatch. • Polymorphism of arguments is performed using multiple-level dispatch, which is resource consuming. Therefore, it is not supported. • Nevertheless, we can simulate it using the Visitor Pattern.

The visitor pattern (for methods with one argument) Define two interfaces: Visitor and Visited. The Visitor interface contains a method for each possible argument type. The Visited interface contains an accpet() method. Visitor Visited +visit (cat : Cat) +accept(v : Visitor) +visit (mouse : Mouse)

The visitor pattern (for methods with one argument) • The receiver's base class implements the visitor interface • The argument’s base class implements the visited interface Visitor +visit (cat : Cat) Visited +visit (mouse : Mouse) +accept (v : Visitor) Animal * +eats(animal: Animal)* +visit (cat : Cat)* +visit (mouse : Mouse)*

Implementation of Visitor subclasses Implementation of Visited subclasses public class Cat extends Animal{ … public void eats(Animal animal){ public void accept(Animal animal){ animal. accept(this); } animal. visit(this); public void visit(Cat cat){ } s. o. p(“No”); } } public void visit(Mouse mouse){ s. o. p(“Yes”); } …

Implementation of Visitor subclasses Implementation of Visited subclasses public class Mouse extends Animal{ … public void eats(Animal animal){ public void accept(Animal animal){ animal. accept(this); } animal. visit(this); public void visit(Cat cat){ } s. o. p(“No”); } } public void visit(Mouse mouse){ s. o. p(“No”); } …

Putting it all together Visitor Visited +visit (cat : Cat) +accept (v : Visitor) +visit (mouse : Mouse) Animal * +eats (animal: Animal) animal. accept(this) Cat Mouse +accept(animal: Animal) +visit (cat : Cat) +visit (mouse : Mouse) animal. visit(this)

Different types of Visitor and Visited Employees and Reports example

Format f = new CSV(); Employee e = new Manager(); f. print(e); Format print(r: Regular)+ Employee print(m: Manager)+ print(s: Specialist)+ Regular Manager Specialist Block CSV print(r: Regular)+ print(m: Manager)+ print(s: Specialist)+

Visited Visitor accept(v: Visitor) visit(r : Regular) visit(m : Manager) Employee Format accept(v: Visitor) print(e : Employee)+ Regular visit(s : Specialist) e. accept(this) accept(v: Visitor) + Manager accept(v: Visitor)+ Specialist accept(v: Visitor)+ v. visit(this) Block Csv visit(r: Regular)+ visit(r : Regular)+ visit(m: Manager)+ visit(m : Manager)+ visit(s: Specialist)+ visit(s : Specialist)+

The Visitor Pattern Advantages • Simulating multiple-level dispatch. • Type-based treatment without instanceof. • Extending the functionality of a class hierarchy by an external class.

The Visitor Pattern Shortcomings • Tedious to code. • Adding a Visited class requires modifying existing Visitor classes. • Dispatching multiple arguments becomes inconvenient.