Universidad Carlos III de Madrid

The Figure class represents a generic figure that will materialize later on a specific one (Triangle, Square, etc...). In Java, all this concept is represented by abstract classes that must be declared with the abstract reserved keyword.

The first task of the exercise is to define the following Figure abstract class which represents a generic geometric figure:

public abstract class Figure {
    
    /** Name of the figure */
    String name;
    
    /** Constructor of the figure with a name */
    public Figure(String name) {
    }
    
    /** Calculates the area of a figure */
    abstract public double area();
    
    /** Indicates if the figure is regular or not */
    abstract public boolean isRegular();
    
}

Start by downloading the following code Figure.java.

public class Square extends Figure {

    /** Square vertexes */
    private Point vertex1;
    private Point vertex2;
    private Point vertex3;
    private Point vertex4;
      
    /** Constructor with name and vertexes */
    public Square(String name, Point diagonalVertex1, Point diagonalVertex3) {
    }

    /** Private method to calculate the vertexes for the other diagonal*/
    private void otherDiagonal(Point vertex1, Point vertex3) {
    }
    
    /** Method implementation to calculate the area */  
    public double area() {
      return 0;
    }
  
    /** Implementation of the abstract method to calculate if the figure is regular. */
    public boolean isRegular() {
      return false;
    }
  
    /** Returns a representative string of the square. */
    public String toString() {
      return null;
    }
}

The FiguresArea class, which contains an array of figures, is the one that will allows us to calculate the total area of a collection of figures. It has the following definition:

public class FiguresArea {
    
    /** The array of figures */
    private Figure figures[] = null;
    
    /**  Constructor of the class with a fixed number of figures. */
    public FiguresArea(int figuresNumber) {
    }
    
    /** Calculates the total area of the array figures. */
    public double totalArea() {
	return 0.0;
    }
    
    /** Adds a new figure in the first empty position of the figures array. */
    public void addFigure (Figure f){
    }
    
    /** Prints a list with the array figures. */
    public void print() {
    }
    
    /** Main Program */
    public static void main(String args[]) throws Exception {
    }    
}

The constructor of the class initialises the array with the maximum number of figures. The addFigure() method allows to add an object of the Figure class at the first free position of the array. The totalArea() method will add the respective areas of the figures that are contained in the array and will return the total sum of them. The print() method must print that total area and a descriptive message for every figure on the console.

The resolution of this exercise expects that the student learns the basics of references to a base class in inheritance hierarchies.

Download the following code listings ( Position.java, Figure.java, Castle.java, Queen.java ) and analyse both the class hierarchy and the Position class that is going to be used.

We are going to deal with a set of figure elements. As Figure class is abstract, we can't create instances from it, therefore, the collection of elements will be made up of objects from the Castle and Queen classes, indistinctly.

Implement the necessary code to hold, in the same collection and indistinctly, 2 objects of Queen class and 4 objects of Castle class.

Once the previous code has been implemented, traverse the collection invoking public void whoAmI() method to test the correct operation of the base class references.

Once this exercise has been finished, answer the following questions:

In Java, an interface represents a kind of specification for all classes that implement it. Is is normally used to define a set of methods that we want to be provided by those classes.

For example, the Comparable interface represents objects that can be compared among them. It defines the compareTo() method that allows to compare two objects. Every class whose objects want to be compared, as stated before, must implement this method. With an interface, further design and reuse of code is easily made since all objects share the same comparison method and the result of it.

Before going on to the next sections, try to answer the following questions:

All classes that are defined in this exercise must provide a basic set of methods, such as calculating the area of a geometric figure. In Java, this is achieved by defining the interface that declares all methods that must be implemented by the classes that implement it. For this exercise, every class that is created must implement the Figure interface.

An abstract class is a class that can not be instantiated. This is shown by the use of the abstract keyword in its declaration. An abstract class has "at least" one abstract method. That is, a method which is only declared but not implemented. This abstract method should be implemented by any subclass of the class. There is no point in instantiating objects of an abstract class and only subclasses of it can instantiate objects.

Remember that an abstract class can have constructors, though objects from it can not be instantiated.

The next class to implement represents a rectangle and, obviously, its name will be Rectangle. This class inherits from GeometricFigure and implements the Figure interface. A rectangle is defined by two dimensions, the base and the height and both are assumed to be integer values.

REMEMBER: If a class implements an interface, automatically, all subclasses of it also implement that interface, even though this is not explicitly mentioned in its declaration. Notice that Rectangle implements the Figure interface though you haven't mentioned it in its declaration. That is because Rectangle inherits from a class that implements Figure.

A square is a type of rectangle where both base and height are equals. In Java, we can easily create a Square class by deriving it from Rectangle class.

In this section, you must improve FiguresTesting class to provide a user interface in text mode that allows the user to choose the figure that he/she wants to print on the console, then asks for the correct parameters for each figure, creates an instance of the correct class and, finally, prints the figure description and the figure itself on the console.

Use the following menu:

1.- Create rectangle
2.- Create square
3.- Display figure
0.- Exit

If the user selects one of the 2 first options, the program must ask him/her for the correct data. If he/she selects option 3, the last figure will be printed on the console (including its description). The menu must be shown until the user select the option Exit.

To simplify the generation of the correct object from the data entered by the user, it would be useful to add a readFigureData() method to each class. This method would receive, as an input parameter, an object of type BufferedReader from which, it will read the data introduced by the user. Then, it would return a correct instantiated object of the class with the entered data. Declare it as a static method.

Answer the following questions:

This exercise tries to get an overall view of how Object Oriented Programmig allows us to reuse code, as long as we use it correctly.

Let's assume that we have a little knowledge about cypher theory with strings of characters. Let's say that we have heard of several cypher algorithms, most of them which are very difficult to implement. However, there is one called Caesar, which is based on character's rotation, that has a reasonable implementation.

Caesar's algorithm is based on the order of the alphabet characters. Each character of the input text string is replaced by an output character that is calculated by adding N positions to the letter on the alphabet. For example, if we find the 'A' character and the value of N is 3, the output character that will replace would be 'D'.

Implement an Object Oriented Programming solution that allows us to easily change this algorithm by another one which could be better in the future.

First of all, write a solution based on an abstract Cypher class that models a generic encryption algorithm, with the basic encrypt and decrypt operations (that, for instance, receive a String and return a String), and then a CaesarCypher class that inherits from the first one and implements the Cesar's algorithm.

Second, write a solution based on the definition of a Cryptable interface and a CaesarCypher class that implements it.