Introduction

This assignment will extend the previous one by:

1. Adding 3D and 2D boards with aircrafts and ships with different shapes to the Battleship game by means of inheritance mechanisms.
2. Handling error situations via exceptions.

In order to be able to have 3D and 2D boards, as well as ships and aircrafts with different shapes, and at the same time avoid duplicating our code, we will implement a hierarchy of classes (see the class diagram below), some of which will be abstract. Most of the code handling the logic of the game (adding ships or aircrafts, shooting them, etc.) will be in those abstract classes. These classes will use the methods in their sub-classes to implement the logic of the game without having to bother about the type of board (2D or 3D) and type of craft (ship or aircraft) they are working with.

Class diagram

These are the UML class diagrams that represent the classes in our model; the methods in italics are abstract methods:

The following sections describe all the methods that you have to modify or implement from scratch for this assignment. Attributes or relationships will not be covered as they are already shown in the UML diagram. Elements which do not change with regard to the previous assignment will not be explained again. Setters or getters which simply return the current value of a property, or set a property to a new value, will not be commented either. You will have to decide when to use defensive copy in a setter or getter by looking at the class diagram.

When indicated, your code must check that the argument values passed to a method are correct. The arguments that are references do not need to be checked, unless otherwise stated.

Package structure and directories

We will create three new packages:

• model.ship for the 2D board and ships;
• model.aircraft for the 3D board and aircrafts;
• model.exceptions for the classes dealing with exception.

Roadmap

It is strongly recommended that you implement your solution in the very same order followed in this document.

1. Implement the hierarchy of classes for the exceptions: class BattleshipException and its sub-classes.
2. Implement the hierarchy of classes for the coordinates: classes Coordinate, Coordinate2D, Coordinate3D and CoordinateFactory.
3. Implement the hierarchy of classes for the different types of crafts: classes Craft, Ship, Aircraft and its sub-classes.
4. Implement the hierarchy of classes for the boards: classes Board, Board2D and Board3D.

Exception catching

In this assignment, only the main method or the unit tests catch exceptions thrown by the methods enumerated in the following sections. Many of these exceptions, however, will be caught by methods in some of the new classes of later assignments.

Changes to make to class Coordinate

• Make the class Coordinate abstract

public abstract class Coordinate {
   ...
}

• Change its constructor so that it receives the amount of dimensions of the coordinate, and allocate memory for the attribute components.
• Make the methods copy() and adjacentCoordinates() abstract (make a copy of their implementation, you will use it in Coordinate2D). They will be implemented in Coordinate2D and Coordinate3D. These abstract methods will allow the methods in the rest of classes, such as Board and Craft, to create a copy of a coordinate, or obtain its adjacent positions, without having to wonder whether it is a 2D or 3D coordinate. In this way most of the code will be in the classes belonging to package model.
• Replace any call to the copy constructor of Coordinate by a call to the method copy()
• Make sure that methods add(·) and subtract(·) do their job on all the components available. It is worth noting that it is possible to add/subtract 2D and 3D coordinates; in those case the operation will be done only on the components available (first two components of the coordinate); the type of coordinate to return will be that of the object being used to invoke the method (this). For example: (1, 4, 2) + (2, 3) = (3, 7, 2).
• Remove the implementation of toString(), it will be moved to Coordinate2D.
• Change the visibility of the constructor and copy constructor to protected.
• Change methods set(·) and get(·) so that the exception IllegalArgumentException is thrown when the component to set/get is out of range.
• Change methods add(·) and subtract(·) so that they check if the coordinate received as argument is null, and if it is null the exception NullPointerException is thrown. This checking and throwing of the exception, when appropriate, can be easily done as follows:

Objects.requireNonNull(c);

Class Coordinate2D

Coordinate2D will belong to package model.ship. It inherits from Coordinate and has to implement the methods shown in the UML diagram.

• The constructor creates a coordinate with two dimensions and assigns the corresponding values.
• The copy constructor passes the argument received to the copy constructor of the superclass.
• copy() makes use of the copy constructor.
• The implementation of adjacentCoordinates() is almost identical to that of the class Coordinate of the previous assignment, but using the method CoordinateFactory.createCoordinate(·) (see below) to create a 2D coordinate when needed.
• toString() is identical to that of the class Coordinate of the previous assignment.

Class Coordinate3D

Coordinate3D will belong to package model.aircraft. As Coordinate2D, it inherits from Coordinate and has to implement the methods shown in the UML diagram. The implementation of its methods is similar to their implementation in Coordinate2D but extending them to a third dimension:

• adjacentCoordinates() will return a set with 26 positions.
• toString() will return a String with the three components of the coordinate, for example (1, 1, 4)

Class CoordinateFactory

It is often very useful to have a method that encapsulates object creation. This is usually carried out by implementing a factory method. To do this, add the new class CoordinateFactory to your implementation. This class has only a static method, createCoordinate(·), that receives a variable number of arguments of type int and returns a 2D or 3D coordinate, depending on how many arguments it receives. The signature of the method is as follows:

public static Coordinate createCoordinate(int... coords) {
    ...
}

Inside the method, coords will be an array. If the amount of elements in this array is below 2 or above 3, the method will throw the exception IllegalArgumentException. Remember that every array has an attribute length storing the amount of elements of the array.

Extraction of the superclass Craft

We are going to extract a superclass with name Craft using the Refactor facility provided by Eclipse. To extract this superclass do as follows:

