Question

Question 1- part-1) Provide complete UML class diagrams for the Polygon and Rectangle classes, including access specifiers, parameters, and data/return types. Include the relationship between these two classes in the diagram. And then,

Question 1-part-2) Given the following reference variable declaration and object assignment:

Polygon poly = new Rectangle();

What would happen given each of the following two lines of code? Briefly explain your answer.

System.out.println(poly); double area = poly.getArea(); Then tell me what is the major difference between abstract classes and regular classes? What does this difference prevent you from doing with abstract classes?

Then what is a functional interface? What is a lambda expression? Provide a simple example with code to define a functional interface and with a single line of code to construct the corresponding lambda expression.

And then last but not least. What are the purposes of polymorphism and interfaces in implementing real-world software applications?

You must complete all parts of question 1 in order to receive full credit, failing to do so will result in a zero. Good luck.

note for Cheg: Please do these real carefully I have uploaded questions like this before, they are very hard, and Cheg people always give me the wrong answer. Please take your time on doing this and attempt to get it correct within the first try.

public class Polygon {       private double length;       private double height;       private int sides;       public Polygon() {             length = 1.0;             height = Math.sqrt(3.0) / 2;             sides = 3;       }       public Polygon(double length, double height, int sides) {             this.length = length;             this.height = height;             this.sides = sides;       }       public void setLength(double length) {             this.length = length;       }       public void setHeight(double height) {             this.height = height;       }       public void setSides(int sides) {             this.sides = sides;       }       public double getLength() {             return length;       }       public double getHeight() {             return height;       }       public int getSides() {             return sides;       }       public String toString() {             return "This is a polygon";       } }

Rectangle.java

public class Rectangle extends Polygon {       public Rectangle() {             this.setLength(1.0);             this.setHeight(1.0);             this.setSides(4);       }       public Rectangle(double length, double height) {             this.setLength(1.0);             this.setHeight(1.0);       }       public double getArea() {             return this.getLength() * this.getHeight();       }       public String toString() {             return "This is a rectangle";       } }

Answer 1

Q1) part2

       Polygon poly = new Rectangle();
      
       System.out.println(poly);

The toString method will be overrided by the Rectangle class and print the returned by the toString() method.

this is called Up casting in the oops concept.

and the second statement

double area = poly.getArea();

this will give compilation error because there is no method name getArea() declared in the Polygon class

we need to down cast this reference variable to Rectangle the getArea() method will be accessed.

double area = ((Rectangle) poly).getArea();

The Major difference in abstract class and concrete class is , we can create the object of concrete class or regular class but we can not create the object or we can't instantiate the abstract class but we can assign the object reference to its type;

For example

if we want to make Polygon class as abstract than

public abstract class Polygon {
   private double length;
   private double height;
   private int sides;

   public Polygon() {
       length = 1.0;
       height = Math.sqrt(3.0) / 2;
       sides = 3;
   }

   public Polygon(double length, double height, int sides) {
       this.length = length;
       this.height = height;
       this.sides = sides;
   }

   public void setLength(double length) {
       this.length = length;
   }

   public void setHeight(double height) {
       this.height = height;
   }

   public void setSides(int sides) {
       this.sides = sides;
   }

   public double getLength() {
       return length;
   }

   public double getHeight() {
       return height;
   }

   public int getSides() {
       return sides;
   }

   public String toString() {
       return "This is a polygon";
   }

public abstract double getArea(); //abstract method

}

now every subclass need to implement the getArea() method of Polygon class

Now the statement will not give the compilation error

double area = poly.getArea();

A functional interface is an interface that contains only one abstract method.

A functional interface can have any number of default methods.

lambda expressions can be used to represent the instance of a functional interface.

For example

interface Tripe {

   int triple(int x);
}

public class FuntionalTest {

   public static void main(String[] args) {

       int a = 5;

       // lambda expression to define the triple method
       Tripe t = (int x) -> 3 * x;

       int result = t.triple(a);
       System.out.println(result);
   }
}

The purpose of interface and polymorphism is to provide multiple behavior by single reference variable as its subclass type object. and Programmer can easily understand the code and what should be implemented in the subclass .

Please refer the Polygon class to understand this concept.

Please let me know if you have any doubt or modify the answer, Thanks :)