Inheritance in Java

Explanation

This Java code demonstrates fundamental Object-Oriented Programming (OOP) concepts, specifically inheritance, abstract classes, and method overriding.

At its core, the program aims to represent different two-dimensional geometric figures (Rectangles, Triangles, Squares) and calculate their areas, while sharing common properties and behaviors through a base class.

1. TwoDFigure Abstract Class:

   • This is the blueprint for all two-dimensional figures. It's declared abstract, meaning you cannot directly create an object of TwoDFigure. Its purpose is to define a common interface and common properties for its subclasses.
   • It has two double fields, dim1 and dim2, which are intended to represent the primary dimensions of any figure (e.g., length/breadth, base/height, side/side).
   • It has a constructor TwoDFigure(double d1, double d2) that initializes dim1 and dim2.
   • It declares three abstract methods: getDim1(), getDim2(), and calcArea(). Being abstract means these methods have no implementation in TwoDFigure itself. Instead, any concrete class that extends TwoDFigure must provide its own specific implementation for these methods. This forces all derived figures to have a way to report their dimensions and calculate their area.

2. Rectangle Class:

   • This class extends TwoDFigure, meaning it inherits the properties (dim1, dim2) and the contract (must implement abstract methods) from TwoDFigure.
   • Its constructor Rectangle(double l, double b) takes length (l) and breadth (b). It uses super(l, b) to call the constructor of its parent class (TwoDFigure), initializing dim1 as length and dim2 as breadth.
   • It provides concrete implementations for getDim1() (prints "Length"), getDim2() (prints "Breadth"), and calcArea() (returns dim1 * dim2).

3. Triangle Class:

   • Similar to Rectangle, this class also extends TwoDFigure.
   • Its constructor Triangle(double b, double h) takes base (b) and height (h), passing them to the superclass constructor.
   • It implements getDim1() (prints "Base"), getDim2() (prints "Height"), and calcArea() (returns 0.5 * dim1 * dim2).

4. Square Class:

   • This class extends TwoDFigure as well.
   • Its constructor Square(double side) takes only one dimension, side. It then calls super(side, side) because a square's length and breadth are the same.
   • It implements getDim1() (prints "Side").
   • Notice that getDim2() is provided with an empty implementation /* For a square, both dims are same */. While technically fulfilling the abstract method contract, it highlights that for a square, dim2 is redundant if dim1 is already "Side." A more robust design might have getDim2() also print "Side" or TwoDFigure could have fewer abstract methods if some dimensions are always identical.
   • It implements calcArea() (returns dim1 * dim1).

5. Q7Main Class:

   • This is the entry point of the program.
   • Inside the main method, it creates instances (objects) of Rectangle, Triangle, and Square.
   • For each object, it calls its respective getDim1(), getDim2(), and calcArea() methods.
   • The output clearly shows that even though these methods have the same names (due to method overriding), they execute the specific logic defined within each subclass, demonstrating polymorphism in action (where specific behavior depends on the actual type of the object at runtime).

In essence, the code establishes a hierarchy where TwoDFigure defines what it means to be a 2D figure, and its subclasses define how they are specific types of 2D figures and how they perform common operations like getting dimensions and calculating area.

Algorithm

The algorithm implemented in this Java code can be described as follows:

1. Define an Abstract Base Class (TwoDFigure):

   • Declare an abstract class TwoDFigure to serve as a common blueprint for all 2D geometric shapes.
   • Include common double fields dim1 and dim2 to store dimensions.
   • Provide a constructor to initialize these dimensions.
   • Declare abstract methods getDim1(), getDim2(), and calcArea(), forcing all concrete subclasses to implement these functionalities.

2. Implement Concrete Subclasses:

   • Rectangle Class:
     • Extend TwoDFigure.
     • Define a constructor that takes length and breadth and passes them to the superclass constructor (super(l, b)).
     • Override getDim1() to print "Length" and its value.
     • Override getDim2() to print "Breadth" and its value.
     • Override calcArea() to return dim1 * dim2.
   • Triangle Class:
     • Extend TwoDFigure.
     • Define a constructor that takes base and height and passes them to the superclass constructor (super(b, h)).
     • Override getDim1() to print "Base" and its value.
     • Override getDim2() to print "Height" and its value.
     • Override calcArea() to return 0.5 * dim1 * dim2.
   • Square Class:
     • Extend TwoDFigure.
     • Define a constructor that takes a single side length and passes it twice to the superclass constructor (super(side, side)).
     • Override getDim1() to print "Side" and its value.
     • Override getDim2() with an empty body (or a message indicating dim2 is the same as dim1 for a square).
     • Override calcArea() to return dim1 * dim1.

3. Demonstrate in Main Program (Q7Main):

   • In the main method:
     • Create an object of Rectangle with specific dimensions.
     • Create an object of Triangle with specific dimensions.
     • Create an object of Square with a specific side length.
     • For the Rectangle object, call getDim1(), getDim2(), and calcArea() and print the results with descriptive labels.
     • For the Triangle object, call getDim1(), getDim2(), and calcArea() and print the results with descriptive labels.
     • For the Square object, call getDim1() and calcArea() and print the results with descriptive labels. (Note: getDim2() is intentionally skipped in the output for Square, aligning with its empty implementation, but could technically be called).