1. CS 210 Final Review November 28, 2006

2. CS 210 Adapter Pattern

3. Adapters in real life Page 236 – Head First Design Patterns

4. Object-Oriented Adapters Page 237 Head First Design Patterns

5. Turkey that wants to be a duck example public interface Duck { public void quack(); public void fly(); }

6. Subclass of a duck – Mallard Duck public class MallardDuck implements Duck { public void quack() { System.out.println("Quack"); } public void fly() { System.out.println("I'm flying"); }

7. Turkey Interface public interface Turkey { public void gobble(); public void fly(); }

8. An instance of a turkey public class WildTurkey implements Turkey { public void gobble() { System.out.println("Gobble gobble"); } public void fly() { System.out.println("I'm flying a short distance"); }

9. Turkey adapter – that makes a turkey look like a duck public class TurkeyAdapter implements Duck { Turkey turkey; public TurkeyAdapter(Turkey turkey) { this.turkey = turkey; } public void quack() { turkey.gobble(); } public void fly() { for(int i=0; i < 5; i++) { turkey.fly(); }

10. Duck test drive public class DuckTestDrive { public static void main(String[] args) { MallardDuck duck = new MallardDuck(); WildTurkey turkey = new WildTurkey(); Duck turkeyAdapter = new TurkeyAdapter(turkey); System.out.println("The Turkey says..."); turkey.gobble(); turkey.fly(); System.out.println("\nThe Duck says..."); testDuck(duck); System.out.println("\nThe TurkeyAdapter says..."); testDuck(turkeyAdapter); } static void testDuck(Duck duck) { duck.quack(); duck.fly(); }

11. Test run – turkey that behaves like a duck The Turkey says... Gobble gobble I'm flying a short distance The Duck says... Quack I'm flying The TurkeyAdapter says... Gobble gobble I'm flying a short distance

12. Adapter Pattern explained Page 241 – Head First Design Patterns

13. Adapter Pattern defined 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.

14. Adapter Pattern Page 243 – Head First Design Patterns

15. Façade Pattern Simplifying complex subsystems

16. Page 255 – Head First Design Patterns

17. Watching the movie the hard way…. Page 256 – Head First Design Patterns

18. What needs to be done to watch a movie….

20. Façade Pattern defined 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.

21. Façade pattern – Class Diagram

22. Design Principle Principle of Least Knowledge talk only to your immediate friends Basically this says minimize your dependencies

23. Client The client only has one friend – and that is a good thing If the subsystem gets too complicated One can recursively apply the same principle.

24. A little comparison PatternIntent Decorator Converts one interface to another Adapter Doesn’t alter the interface, But adds responsibility FacadeMakes an interface simpler

25. CS 210 Template Method Pattern

29. Abstracted Recipe method

30. Abstract base class public abstract class CaffeineBeverage { final void prepareRecipe() { boilWater(); brew(); pourInCup(); addCondiments(); } abstract void brew(); abstract void addCondiments(); void boilWater() { System.out.println("Boiling water"); } void pourInCup() { System.out.println("Pouring into cup"); }

31. Coffee and Tea in terms of the abstract caffeine class public class Coffee extends CaffeineBeverage { public void brew() { System.out.println("Dripping Coffee through filter"); } public void addCondiments() { System.out.println("Adding Sugar and Milk"); } public class Tea extends CaffeineBeverage { public void brew() { System.out.println("Steeping the tea"); } public void addCondiments() { System.out.println("Adding Lemon"); }

34. Template Method Pattern defined The Template Method Pattern 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.

38. Design Principle The Hollywood Principle Don’t call us, we’ll call you.

42. CS 210 Iterator Pattern

43. 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

44. 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)

45. Iterating through breakfast items

46. Iterating through lunch items

47. Encapsulating iteration Instead of using multiple ways to iterate through the lists, define ONE interface to iterate through the lists …

48. Using iterator to get breakfast items

49. Using iterator to get lunch items

50. Meet the iterator pattern…

51. DinerMenuIterator

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

54. 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.

59. Iterators and collections

60. CS 210 Iterator & Composite Pattern

61. Adding to the menu scenario…

64. 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.

65. Using composite pattern

66. Composite Pattern

67. Complex hierarchy of menu items

68. Composition treated as one entity or as parts

69. Operations applied to whole or parts

73. CS 210 State Pattern

74. Example: Managing States

75. Design using State

81. State Pattern defined The State Pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class.

82. State Pattern Class Diagram

83. Comparison of patterns

84. CS 210 Proxy Pattern

85. Revisit the Gumball machine example The same example covered in the State pattern Now we want to add some monitor a collection of Gumball machines

86. Gumball Class

87. Gumball Monitor

88. Role of the remote Proxy

89. RMI Detour in looking at Proxy Pattern

90. Remote Methods 101

91. How the method call happens Client calls method

92. Client Helper forwards to service helper

93. Service helper calls the real object

94. Real object returns result

95. Service helper forwards result to client helper

96. Client helper returns result to client

98. Hooking up client and server objects

100. Back to Gumball machine problem

101. Proxy Pattern defined The Proxy Pattern provides a surrogate or placeholder for another object to control access to it. The proxy pattern is used to create a representative object that controls access to another object, which may be remote, expensive to create or in need of securing.

102. Proxy Class Diagram

103. 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.

104. 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. Command Pattern – Encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

105. OO Patterns - Continued 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. The State Pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class. The Proxy Pattern provides a surrogate or placeholder for another object to control access to it.