Question

Java programing Implement and text folling classes

Parallelogram:

# leftUpper : Point //the left upper corner of the Parallelogram # leftLower : Point //the left lower corner of the Parallelogram # length : int //horizontal length

+ Parallelogram ()
+ Parallelogram (Point leftUpper, Point leftLower, int len)
+ getLeftUpper(): Point //returns the left upper corner
+ getLeftLower(): Point //returns the left lower corner
+ setLeftUpper( Point p): void //changes the left upper corner + setLeftLower( Point p): void //changes the left lower corner + get, set methods for length
+ area() : double; //height*length
+ shift(int deltX, int deltY) : void
+ toString(): String

+ getRightUpper(): Point // calculates and returns the right upper corner + getRightLower(): Point // calculates and returns the right lower corner + getHeight() : double //calculates and returns the height of the
+ getSide(): double

Square

+ Square () + Square (Point upperLeft, int length) + area() : double + toString(): String --------------------------- get above methods and Parallelogram right, no errors: You earn 20 points + contains(Square anotherSquare) : boolean + overlap(Square anotherSquare) : boolean + disjoint(Square anotherSquare) : boolean ------------------ Get every method right, good job: 25 points will be awarded to you.

1. Implement both classes with inheritance

2. Create following Squares:

squareA: its left upper corner is at (10, 20) , length is 100. //Four corners are (10, 20), (110, 20), (110,120), (10, 120)

squareB: its left upper corner is at (30, 40) , length is 25. squareC: its left upper corner is at (70, 60) , length is 80.

3. Test whether squareB is contained in squareA; whether squareA and squareB are overlapped or disjoint.

4. Test whether squareC is contained in squareA; whether squareA and squareC are overlapped or disjoint.

5. Output the area of squareA

6. Output the four corners of squareA and squareB

Answer 1

Square.java

public class Square extends Parallelogram
{
public Square() { super(); }
public Square(Point leftUpper, int length)
{
super(leftUpper,new Point(leftUpper.get_x(), leftUpper.get_y()+length), length);
}
public double area() { return (get_length() * get_length()); }
public String toString()
{
String output = "Sqaure: \n";
output += "LeftUpper: ";
output += getLeftUpper().toString();
output += "\n";
output += "LeftLower: ";
output += getLeftLower().toString();
output += "\n";
output += "Length: ";
output += get_length();
output += "\n";
return output;
}
public double getSide() { return get_length(); }
public boolean contains(Square another)
{
if (((getLeftLower().get_x() < another.getLeftLower().get_x()) && (getLeftLower().get_y() > another.getLeftLower().get_y()))
&& ((getRightLower().get_x() > another.getRightLower().get_x()) && (getRightLower().get_y() < another.getRightLower().get_y())))
return true;
return false;
}
public boolean overlap(Square another)
{
Point left1 = new Point(getLeftLower());
Point left2 = new Point(another.getLeftLower());
Point right1 = new Point(getRightLower());
Point right2 = new Point(another.getRightLower());
if (left1.get_x() > right2.get_x() || left2.get_x() > right1.get_x())
return false;
if (left1.get_y() < right2.get_y() || left2.get_y() < right1.get_y())
return false;
return true;
}
public boolean disjoint(Square another)
{
if (!overlap(another))
return true;
return false;
}
static public void main(String [] argv)
{
Point pointA = new Point(10,20);
Square squareA = new Square(pointA, 100);
System.out.println(squareA);
System.out.println("Square A: " + squareA.getLeftUpper().toString() + "\n" + squareA.getLeftLower().toString() + "\n" + squareA.getRightLower().toString() + "\n" + squareA.getRightUpper().toString());
Point pointB = new Point(30,40);
Square squareB = new Square(pointB, 25);
System.out.println("Square B: " + squareB.getLeftUpper().toString() + "\n" + squareB.getLeftLower().toString() + "\n" + squareB.getRightLower().toString() + "\n" + squareB.getRightUpper().toString());
Point pointC = new Point(70,60);
Square squareC = new Square(pointC, 80);
if (squareA.contains(squareB))
System.out.println("squareB is contained in squareA");
else if (squareA.overlap(squareB))
System.out.println("squareB is overlapped with squareA");
else
System.out.println("squareB is disjoint with squareA");
if (squareA.contains(squareC))
System.out.println("squareC is contained in squareA");
else if (squareA.overlap(squareC))
System.out.println("squareC is overlapped with squareA");
else
System.out.println("squareC is disjoint with squareA");
System.out.println("Area of square A: " + squareA.area());
}
}

Parallelogram.java

import java.lang.Math;
public class Parallelogram
{
private Point leftUpper;
private Point leftLower;
private int length;

Parallelogram()
{
leftUpper = new Point();
leftLower = new Point();
length = 0;
}
Parallelogram(Point leftUpper, Point leftLower, int len)
{
this.leftUpper = leftUpper;
this.leftLower = leftLower;
this.length = len;
}

public Point getLeftUpper() { return leftUpper; }
public Point getLeftLower() { return leftLower; }
public double getHeight() { return (leftUpper.get_y() - leftLower.get_y()); }
public void setLeftUpper(Point p) { leftUpper = p; }
public void setLeftLower(Point p) { leftLower = p; }
public int get_length() { return length; }
public void set_length(int len) { length = len; }
public double area() { return getHeight() * length; }
public void shift(int deltaX, int deltaY) {
leftUpper.shift(deltaX, deltaY);
leftLower.shift(deltaX, deltaY);
}
public String toString() {
String output = "Parallelogram: \n";
output += "LeftUpper: ";
output += leftUpper.toString();
output += "\n";
output += "LeftLower: ";
output += leftLower.toString();
output += "\n";
return output;
}
public Point getRightUpper() {
Point p3 = new Point(leftUpper);
p3.shift(length, 0);
return p3;
}

public Point getRightLower() {
Point p4 = new Point(leftLower);
p4.shift(length,0);
return p4;
}
public double getSide() {
double x = leftUpper.get_x() - leftLower.get_x();
double x2 = x*x;
double y = leftUpper.get_y() - leftLower.get_y();
double y2 = y*y;
double ans = Math.sqrt(x2 + y2);
return ans;
}

}

Point.java

class Point
{
private double x;
private double y;
public double get_x() { return x; }
public double get_y() { return y; }
public Point(Point p) {
x = p.get_x();
y = p.get_y(); }
public Point()
{
x = 0;
y = 0;
}
public void shift(int deltax, int deltay)
{
x += deltax;
y += deltay;
}
public Point(double x, double y)
{
this.x = x;
this.y = y;
}
public String toString()
{
String output = new String();
output += "X : " + x + "\n";
output += "Y : " + y + "\n";
return output;
}
}