ITNP090 - Object Oriented Software Design

Transcription

1 In this practical, we will create a model for a part of the reservation system for a library. There are Book objects and an application object that creates and manipulates them. Two view objects in the visual interface allow users to track the status of a particular book: LibrarianView and BorrowerWishlistView. We will use the Observer Pattern to keep the views updated, and the Strategy Pattern to sort the books in a collection. Create the classes for Observer 1. Create new Java Modelling Project, with the name Practical3 2. To begin with, we will create the classes that we need. Refer to Practical 1 if you need a reminder to do these. 3. Add a new class called Book 4. Select the Book class, and add these attributes, with the types given after the colon (right click Book, New, Attribute): a. title : String b. authorsurname : String c. yearpublished : int d. isborrowed : boolean 5. Also add these operations, with no parameters, with visibility public, and the return types given after the colon (right click Book, New, Operation): a. checkin() : void b. checkout() : void c. tostring() : String 6. Add a constructor to Book (right click Book, New, Constructor). Give it the parameters: a. title : String b. authorsurname : String c. yearpublished : int 7. We will make use of Java s abstract Observable class. This implements the list of Observers for us, and provides methods to add, remove, and notify observers. Click on Book class, scroll down properties, and in the extends box, type java.util.observable 8. Add two more classes: LibrarianView and BorrowerWishlistView 9. To these two view classes: a. Left click on each and set the property implements to java.util.observer b. Add an operation update() - set its visibility to public, and give it the parameters: i. obs : java.util.observable ii. obj : Object 10. Once this is all done, your class diagram should look like this: 1

2 Adding source code to make it work You have now implemented the Observer pattern. The views implement the Observer interface, and can be registered as observers of a Book object. The Book can notify all its registered observers if and when it changes state. The only thing that s missing is some code to give the objects something useful to do and a demo of it working. 11. Double click on Book s constructor (<<create>> Book). The source code editor will open in the middle of the screen, with the constructor highlighted. public Book(String authorsurname, String title, int yearpublished){ } 12. Delete the content between the curly brackets {}, and enter the following (you can copy and paste): this.isborrowed = false; this.authorsurname = authorsurname; this.title = title; this.yearpublished = yearpublished; This will allow us to create a new Book object by specifying the title, author and publication year, and the new book will always default to being available (that is, not borrowed). 13. Now add the following code to the checkin() operation. As above, double click the operation name, and add the code between the curly brackets, before return: 14. Repeat (13) for checkout(): this.isborrowed = false; this.setchanged(); this.notifyobservers(); this.isborrowed = true; this.setchanged(); this.notifyobservers(); These two methods allow a Book object to be checked in and out of the library. Doing this will change its state from borrowed to not borrowed and back again. Once the state is changed, we will call the notifyobservers() method, which Book has inherited from the Observable abstract class, and it will take care of notifying any objects that have registered. (setchanged() is also needed before notifyobservers() in the Java implementation) 15. Now add the following code to the tostring() operation. The job of this is to report the some details about the book, including its current state: return "Book[" + this.title + " by " + this.authorsurname + " (" + this.yearpublished + ") " + (this.isborrowed? "borrowed" : "available") + "]"; 2

3 16. We also need to add some code to the update() operations in the view objects, so they can do something when they receive an update notification. To both LibrarianView.update() and BorrowerWishlistView.update(), add the following (using Borrower or Librarian as appropriate): System.out.println("Borrower:" + obs.tostring()); 17. The last code to add is that which will make some Book objects, make LibrarianView and BorrowerWishlistView objects, and manipulate them. This code will sit inside a special method called main(), which we ll put in a separate Application class. a. Right click on the class diagram, then New, Class Diagram Elements, Class By Template b. Under Templates, choose Main Class, then click finish. c. Change the name of the new class to Application. d. Double click on the operation +main:void. Delete the line Application _main = new Application(); and add the following code between the curly brackets: Book b1 = new Book("Hartley", "Fly Fishing", 1991); System.out.println(b1); LibrarianView librarian = new LibrarianView(); BorrowerWishlistView borrower = new BorrowerWishlistView(); b1.addobserver(librarian); b1.addobserver(borrower); b1.checkout(); b1.checkin(); Running the Library Application 18. Finally we create a run configuration. This tells Together where our main class is and how to run it. a. Click on the small down arrow to the right of the green arrow button in the toolbar, and choose Run Configurations. b. Double click Java Application on the left c. For name, enter Library d. For project, click Browse and then double click Practical3. e. For main class, click Search and then double click Application. f. Click Apply, then Run. 19. You should see some text like the following appear in the console window at the bottom of the screen: 3

