G51PGP Programming Paradigms. Lecture OO-14 More Design Patterns And Java Examples

Transcription

1 G51PGP Programming Paradigms Lecture OO-14 More Design Patterns And Java Examples 1

2 Last lecture Design patterns Creational patterns Singleton Factory more this lecture 2

3 Reminder: Sub-type polymorphism With polymorphic functions we implement a new version in the sub-class Then the new version is used instead of the old version This means that your sub-class gets all of the base class functions and can optionally replace some of them So if your base class function calls three functions And you replace one It calls the original two and your new one 3

4 A base class nothing complex public class BaseClass public void func1() System.out.println("BaseClass func1()" ); public void func2() System.out.println("BaseClass func1()" ); public void func3() System.out.println("BaseClass func1()" ); public void dostuff() func1(); func2(); func3(); 4

5 A sub-class and main class public class SubClass extends BaseClass public void func1() System.out.println("SubClass func1()" ); What is the output? public class Main public static void main(string[] args) BaseClass ob = new SubClass(); ob.dostuff(); 5

6 A sub-class and main class public class SubClass extends BaseClass public void func1() System.out.println("SubClass func1()" ); Output: SubClass func1() BaseClass func1() BaseClass func1() public class Main public static void main(string[] args) BaseClass ob = new SubClass(); ob.dostuff(); 6

7 This is how the factory method works One function is used to create the object Sub-class overrides this to create its own type of object Base class uses a base class object reference to refer to the new object This is perfectly valid to do subclass IS-A base class When the reference is used: Original versions of functions which were not overridden are used New versions of functions which were overridden are used 7

8 Same slide as before: Factory Method Build an interface for create an object but lets sub-classes decide which object to create e.g. Allow some extension to create classes without knowing about them Example use: Application framework which can handle multiple document types You want to create an application which supports your own document type The framework shouldn t have to know what type of document you will create Document open() close() save() MyDocument open() close() save() MyApplicationobject creates MyDocument objects Application createdoc() newdoc() opendoc() MyApplication createdoc() 8

9 FMApplication the big bit public abstract class FMApplication // This acts like the custom collection ArrayList<FMDocument> documents = new ArrayList<>(); // Create a new document by subclass public abstract FMDocument createdoc(); public FMDocument opendoc( String filename ) // Ask subclass to actually create the doc FMDocument newdoc = createdoc(); newdoc.open( filename ); documents.add(newdoc); // Store return newdoc; // Create a new document public FMDocument newdoc() // Ask subclass to do it FMDocument newdocument = createdoc(); documents.add(newdocument); return newdocument; // Ignore until covered the iterator pattern public void closeall() for ( FMDocumentdoc : documents ) doc.close(); 9

10 FMDocument, and subclasses public interface FMDocument void open( String filename ); void close(); void save( String filename ); public class FMMyApplication extends FMApplication public FMDocument createdoc() return new FMMyDocument(); public class FMMyDocument implements FMDocument public FMMyDocument() System.out.println( "FMMyDocument created"); public void open( String filename ) System.out.println( "Opening FMMyDocument " + filename + " now"); public void close() System.out.println( "Closing FMMyDocument now"); public void save( String filename ) System.out.println( "Saving FMMyDocument now"); 10

11 Abstract Factory An abstract factory works similarly in my opinion think of it as having many functions Base factory class creates many different types of objects Multiple classes exist for multiple types of things, e.g. types of UI components They are grouped, so that one group is used at a time One class is the factory Subclasses actually decide which classes will be used to create each type of object Factory works with one group and creates the objects 11

12 Example Abstract Factory ComponentFactory createwindow() createbutton() Client MSWindow Window MSWindowsUIFactory createwindow() createbutton() Sub-class does the creation of the item In this case, specifying the type of window to create 12

13 Multiple sub-classes different window styles ComponentFactory createwindow() createbutton() Client MSWindow Window JavaWindow MSWindowsUIFactory JavaUIFactory createwindow() createbutton() createwindow() createbutton() 13

14 Multiple functions family of components ComponentFactory createwindow() createbutton() Client MSWindow Window JavaWindow Button MSWindowsUIFactory JavaUIFactory createwindow() createbutton() createwindow() createbutton() MSButton JavaButton 14

