What is the difference between interface and abstract classes?

Interface and Abstract Class are very important concepts in object-oriented programming. Both can define a specification or blueprint that classes must adhere to, but they differ in usage and design intent. I will explain their differences from several key aspects:

1. Default Method Implementations

Abstract Classes can include methods with concrete implementations, meaning that some methods are already implemented, while others are implemented by subclasses.

Interfaces could not contain implementation code in older Java versions and could only define method signatures. However, from Java 8 onwards, interfaces can include default methods and static methods, enhancing their flexibility.

Example:

java
abstract class Animal {
    // Abstract method
    abstract void eat();

    // Implemented method
    public void breathe() {
        System.out.println("Breathing...");
    }
}

interface IAnimal {
    void eat();

    // Java 8 default method
    default void breathe() {
        System.out.println("Breathing...");
    }
}

2. Inheritance and Implementation

Abstract Classes support single inheritance, meaning a subclass can inherit from only one abstract class.

Interfaces support multiple implementation, meaning a class can implement multiple interfaces.

Example:

java
interface IRunner {
    void run();
}

interface IEater {
    void eat();
}

// A class implementing multiple interfaces
class Person implements IRunner, IEater {
    public void run() {
        System.out.println("Running...");
    }

    public void eat() {
        System.out.println("Eating...");
    }
}

3. Design Intent

Abstract Classes are typically used to provide a common, well-defined functional framework for a series of closely related classes, often including default implementations for basic operations.

Interfaces are primarily used to define a set of protocols that specify the rules implementing classes must follow, emphasizing functionality diversity and flexibility. Introducing interfaces is typically to decouple system components, enabling independent development as long as they comply with the interface specifications.

4. Member Variables

Abstract Classes can have member variables with different access levels.

Interfaces prior to Java 8, all member variables are implicitly public static final, meaning they must be constants. From Java 8 onwards, this remains true, but interfaces also support additional methods such as default and static methods.

Summary

While abstract classes and interfaces share some functionalities, their primary differences are in usage scenarios and design purposes. Abstract classes are better suited for objects with common behaviors, whereas interfaces are ideal for providing a unified functional specification across different objects. In designing large systems, appropriately using interfaces and abstract classes can enhance flexibility, extensibility, and maintainability.