Example to motivate discussion We have two lists (of menu items) one implemented using ArrayList and another using Arrays. How does one work with these two implementations of lists in a uniform way? Example here uses restaurant items Look at code for (book page 316) Class MenuItem Class PancakeHouseMenu Class DinerMenu Now if we want to printMenu() Print every item on the menu printBreakfastMenu() Print just breakfast items printLunchMenu() Print just lunch items printVegetarianMenu() isItemVegetarian(name) Iterating through breakfast items Iterating through lunch items Look at MenuTestDrive (print out) Encapsulating iteration Instead of using multiple ways to iterate through the lists, define ONE interface to iterate through the lists Using iterator to get breakfast items Using iterator to get lunch items Meet the iterator pattern DinerMenuIterator Look at Code for DinerMenuIterator Code for PancakeHouseMenuIterator Code for Waitress Some improvements Utilizing the Java provided implementation of iterator Look at Eclipse Iterator Pattern defined The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. Design Principle A class should have only one reason to change. 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. Extending the Menu example with one more aggregate Cafemenu which uses Hashtable to implement the collection. Look at Eclipse. Iterators and collections 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); } 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()); } 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. Using composite pattern Composite Pattern Complex hierarchy of menu items Composition treated as one entity or as parts Operations applied to whole or parts Look at Eclipse Code for MenuComponent Code for MenuItem Code for Menu Code for Waitress TestDrive 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 Look at Eclipse code for Composite iterator Null iterator Vegetarian menu Patterns and their role Strategy Adapter Iterator Faade Composite Observer Clients treat collections of objects and individual objects uniformly Provides a way to traverse a collection of objects without exposing the collections 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. 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 Dont call us, we will call you A class should have only one reason to change. 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. 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 couldnt otherwise because of incompatible interfaces. The Faade Pattern provides a unified interface to a set of interfaces in a subsystem. Faade 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 algorithms 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.