15 Look and feel abstract factory used // Default cross-platform one is 'metal' changelookandfeel( UIManager.getCrossPlatformLookAndFeelClassName() ); changelookandfeel( "javax.swing.plaf.metal.metallookandfeel"); // System one is windows since I am running on windows changelookandfeel( UIManager.getSystemLookAndFeelClassName() ); changelookandfeel( "com.sun.java.swing.plaf.windows.windowslookandfeel"); // Motif is an old X (UNIX/Linux) widget set changelookandfeel( "com.sun.java.swing.plaf.motif.motiflookandfeel"); public static void changelookandfeel( String classname) try UIManager.setLookAndFeel( classname); catch( Exception e) // Todo- actually handle exceptions properly e.printstacktrace(); 15

16 Factory pattern(s) The important part is that the creation of the objects is delegated to another class That class may have one method Factory Method create objects of one class Or it may have a series of methods Abstract factory each method creates one type of object This kind of behaviour, where a subclass adapts behaviour (e.g. to create the object required) is really common in OO programs I have chosen some of the easier patterns to explain and understand there are many! But you only need to understand each once, then identify its usefulness and use it many times 16

17 Behavioural patterns Iterator Observer 17

18 My fake collection class Class which will maintain an array internally Allows array to grow Use functions to store items Use functions to retrieve items Store items as Objects MyObjectArrayClass -myarray: Object[] + MyObjectArray( intsize ) + MyObjectArray( Object[] array ) + get( intpos) : Object + set( intpos, Object val) : void + grow( intnewsize) : void + size() : int + setandgrow(int pos, Object val) : void Note: + for public, -for private You don t need to label these in any class diagrams that you create for assessment 18

19 Iterator Pattern A method to move through (iterate through) the elements of something E.g. to move through a list Design patterns book suggests that an iterator should have: first() get the first entry next() get the next entry isdone() work out whether you have finished currentitem() get the current item that iterator refers to 19

20 Java support for iterator Iterator interface exists simplified version public interface Iterator<E> boolean hasnext(); E next(); Note the generic type here! Also note that there are two other functions, which you can ignore ( remove() and foreachremaining() ) Iteration for loops for ( <VarType> <varname> : <ObjectWithIterator> ) 20

21 Code to add to my object array public class MyObjectArrayClass<T> implements Iterable<T> public class MyIterator implements Iterator<T> int index = -1; // Default it public boolean hasnext() return index < size() - 1; //return index < MyObjectArrayClass.this.size() - 1; public T next() return get(++index); // Increment then get public Iterator<T> iterator() return new MyIterator(); 21

22 Code to use it You can use the iterator directly: Iterator<T> it = this.iterator(); while( it.hasnext() ) System.out.println("Loop item: " + it.next() ); Java has a for loop which understand iterators Provide two arguments separated by a colon: The variable type and name which you will use An Iterable object (object supporting Iterable interface) for ( T item : this ) System.out.println( "Item: " + item ); They also work with arrays (e.g. String[] ) 22

23 Collection Classes Java has built in collection classes E.g. ArrayList, LinkedList, TreeSet, TreeMap These provide lists, arrays, etc They support iterators (so you can use for ) Example: ArrayList<String> list = new ArrayList<>(); list.add("item 1"); list.add("item 4"); list.add("item 3"); list.add("item 2"); list.addall( list ); list.sort( null/*default comparitor*/ ); for( String str: list ) System.out.println( str); 23

24 Observer pattern Register something to be notified of changes to something else Observe changes 24

25 Observer pattern Subject Attach(Observer) Detach(Observer) Notify() Observer Update() ConcreteSubject GetState() SetState() ConcreteObserver Update() 25

26 Example: action listeners JButton addactionlistener() removeactionlistener() notify() ActionListener actionperformed() MyButton OtherThings MyListener actionperformed() 26

27 The code to implement it (1/2) // I wanted to use this array thing itself for this // even though it has a problem with needing >= 1 element MyObjectArrayWithIteratorAndObserver<IObserver> observerlist = null; public void registerobserver( IObserver ob ) if ( ob == null ) return; // Do nothing - null is not an object if ( observerlist == null ) observerlist = new MyObjectArrayWithIteratorAndObserver<>(1); observerlist.set(0, ob); return; // Otherwise add it to the end of the list observerlist.setandgrow(observerlist.size(), ob); 27

