Question

In Java, write a class Rectangle. This Rectangle class should have only the following public methods (you can add other non-public methods):

• Write a constructor that creates a rectangle using the x, y coordinates of its lower left corner, its width and its height in that order. Creating a rectangle with non-positive width or height should not be allowed, although x and y are allowed to be negative.

• Write a method overlap(Rectangle other). This method should return true if this rectangle overlaps with other, false otherwise. Rectangles that touch each other are not considered to be overlapping.

• Write a method intersect(Rectangle other). This method should return a Rectangle object that represents the overlap of the two rectangles. If no intersection exists, it should throw a NoSuchElementException with a helpful message.

• Write a method union(Rectangle other). This method returns a Rectangle object that represents the union of this rectangle and the other rectangle. The union is the smallest rectangle that contains both rectangles. Note that unlike the intersection, the union always exists.

Answer 1

import java.util.NoSuchElementException;

public class Rectangle {
    private int x,y;
    private int height,width;
    /**
     *  creates a rectangle using the x, y coordinates
     *  of its lower left corner, its width and its height
     *  in that order. Creating a rectangle with non-positive
     *  width or height
     *  should not be allowed,
     *  although x and y are allowed to be negative.

     */
    public Rectangle(int x,int y,int height, int width)
    {
        if(height>0)
            this.height= height;
        if(width>0)
            this.width= width;
        this.x= x;
        this.y=y;
    }
    /**
     *  a method overlap(Rectangle other).
     *  This method should return true if this rectangle overlaps
     *  with other, false otherwise. Rectangles
     *  that touch each other are not considered to be overlapping.
     */
    public boolean overlap(Rectangle other)
    {
        return (x < other.x + other.width && x + width > other.x && y < other.y + other.height && y + height > other.y);
    }
    /**
     * a method intersect(Rectangle other).
     * This method should return a Rectangle object that
     * represents the overlap of the two rectangles.
     * If no intersection exists,
     * it should throw a NoSuchElementException .
     */
    public Rectangle intersect(Rectangle other)
    {
        Rectangle rectangle=null;
        //finding new coordinates
        int x2 = this.x+ this.width;
        int x4 = other.x + other.width;
        int y1 = this.y - this.height;
        int y3 = other.y - other.height;
try {
        // find intersection:
    int xLeft = Math.max(this.x, other.x);
    int xRight = Math.min(x2, x4);
    if (xRight <= xLeft)
        throw new NoSuchElementException("No Rectangle intersect.");
    else {
        int yTop = Math.max(y1, y3);
        int yBottom = Math.min(this.y, other.y);
        if (yBottom <= yTop)
            throw new NoSuchElementException("No Rectangle intersect.");
        else
            rectangle= new Rectangle(xLeft, yBottom, xRight - xLeft, yBottom - yTop);
        }
    }
catch (NoSuchElementException ex)
{
    System.out.println(ex);
}
return rectangle;


    }
    /**

     *      * a method union(Rectangle other).
     *      * This method returns a Rectangle object that
     *      * represents the union of this rectangle and the
     *      * other rectangle. The union is the smallest rectangle
     *      * that contains both rectangles.
     *      * Note that unlike the intersection, the union always exists.
     *      *
     *
     */
      public Rectangle union(Rectangle other)
     {
     int Xmin=Math.min(this.x,other.x);
     int Ymin=Math.min(this.y,other.y);
     int Xmax=Math.max((this.x+this.height),(other.x+other.height));
     int Ymax=Math.max((this.y+this.width),(other.y+other.width));
     int newHeight=Xmax-Xmin;
     int newWidth=Ymax-Ymin;
     return new Rectangle(Xmin,Ymin,newHeight,newWidth);
     }


    @Override
    public String toString() {
        return "coordinates of lower left corner ( "+x+","+y+" ) and height = "+height+" width: "+ width;
    }
}

public class Main {
    public static void main(String[] args)
    {
        //Create objects Of Rectangle
        Rectangle rectangle1= new Rectangle(100,150,20,30);
        Rectangle rectangle2 = new Rectangle(200,150,10,20);

        if(rectangle1.overlap(rectangle2))
        {
            System.out.println("Yes overlapping..........");
        }
        else
            System.out.println("No overlapping .............");
        System.out.println(rectangle1.union(rectangle2));

        System.out.println(rectangle1.intersect(rectangle2));
    }
}

//output

//if you need any help regarding this solution ............. please leave a comment ........... thanks.......