4 Book[Fly Fishing by Hartley (1991) available] Borrower:Book[Fly Fishing by Hartley (1991) borrowed] Librarian:Book[Fly Fishing by Hartley (1991) borrowed] Borrower:Book[Fly Fishing by Hartley (1991) available] Librarian:Book[Fly Fishing by Hartley (1991) available] 20. When the Book is created, its details are displayed (line 1). Then when it is checked out, the observers are notified, and each one displays the state of the book (lines 2 and 3). Finally, when it is checked in again, the observers are notified again, and each displays the updated state of the book (lines 4 and 5). 21. Try putting // at the start of the addobserver() lines in main(). This comments out the lines so they won t run. Rerun the library application by clicking on the green button with the white arrow in the toolbar. What happens? 22. Try duplicating one of the addobserver() lines in main(), so the same observer is added twice. Rerun the library application. What happens now? 23. Try adding a call to b1.deleteobserver(librarian) between the checkout() and checkin() lines. What happens now? We have now seen in practice how easy it is to add and remove observers from an Observable object (the Subject in design pattern terms). All the observers are notified when some change happens and can take an appropriate course of action (such as displaying the new information). The observer is only notified once, even if it was added to the observed object more than once. If you have time The library isn t going to be popular if it only has one book to borrow! Let s add a few more books, and store them in a sorted set so that we can view them in a logical manner. We ll use the strategy pattern to implement different sorting behaviours. 1. Add a new class YearComparator, which implements the interface java.util.comparator. 2. Add an operation to YearComparator, called compare(), which returns an int, and has parameters of type Object called o1 and o2. Double click on the compare() operation and set its body (between the {} brackets) to the following: return ((Book)o1).yearPublished - ((Book)o2).yearPublished; 3. YearComparator is our first sorting behaviour (or strategy): it specifies that if book 1 was published before book 2, then book 1 is less than book 2. So sorting the books according to this rule will sort them by year of publication. Let s create some books in our main() method, and store them in a TreeSet, which automatically sorts them according to the strategy specified by an object implementing Comparator. Finally, we ll loop over all the books in the catalogue, displaying them in the order that they are stored. (the <Book> syntax is needed: this is Java s way of telling what class of object is stored in the TreeSet) 4

5 java.util.comparator cmp = new YearComparator(); java.util.sortedset<book> catalogue = new java.util.treeset<book>(cmp); catalogue.add(new Book ("Hartley", "Fly Fishing", 1991)); catalogue.add(new Book ("Wells", "The Time Machine", 1895)); catalogue.add(new Book ("Shatner", "TekWar", 1989)); catalogue.add(new Book ("Lineker", "Ghost Stories", 1995)); catalogue.add(new Book ("Keegan", "Football: It's a Funny Old Game", 1988)); System.out.println("Library catalogue:"); for (Book b : catalogue) { System.out.println(b); } 4. Try running the application now. The output should be the following, with all the books sorted by year of publication: Library catalogue: Book[The Time Machine by Wells (1895) available] Book[Football: It's a Funny Old Game by Keegan (1988) available] Book[TekWar by Shatner (1989) available] Book[Fly Fishing by Hartley (1991) available] Book[Ghost Stories by Lineker (1995) available] 5. Try creating a class ReverseYearComparator, where the o1 and o2 are the other way round, and passing that to the TreeSet in main(). What do you expect will happen this time? 6. Java has a built-in comparison method for Strings which we could use to make a Comparator that will sort on book titles or author names. Create a new class TitleComparator, which uses the following in its body: return ((Book)o1).title.compareTo(((Book)o2).title) Pass this into the TreeSet in main(). What do you expect will happen this time? Now that we ve created these comparator classes, we can reuse them for sorting books into the appropriate order in any part of the application. Just swap in the particular comparator that s needed in any given location to get the right sorting behaviour. This is the major benefit of the strategy pattern: wrapping up behaviours so they can be easily replaced or reused. 5