How do interfaces differ from abstract classes?

Interfaces and abstract classes are both used to achieve abstraction in object-oriented programming, but they have distinct differences in their design and usage. Here’s a concise comparison:

Key Differences Between Interfaces and Abstract Classes

1. Definition:

   • Interface: A contract that defines a set of methods that implementing classes must provide, without any implementation details.
   • Abstract Class: A class that cannot be instantiated and may contain both abstract methods (without implementation) and concrete methods (with implementation).

2. Instantiation:

   • Interface: Cannot be instantiated directly. You must implement it in a class.
   • Abstract Class: Cannot be instantiated directly either, but it can provide some implementation that subclasses can use.

3. Method Implementation:

   • Interface: All methods are implicitly abstract (unless they are default or static methods in Java 8 and later) and do not have implementations.
   • Abstract Class: Can have both abstract methods (without implementation) and concrete methods (with implementation).

4. Multiple Inheritance:

   • Interface: A class can implement multiple interfaces, allowing for a form of multiple inheritance.
   • Abstract Class: A class can inherit from only one abstract class (single inheritance).

5. Access Modifiers:

   • Interface: All methods are public by default, and fields are public, static, and final.
   • Abstract Class: Can have various access modifiers (public, private, protected) for its methods and fields.

6. Purpose:

   • Interface: Used to define a contract for what a class can do, promoting a separation of concerns and enabling polymorphism.
   • Abstract Class: Used to provide a common base with shared implementation for related classes, ideal for "is-a" relationships.

Example

Interface Example:

interface Animal {
    void makeSound(); // No implementation
}

Abstract Class Example:

abstract class Animal {
    public abstract void makeSound(); // Abstract method

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

Summary

In summary, interfaces are best suited for defining capabilities that can be shared across unrelated classes, while abstract classes are ideal for providing a common base for closely related classes with shared behavior. If you have further questions or need more examples, feel free to ask!