What is Inheritance?

Inheritance allows one class (child) to reuse and extend another class (parent).

Benefits:
● Code reuse
● Centralized logic
● Easy maintenance
● Extensible design

Apex uses the extends keyword.

Base Class Example

Example - Base Logger

public virtual class Logger {

    public virtual String logMessage() {
        return 'Default log';
    }
}

Explanation

● virtual allows child classes to override methods.

Child Class Example

Example - File Logger

public class FileLogger extends Logger {

    public override String logMessage() {
        return 'File log created';
    }
}

Polymorphism in Action

Polymorphism means one reference behaving differently based on actual object type.

Example - Dynamic Behavior

Code:

Logger logger;

logger = new Logger();
System.debug(logger.logMessage());

logger = new FileLogger();
System.debug(logger.logMessage());

Output:

Default log
File log created

Explanation

● Same reference variable
● Different implementation executed

Using super Keyword

The super keyword allows child classes to access parent logic.

Example - Extending Parent Behavior

public class AdvancedLogger extends Logger {

    public override String logMessage() {
        return super.logMessage() + ' | Advanced log';
    }
}

Usage:

Logger logger = new AdvancedLogger();
System.debug(logger.logMessage());

Output:

Default log | Advanced log

Abstract Classes in Apex

Abstract classes define structure without implementation.

Example - Abstract Payment Processor

public abstract class PaymentProcessor {

    public abstract Decimal calculateFee(Decimal amount);
}

Child implementation:

public class CardPayment extends PaymentProcessor {

    public override Decimal calculateFee(Decimal amount) {
        return amount * 0.02;
    }
}

Usage:

PaymentProcessor processor = new CardPayment();
System.debug(processor.calculateFee(1000));

Output:

Real-World Example – Service Strategy Pattern

Example - Notification Services

public virtual class NotificationService {
    public virtual String send() {
        return 'Generic notification sent';
    }
}

public class EmailNotification extends NotificationService {
    public override String send() {
        return 'Email sent';
    }
}

public class SmsNotification extends NotificationService {
    public override String send() {
        return 'SMS sent';
    }
}

Usage:

NotificationService service;

service = new EmailNotification();
System.debug(service.send());

service = new SmsNotification();
System.debug(service.send());

Output:

Email sent
SMS sent

Explanation

● Runtime behavior selection

● Easily extensible

Common Pitfalls

● Forgetting virtual keyword

● Overusing inheritance instead of composition
● Tight coupling between classes
● Deep inheritance chains

Productivity Tips

● Keep base classes small

● Favor interfaces for contracts
● Override only when necessary
● Write unit tests for child behavior

Conclusion

You now understand:
● Inheritance fundamentals

● Method overriding
● Polymorphism behavior
● Abstract class usage
● Real-world extensibility patterns

Keep Exploring! 🔍

Apex Beginner to Advance

Inheritance & Polymorphism in Apex