CS 210

1. CS 210 Iterator & Composite Pattern Nov 2nd, 2006

2. Iterator Pattern defined The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

4. Design Principle A class should have only one reason to change.

5. Design principle applied to Iterator pattern • Iterator pattern places the task of traversal on the iterator object, not on the aggregate, which simplifies the aggregate interface and implementation, and places the responsibility where it should be.

6. Extending the Menu example with one more aggregate • Cafemenu which uses Hashtable to implement the collection. • Look at Eclipse.

11. Iterators and collections

13. A look at the waitress class • public class Waitress { Menu pancakeHouseMenu; Menu dinerMenu; Menu cafeMenu; public Waitress(Menu pancakeHouseMenu, Menu dinerMenu, Menu cafeMenu) { this.pancakeHouseMenu = pancakeHouseMenu; this.dinerMenu = dinerMenu; this.cafeMenu = cafeMenu; } public void printMenu() { Iterator pancakeIterator = pancakeHouseMenu.createIterator(); Iterator dinerIterator = dinerMenu.createIterator(); Iterator cafeIterator = cafeMenu.createIterator(); System.out.println("MENU\n----\nBREAKFAST"); printMenu(pancakeIterator); System.out.println("\nLUNCH"); printMenu(dinerIterator); System.out.println("\nDINNER"); printMenu(cafeIterator); }

14. Removing dependence on specific menu items… public class Waitress { ArrayList menus; public Waitress(ArrayList menus) { this.menus = menus; } public void printMenu() { Iterator menuIterator = menus.iterator(); while(menuIterator.hasNext()) { Menu menu = (Menu)menuIterator.next(); printMenu(menu.createIterator()); } } void printMenu(Iterator iterator) { while (iterator.hasNext()) { MenuItem menuItem = (MenuItem)iterator.next(); System.out.print(menuItem.getName() + ", "); System.out.print(menuItem.getPrice() + " -- "); System.out.println(menuItem.getDescription()); } } }

15. Adding to the menu scenario…

18. Composite Pattern defined The Composite Pattern allows you to compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

19. Using composite pattern

20. Composite Pattern

21. Complex hierarchy of menu items

22. Composition treated as one entity or as parts

23. Operations applied to whole or parts

27. Look at Eclipse … • Code for MenuComponent • Code for MenuItem • Code for Menu • Code for Waitress • TestDrive

28. Some observations • The “print menu” method in the MenuComponent class is recursive. • Now lets look at an alternative implementation which uses an iterator to iterate through composite classes the composite iterator

29. Look at Eclipse code for … • Composite iterator • Null iterator • Vegetarian menu

30. Strategy Adapter Iterator Façade Composite Observer Clients treat collections of objects and individual objects uniformly Provides a way to traverse a collection of objects without exposing the collection’s implementation. Simplifies the interface of a group of classes Changes the interface of one or more classes Allows a group of objects to be notified when some state changes. Encapsulation interchangeable behaviors and uses delegation to decide which one to use. Patterns and their role

31. Summary so far.. • OO Basics • Abstraction • Encapsulation • Inheritance • Polymorphism • OO Principles • Encapsulate what varies • Favor composition over inheritance • Program to interfaces not to implementations • Strive for loosely coupled designs between objects that interact • Classes should be open for extension but closed for modification. • Depend on abstracts. Do not depend on concrete classes. • Only talk to your friends • Don’t call us, we will call you • A class should have only one reason to change.

32. Summary so far… • OO Patterns • Strategy Pattern defines a family of algorithms, Encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it. • Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically. • Decorator Pattern – attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative for sub-classing for extending functionality • Abstractor Factory – Provide an interface for creating families of related or dependent objects without specifying their concrete classes. • Factory Method – Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory method lets a class defer instantiation to the subclasses.

33. OO Patterns - Continued • Command Pattern – Encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations. • The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. • The Façade Pattern provides a unified interface to a set of interfaces in a subsystem. Façade defines a higher level interface that makes the subsystem easier to use. • Template Method defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure. • Iterator - provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. • The Composite Pattern allows you to compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.