Abstract Classes vs. Interfaces in Java

Question

What are the key differences between abstract classes and interfaces in Java? When should you use each, and what are their respective advantages and limitations?

Answer

Abstract classes and interfaces are both used to achieve abstraction in Java, but they serve different purposes and have distinct characteristics. Understanding their differences is crucial for making the right design decisions.

Abstract Classes

An abstract class is a class that is declared with the abstract keyword and can have both abstract and non-abstract methods.

Characteristics:

Can have instance variables
Can have constructors
Can have both abstract and concrete methods
Can have access modifiers (public, protected, private)
Can have static methods
Can have main method
Can extend only one class

Example:

public abstract class Animal {
    protected String name;
    protected int age;

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

    // Abstract method
    public abstract void makeSound();

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

    // Static method
    public static void sleep() {
        System.out.println("Animal is sleeping");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

Interfaces

An interface is a completely abstract class that contains only abstract methods (except for default and static methods in Java 8+).

Characteristics:

All methods are public and abstract by default
All variables are public, static, and final by default
Cannot have constructors
Cannot have instance variables
Can extend multiple interfaces
Cannot have instance methods (except default methods)
Can have static methods (Java 8+)

Example:

public interface Flyable {
    void fly();  // public abstract by default

    // Default method (Java 8+)
    default void land() {
        System.out.println("Landing...");
    }

    // Static method (Java 8+)
    static void takeOff() {
        System.out.println("Taking off...");
    }
}

public interface Swimmable {
    void swim();
}

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }
}

Key Differences

Multiple Inheritance

// Abstract class - single inheritance
public abstract class A {}
public abstract class B {}
public class C extends A {}  // Can only extend one class

// Interface - multiple inheritance
public interface X {}
public interface Y {}
public class Z implements X, Y {}  // Can implement multiple interfaces

Constructor Support

// Abstract class - can have constructors
public abstract class AbstractClass {
    public AbstractClass() {
        // Constructor code
    }
}

// Interface - cannot have constructors
public interface Interface {
    // No constructors allowed
}

Variable Declaration

// Abstract class - can have non-final variables
public abstract class AbstractClass {
    private int x;  // Can be modified
    protected String y;  // Can be modified
}

// Interface - variables are final by default
public interface Interface {
    int x = 10;  // public static final by default
    String y = "Hello";  // public static final by default
}

When to Use Each

Use Abstract Classes When:

You want to share code among several closely related classes
Classes that extend your abstract class have many common methods or fields
You want to provide a default implementation of some methods while leaving others abstract
You need to access modifiers other than public
You need constructors

Example:

public abstract class Database {
    protected String connectionString;
    protected boolean isConnected;

    public Database(String connectionString) {
        this.connectionString = connectionString;
        this.isConnected = false;
    }

    public abstract void connect();
    public abstract void disconnect();

    public boolean isConnected() {
        return isConnected;
    }
}

public class MySQLDatabase extends Database {
    public MySQLDatabase(String connectionString) {
        super(connectionString);
    }

    @Override
    public void connect() {
        // MySQL specific connection
    }

    @Override
    public void disconnect() {
        // MySQL specific disconnection
    }
}

Use Interfaces When:

You want to define a contract that multiple unrelated classes should follow
You need to achieve multiple inheritance
You want to specify the behavior of a particular data type, but not concerned about who implements its behavior
You want to separate the definition of a method from its implementation
You want to achieve loose coupling

Example:

public interface PaymentMethod {
    void processPayment(double amount);
    boolean validatePayment();
}

public class CreditCard implements PaymentMethod {
    @Override
    public void processPayment(double amount) {
        // Credit card processing
    }

    @Override
    public boolean validatePayment() {
        return true;
    }
}

public class PayPal implements PaymentMethod {
    @Override
    public void processPayment(double amount) {
        // PayPal processing
    }

    @Override
    public boolean validatePayment() {
        return true;
    }
}

Best Practices

For Abstract Classes:
Use when you have a partial implementation to share
Keep the abstract class focused and cohesive
Provide meaningful default implementations
Use protected access for shared members
For Interfaces:
Keep interfaces small and focused
Use default methods sparingly
Document the contract clearly
Consider using functional interfaces for single-method contracts

Common Pitfalls

Abstract Class Pitfalls:

public abstract class BadAbstract {
    private abstract void method();  // Cannot be private
    public abstract void method() {}  // Cannot have body
}

Interface Pitfalls:

public interface BadInterface {
    void method() {}  // Cannot have body (except default methods)
    private void method();  // Cannot be private
    protected void method();  // Cannot be protected
}

Modern Java Features

Default Methods in Interfaces (Java 8+)

public interface ModernInterface {
    void method();

    default void defaultMethod() {
        System.out.println("Default implementation");
    }
}

Static Methods in Interfaces (Java 8+)

public interface ModernInterface {
    static void utilityMethod() {
        System.out.println("Utility method");
    }
}

Private Methods in Interfaces (Java 9+)

public interface ModernInterface {
    default void method() {
        helperMethod();
    }

    private void helperMethod() {
        // Private helper implementation
    }
}