Interfaces and abstract classes are fundamental concepts in object-oriented programming (OOP) that enable the creation of flexible, extensible, and modular code. Understanding the hierarchy of these constructs is crucial for designing robust software systems. In this blog post, we'll delve into the hierarchy of interfaces, abstract classes, and their corresponding subordinate classes.

Interfaces

An interface in Java is a blueprint of a class. It defines a set of method signatures without implementation details. Classes that implement an interface must provide concrete implementations for all the methods declared in the interface.

Example:

public interface Shape {
    double calculateArea();
    void draw();
}

In this example, Shape is an interface with two method signatures: calculateArea() and draw(). Any class that implements the Shape interface must provide implementations for these methods.

Abstract Classes

An abstract class is a class that cannot be instantiated on its own. It often serves as a base class for other classes, providing a template for their behavior. Abstract classes can have both abstract and concrete methods.

Example:

public abstract class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    abstract void makeSound();

    void eat() {
        System.out.println(name + " is eating.");
    }
}

In this example, Animal is an abstract class with an abstract method makeSound() and a concrete method eat(). Subclasses of Animal must implement makeSound().

Hierarchy: Interface vs Abstract Class

1. Instantiation:

   • Interfaces cannot be instantiated. They serve as contracts for classes to implement.

   • Abstract classes cannot be instantiated on their own, but they can be subclassed.

2. Multiple Inheritance:

   • A class can implement multiple interfaces, allowing it to inherit behavior from multiple sources.

   • Java does not support multiple inheritance of classes, meaning a class can only extend one abstract class.

Subordinate Class Objects

Subordinate class objects are instances of classes that either implement an interface or extend an abstract class. These objects inherit the behavior defined by the interface or abstract class, and they can provide specific implementations as required.

Example:

public class Circle implements Shape {
    double radius;

    @Override
    public double calculateArea() {
        return Math.PI * Math.pow(radius, 2);
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

In this example, Circle is a class that implements the Shape interface. It provides specific implementations for calculateArea() and draw(), which are required by the interface.

Conclusion

Interfaces and abstract classes are powerful tools for designing modular and extensible code. Understanding their hierarchy and usage is essential for building flexible software systems. By leveraging interfaces and abstract classes, developers can create well-organized and easily maintainable codebases.