Interface Vs. Abstract Class After Java 8

In the realm of object-oriented programming (OOP), Java has long been a prominent player, offering developers powerful tools to create robust and flexible software systems. With the release of Java 8, the programming landscape witnessed significant changes in the way developers design and structure their code. Among these changes, the evolution of interfaces and abstract classes gained substantial attention. In this section, we will explore the post-Java 8 differences between interfaces and abstract classes, their respective strengths, and when to choose one over the other.

The Evolution of Interfaces and Abstract Classes

Traditionally, interfaces and abstract classes have served distinct purposes in Java. Interfaces offered a way to define contracts, specifying methods that classes implementing the interface must provide. Abstract classes, on the other hand, allowed developers to create partially implemented classes that could be extended to provide concrete functionality.

Java 8 introduced a ground-breaking feature- the concept of default methods in interfaces. Default methods are method implementations that provide a default behavior directly in the interface itself. This innovation blurred the lines between interfaces and abstract classes, enabling interfaces to offer a degree of concrete implementation.

Interface Advantages Post-Java 8

Multiple Inheritance via Default Methods: With default methods, interfaces gained the ability to provide method implementations while still allowing classes to implement multiple interfaces. It alleviated the long-standing issue of multiple inheritance conflict that was prevalent in Java. Developers can now add new functionality to existing interfaces without breaking existing implementations.
Functional Interfaces and Lambda Expressions: Java 8 also introduced functional interfaces, which are interfaces with a single abstract method (SAM). These interfaces became the foundation for lambda expressions and the Stream API, enabling more concise and expressive code when working with collections and functional programming constructs.
API Evolution and Backward Compatibility: The introduction of default methods allowed library developers to evolve their APIs without breaking existing implementations. This is particularly useful for third-party libraries and frameworks that need to adapt to new requirements over time.

Abstract Class Advantages Post-Java 8

Partial Implementation: Abstract classes still retain their advantage of providing a partial implementation of a class. It is especially useful when a base class contains common methods and fields that should be shared among its subclasses.
Constructor Support: Abstract classes can define constructors that can be used by their subclasses, providing a way to enforce certain initialization procedures and ensuring a consistent state across subclasses.
Non-Public Members: Abstract classes can have non-public methods and fields, which can be useful when you want to encapsulate certain functionality or data that shouldn't be exposed to external classes.

Choosing Between Interface and Abstract Class

The decision between using an interface or an abstract class after Java 8 depends on the specific needs of your design. Here are some considerations to guide your choice:

Use Interfaces When

We need to define a contract for a group of related classes.
We want to achieve multiple inheritance-like behavior by using default methods.
We are working with functional programming concepts and want to leverage lambda expressions.

Use Abstract Classes When

We want to provide a base class with shared methods and fields among its subclasses.
We need to enforce a specific constructor pattern across subclasses.
We want to encapsulate certain methods or fields that are not meant to be exposed publicly.

DeviceExample.java

// Interface representing a device
interface Device {
    void powerOn();
    void powerOff();
}
// Interface representing a device with a battery
interface BatteryPowered {
    void charge();
}
// Abstract class for electronic devices
abstract class AbstractDevice implements Device {
    private boolean isPoweredOn;
    @Override
    public void powerOn() {
        isPoweredOn = true;
        System.out.println("Device powered on");
    }
    @Override
    public void powerOff() {
        isPoweredOn = false;
        System.out.println("Device powered off");
    }
    public boolean isPoweredOn() {
        return isPoweredOn;
    }
}
// Concrete class representing a phone
class Phone extends AbstractDevice implements BatteryPowered {
    private int batteryLevel;
    @Override
    public void charge() {
        batteryLevel += 20;
        System.out.println("Phone battery charged by 20%");
    }
    public int getBatteryLevel() {
        return batteryLevel;
    }
}
// Concrete class representing a TV
class TV extends AbstractDevice {
    // TV-specific methods and fields can be added here
}
public class DeviceExample {
    public static void main(String[] args) {
        Phone phone = new Phone();
        TV tv = new TV();
        phone.powerOn();
        phone.charge();
        System.out.println("Phone Battery Level: " + phone.getBatteryLevel());
        phone.powerOff();
        System.out.println();
        tv.powerOn();
        tv.powerOff();
    }
}

Output:

Device powered on
Phone battery charged by 20%
Phone Battery Level: 20
Device powered off

Device powered on
Device powered off

Java 8's introduction of default methods in interfaces expanded their capabilities and brought them closer to the functionality traditionally offered by abstract classes. This evolution provides developers with more tools and flexibility when designing software systems. Understanding the distinctions and advantages of both interfaces and abstract classes post-Java 8 is crucial for making informed design decisions. Each has its strengths, and the choice between them should be based on the specific requirements of your application and the architectural patterns you're employing.

Next TopicJava 9 Optional Class Improvements

← prev next →