realNameHidden

Posted on Apr 24

Why Did You Choose Interface Instead of Abstract Class in Java?

#java #interview #oops #interface

Learn why to choose interface instead of abstract class in Java programming with simple examples, use cases, and best practices for beginners.

🚀 Introduction

Imagine you're designing a system where multiple devices—like a car, drone, and robot—all need a start() function. But each behaves differently.

Should you force them into a shared base class? Or just define a common contract?

This is where the question arises:
👉 Why did you choose interface instead of abstract class?

Understanding this is crucial if you're serious about Java programming and want to write clean, scalable code. Many beginners struggle here—but once it clicks, your design skills level up instantly.

🧠 Core Concepts

🔑 What is an Interface?

An interface is like a contract:

“If you implement me, you must follow these rules.”

Contains method declarations (and default/static methods in Java 8+)
Supports multiple inheritance
No state (only constants)

🔑 What is an Abstract Class?

An abstract class is like a partially built blueprint:

“I provide some implementation, you complete the rest.”

Can have both abstract and concrete methods
Supports single inheritance only
Can maintain state (instance variables)

⚖️ When to Choose Interface Instead of Abstract Class?

✅ Use Interface When:

You need multiple inheritance
You want to define a common capability
You don’t need shared state
You want loose coupling

❌ Avoid Abstract Class When:

You don't need shared code
You need flexibility across unrelated classes

💡 Real-Life Analogy

Interface = Driving License (anyone can implement driving)
Abstract Class = Vehicle (has shared structure like engine, wheels)

💻 Code Examples

✅ Example 1: Interface for Payment System (Real-World Use Case)

// Payment interface defining a contract
interface Payment {
    void pay(double amount);
}

// CreditCard implementation
class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paid ₹" + amount + " using Credit Card");
    }
}

// UPI implementation
class UPIPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paid ₹" + amount + " using UPI");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Payment payment;

        payment = new CreditCardPayment();
        payment.pay(500);

        payment = new UPIPayment();
        payment.pay(1000);
    }
}

🔍 Why Interface Here?

Different payment methods
No shared state
Flexible and extendable

✅ Example 2: REST API Design Using Interface (Java 21)

// Interface defining API contract
interface UserService {
    String getUser(int id);
}

// Implementation class
class UserServiceImpl implements UserService {

    @Override
    public String getUser(int id) {
        // Simulated database response
        return "{\"id\": " + id + ", \"username\": \"user_" + id + "\"}";
    }
}

// Simple Controller Simulation
class UserController {
    private final UserService userService = new UserServiceImpl();

    public String handleRequest(int id) {
        return userService.getUser(id);
    }
}

// Main class to simulate API call
public class Main {
    public static void main(String[] args) {
        UserController controller = new UserController();

        String response = controller.handleRequest(1);
        System.out.println(response);
    }
}

🌐 API Simulation (cURL + Response)

Request:

curl -X GET "http://localhost:8080/users/1"

Response:

{
  "id": 1,
  "username": "user_1"
}

🏆 Best Practices

✔️ 1. Prefer Interface for Flexibility

Interfaces allow multiple implementations—great for scalable systems.

✔️ 2. Avoid Overusing Abstract Classes

Use them only when you need shared logic or state.

✔️ 3. Use Default Methods Carefully

Too many default methods = hidden complexity.

✔️ 4. Follow SOLID Principles

Interfaces help achieve:

Dependency Inversion
Interface Segregation

✔️ 5. Name Interfaces Clearly

Use meaningful names like:

Payment
Runnable
Comparable

📚 Useful Resources

Oracle Docs: https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html
Java Interfaces Guide: https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/package-summary.html

🎯 Conclusion

Choosing between an interface and an abstract class is not random—it’s a design decision.

👉 Choose interface instead of abstract class when:

You need flexibility
You want multiple inheritance
You’re defining behavior, not structure

Mastering this concept will make your Java programming cleaner, more scalable, and industry-ready.

📢 Call to Action

Have you used an interface instead of an abstract class in your projects?
Drop your example or question in the comments—let’s discuss and learn Java together! 🚀

DEV Community