Great question! Even with Java 8 introducing default methods (which let interfaces have concrete implementations), abstract classes and interfaces still have distinct roles and behaviors that you can't ignore. Let's break down the key differences one by one:

1. Inheritance Limitation #

• Abstract classes follow Java's single inheritance rule: a class can only extend one abstract class.
• Interfaces support multiple implementations: a class can implement any number of interfaces.
  Example:

  // Valid: Single abstract class + multiple interfaces
  class MyService extends BaseService implements Cacheable, Loggable {}
  
  // Invalid: Can't extend two abstract classes
  // class MyService extends BaseService, AnotherBaseService {}
  

2. State & Member Variables #

• Abstract classes can have instance variables (with any access modifier: private, protected, public) that hold object state. These variables are part of the subclass's instance when it's created.

  abstract class BaseService {
      protected String serviceName; // Instance variable for state
  
      public BaseService(String serviceName) {
          this.serviceName = serviceName;
      }
  }
  

• Interfaces can only contain public static final constants (even if you omit these modifiers, the compiler adds them automatically). You can't modify these values at runtime.

  interface Cacheable {
      // This is implicitly public static final
      int MAX_CACHE_SIZE = 100;
  }
  

3. Constructors #

• Abstract classes can have constructors (even though you can't instantiate the abstract class directly). Subclasses must call the abstract class's constructor (explicitly or via super()) when they're instantiated.
• Interfaces cannot have constructors—they aren't meant to represent instantiable objects, just contracts or capabilities.

4. Access Modifiers for Methods #

• Abstract class methods can use any access modifier: public, protected, private (Java 9+ even allows private concrete methods in abstract classes).
• Interface methods have strict modifier rules:
  • Abstract methods are implicitly public abstract.
  • default and static methods are implicitly public—you can't mark them as protected or private.

5. Design Intent #

• Abstract classes model "is-a" relationships: they define a base type for a hierarchy of related classes. For example, Animal as an abstract class, with Dog and Cat extending it—dogs and cats are animals.
• Interfaces model "can-do" capabilities: they define a contract for what a class can do, regardless of its position in the inheritance hierarchy. For example, Runnable—any class that implements it can be run, whether it's a Dog, Service, or Thread.

6. Default Method Conflict Resolution #

When a class inherits from both an abstract class and an interface (or multiple interfaces) with overlapping method signatures:

• If an abstract class has a concrete method with the same signature as an interface's default method, the abstract class's implementation takes priority—no need to override.

  abstract class BaseTask {
      public void execute() {
          System.out.println("Abstract class execution");
      }
  }
  
  interface Executable {
      default void execute() {
          System.out.println("Interface default execution");
      }
  }
  
  class MyTask extends BaseTask implements Executable {
      // Uses BaseTask's execute() automatically
  }
  

• If two interfaces have default methods with the same signature, you must explicitly override the method to resolve the conflict. You can choose to delegate to one of the interfaces using InterfaceName.super.methodName().

  interface TaskA {
      default void execute() {
          System.out.println("Task A execution");
      }
  }
  
  interface TaskB {
      default void execute() {
          System.out.println("Task B execution");
      }
  }
  
  class CombinedTask implements TaskA, TaskB {
      @Override
      public void execute() {
          // Choose which interface's implementation to use
          TaskA.super.execute();
      }
  }
  

These differences aren't just technicalities—they guide how you structure your code. Pick an abstract class when you need to share state and a hierarchical relationship, and an interface when you want to define a reusable capability across unrelated classes.

内容的提问来源于stack exchange，提问作者fawad