1. Right click on the class Ship, then select Refactor->Extract Superclass…
2. Set the name of the superclass to be created: Craft
3. Select all attributes and methods so that they are moved to the superclass
4. Make sure that the option Use the extracted class where possible is selected
5. Click on the Finish button

As a results we will have two classes, Craft and Ship, with Ship inheriting from Craft. If you have a look to the line where the class Ship is declared, you will see that the extends reserved word is used:

public class Ship extends Craft {
    ...
}

Changes to make to the class Ship

• Create package model.ship
• Move this class to the new package. You can do so with Refactor->Move….
• Change the constructor so that it passes its arguments to the constructor in its superclass using super().
• Make the class abstract.

Sub-classes of Ship

Ship will have a total of four sub-classes, all belonging to package model.ship: Battleship, Carrier, Cruiser and Destroyer. Do as follow:

1. Create these sub-classes.
2. Create their constructors. They have to pass the orientation, the symbol used to represent them (see below) and their name (that of the class) to their superclass using super(). After that, they have to allocate memory and initialise the attribute shape (see below).

Class Aircraft

• Create package model.aircraft
• Create an abstract class with name Aircraft that inherits from Craft and belongs to package model.aircraft.
• Implement the constructor so that it behaves as the constructor of Ship.

Sub-classes of Aircraft

Aircraft will have a total of three sub-classes, all belonging to package model.aircraft: Bomber, Fighter and Transport. Like the sub-classes of Ship these sub-classes have to initialise the attribute shape in their constructor (you can download the initialisation of the attribute shape from here). Their constructors will also pass the orientation, the symbol used to represent them (see next) and their name (that of the class) to their superclass using super().

Extraction of the superclass Board

What follows is an explanation of how to extract the superclass Board

1. Rename class Board to Board2D (Refactor -> Rename…).
2. Extract the superclass Board from Board2D (Refactor->Extract Superclass…). All members (attributes and methods), except the methods checkCoordinate(·) and show(·), must be moved to the superclass.
3. Move Board2D to package model.ship (Refactor->Move…).

Changes to make to class Board

• Make the class Board abstract
• Declare an abstract method with name checkCoordinate(·)

public abstract boolean checkCoordinate(Coordinate c);

• Declare an abstract method with name show(·)

public abstract String show(boolean unveil);

These two methods will be implemented in Board2D and Board3D.

• Add constant BOARD_SEPARATOR with value '|'.
• Move the code in the constructor of Board2D to the constructor of Board.
• Change the attribute board so that it maps coordinates to crafts (instead of ships):

private Map<Coordinate,Craft> board;

• Check the visibility of the attributes of Board. All of them should be private with the exception of the constants, which should be public. Same as in the second practical assignment.
• In the constructor, if the size of the board is not within the limits, the exception IllegalArgumentException must be thrown.
• In getNeighborhood(·) check that the arguments are not null and if they are null throw exception NullPointerException.
• In hit(·) check that the coordinate received as argument is within the limits of the board and if it is not, throw exception InvalidCoordinateException. If a method invoked by hit(·) throws an exception it must be propagated (i.e. it must not be caught).
• Rename method getShip() to getCraft() (Refactor -> Rename…).
• Changes to method addShip(·)
  • Rename it, the new name is addCraft(·)
  • Change the method signature to public boolean addCraft(Craft craft, Coordinate position)
  • If any of the coordinates to be occupied by the new craft (ship or aircraft) is not within the limits of the board, throw exception InvalidCoordinateException; if any of them is occupied by another craft, throw exception OccupiedCoordinateException; if any of them is next to another craft, throw exception NextToAnotherCraftException.

Changes to make to class Board2D

• Change the constructor of Board2D so that it passes the size received as argument to the constructor of Board.
• Annotate methods checkCoordinate(·) and show(·) with @Override to tell the compiler that they implement methods inherited from Board:

@Override
public boolean checkCoordinate(Coordinate c) {
    ...
}

• Change the implementation of checkCoordinate(·) so that it checks that the coordinate received as argument is of type Coordinate2D. If it is not an instance of Coordinate2D, throw an exception of type IllegalArgumentException.
• Change the implementation of show(·) so that it uses CoordinateFactory.createCoordinate(·) to create coordinates of type Coordinate2D.

Class Board3D

The new class Board3D is analogous to Board2D but working with coordinates of type Coordinate3D. This class inherits from Board and has to implement its constructor and methods checkCoordinate(·) and show(·):

• The constructor is identical to that of Board2D
• The implementation of checkCoordinate(·) is analogous to that of Board2D.checkCoordinate(·); remember to check that the coordinate received is of type Coordinate3D and to check that the three values of the coordinate are within the limits of the board.
• This class belongs to package model.aircraft

????????|????????|????????|????????|????????|????????|????????|????????
????????|????????|??? ????|????????|????????|????????|????????|????????
????????|????????|???•????|????????|????????|????????|????????|????????
????????|????????|??•••???|????????|????????|????????|????????|????????
????????|????????|???•????|????????|????????|????????|????????|????????
????????|????????|????????|????????|????????|????????|????????|????????
????????|????????|????????|????????|????????|????????|????????|????????
????????|????????|????????|????????|????????|????????|????????|????????

Previous tests

Here you can download the pre-tests. Copy them to a model folder in the test directory of your project.

There are some tests to be completed in each file (look for the comment //TODO). These will also be used to grade your assignment, so it is worth trying to complete them, so you can get a good score. Most probably, you will be required to write some unit tests in the practical exam, so make yourself sure you know how to code them!