Question

In Java programming language.

For this assignment, you must write a class Rectangle and a tester RectangleTest. The 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.

• Write a method toString that returns a String. The string should be formatted exactly as: “x:2, y:3, w:4, h:5” without the quotation marks and replacing the numbers with the actual attributes of the object.

There exists a class called Rectangle in Java already. You are not allowed to use this class in any way! Make sure that you are not accidentally importing it!

A few suggestions about tests:

• You need more than one tests for overlap, because there can be several kinds of overlap. Think about it!

• Write as many tests as you can think of. But you do not need to conflate many tests into one method: for example, you can write several different methods to test just overlap provided you isolate the objective of each test.

Answer 1

Short Summary:

• Modify the main class rectangle1 and rectangle2 constructor values to produce various output.
• Shown the pictorial representation as well for the rectangles used in the sample runs

Source Code:

Rectangle.java

import java.util.NoSuchElementException;

/**
* Rectangle Java class
*/
public class Rectangle {
  
//Private member instances to store input values
private int x, y,height,width;
  
/**
* Constructor
* Creates a rectangle using the x, y coordinates of its lower left corner, its width and its height
*/
public Rectangle(int x, int y, int height, int width)
{
//Creating a rectangle with non-positive width or height should not be allowed
if(height > 0)
this.height = height;
if(width > 0)
this.width = width;
//although x and y are allowed to be negative.
this.x = x;
this.y =y;
}
  
/**
* Method: overlap(Rectangle other).
* Returns true if this rectangle overlaps with other, false otherwise.
* Rectangles that touch each other are not considered to be overlappingg.
*/
public boolean overlap(Rectangle other)
{
return (x < other.x + other.width && x + width > other.x &&
y < other.y + other.height && y + height > other.y);
}
  
/**
* Method intersect(Rectangle other).
* Returns a Rectangle object that represents the overlap of the two rectangles.
* throws a NoSuchElementException with a helpful message, If no intersection exists.
*/
public Rectangle intersect(Rectangle other)
{
//Return type object rectangle
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)
{
//Throw the exception
throw ex;
}
return rectangle;
}

/**
* Method union(Rectangle other).
* 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)
{
//find x point minimum
int Xminimum = Math.min(this.x, other.x);
//find y point minimum
int Yminimum = Math.min(this.y, other.y);
//find x point maximum
int Xmaximum = Math.max((this.x + this.height), (other.x + other.height));
//find y point maximum
int Ymaximum = Math.max((this.y + this.width), (other.y + other.width));
int newHeight = Xmaximum - Xminimum;
int newWidth = Ymaximum - Yminimum;
//Draw new rectangle with calculated points
return new Rectangle(Xminimum, Yminimum, newHeight, newWidth);
}

  
/**
* Method: toString() - override
* Returns a String.
* The string should be formatted exactly as: “x:2, y:3, w:4, h:5”
*/
@Override
public String toString() {
return "x:" + this.x +", y:" + y + ", w: " + width + ", h: " + height;
}
}

Main.java - RectangleTest

//Main.java
public class Main {
public static void main(String[] args)
{
//rectangle1
Rectangle rectangle1= new Rectangle(100, 150, 100, 200);
//Print rectangle1
System.out.println("Rectangle1 :");
System.out.println(rectangle1);
  
//rectangle2
Rectangle rectangle2 = new Rectangle(100, 150, 100, 200);
//Print rectangle2
System.out.println("Rectangle2 :");
System.out.println(rectangle2);
  
//Check overlapping
if(rectangle1.overlap(rectangle2))
{
System.out.println("There is overlapping");
}
else
{
System.out.println("There is no overlapping");
}
  
//check Intersect
try {
System.out.println("Intersect: " + rectangle1.intersect(rectangle2));
} catch(Exception e) {
System.out.println("Intersect: " + e.getMessage());
}
  
//Get Union
System.out.println("Union: " + rectangle1.union(rectangle2));
}
}

Refer the following screenshots for code indentation:

Sample Run -1

Sample Run -2:

Sample Run -3: Rectangle 1 == Rectangle 2

Feel free to rate the answer and comment your questions, if you have any.

Happy Studying!!!