Description
The purpose of this assignment is to practice OOP with exceptions, generics, and collections. Your task is to create a set of classes for storing and managing a game catalog. This will require an understanding of exceptions, generics, and the Java collections framework.
Rules
1. You may import the following classes only: Collection, List, LinkedList, A
ayList, Set, HashSet, EnumSet, A
ays, Collections
2. Comment your code in javadoc style, especially any parts that is not obvious what you are doing.
3. Class fields should not be visible to other classes (unless otherwise noted). Create getter methods if necessary.
4. You may add your own methods, but they must be declared private. No additional fields are allowed.
Grading
The implementation of each class is worth the points specified at the beginning of each section. We will use both automated testing and manual inspection for the grading. Partial credit is possible but do not count on it if your code does not pass any tests. Hard coding to pass a certain set of test cases will receive an automatic zero.
Testing
You will be programming without a tester. The goal is to help you put more focus on writing logically co
ect programs instead of trying to pass certain tests only. Before using any tester, make sure you always compile and run your code without the tester to verify that there are no syntax e
ors. It is expected and helpful to write JUnit tests for running some basic tests on your own. From now on, place your debugging logic (static main methods) into a tester (e.g., P4Tester.java).
On Windows: javac -cp .;junit-cs211.jar *.java
java -cp .;junit-cs211.jar P4Tester
On Mac or Linux: javac -cp .:junit-cs211.jar *.java
java -cp .:junit-cs211.jar P4Teste
Note: all the required classes and public members must exist for the grading tester to compile successfully. If you would like to test your code before you have implemented everything, make sure you have at least created the appropriate files and included the necessary members (fields and methods), even if their implementation is not complete.
The grader will check the framework’s (collections) interface and class you use. Using classes without their interfaces will result on deductions.
Tasks
You must implement the following classes based on the specification provided. Be reminded that it is very important to follow these specs, otherwise your code will not compile
un with the tester. If you get e
ors or warnings from the compiler (e.g., erasure, abstract), do not ignore them.
Game class
This is an abstract class for representing different kinds of games (videogames, table-top games, etc.). All the games in the game catalog will be descendants of this class. It should implement the Comparable interface and specify the generic type for that interface so that Game can be compared to another Game. However, the details of the compareTo method should be left to subclasses.
• puc: A string representing the Product Unique Code (PUC) of this game. Should have a getter (final) but no setter.
• genres: A collection of strings representing the genres of this game. Should have a getter (final) but no setter. Such strings are unique within the collection. At least one genre must be provided.
• getType(): A method that will return a string representing the type of this game. The details of this method should be left to subclasses.
• Game(puc, genres): constructor with two arguments. Initializes private fields.
• equals(obj): Ove
ides parent to return true if the given object is also a game, and their PUCs match. Otherwise, return false.
• toString(): returns a string representation of this game. This should have the form "type: type, puc: puc, genres: genres", replacing the italicized placeholders with the string returned by getType(), puc, and genres values.
Collections such as genres must be formatted using A
ays.deepToString().
Spacing, spelling, and capitalization are all important. Carefully implementing this method will allow for significant code reuse in subclasses.
Format enumeration
This is an enumeration representing the different formats a videogame can be distributed. It should have the following options:
• CARTRIDGE
• CD
• MINIDISC
• BLURAY
• DOWNLOAD
• CLOUD
Videogame class
This is an abstract subclass of Game that represents different types of videogames. It has a constructor, toString(), and provides an implementation for compareTo().
• publisher: A string with the name of the publisher. Should have a getter (final) but no setter.
• director: A string with the name of the director. Should have a getter (final) but no setter.
• formats: A collection of instances of the Format enum (described above). Should have a getter (final) but no setter. Such instances are unique within the collection. At least one format must be provided.
• developers: A collection of strings with the names of the studios that developed the videogame. Should have a getter (final) but no setter. The order of developers indicates their contribution efforts, it must be preserved.
• title: A string with the title of the videogame. Should have a getter (final) but no setter.
• year: An integer representing the year the videogame was released. Should have a getter (final) but no setter.
• Videogame (puc, genres, publisher, director, formats, developers, title, year): A constructor which sets the private fields. Must call the parent class constructor.
• toString(): A string representation of this object. Has the form "publisher: publisher, director: director, formats: formats, developers: developers, title: title, year: year, " followed by the information given by its parent’s toString() method. Consider how inheritance can enable code reuse in this method. Collections such as formats and developers must be formatted using A
ays.deepToString().
• compareTo(argument): This method returns an integer value representing whether the instance given as an argument should be ordered before or after the calling instance. Negative numbers indicate the calling instance (this) should be ordered first. Positive numbers indicate the argument should be ordered first. Zero indicates that both instances have the same ordering. This method is what is used to sort collections in the collections framework. See the description of the sort() method in the GameCatalog class for how this method should be implemented.
FirstPartyVideogame class
This is a concrete class that inherits from VideoGame and represents first-party games. It ove
ides the constructor, and getType() methods.
• getType(): Returns the string "First-Party".
• FirstPartyVideogame(puc, genres, publisher, director, formats, developers, title, year): Calls the parent class constructor with the given arguments.
SecondPartyVideogame class
This is a concrete class that inherits from VideoGame and represents first-party games. It ove
ides the constructor, and getType() methods.
• getType(): Returns the string "Second-Party".
• SecondPartyVideogame(puc, genres, publisher, director, formats, developers, title, year): Calls the parent class constructor with the given arguments.
ThirdPartyVideogame class
This is a concrete class that inherits from VideoGame and represents first-party games. It ove
ides the constructor, and getType() methods.
• getType(): Returns the string "Third-Party".
• ThirdPartyVideogame(puc, genres, publisher, director, formats, developers, title, year): Calls the parent class constructor with the given arguments.
ReleasedGame class
This is a generic class, with two type specifications, that represents a mapping between keys and values. The first type can be any type, the second type must implement the Comparable interface and be comparable to other instances of the same type. The Releasedgame class itself should also implement Comparable, such that ReleasedGame instances are comparable to other ReleasedGame instances of the same kind (same generic type specifiers). The specific syntax for this class declaration should be:
public class ReleasedGame
implements Comparable
• key: A reference of the first generic type. Should have a getter but no setter.
• value: A reference of the second generic type. Should have a getter but no setter.
• ReleasedGame(key, value): A constructor which sets the private data members.
• equals(obj): Ove
ides the parent’s method to return true if the other object is also a ReleasedGame and has the same value. Otherwise, returns false.
• compareTo(...): Returns the result of comparing the value field. If the generic specification is co
ect, there should be no need to cast anything.
Searchable interface
This interface contains a single method, matches, which returns true if a given game matches the criteria of this search.
• matches(ReleasedGame): this is the method that will be called by the game catalog when searching. Items which return true will be included, items which return false will not be.
GameSearcher class
This is a concrete class that implements the Searchable interface, and represents a search with multiple terms, matching games which contain a given search strings among their fields.
• searchTerms: a collection of strings to search for in each released game. No getters or setters.
• GameSearcher(searchTerms): constructor that takes a collection of strings and should set searchTerms.
• matches(ReleasedGame): returns true if the released game contains any of the search terms. Consider using the string returned by the toString method of the Game class. You may find the string method indexOf useful as well.
GameCatalog class
This class represents the catalog of released games. It contains a list of games and provides methods for games with the PUC it has been released with, returning a subset of items in the catalog given some search terms, and sorting the catalog.
• catalog: A list of released games. A released game is an instance of the ReleasedGame class with the first type specified to be a string, and the second type specified to be Game (ReleasedGame
). Should have a getter (final), no setter.
• GameCatalog (): A default constructor which initializes the catalog.
• add(puc, game): A method for adding games to the catalog. The first argument is a string, the second the game. This method should create a new ReleasedGame instance with the given data.
• search(searchable): This method creates and returns a new list of released games. This new list should contain all released games from the catalog for which the given searchable's matches method returns true.
• sort(): This method sorts (ascending) the field catalog according to the following rules:
1. First-party videogames come before second-party videogames, second-party videogames come before third-party videogames.
2. First-party videogames are sorted first by year, then by title.
3. Second-party videogames are sorted first by year, then by number of developers.
4. Third-party videogames