SE 450 Fall 2001/2002

Week 7 Lecture Notes

• Originally formulated for architectural designs by Christopher Alexander.
• Patterns represent generic (i.e. reusable) solution to recurring problem.
• Small number of patterns can be combined to form endless possibilities.
• Three types of patterns in software engineering:
  • creational - object creation
  • structural - relationships between classes
  • behavorial - dynamic interaction between classes
• Example: Singleton Pattern - Creational (p. 178 in Jia)

• Class with no or partial implementation.
• Implements behaviors common to all subclasses but defers to the subclasses implementation of others (abstract methods).
• Abstract methods must be implemented in each non-abstract class. Enforced by the compiler.
• Abstract method example: pubilc abstract class X{ // abstract method abstract public void methA(); // non-abstract with default implemetation public void methB(){//do something here} // non-abstract with empty default implemetation public void methC(){} }
• Instance of abstract class is not allowed.
• Server as placeholders for subclasses.  

• Interfaces represent pure design (no implementation).
• Interfaces only contain abstract methods and constants (static, final fields).
• All methods and constants are public.
• No instances allowed, only instances of classes that implement interface.
• No single root for interfaces.

• One method for developing generic components.
• Three steps:
  • Identify code segments that implement same logic in different places
  • Capture code segments into a generic component that is defined once.
  • Reorganize program so every occurrence of code segment is replaced by the use of the generic component.
• Prevents code from drifting apart.
• Be sure that you replace only code that actually implements the same logic, not just looks similar.
• Easiest for of factorization is method factorization .

• Non-factored code class Computation{ void method1(){ .... computeStep1(); computeStep2(); computeStem3(); .... } void method2(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... }
• Factored Code class Computation{ void ComputeAll(){ computeStep1(); computeStep2(); computeStem3(); } void method1(){ .... computeAll(); .... } void method2(){ .... computeAll(); .... } .... }
• Good when all factored code can be put into one method and all of the methods belong to the same class.

• Used to factor code that occur in different classes.
• Non-factored code class ComputationA{ void method1(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... } class ComputationB{ void method2(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... }
• Factored code class Common{ void computeAll(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... } class ComputationA extends Common{ void method1(){ .... computeAll(); .... } .... } class ComputationB extends Common{ void method2(){ .... computeAll(); .... } .... }
• Not only are methods extracted to the superclass but any fields involved in the computations must be moved to the superclass as well.

• Also used to factor code that occur in different classes.
• Non-factored code class ComputationA{ void method1(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... } class ComputationB{ void method2(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... }
• Factored code class Helper{ void computeAll(){ .... computeStep1(); computeStep2(); computeStem3(); .... } .... } class ComputationA{ Helper helper; void method1(){ .... helper.computeAll(); .... } .... } class ComputationB{ Helper helper; void method2(){ .... helper.computeAll(); .... } .... }
• Not only are methods extracted to the new class but any fields involved in the computations must be moved to the new class as well.
• This can be used when the classes that use the factored code are already subclasses of another class.

• Intent - Used to design a skeleton of an algorithm but allow subclasses to redefine parts of the algorithm by implementing hook methods, which are typically abstract methods defined in the superclass.
• Applicability
  • implement the invariant parts of the algorithm once and let subclasses change parts as needed
  • to factor and localize code common to subclasses to prevent code duplication
• Hook methods do not have to be abstract. Base class can provide a default implementation. (See initAnimator() of DBAnimationApplet).
• Allows you to intermix common code segments with context specific code by forcing subclasses to implement context specific code. abstract class Common{ void method(){ .... (common code segment 1) contextSpecificCode(); (common code segment 2) .... } abstract void contextSpecificCode(){....} } class ContextA extends Common{ void contextSpecificCode(){ (context specific code A) } .... } class ContextB extends Common{ void contextSpecificCode(){ (context specific code B) } .... }
• Example - double buffered animation applet.

• Allows you to design a system that solves a general family of problems.
• Example - Function Plotter
• How do we accomplish this?? Use the Strategy pattern.

• Variation on the Template Method design pattern.
• Template methods and hook methods reside in different classes.
• Encapsulate differing behavior into classes that all have the same external interface.
• Allows you to pass functions as parameters and remove the need for function pointers.

• A way of linking clients with service providers without the clent having to know what service provider is providing service.
• Example - the phone company
• Forces you to program to an interface and not an implementation.
• Real programming example - iterating through a collection of objects.

• Provide sequential access to a collection without revealing the underlying representation.
• Also supports multiple traversals of collections at the same time.
• Never have to worry about what kind of list you are iterating.
• Each type of collection that you want to iterate must provide an implementaion of an iterator.

• Define an interface for object creation and let subclasses decide what classes to instantiate.
• Use when system should be independent of how products are created.
• Can combine with the Strategy pattern for flexible object creation.
• Example - Use factory to create functions. Change the PlotSineCosine class to use the factory.

• Simple, extensible framework to handle collections of objects.
• Interfaces represent each of the different types of collections in Java and each type can have different implementations.
• Interfaces share common operations with common conventions, for example insertion and deletion.
• Each type of collection adds its specific needs (if there are any) to the common operations (ie Collection and List).
  • List adds an add(int, Object) method to allow where to insert object
• Some types do not add any new operations, just change the semantics of existing ones (ie Collection and Set).
  • Set.add(Object) only adds if Object isn't already present
• User can effectively use a type of collection without worrying about the actual implementation.

• Implementations may vary by:
  • bounded vs non-bounded - fixed size or dynamically sized
  • time and space complexity of operations (ie insertion, deletion, searching)
• Because all implementations have the same interface, they are interchangeable.
• Beware that most collections implementations are not thread safe. See API for more information.
• Implementations:

  Interface	Concrete Implementation	Notes
  Set	HashSet	Hash Table implementation
  Sorted Set	TreeSet	Requires a sorting order.
  List	ArrayList	Array implementation.
  List	LinkedList	Doubly linked list implementation.
  List	Vector	Supports legacy methods from JDK 1.0.
  Map	HashMap	Hash table implementation.
  SortedMap	TreeMap	Requires a sorting order.
  Map	Hashtable	Supports legacy methods from JDK 1.0.

• Example - Counting different words in a text input

• Provide a uniform way to iterate through different collections without caring what implementation we are using (polymorphic iteration).
• Each collection class is responsible for implementing it's corresponding iterator.
• Two types:
  • Iterator - forward only iteration
  • ListIterator - forward and backward iteration for Lists only
• Iterators return Object types so casting is needed.
• Iterator Design Pattern - (p 211 in Jia text)
• Example - Counting occurrences of words in a text input

• Natural Orders
  • Used to compare two objects of the same class.
  • Implement the Comparable interface (one method compareTo(Object)).
  • Natural orders for many Java classes are already defined.
• Comparators
  • Used to define arbitrary order on any objects.
  • Implement Comparator interface (two methods compare(Object, Object) and equals(Object)).
• Sorted Collections
  • SortedSet extends the Set interface with methods to reflect that the Set is ordered (ie headSet(Object), subSet(Object, Object), tailSet(Object)).
  • SortedMap extends the Map interface with methods to reflect that the Map is ordered (ie headMap(Object), subMap(Object, Object), tailMap(Object)).
• Example - Count occurrences of the word in a text input and output results sorted by:
  • alphabetical order of words
  • reverse alphabetical order of words
  • frequency of words