What is the difference between an abstract class and an interface in Java?

The Interview Question

Short Answer

An abstract class is a class that cannot be instantiated and may contain both abstract and concrete methods, while an interface is a completely abstract type that can only contain abstract methods (before Java 8) and constants.

Key differences include:

• Abstract classes can have constructors, interfaces cannot
• Abstract classes can have instance variables, interfaces can only have constants
• Abstract classes can have any access modifier for methods, interface methods are public by default
• A class can extend only one abstract class but can implement multiple interfaces

Detailed Explanation

Understanding when to use an abstract class versus an interface is crucial for designing robust Java applications. Let's dive deep into their differences and use cases.

Abstract Classes

Abstract classes are used when you want to provide a common base implementation while leaving some methods to be implemented by subclasses:

• Can have both abstract and concrete methods
• Can have constructors
• Can have instance variables with any access modifier
• Can have static and instance initializers
• Can have any access modifier for methods
• Can extend only one class (abstract or concrete)

Interfaces

Interfaces define a contract that implementing classes must follow:

• All methods are public and abstract by default (before Java 8)
• Can have default and static methods (Java 8+)
• Can have private methods (Java 9+)
• Can only have public static final fields (constants)
• A class can implement multiple interfaces

Code Example

Let's look at a practical example that demonstrates the differences between abstract classes and interfaces:

// Abstract class example
abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Concrete method
    public void eat() {
        System.out.println(name + " is eating");
    }
    
    // Abstract method
    public abstract void makeSound();
}

// Interface example
interface Flyable {
    // Constant
    int MAX_ALTITUDE = 10000;
    
    // Abstract method
    void fly();
    
    // Default method (Java 8+)
    default void land() {
        System.out.println("Landing...");
    }
    
    // Static method (Java 8+)
    static boolean canFly(int altitude) {
        return altitude <= MAX_ALTITUDE;
    }
}

// Concrete class implementing both
class Bird extends Animal implements Flyable {
    public Bird(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println("Chirp chirp!");
    }
    
    @Override
    public void fly() {
        System.out.println(name + " is flying");
    }
}

// Usage example
public class AbstractVsInterface {
    public static void main(String[] args) {
        Bird sparrow = new Bird("Sparrow", 2);
        sparrow.eat();        // Inherited from Animal
        sparrow.makeSound();  // Implemented from Animal
        sparrow.fly();        // Implemented from Flyable
        sparrow.land();       // Default method from Flyable
        
        // Using static method from interface
        System.out.println("Can fly at 5000m: " + Flyable.canFly(5000));
    }
}

Key Points from the Example

This example demonstrates several important concepts:

• The abstract class Animal provides a common base with both concrete and abstract methods
• The interface Flyable defines a contract with abstract methods, constants, and default methods
• The Bird class extends Animal and implements Flyable, showing multiple inheritance through interfaces
• Default methods in interfaces provide backward compatibility
• Static methods in interfaces can be used without implementing the interface

When to Use Each

Choosing between abstract classes and interfaces depends on your specific requirements:

Use Abstract Classes When:

• You want to share code among several related classes
• You need to declare non-public members
• You need to define constructors
• You want to provide a common base implementation
• You need to maintain state through instance variables

Use Interfaces When:

• You want to define a contract that can be implemented by unrelated classes
• You need multiple inheritance of type
• You want to specify the behavior of a particular data type
• You need to provide default implementations (Java 8+)
• You want to define constants

Why This Question Matters in Interviews

This question is crucial in Java interviews because it tests your understanding of:

• Object-oriented design principles
• Java's type system and inheritance model
• Design patterns and best practices
• Recent Java features (default methods, private methods in interfaces)
• Architectural decision-making

Common Interview Scenarios

Conclusion

Understanding the differences between abstract classes and interfaces is fundamental to Java development. While they share some similarities, they serve different purposes in your application's architecture.

Key takeaways:

• Abstract classes are about inheritance and code reuse
• Interfaces are about defining contracts and behavior
• Java 8+ features have made interfaces more powerful
• The choice between them affects your application's flexibility and maintainability

Remember that the best choice depends on your specific requirements and design goals. A well-designed Java application often uses both abstract classes and interfaces appropriately to achieve its objectives.