Universidad Carlos III de Madrid

public abstract class Figure {

    // Name of the figure
    private String name;

    // Constructor of the figure with a name
    public Figure (String name){
        this.name = name;
    }

    // Calculates the area of a figure
    public abstract double area();

    // Indicates if the figure is regular or not
    public abstract boolean isRegular();

    // Gets the name of the figure
    protected String getName(){
        return this.name;
    }

    // Sets the name of the figure
    protected void setName(String name){
        this.name = name;
    }
}

  

public class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    /**
     * Returns the string representation of the point.
     *
     */
    public String toString() {
        return "(" + x + ", " + y + ")";
    }

    /**
     * Returns the distance to the origin.
     *
     */
    public double distance() {
        Point origin = new Point(0.0, 0.0);
        return distance(origin);
    }

    /**
     * Returns the x coordinate of the point.
     *
     */
    public double getX() {
        return x;
    }

    /**
     * Returns the y coordinate of the point.
     *
     */
    public double getY() {
        return y;
    }

    /**
     * Returns the distance to another point.
     *
     */
    public double distance(Point anotherPoint) {
        return Math.sqrt(Math.pow(x - anotherPoint.getX(), 2) +
                         Math.pow(y - anotherPoint.getY(), 2));
    }

    /**
     * Returns the quadrant in which the point is.
     *
     */
    public int quadrant() {
        if (x > 0.0 && y > 0.0) {
            return 1;
        } else if (x < 0.0 && y > 0.0) {
            return 2;
        } else if (x < 0.0 && y < 0.0) {
            return 3;
        } else if (x > 0.0 && y < 0.0) {
            return 4;
        } else {
            // (x==0.0 || y==0.0)
            return 0;
        }
    }

    /**
     * Returns the nearest point of the array in the parameter, or
     * null if array is empty.
     *
     */
    public Point nearest(Point[] otherPoints) {
        Point nearestPoint = null;
        double minDistance = Double.MAX_VALUE;
        double currentDistance;

        for (int i=0; i<otherPoints.length; i++) {
            currentDistance = this.distance(otherPoints[i]);
            if (currentDistance <= minDistance) {
                minDistance = currentDistance;
                nearestPoint = otherPoints[i];
            }
        }
        return nearestPoint;
    }
}

  

public class Circle extends Figure {

    public static final double PI = Math.PI;
    private Point center;
    private int radius;

    // Constructor of the circle
    public Circle (String name, Point center, int radius){
        super(name);
        this.center = center;
        this.radius = radius;
    }

    // Calculates the area of the circle
    public double area() {
        return PI*radius*radius;
    }

    // The circle is always a regular figure
    public boolean isRegular() {
        return true;
    }

    // Circle to String
    public String toString() {
        return ("Circle: " + getName() + "; Radius: " + getRadius()
                + "; Center" + getCenter().toString());
    }

    // Gets the center of the circle
    private Point getCenter(){
        return this.center;
    }

    // Sets the center of the circle
    private void setCenter(Point center){
        this.center = center;
    }

    // Gets the radius of the circle
    private int getRadius(){
        return this.radius;
    }

    // Sets the radius of the circle
    private void setRadius(int radius){
        this.radius = radius;
    }
}

  

public class Triangle extends Figure{

    // Vertexes of the triangle
    private Point vertex1;
    private Point vertex2;
    private Point vertex3;

    // Constructor of the triangle
    public Triangle(String name, Point vertex1, Point vertex2, Point vertex3) {
        super(name);
        this.vertex1 = vertex1;
        this.vertex2 = vertex2;
        this.vertex3 = vertex3;
    }

    // Calculates the area of the triangle
    public double area() {
        return 0.5 * Math.abs(vertex1.getX() * (vertex2.getY() - vertex3.getY())
                         + vertex2.getX() * (vertex3.getY() - vertex1.getY())
                         + vertex3.getX() * (vertex1.getY() - vertex2.getY()));
    }

    // Indicates if the triangle is regular (equilateral triangle) or not
    public boolean isRegular(){
        return (vertex1.distance(vertex2) == vertex2.distance(vertex3))
            && (vertex1.distance(vertex2) == vertex3.distance(vertex1));
    }

    // Triangle to String
    public String toString() {
        return ("Triangle: " + getName() + "; Vertexes: "
                + getVertex1().toString() + getVertex2().toString()
                + getVertex3().toString());
    }

    // Gets vertex1 of the triangle
    private Point getVertex1() {
        return vertex1;
    }

    // Gets vertex2 of the triangle
    private Point getVertex2() {
        return vertex2;
    }

    // Gets vertex3 of the triangle
    private Point getVertex3() {
        return vertex3;
    }

    // Sets vertex1 of the triangle
    private void setVertex1(Point vertex1) {
        this.vertex1 = vertex1;
    }

    // Sets vertex2 of the triangle
    private void setVertex2(Point vertex2) {
        this.vertex2 = vertex2;
    }

    // Sets vertex3 of the triangle
    private void setVertex3(Point vertex3) {
        this.vertex3 = vertex3;
    }
}

  

public abstract class Quadrilateral extends Figure {

    // Vertexes of the quadrilateral
    private Point vertex1;
    private Point vertex2;
    private Point vertex3;
    private Point vertex4;

    // Constructor of the quadrilateral
    public Quadrilateral(String name, Point vertex1, Point vertex2,
                         Point vertex3, Point vertex4) {
        super(name);
        this.vertex1 = vertex1;
        this.vertex2 = vertex2;
        this.vertex3 = vertex3;
        this.vertex4 = vertex4;
    }

    // Calculates the area of the quadrilateral
    public abstract double area();