28 The code to implement it (2/2) // MyObjectArrayWithIteratorAndObserver<IObserver> observerlist = null; public void notifyallobservers( int positionchanged ) if ( observerlist == null ) return; // No observers so skip this for ( IObserver ob : observerlist ) if ( ob!= null ) // Check for null just in case ob.somethinghappened( positionchanged ); // Add to set and setandgrow(): notifyallobservers( position ); 28

29 Structural pattern Adapter 29

30 Adapter pattern Assume that we have a (very simplified) immutable list, of the type you saw in Haskell Simple lists: Empty Infinite (same item) Infinite (create new item from old) All you can do with a list is: Extract head: gethead() Get the tail list: gettail() Create new list adding to the head: addtohead() Copy list: make a new list: copy() Imagine that we want to add an iteratorbut NOT change the class itself This is where an adapter comes in 30

31 My List Class public class ImmutableList<T> public ImmutableList().. // New empty list public ImmutableList( T head ) // Infinite list public ImmutableList( T head, INext<T> next ). // Infinite list with new item maker public T gethead(). // Get head of current list public ImmutableList<T> gettail(). // Return tail of list public booleanempty() // Test for empty list public ImmutableList<T> addtohead( T newhead) // Add new item to head of list public ImmutableList<T> copy() // Copy entire length public ImmutableList<T> copy( intlength ) // Copy with a max length Examples: ImmutableList<Integer> list = new ImmutableList<>(); ImmutableList<Integer> list2 = list.addtohead(5).addtohead(6).addtohead(4); ImmutableList<Integer> list3 = new ImmutableList<Integer>(4,x->x+1); ImmutableList<Integer> list4 = new ImmutableList<Integer>(12); ImmutableList<Integer> list5 = list3.copy(20); 31

32 Class Adapter pattern -inheritance Client ExpectedInterface dosomething() LegacyCodeOrObjects somethingtodo() AdapterClass dosomething() [calls somethingtodo() ] Inherit from the old class allows you to reimplementcode Some issues because old class does not know about the new subclass Implement the new interface and add the functionality I failed to make this work on the list class because all data was private, so I couldn t access it, and the class creates objects without a factory 32

33 Object Adapter pattern -composition Client ExpectedInterface dosomething() LegacyCodeOrObjects somethingtodo() AdapterClass dosomething() [calls somethingtodo() ] I prefer this version more flexible Think of it as wrapping up the legacy code class This was easy to implement for my list class 33

34 My implementation -wrapper package adapter; import java.util.iterator; public class AdapterComposition<T> implements Iterable<T> private ImmutableList<T> list; // Important - aggregation public AdapterComposition( ImmutableList<T> list ) this.list = list; public Iterator<T> iterator() return new MyIterator(); 34

35 My implementation iterator inner class public class MyIterator implements Iterator<T> private ImmutableList<T> currentitem = list; // Move to next item and return current one public T next() ImmutableList<T> thisitem = currentitem; currentitem = currentitem.gettail(); return thisitem.gethead(); // Check whether there is a next item public boolean hasnext() return!currentitem.empty(); 35

36 Code to use it ImmutableList<Integer> listempty = new ImmutableList<>(); // Empty list ImmutableList<Integer> list3item = listempty.addtohead(5).addtohead(6).addtohead(4); // List with infinite entries, 4,5,6,7,8,... ignore the use of a lambda! ImmutableList<Integer> listinfiniteplusone = new ImmutableList<Integer>(4,x->x+1); ImmutableList<Integer> listinfinite12 = new ImmutableList<Integer>(12); ImmutableList<Integer> listinfiniteplus1first20 = listinfiniteplusone.copy(20); ImmutableList<Integer> listinfinite12first5 = listinfinite12.copy(5); AdapterComposition<Integer> a1 = new AdapterComposition<Integer>(listInfinitePlus1First20); for( Integer x : a1 ) System.out.println("a1:" + x); AdapterComposition<Integer> a2 = new AdapterComposition<Integer>(listInfinite12First5); for( Integer x : a2 ) System.out.println("a2:" + x); 36

37 Next lecture The End of Java and OO on its own Remaining lectures: Final Haskell lecture Comparison lecture our views and discussion Two revision lectures, one per module Don t forget to get your Java coursework marked in the Tuesday lab!!!! 37