When should we use an interface and when an abstract class?

Interfaces and abstract classes are two essential components of object-oriented programming in Java and C# that allow for abstraction and polymorphism.

Interfaces establish a set of methods that a class must implement, while abstract classes are classes that cannot be instantiated directly and may have abstract methods, concrete methods, and instance variables.

The question is now: When should we use an interface and when an abstract class?

1. Use interfaces when you want to define a set of methods that multiple classes should implement, but the classes may not have any other common behavior or state. For example, the Comparable interface in Java defines a compareTo() method that allows objects of a class to be compared to each other. Any class that implements the Comparable interface can be sorted and compared with other instances of the same class.

public interface Comparable<T> {
   int compareTo(T o);
}

2. Use abstract classes when you want to provide a common implementation or behavior for a set of related classes, but the classes may also have their own unique behavior or state. For example, the Animal class may be abstract and contain common behavior for all animals, such as eating and sleeping, but each subclass of Animal, such as Cat or Dog, may have its own unique behavior, such as meowing or barking.

public abstract class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }

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

    // abstract method for subclasses to implement
    public abstract void makeSound();
}

public class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}
public class Dog extends Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

Summary

In conclusion, abstract classes and interfaces are helpful for defining a common set of behaviour or state for a collection of related classes, albeit the classes may also have their own particular behaviour or state. While abstract classes are helpful when you want to provide a consistent implementation or behaviour for a group of related classes, interfaces are handy when you want to specify a set of methods that numerous classes should implement.