Abstraction with Abstract Classes and Interfaces in Java

Abstraction is a fundamental concept in object-oriented programming (OOP). It involves hiding complex implementation details and exposing only the essential features of an object. In Java, abstraction can be achieved through abstract classes and interfaces. These mechanisms allow you to define a blueprint for classes without specifying all the implementation details, promoting flexibility and maintainability in your code.

What is Abstraction?

Abstraction allows you to focus on what an object does rather than how it does it. Think of it like driving a car. You know you need to turn the steering wheel to change direction, but you don't need to understand the intricate mechanics of the steering system. Abstraction simplifies complex systems by providing a high-level view.

Abstract Classes

An abstract class is a class that cannot be instantiated directly. It serves as a template for other classes. An abstract class may contain abstract methods, which are methods declared without an implementation. Subclasses of an abstract class must provide implementations for all abstract methods, unless the subclass is also declared as abstract.

Key Features of Abstract Classes:

• Cannot be instantiated directly (using new).
• Can contain both abstract and concrete (implemented) methods.
• Abstract methods must be implemented by subclasses (unless the subclass is also abstract).
• Declared using the abstract keyword.

Example of an Abstract Class:

 abstract class Shape {
    // Abstract method (no implementation)
    abstract double getArea();

    // Concrete method (has implementation)
    void display() {
        System.out.println("This is a shape.");
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    double getArea() {
        return width * height;
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        // Shape myShape = new Shape(); // This will cause a compile-time error: Cannot instantiate the type Shape
        Circle myCircle = new Circle(5);
        Rectangle myRectangle = new Rectangle(4, 6);

        System.out.println("Circle area: " + myCircle.getArea());
        System.out.println("Rectangle area: " + myRectangle.getArea());

        myCircle.display(); // Calls the concrete method from the abstract class
    }
} 

Interfaces

An interface is a completely abstract "class" that is used to specify a contract that classes must adhere to. All methods in an interface are implicitly abstract and public (prior to Java 8). Starting from Java 8, interfaces can also have default and static methods. A class can implement multiple interfaces.

Key Features of Interfaces:

• Cannot be instantiated directly.
• All methods are implicitly abstract and public (before Java 8).
• Can contain default and static methods (from Java 8 onwards).
• A class can implement multiple interfaces.
• Declared using the interface keyword.
• Variables declared in interface are implicitly public static final

Example of an Interface:

 interface Drawable {
    void draw();  // Abstract method (no implementation)
}

class Circle implements Drawable {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

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

class Square implements Drawable {
    private double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a square with side: " + side);
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Drawable circle = new Circle(5);
        Drawable square = new Square(4);

        circle.draw();
        square.draw();
    }
} 

Abstract Classes and Interfaces: Achieving Abstraction Together

Abstract classes and interfaces can be used together to create flexible and robust designs. Here's how:

• Multiple Interface Implementation: A class can implement multiple interfaces, allowing it to fulfill multiple contracts. This provides greater flexibility compared to inheritance, where a class can only inherit from one class (in Java).
• Partial Implementation with Abstract Classes: An abstract class can provide a partial implementation of an interface. This allows subclasses to inherit the common behavior and only implement the remaining abstract methods.
• Defining Core Behavior with Abstract Classes, Extending Functionality with Interfaces: You can use abstract classes to define the core behavior of a set of related classes. Then, use interfaces to add specific functionality to certain classes that implement those interfaces.

Example of Combining Abstract Classes and Interfaces:

 interface Printable {
    void print();
}

abstract class Vehicle {
    private String modelName;

    public Vehicle(String modelName) {
        this.modelName = modelName;
    }

    public String getModelName() {
        return modelName;
    }

    // Abstract method that must be implemented by subclasses
    abstract void startEngine();
}


class Car extends Vehicle implements Printable {
    public Car(String modelName) {
        super(modelName);
    }

    @Override
    void startEngine() {
        System.out.println("Starting the car engine for " + getModelName());
    }

    @Override
    public void print() {
        System.out.println("Car model: " + getModelName());
    }
}


class Bicycle extends Vehicle { // Doesn't need to be printable
   public Bicycle(String modelName) {
       super(modelName);
   }

   @Override
   void startEngine() {
       System.out.println("Bicycle " + getModelName() + " doesn't have an engine.");
   }
}


public class CombinedExample {
    public static void main(String[] args) {
        Car myCar = new Car("Sedan X");
        Bicycle myBike = new Bicycle("Mountain 2000");


        myCar.startEngine();
        myCar.print(); // Only cars can print

        myBike.startEngine();
        //myBike.print(); // Compilation error: Bicycle doesn't implement Printable
    }
} 

In this example, Vehicle is an abstract class that defines the core behavior of vehicles. The startEngine() method is abstract, forcing subclasses to implement it. The Printable interface defines the ability to print. The Car class extends Vehicle and implements Printable, providing implementations for both startEngine() and print(). The Bicycle class extends Vehicle but *does not* implement `Printable`. This demonstrates how you can selectively add functionality using interfaces to only certain classes.

Conclusion

Abstract classes and interfaces are powerful tools for achieving abstraction in Java. They allow you to define a blueprint for classes, enforce contracts, and create flexible and maintainable designs. By combining these mechanisms effectively, you can build complex systems with a clear separation of concerns and improved code organization. Understanding when to use abstract classes and interfaces is crucial for writing high-quality object-oriented code.