Abstraction

🔍 What Is It?

Abstract Class

• →Declared with abstract keyword
• →Can have abstract methods (no body) and concrete methods (with body)
• →Can have instance fields and constructors
• →Cannot be instantiated directly
• →A subclass must implement all abstract methods (or also be abstract)

Interface

• →Pure contract — defines what a class can do, not how
• →All methods are implicitly public
• →Java 8+: can have default methods (concrete) and static methods
• →Java 9+: can have private methods (for internal use by default methods)
• →Fields are implicitly public static final (constants)
• →A class can implement multiple interfaces

When to use which:

• →Abstract class: shared state + partial implementation; template method pattern; "is-a" with common behavior
• →Interface: pure contract; multiple inheritance of type; unrelated classes sharing behavior (Serializable, Comparable, Runnable)

🎯 Why Do We Need It?

Abstraction enables:

• →Loose coupling — callers depend on abstractions, not implementations
• →Testability — inject mock implementations in tests
• →Replaceability — swap implementations without changing callers
• →Parallel development — teams work against an interface contract before implementation exists
• →Framework integration — Spring, JPA, and all major frameworks work through interfaces

The Dependency Inversion Principle (SOLID) states: high-level modules should depend on abstractions. This is impossible without abstract classes and interfaces.

🏗️ What Happens in Real Projects?

In every Spring Boot project:

// Interface: the contract
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByDepartmentAndActive(String dept, boolean active);
}
// Spring Data generates the implementation at runtime — you never write it

// Interface: service contract
public interface PaymentService {
    PaymentResult process(PaymentRequest request);
    void refund(String paymentId, BigDecimal amount);
}

// Implementation (can be swapped without changing callers)
@Service
public class StripePaymentService implements PaymentService { ... }
// In tests: mock PaymentService, don't call Stripe

⚙️ How It Works

Abstract Method Resolution:

When you call an abstract method, Java uses dynamic dispatch to find the concrete implementation in the actual object's class.

Interface Default Methods:

Java 8+ allows default methods in interfaces — concrete implementations that subclasses inherit. This enables adding methods to interfaces without breaking existing implementations.

Functional Interfaces:

An interface with exactly one abstract method is a functional interface. It can be implemented with a lambda expression. @FunctionalInterface annotation enforces this.

Interface Segregation Principle:

Keep interfaces small and focused. A fat interface (20 methods) forces implementors to implement methods they don't need. Split into smaller, cohesive interfaces.

💻 Example

Abstract Classes and Interfaces in a Repository Pattern — How abstraction enables testable, swappable data access in enterprise Java.

// Interface: pure contract
public interface ReportGenerator {
    byte[] generate(ReportRequest request);
    String getFormat();  // "PDF", "EXCEL", "CSV"
}

// Abstract class: partial implementation with template method
public abstract class BaseReportGenerator implements ReportGenerator {
    private final AuditService auditService;
    
    protected BaseReportGenerator(AuditService auditService) {
        this.auditService = auditService;
    }
    
    // Template method — defines the algorithm
    @Override
    public final byte[] generate(ReportRequest request) {
        validateRequest(request);          // common validation
        ReportData data = fetchData(request); // abstract — subclass implements
        byte[] content = render(data);     // abstract — subclass implements
        auditService.logReport(request, getFormat()); // common audit
        return content;
    }
    
    // Common validation for all report types
    protected void validateRequest(ReportRequest request) {
        if (request.getStartDate().isAfter(request.getEndDate())) {
            throw new IllegalArgumentException("Start date must be before end date");
        }
    }
    
    // Subclasses implement these
    protected abstract ReportData fetchData(ReportRequest request);
    protected abstract byte[] render(ReportData data);
}

// Concrete implementation
@Component
public class PdfSalesReport extends BaseReportGenerator {
    private final SalesRepository salesRepo;
    
    public PdfSalesReport(AuditService audit, SalesRepository sales) {
        super(audit);
        this.salesRepo = sales;
    }
    
    @Override
    protected ReportData fetchData(ReportRequest request) {
        List<Sale> sales = salesRepo.findByDateRange(
            request.getStartDate(), request.getEndDate()
        );
        return new ReportData(sales);
    }
    
    @Override
    protected byte[] render(ReportData data) {
        // Use iText or Apache PDFBox to generate PDF
        return pdfRenderer.render(data);
    }
    
    @Override
    public String getFormat() { return "PDF"; }
}

// Another implementation — just add it, no other code changes
@Component
public class ExcelSalesReport extends BaseReportGenerator {
    @Override
    protected ReportData fetchData(ReportRequest request) { ... }
    
    @Override
    protected byte[] render(ReportData data) {
        // Use Apache POI to generate Excel
        return excelRenderer.render(data);
    }
    
    @Override
    public String getFormat() { return "EXCEL"; }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits