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

Abstract class — partial implementation, single inheritance. Interface — pure contract (mostly), multiple inheritance.

Analogy: An abstract class is like a blueprint for a house — it has some rooms built (concrete methods) and some rooms left empty (abstract methods). An interface is like a building code/standard — it tells you what capabilities a building MUST have, but doesn't build anything itself.

Abstract class:

• Declared with the abstract keyword.
• Can have both concrete (implemented) and abstract (unimplemented) methods.
• Can have constructors (called via super() from subclass).
• Can have instance variables (fields with any access modifier).
• Can have static methods and static variables.
• A class can extend only ONE abstract class (single inheritance).
• Cannot be instantiated directly.

1abstract class Animal {
2    // Instance field
3    protected String name;
4
5    // Constructor (interfaces can't have constructors)
6    public Animal(String name) {
7        this.name = name;
8    }
9
10    // Concrete method — provides default behavior
11    public void sleep() {
12        System.out.println(name + " is sleeping");
13    }
14
15    // Abstract method — subclasses MUST implement
16    public abstract void makeSound();
17
18    // Static method
19    public static boolean isAnimal(Animal a) {
20        return a != null;
21    }
22}
23
24class Dog extends Animal {
25    public Dog(String name) {
26        super(name);
27    }
28
29    @Override
30    public void makeSound() {
31        System.out.println(name + " barks!");
32    }
33}
34
35// Animal a = new Animal("test"); // COMPILE ERROR: cannot instantiate
36Animal a = new Dog("Rex");
37a.sleep();    // Rex is sleeping
38a.makeSound(); // Rex barks!

Interface:

• Declared with the interface keyword.
• All methods are public abstract by default (pre-Java 8).
• All variables are public static final (constants) by default.
• Cannot have constructors.
• A class can implement MULTIPLE interfaces.
• Java 8+ added default methods (with body) and static methods.
• Java 9+ added private methods (helper methods for default methods).

1interface Swimmable {
2    void swim(); // public abstract by default
3
4    // Default method (Java 8+)
5    default void float_() {
6        System.out.println("Floating gently");
7    }
8}
9
10interface Flyable {
11    void fly();
12
13    default void glide() {
14        System.out.println("Gliding");
15    }
16}
17
18// A class can implement MULTIPLE interfaces
19class Duck extends Animal implements Swimmable, Flyable {
20    public Duck(String name) {
21        super(name);
22    }
23
24    @Override
25    public void makeSound() {
26        System.out.println("Quack!");
27    }
28
29    @Override
30    public void swim() {
31        System.out.println("Duck swims in water");
32    }
33
34    @Override
35    public void fly() {
36        System.out.println("Duck flies low");
37    }
38}
39
40Duck duck = new Duck("Donald");
41duck.swim();  // Duck swims in water
42duck.fly();   // Duck flies low
43duck.glide(); // Gliding (default method)

Key differences:

• Abstract class — single inheritance. Interface — multiple inheritance.
• Abstract class — can have constructors. Interface — cannot.
• Abstract class — can have instance variables. Interface — only constants.
• Abstract class — any access modifier on methods. Interface — public by default.
• Abstract class — "is-a" relationship (Dog IS an Animal). Interface — "can-do" capability (Duck CAN swim).
• Abstract class — concrete methods provide shared logic. Interface — default methods (Java 8+) are limited.

When to use which:

• Use abstract class when classes share common state and behavior (inheritance hierarchy).
• Use interface when defining capabilities/contracts that unrelated classes can implement.
• Use interface for polymorphism without tight coupling.
• Use abstract class when you need constructors or protected fields.

Common mistake: Using an abstract class when you need multiple inheritance. Java doesn't allow extending multiple classes, but it does allow implementing multiple interfaces.