When Do You Use Interface And Abstract Class In Java ?

Both interfaces and abstract classes are used to achieve abstraction in Java, but they serve different purposes and have different rules and use cases. Understanding when to use each is crucial in designing scalable, maintainable, and extensible systems.

1.Interface

Definition:

An interface in Java is a blueprint of a class that contains only abstract methods (methods without a body) and constants. An interface is a contract that defines what a class can do, but not how it does it. Starting from Java 8, interfaces can also have default and static methods with concrete implementations.

Example:

interface Animal {
    void sound();  // abstract method
}

class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.sound();  // Output: Bark
        Animal cat = new Cat();
        cat.sound();  // Output: Meow
    }
}

Output:

Bark
Meow

Advantages of Interface:

• A class can implement multiple interfaces, overcoming the limitation of single inheritance in Java.
• Interfaces promote loose coupling by defining behavior without specifying the implementation, allowing various classes to implement it in different ways.
• By using interfaces, different classes can share the same method signatures but implement them in their own ways.

Uses:

• Interfaces are used when different classes share the same behavior but may have completely different implementations. For example, List , Set, and Queue interfaces in the Java Collections Framework.
• When a class needs to inherit behaviors from more than one type, interfaces allow the class to implement multiple contracts.

2.Abstract Class

Definition:

An abstract class is a class that cannot be instantiated and can have both abstract methods (without implementation) and concrete methods (with implementation). Abstract classes are used to represent common features of subclasses and provide a base implementation for some or all methods, leaving the rest to be implemented by subclasses.

Example:

abstract class Animal {
    // Concrete method (has implementation)
    public void eat() {
        System.out.println("This animal eats food.");
    }
    
    // Abstract method (must be implemented by subclasses)
    public abstract void sound();
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();  // Output: This animal eats food.
        dog.sound(); // Output: Bark
        
        Animal cat = new Cat();
        cat.eat();  // Output: This animal eats food.
        cat.sound(); // Output: Meow
    }
}

Output:

This animal eats food.
Bark
This animal eats food.
Meow

Advantages of Abstract Class:

• Abstract classes allow a combination of abstract and concrete methods. This allows them to define a default behavior, while subclasses can override or add new behaviors.
• Code Abstract classes provide a way to define common behaviors and attributes that can be reused by subclasses.
• Unlike interfaces, abstract classes follow the single inheritance rule, but they provide a more cohesive implementation for related classes.

Uses:

• Abstract classes are used when a class should act as a base for related subclasses with shared attributes and behaviors. For example, Vehicle as an abstract class can define shared behaviors (like accelerate() and brake()) for different types of vehicles (Car, Bike).
• When you want to provide some default behavior but enforce that some methods must be implemented by the subclass.