Understanding and Applying Real-World OOP Principles in Laravel Framework : A Practical Guide

OOP Examples with like “book,” “animal,” or “car” are often oversimplified and can feel disconnected from real-world backend development. To bridge this gap, let’s focus on practical, real-world OOP principles in the context of a Laravel framework.

1. Understand the Core of OOP

• Encapsulation: Keep data and methods private to ensure better control and reduce bugs.
  Example: Use models to encapsulate business logic related to database interactions.
• Inheritance: Share common behaviors among related classes.
  Example: Create a base Notification class with shared functionality and extend it for specific notifications.
• Polymorphism: Write code that works with objects of multiple types interchangeably.
  Example: Use interfaces for dependency injection (e.g., PaymentGatewayInterface for multiple payment processors).
• Abstraction: Define essential behaviors and hide the implementation details.
  Example: Abstract controllers for common CRUD operations.

2. Real-World OOP Examples in Laravel

Let’s translate these concepts into practical Laravel examples:

a. Encapsulation with Models

• Use models to handle business logic:

class Order extends Model
{
    public function calculateTotal()
    {
        return $this->items->sum(fn($item) => $item->price * $item->quantity);
    }

    public function markAsPaid()
    {
        $this->update(['status' => 'paid']);
    }
}

b. Inheritance with Base Classes

• Use a base controller for shared logic:

class BaseController extends Controller
{
    protected function jsonResponse($data, $message = 'Success', $status = 200)
    {
        return response()->json([
            'message' => $message,
            'data' => $data,
        ], $status);
    }
}

class ProductController extends BaseController
{
    public function show($id)
    {
        $product = Product::findOrFail($id);
        return $this->jsonResponse($product, 'Product retrieved');
    }
}

c. Polymorphism with Interfaces

• Implement a payment system:

interface PaymentGateway
{
    public function charge($amount);
}

class StripePayment implements PaymentGateway
{
    public function charge($amount)
    {
        // Stripe-specific logic
    }
}

class PayPalPayment implements PaymentGateway
{
    public function charge($amount)
    {
        // PayPal-specific logic
    }
}

• Inject the dependency:

class PaymentService
{
    protected $gateway;

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

    public function processPayment($amount)
    {
        return $this->gateway->charge($amount);
    }
}

d. Abstraction with Repositories

• Separate data access logic from controllers:

interface UserRepositoryInterface
{
    public function findByEmail(string $email): User;
}

class EloquentUserRepository implements UserRepositoryInterface
{
    public function findByEmail(string $email): User
    {
        return User::where('email', $email)->firstOrFail();
    }
}

// Bind the interface in a service provider
app()->bind(UserRepositoryInterface::class, EloquentUserRepository::class);

3. Conclusions:

From this article you understand the Core of OOP and practical, real-world example in Laravel Framework. Happy coding :)

💡 Let’s connect and stay in touch!

🌐 Portfolio: mohasin.dev
💼 LinkedIn: linkedin.com/in/mohasin-dev
👨‍💻 GitHub: github.com/mohasin-dev
🤝 ADPList: adplist.org/mentors/mohasin-hossain