    // Indicates if the quadrilateral is regular.
    public boolean isRegular(){
        return checkRectangle(vertex1, vertex2, vertex3, vertex4);
    }

    /**
     * Indicates if the quadrilateral is a rectangle or square by
     * comparing sizes and diagonals and calculating the scalar product.
     *
     */
    private boolean checkRectangle(Point v1, Point v2, Point v3, Point v4){
        Point auxVertex = v1.nearest(new Point[]{v2,v3,v4});
        if (auxVertex.equals(v2)){
            return v1.distance(v3) == v2.distance(v4)
                && v1.distance(v4) == v2.distance(v3)
                && scalarProduct(v1,auxVertex,v1.nearest(new Point[]{v3,v4}));
        } else if (auxVertex.equals(v3)){
            return v1.distance(v2) == v3.distance(v4)
                && v1.distance(v4) == v3.distance(v2)
                && scalarProduct(v1,auxVertex,v1.nearest(new Point[]{v2,v4}));
        } else if (auxVertex.equals(v4)){
            return v1.distance(v2) == v4.distance(v3)
                && v1.distance(v3) == v4.distance(v2)
                && scalarProduct(v1,auxVertex,v1.nearest(new Point[]{v2,v3}));
        } else {
            return false;
        }
    }

    private boolean scalarProduct(Point p1, Point p2, Point p3){
        return (p3.getY()-p1.getY())*(p2.getY()-p1.getY())
	    + (p3.getX()-p1.getX())*(p2.getX()-p1.getX()) == 0;
    }

    // Quadrilateral to String
    public String toString(){
        return (getName() + "; Vertexes: " + getVertex1().toString()
                + getVertex2().toString() + getVertex3().toString()
                + getVertex4().toString());
    }

    // Gets vertex1 of the quadrilateral
    protected Point getVertex1(){
        return vertex1;
    }

    // Gets vertex2 of the quadrilateral
    protected Point getVertex2(){
        return vertex2;
    }

    // Gets vertex3 of the quadrilateral
    protected Point getVertex3(){
        return vertex3;
    }

    // Gets vertex4 of the quadrilateral
    protected Point getVertex4(){
        return vertex4;
    }

    // Sets vertex1 of the quadrilateral
    protected void setVertex1(Point vertex1){
        this.vertex1 = vertex1;
    }

    // Sets vertex2 of the quadrilateral
    protected void setVertex2(Point vertex2){
        this.vertex2 = vertex2;
    }

    // Sets vertex3 of the quadrilateral
    protected void setVertex3(Point vertex3){
        this.vertex3 = vertex3;
    }

    // Sets vertex4 of the quadrilateral
    protected void setVertex4(Point vertex4){
        this.vertex4 = vertex4;
    }
}

  

public class Rectangle extends Quadrilateral {

    // Constructor of the rectangle
    public Rectangle(String name, Point vertex1, Point vertex2, Point vertex3,
                     Point vertex4) throws BadFigureException {
        super(name,vertex1,vertex2,vertex3,vertex4);
        if (isRegular() == false){
            throw new BadFigureException("The vertexes are incompatible with"
                                         + " a rectangle.");
        }
    }

    // Calculates the area of the rectangle (base times the height)
    public double area() {
        Point[] vertices234 = new Point[] {getVertex2(), getVertex3(),
                                           getVertex4()};
        Point auxVertex = getVertex1().nearest(vertices234);
        Point[] otherVertices = null;
        if (auxVertex.equals(getVertex2())) {
            otherVertices = new Point[] {getVertex3(), getVertex4()};
        } else if (auxVertex.equals(getVertex3())) {
            otherVertices = new Point[] {getVertex2(), getVertex4()};
        } else if (auxVertex.equals(getVertex4())) {
            otherVertices = new Point[] {getVertex2(), getVertex3()};
        }
        double base = getVertex1().distance(auxVertex);
        double height = auxVertex.distance(auxVertex.nearest(otherVertices));
        return base * height;
    }

    // Rectangle to String
    public String toString() {
        return ("Rectangle: " + super.toString());
    }
}

  

import java.util.ArrayList;

public class FiguresSet {

    // Array of figures
    private ArrayList<Figure> figures;

    // Constructor of FiguresSet
    public FiguresSet() {
        figures = new ArrayList<Figure>();
    }

    // Calculates the total area of the figures
    public double totalArea() {
        double totalArea = 0;
        for (int i=0; i<figures.size(); i++){
                totalArea = totalArea + figures.get(i).area();
        }
        return totalArea;
    }

    // figures to String
    public String toString() {
        String s = new String();
        for (int i=0; i<figures.size(); i++){
                s = s + figures.get(i).toString() + "\n";
        }
        return s;
    }

    // Adds a new figure to the FigureSet
    public void addFigure(Figure f) {
        figures.add(f);
    }

    // Main program
    public static void main(String args[]) throws Exception {
        FiguresSet figures = new FiguresSet();
        Circle c = new Circle("Circle1", new Point(1, 1), 4);
        Triangle t = new Triangle("Triangle1", new Point(1, 1),
                                  new Point(3, 1), new Point(2, 3));
        figures.addFigure(c);
        figures.addFigure(t);
        try {
            Rectangle r = new Rectangle("Rectangle1", new Point(1, 4),
                                        new Point(4, 1), new Point(1, 1),
                                        new Point(4, 4));
            figures.addFigure(r);
        } catch (BadFigureException e) {
            System.out.println("Error: " + e.getMessage());
        }
        System.out.println(figures.toString());
        System.out.println("Total area: " + figures.totalArea());
    }
}