Download the lab zip file and unzip it. Start a new Project in
eclipse with the name Lab9. Add all .java files from the unzipped lab folder
to your project. Also, add the libraries `jpt.jar`

and
`SimpleTestHarness.jar`

to the project.

The test harness used here is there same as that introduced in lab 7. Refer to lab 7 if you need to review how to use the test harness.

We will be working with a class of books. Each book has an author, year of publication, and a price. We would like to answer the following questions about various lists of books:

A1: Is there a book in this list that is written by the "MF"? B1: Are all the books in this list written by "MF"? C1: Produce a list of all books in this list written by "MF". A2: Is there a book in this list that was published before 1980? B2: Are all the books in this list published before 1980? C2: Produce a list of all books in this list published before 1980. A3: Is there a book in this list that costs more that $10? B3: Are all the books in this list that cost more that $10? C3: Produce a list of all books in this list that cost more that $10.

We can clearly see several patterns in these questions. All the 'A' questions inquire whether there is at least one item with the given property. All the 'B' question question whether all items in the list satisfy the given property. Finally, the question 'C' is really a request to extract from the list only those items that satisfy the given property.

We start with designing the classes to represent books and lists of books. The class diagram is shown here - the code is included with the lab, together with examples.

+------+ | ALoB |<-------------+ +------+ | +------+ | / \ | --- | | | ---------------- | | | | +-------+ +------------+ | | MTLoB | | ConsLoB | | +-------+ +------------+ | +-------+ +-| Book first | | | | ALoB rest |----+ | +------------+ | v +---------------+ | Book | +---------------+ | String author | | int year | | int price | +---------------+

We will start with methods for the questions A1, A2, and A3. Below are the purpose statements and headers for the methods in the class ALoB.

// is there a book written by "MF" in this list? abstract boolean anyBookWrittenByMF(); // is there a book published before 1980 in this list? abstract boolean anyBookBefore1980(); // is there a book that costs more than $10 in this list? abstract boolean anyBookMoreThan10();

**Exercise:** design the above methods for the classes representing
lists of books. Be sure to include tests in the class `Tests`

.

**Note:** to complete the bodies of these three methods in the
`ConsLoB`

class, we must first add to the class `Book`

the methods that determine whether this book was written by "MF",
or whether this book was published before 1980, or whether this book
costs more than $10.

We see, that if we changes the names of the three methods to
a common name (e.g. `anyBookSuch`

), the only place where they
differ is in determining whether the `Book`

`this.first`

satisfies
the predicate. We would like to abstract over this part and
pass it to the method `anyBookSuch`

as an argument.

There are two problems to overcome. The way the question
is written in our body requires that the methods `writtenBy`

,
`before1980`

, and `moreThan10`

are defined
in the class `Book`

.
But if the methods are to have the same name, they cannot
be defined in the same class. Furthermore, we can only pass
an instnce of a class as an argument to a method. This leads
us to consider to have three different classes, each with the
method that determines whether a book satisfies the specific
predicate. Here is the method purpose statement and the header:

// determine whether the given book satisfies a condition boolean selectBook(Book b){...}

However, to define an argument for our method `anyBookSuch`

, we
need to specify its type. The instances of our three classes
need to have some unifying type. One option os for all three
classes to extend a common superclass. We will see later why
that may not be the best option. The other option is for all
three classes to implement a common interface. This option
makes it clear that we aim to represent commmon behavior.

So, the interface is:

interface ISelectBook{ // determine whether the given book satisfies a condition boolean selectBook(Book b); }

**Exercise:** Design the following three classes, each of which implements
the interface `ISelectBook`

above. Each must implement the method
`selectBook`

as defined above (which returns `true`

if the
given `Book`

satifies the corresponding predicate.

class WrittenByMF implements ISelectBook{...} class Before1980 implements ISelectBook{...} class MoreThan10 implements ISelectBook{...}

We can now define the method anyBookSuch with the following purpose statement and header.

// is there a book that satisfies the condition? boolean anyBookSuch(ISelectBook choose);

**Exercise:** Design the method `anyBookSuch`

as described
above and rerun the original tests using the method `anyBookSuch`

with the appropriate arguments.

The methods we defined for selecting books are rather limited. We canonly select one specific author, one specific publication date limit, or one base price. But this is easily remedied by adding a field to the classes that implement the 'selectBook' method as follows:

class WrittenBy implements ISelectBook{ String author; WrittenBy(String author){ this.author = author; } boolean selectBook(Book b){ return b.author.equals(this.author); } }

The test cases will become:

// tests for the method anyBookWrittenBy sth.test("AnyBookWritten1", mtlist.anyBookSuch(new WrittenBy("MF")), false); sth.test("AnyBookWritten2", list1.anyBookSuch(new WrittenBy("MF")), true); sth.test("AnyBookWritten3", list2.anyBookSuch(new WrittenBy("MF")), false);

**Exercise:** Design the classes `Before`

and `MoreThan`

that allow us to select a book published before a specified date,
or a book that costs more than a specified price. Make sure you run
again the examples using the new function objects.

Let us step back and think about the method we just designed.
It determines whether there is an item in a list that satisfies
the given predicate. This corresponds to the Scheme the loop `ormap`

.
Here is the description of `ormap`

:

;; ormap: (X -> boolean)(Listof X) -> boolean ;; to determine whether p holds for at least one item on alox ;; that is, (ormap p (list x-1 ... x-n)) = (or (p x-1) (or ... (p x-n))) (define (ormap p alox) ... )

Our `(Listof X)`

is the list of books that invokes the method
`anyBookSuch`

, the `function (X -> boolean)`

is encapsulated in the function objects
that implement ISelectBook that we pass to our method, and our result
is boolean, the same as for the 'ormap'.

**Exercise:** Figure out which Scheme loops correspond to questions B and C.

**Exercise:** Design the methods that solve the problems B1, B2, and B3,
and abstract them into the corresponding Scheme loop.

**Exercise:** Do the same for the methods needed to solve the problems C1, C2, C3.

`ICompBook`

defines this type of function object.
**Challange Problem:**

Define three classes that all implement `ICompBook`

:
`CompBookByAuthor`

, `CompBookByYear`

, and
`CompBookByPrice`

, that compare two `Book`

s by
the corresponding field.

Design a single `sort`

method in the list-of-books classes
that sorts using the provided comparator. The sort and insert methods
should have the following purpose statements and headers:

// Sort this list of books using the given comparator ALoB sort(ICompBook comp); // Insert the given Book into this sorted list, according to the given comparator ALoB insert(Book b, ICompBook comp);

For more details and help, see these Lecture Notes on Sorting Using Function Objects.