Java OOP problem

Question

I'm working on a Java programming assignment. In this assignment, there's an immutable class Book and a mutable class BookCopy. You can have multiple BookCopy of the same Book.

Now here comes the tricky part, there's an interface Library that has a public void checkout(BookCopy copy) method, a public BookCopy buy(Book book) method which adds a new copy of the book to the library's collection and returns a defensive copy of the BookCopy, and a bunch of other functions including get()'s.

This is tricky because BookCopy is mutable so I do not override the equals() method and also because BookCopy is mutable, any function in the Library returning BookCopy will return defensive copies... so I have no idea how checkout(copy) will work since the passed in argument will always be a defensive copy AND because I did not override equals() in BookCopy, the argument will never equal anything in the Library private fields.

The assignment can be found at: https://openlearninglibrary.mit.edu/courses/course-v1:MITx+6.005.1x+3T2016/courseware/Week_9/ps3-beta/?activate_block_id=block-v1%3AMITx%2B6.005.1x%2B3T2016%2Btype%40sequential%2Bblock%40ps3-beta

Answer 1

"Finally, you'll be expected to implement equality appropriately for all the types." From Problem Set 3: The Librarians - Overview - Paragraph 1

Have you ever heard of value objects and entities? The difference is all about what establishes the objects identity. A value objects identity is about it's values. An entities is not. An entity could change every value and still be itself. Understand, this is about modeling. This is a choice we're making about how we treat something.

For example, if you loan me a dollar, and I give you back a dollar, only for you to get upset that I didn't give you back the same dollar, then you're treating your dollar like an entity and not a value object.

Caring more about the dollars serial number than the face value of the dollar is a modeling choice. It really has nothing to do with dollars being immutable. However, when dealing with something like a gift card, whose value can change over time, trying to model that things identity as a value object based on its current value becomes silly.

Immutable things can have their identities modeled either way. There are advantages to being able to model identity on values. But mutable things make basing identity on values a huge pain.

Identity is important to you here because how you implement equals (and you were told to implement equals) shows how you're modeling identity.

Overriding equals is not a no-no for mutable objects if you've given them an identity. Just because part of an object is mutable doesn't mean the whole thing is. Keep wherever you're storing the identity immutable and the rest can mutate as it likes. This will work with HashCodes and Sets just fine if you understand that those will be operating on the immutable identity and not the mutable values.

the assignment does not allow the change of the BookCopy(Book book) constructor - Ray

    /**
     * Make a new BookCopy, initially in good condition.
     * @param book the Book of which this is a copy
     */
    public BookCopy(Book book) {
        throw new RuntimeException("not implemented yet");
    }

Looks to me like you're being required to change it.

Don't change the method signatures and specifications: The public methods provided for you to implement in Book, BookCopy, and Library must use the method signatures and the specifications that we provided.

That means you can't simply pass in the UUID Doc Brown wanted you to use. Your constructor will have to reach out and get it (yuck).

Now this is student code so such shenanigans are forgivable. But, rather than making you import or implement some UUID library, a typical student solution for this problem is to use a static int. You can increment it in the constructor. It will tell you how many instances of BookCopy you have created (not that you really care about that). It wont tell you which book it's a copy of, or how many copies of that book exist, but it will still be unique and that's enough. Save whatever it was when the BookCopy was constructed and save whatever book it's a copy of and that's your identity.

Answer 2

From what you wrote, this sounds like a trivial problem. Each BookCopy object should have a unique identifier which checkout can use to identify it in the library. It could be simply a GUID, or a counter for each BookCopy, combined with the ID of the Book. The library itself should store the set of all of these IDs associated with the information if a book is currently checked out, who is currently posessing the book and since when.

Of course, the unique identifier of a BookCopy should stay constant after it is initialized once, at least that is what I would expect from such an object. Still a BookCopy object does not need to be immutable in full in case it contains more (non-identifying) attributes. You can also override equals for comparing the IDs, if you like (but if you don't like it, implement the lookup/equality checking using the IDs separately, in a function of your choice).

Answer 3

It might be that I'm stating the obvious, I'm helpless I find it difficult to refrain, what if is not the obvious and I'm just smart.

... because BookCopy is mutable so I do not override the equals() method...

...or override equals and hashCode methods and remove them from any data structure relying on hashCode before mutating the objects, mutate them and then add them back to the data structure, or develop own implementations of collections relying on hashCode to support removing the elements from the collection when collection's getters methods are called, kind of the collection saying "you need an element form the collection? take it, it's out, it's your concern what you do with it". It might be that the assignment is just a mean to get a new set of implementations for Collection interface safe to use with mutable objects.