Understanding Object Composition and Abstractions

Object composition and abstraction are key principles of object-oriented programming (OOP) that help in designing scalable, modular, and maintainable software systems.

Let’s break these concepts down:

1. Object Composition

Definition

Object composition is a design principle where complex objects are built by combining simpler, reusable objects. This is often referred to as the "has-a" relationship (e.g., a car has-a engine).

Advantages

Promotes reusability by combining smaller objects.
Reduces tight coupling compared to inheritance.
Makes it easier to change behavior at runtime.

Example of Object Composition in PHP

In Laravel, you might use object composition to create a service that relies on other objects.

class Engine
{
    public function start()
    {
        return "Engine started.";
    }
}

class Car
{
    private $engine;

    public function __construct(Engine $engine)
    {
        $this->engine = $engine;
    }

    public function start()
    {
        return $this->engine->start();
    }
}

// Usage
$engine = new Engine();
$car = new Car($engine);
echo $car->start(); // Output: Engine started.

Real-Life Example in Laravel

Middleware in Laravel: Middleware is composed of various classes that are combined to process HTTP requests.
Eloquent Relationships: Eloquent models are composed of relationships like hasOne, hasMany, or belongsTo.

2. Abstraction

Definition

Abstraction is the concept of hiding the complex implementation details of an object and exposing only the necessary and relevant parts. It is often achieved using abstract classes or interfaces.

Advantages

Simplifies the usage of complex systems.
Allows developers to focus on the "what" rather than the "how."
Promotes polymorphism by enabling different implementations of the same interface.

Abstract Class Example

An abstract class provides a blueprint for derived classes.

abstract class PaymentProcessor
{
    abstract public function processPayment(float $amount): string;

    public function logTransaction(float $amount)
    {
        return "Transaction of $amount logged.";
    }
}

class PayPalProcessor extends PaymentProcessor
{
    public function processPayment(float $amount): string
    {
        return "Processing $amount through PayPal.";
    }
}

// Usage
$payment = new PayPalProcessor();
echo $payment->processPayment(100); // Output: Processing $100 through PayPal.
echo $payment->logTransaction(100); // Output: Transaction of $100 logged.

Interface Example

An interface defines a contract that classes must adhere to.

interface Notification
{
    public function send(string $message): string;
}

class EmailNotification implements Notification
{
    public function send(string $message): string
    {
        return "Email sent: $message";
    }
}

class SmsNotification implements Notification
{
    public function send(string $message): string
    {
        return "SMS sent: $message";
    }
}

// Usage
function notify(Notification $notification, string $message)
{
    echo $notification->send($message);
}

$email = new EmailNotification();
$sms = new SmsNotification();

notify($email, "Hello via Email!"); // Output: Email sent: Hello via Email!
notify($sms, "Hello via SMS!");     // Output: SMS sent: Hello via SMS!

Comparison of Composition and Abstraction

Aspect	Composition	Abstraction
Definition	Combining simpler objects to form a complex object.	Hiding details of implementation while exposing behavior.
Focus	"Has-a" relationship.	"What-to-do" (not how to do it).
Example in Laravel	Middleware composition, Eloquent relationships.	Contracts, Service Providers.
Implementation	Directly using instances of other classes.	Abstract classes or interfaces to define behavior.

When to Use

Use Object Composition:
- When you need to combine existing objects for new functionality.
- When behaviors can change dynamically at runtime (e.g., a Strategy pattern).
- To reduce tight coupling caused by inheritance.
Use Abstraction:
- When you want to define a blueprint or contract for related objects.
- When you need polymorphism (different implementations under the same interface).
- To hide implementation details from the users of your class.

Real-Life Scenarios Combining Both

1. Payment Processing System

You might use abstraction to define the behavior of different payment gateways and use composition to combine logging, validation, and processing.

interface PaymentGateway
{
    public function process(float $amount): string;
}

class StripePayment implements PaymentGateway
{
    public function process(float $amount): string
    {
        return "Processing $amount via Stripe.";
    }
}

class PaymentService
{
    private $gateway;

    public function __construct(PaymentGateway $gateway)
    {
        $this->gateway = $gateway;
    }

    public function pay(float $amount)
    {
        echo $this->gateway->process($amount);
    }
}

// Usage
$payment = new PaymentService(new StripePayment());
$payment->pay(100); // Output: Processing $100 via Stripe.

2. Notification System

Use abstraction for notification types and composition to add logging or formatting.

interface Notification
{
    public function send(string $message): string;
}

class EmailNotification implements Notification
{
    public function send(string $message): string
    {
        return "Email sent: $message";
    }
}

class NotificationService
{
    private Notification $notification;

    public function __construct(Notification $notification)
    {
        $this->notification = $notification;
    }

    public function notify(string $message)
    {
        echo $this->notification->send($message);
    }
}

// Usage
$notificationService = new NotificationService(new EmailNotification());
$notificationService->notify("Hello!"); // Output: Email sent: Hello!

By combining object composition and abstraction, you can build systems that are easy to extend, flexible to change, and adhere to key OOP principles like modularity and separation of concerns.