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

In Java, both abstract classes and interfaces are used to achieve abstraction, but they have different purposes and capabilities. Here's a detailed comparison between the two:

Abstract Class

An abstract class is a class that cannot be instantiated on its own and may contain abstract methods (methods without an implementation) as well as concrete methods (methods with an implementation).

Characteristics:

1. Abstract Methods: Can have abstract methods, which must be implemented by subclasses.

2. Concrete Methods: Can have concrete methods with implementation.

3. Instance Variables: Can have instance variables and can define constructors.

4. Inheritance: A class can extend only one abstract class due to Java's single inheritance limitation.

5. Access Modifiers: Can use various access modifiers (public, protected, private) for methods and variables.

Example:

Interface

An interface is a reference type in Java, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance variables or constructors.

Characteristics:

1. Abstract Methods: By default, all methods in an interface are abstract (unless they are default or static methods).

2. Concrete Methods: Can have default and static methods with implementation.

3. No Instance Variables: Cannot have instance variables; can only have static final constants.

4. Multiple Inheritance: A class can implement multiple interfaces, allowing for a form of multiple inheritance.

5. Access Modifiers: Methods in interfaces are implicitly public; variables are implicitly public, static, and final.

Example:

Key Differences:

1. Implementation:

   • Abstract class can provide some method implementations (concrete methods).

   • Interface cannot provide method implementations (before Java 8), but from Java 8 onwards, it can provide default and static methods.

2. Inheritance:

   • A class can extend only one abstract class.

   • A class can implement multiple interfaces.

3. Instance Variables:

   • Abstract classes can have instance variables.

   • Interfaces cannot have instance variables; they can only have static final constants.

4. Constructors:

   • Abstract classes can have constructors.

   • Interfaces cannot have constructors.

5. Purpose:

   • Abstract class is used to share a common base class with some shared code among related classes.

   • Interface is used to define a contract that classes must follow, without dictating how they must do so.

6. Default Methods (from Java 8 onwards):

   • Abstract class methods can have any access modifier (public, protected, private).

   • Interface methods (default methods) are implicitly public.

Usage:

• Use an abstract class when you want to provide a common base class with shared code.

• Use an interface when you want to define a contract that multiple classes can implement, ensuring they provide certain functionalities.

By understanding these differences, you can choose the appropriate abstraction mechanism based on the design requirements of your Java application.