البرمجة الكائنية (OOP) – المفاهيم الأساسية

البرمجة الكائنية التوجه (Object Oriented Programming - OOP) هي أسلوب حديث في تطوير البرمجيات يُقسّم التطبيق إلى وحدات تسمى كائنات (Objects) تتفاعل مع بعضها. يعتمد هذا الأسلوب على تصميم الكود باستخدام قوالب تسمى (Classes)، بحيث تمثل هذه Classes نماذج أو قوالب يمكننا من خلالها إنشاء كائنات متعددة تشترك في نفس الخصائص والسلوكيات. لقد أصبحت مبادئ البرمجة الكائنية أساسية في تطوير المشاريع الكبيرة، ومعظم أطر العمل الشهيرة في لغة PHP – مثل Laravel – تعتمد عليها بشكل كبير لتوفير هيكل منظم وقابل للتطوير.

1- (Classes)

تعريف: (Class) في البرمجة الكائنية هي بمثابة نموذج أو قالب لوحدة منطقية تضم مجموعة من الخصائص (بيانات) والدوال (سلوكيات) ذات الصلة. يمكن تشبيه Class بالقالب الذي نصنع منه كائنات متعددة متشابهة في البنية. على سبيل المثال، يمكن أن يكون لدينا Class يمثل “سيارة”، يحدد هذا Class خصائص السيارة (مثل اللون والسعة) ودوال تمثل سلوكياتها (مثل التحرك أو إطلاق الصوت).

الأهمية: Classes تساعدنا على تنظيم الكود وتجميع البيانات المرتبطة مع وظائفها في مكان واحد. بدلاً من كتابة برنامج كامل في ملف واحد بشكل إجرائي، يمكن تقسيم البرنامج إلى Classes كل منها تمثل جزءًا منطقيًا من التطبيق. هذا يجعل فهم الكود وتطويره أسهل بكثير، خاصة مع كبر حجم المشروع. كما أن استخدام Classes يسهّل إعادة استخدام الكود؛ فنستطيع إنشاء عدة كائنات من نفس Class بدل تكرار الشفرة نفسها في كل مرة.

خصائص Class: يحتوي Class عادة على نوعين من المكونات الرئيسية:

• الخصائص (Properties): وهي متغيرات تمثل حالة Object أو صفاته. تُعرّف داخل Class ويمكن أن تكون لها قيمة افتراضية.
• الدوال (Methods): وهي وظائف أو إجراءات تمثل سلوك Object أو ما يمكنه فعله. تُعرّف أيضًا داخل Class وتستطيع الوصول إلى خصائصه.

في PHP، نعرّف Class باستخدام الكلمة المحجوزة class متبوعة باسم Class وبين { } نضع تعريف الخصائص والدوال. المثال التالي يوضح تعريف Class بسيط باسم Car يحتوي على خاصية $color ودالة showColor():

<?php
// مثال Class بسيط
class Car {
    // خاصية property
    public $color = "red";

    // دالة method
    public function showColor() {
        echo "The car color is " . $this->color;
    }
}
?>
        

في هذا المثال أنشأنا Class Car يحتوي على خاصية $color مُعرّفة بـpublic (أي متاحة للكود خارج Class) مع قيمة افتراضية "red". يحتوي Class أيضًا على دالة showColor() تقوم بطباعة لون السيارة الحالي. نلاحظ استخدام الكلمة $this داخل الدالة للإشارة إلى خصائص Object الحالي. $this->color معناها أننا نستخدم قيمة الخاصية $color الخاصة بنفس Object الذي استُدعيت عليه الدالة.

2- (Objects)

تعريف: Object هو عبارة عن نسخة (instance) يتم إنشاؤها من Class معين أثناء تنفيذ البرنامج. إذا اعتبرنا Class قالبًا، فإن Object هو المنتج النهائي من هذا القالب. كل Object يحتوي على بياناته الخاصة (قيم الخصائص) ويستطيع استخدام الدوال المعرّفة في Class. في التطبيق العملي، يمثّل Object شيئًا محددًا من الواقع أو مكوّنًا من البرنامج. Objects هي الوحدة الأساسية التي يتم تشغيل البرنامج من خلالها، وهي أساس هيكلية البرمجة الكائنية.

الأهمية: تسمح لنا Objects بإنشاء نسخ متعددة من نفس Class، بحيث يكون لكل Object حالته الخاصة المستقلة. هذا مهم جدًا لإدارة بيانات متعددة المتغيرات بدون تكرار الكود؛ فبدلاً من كتابة كود جديد لكل عنصر، ننشئ كائنات من نفس Class. على سبيل المثال، يمكننا إنشاء عدة كائنات من Class Car تمثل سيارات بألوان مختلفة. كل Object سيحتفظ بقيمة خاصة به للون بينما يشترك الجميع في الدوال (السلوكيات) نفسها.

خصائص Object: يمتلك كل Object:

• حالة خاصة (State): وهي قيم الخصائص في لحظة معينة. (مثلاً لون السيارة المحددة).
• سلوك (Behavior): وهو القدرة على تنفيذ الدوال المعرفة في Class على بياناته الخاصة.
• هوية مستقلة (Identity): بحيث يمكن التمييز بين Object وآخر حتى لو كانا من نفس Class ويملكان بيانات متطابقة.

لإنشاء Object جديد في PHP نستخدم الكلمة new متبوعة باسم Class. يمكن بعد ذلك الوصول إلى خصائصه ودواله باستخدام معامل ->. يوضح المثال التالي كيفية إنشاء كائنين من Class Car وتغيير خصائصهما:

<?php
// إنشاء كائنات من Class Car
$car1 = new Car();
$car2 = new Car();

// تغيير قيمة خاصية color لكل كائن
$car1->color = "blue";
$car2->color = "green";

// استخدام method لعرض اللون
$car1->showColor(); // The car color is blue
$car2->showColor(); // The car color is green
?>
        

هنا قمنا بإنشاء كائنين $car1 و $car2 من Class Car باستخدام new. كل Object يمتلك خاصية $color مستقلة؛ حيث غيّرنا لون $car1 إلى "blue" ولون $car2 إلى "green". عند استدعاء showColor() على كل Object تم استخدام خاصية اللون الخاصة بذلك Object وطباعة لون مختلف لكل منهما. نستنتج أنه يمكن إنشاء عدد غير محدود من Objects من نفس Class حسب الحاجة، وكل Object يحتفظ ببياناته الخاصة مع اشتراكه في بنية Class.

3- (Encapsulation)

تعريف: Encapsulation هو مبدأ يتمثل في إخفاء التفاصيل الداخلية لتنفيذ Class وحماية بياناته من الوصول أو التعديل العشوائي من خارج Class. بدلاً من ذلك، يوفر Class واجهة تعامل (دوال public) للتحكم بالبيانات بشكل آمن. بهذا الشكل يستطيع مطوّر Class ضمان عدم استخدام الكود الخاص به بطريقة خاطئة أو غير متوقعة من قبل أجزاء أخرى من البرنامج. عمليًا، يعني Encapsulation أنه لا يمكن الوصول إلى بيانات Object الداخلية إلا من خلال دوال مخصصة، وليس بشكل مباشر.

الأهمية: هذا المبدأ يساعد على الحفاظ على سلامة حالة Object ومنع التأثيرات الجانبية الضارة. عند إخفاء البيانات الداخلية وجعلها خاصة (private)، لا يمكن لأي جزء من الكود الخارجي تغييرها إلا عبر واجهة محددة (دوال عامة). هذا يضمن تحكمًا أفضل في كيفية تعديل الحالة الداخلية للـ Object، ويقلل الأخطاء لأنه يمنع الاستخدام غير الصحيح للخصائص. Encapsulation يجعل صيانة الكود أسهل أيضًا؛ فإذا أردنا تغيير طريقة تخزين البيانات أو تنفيذ سلوك ما، يمكننا فعل ذلك داخل Class بدون كسر أجزاء أخرى تعتمد عليه طالما أن الواجهة الخارجية (الدوال العامة) لم تتغير.

كيفية تحقيق Encapsulation في PHP: توفر PHP ثلاثة مستويات للوصول إلى مكونات Class، وهي كلمات محجوزة نستخدمها عند تعريف الخصائص أو الدوال:

• private: يجعل الخاصية أو الدالة محصورة داخل Class نفسه فقط. (لا يمكن الوصول إليها من خارج Class أبداً).
• protected: يجعل الخاصية أو الدالة محمية؛ أي يمكن الوصول إليها من داخل Class أو من داخل أصناف ترث هذا Class فقط، لكن ليس من خارجها.
• public: يجعل الخاصية أو الدالة متاحة للجميع؛ أي يمكن الوصول إليها من أي مكان في البرنامج (خارج أو داخل Class).

عادةً ما نجعل الخصائص private لتحقيق Encapsulation، ونوفّر دوال public لقراءة أو تعديل تلك الخصائص عند الحاجة (تُعرف عادةً بـgetter وsetter). المثال التالي يوضح Class BankAccount (حساب بنكي) مع خاصية خاصة $balance ودوال عامة لإيداع وسحب الأموال والتحقق من الرصيد:

<?php
class BankAccount {
    private $balance;

    // Constructor لتعيين رصيد ابتدائي
    public function __construct($initialBalance) {
        $this->balance = $initialBalance;
    }

    // إيداع مبلغ في الحساب
    public function deposit($amount) {
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

    // سحب مبلغ من الحساب
    public function withdraw($amount) {
        if ($amount > 0 && $amount <= $this->balance) {
            $this->balance -= $amount;
        }
    }

    // جلب الرصيد الحالي
    public function getBalance() {
        return $this->balance;
    }
}

// مثال استخدام
$account = new BankAccount(100);
$account->deposit(50);
$account->withdraw(30);
echo "Balance: " . $account->getBalance(); // Balance: 120
?>
        

في هذا الكود، خاصية $balance معرّفة على أنها private وبالتالي لا يمكن تعديلها مباشرة من خارج Class BankAccount. قمنا بتوفير دالة deposit() لإضافة مبلغ إلى الرصيد ودالة withdraw() لسحب مبلغ، وكل منهما يتحقق من صحة المبلغ قبل تعديل الرصيد. أيضًا لدينا دالة getBalance() لإرجاع قيمة الرصيد الحالي. بهذه الطريقة، لا يمكن تغيير قيمة $balance إلا عبر الدوال المحددة، مما يطبق مفهوم Encapsulation ويضمن عدم وقوع تغييرات غير صحيحة أو حالات سلبية (مثل سحب مبلغ أكبر من الرصيد).

4- (Inheritance)

تعريف: Inheritance هي آلية تسمح بإنشاء Class جديد اعتمادًا على Class موجود مسبقًا. يُسمى Class الجديد Class الفرعي (Subclass) أو الابن، بينما يسمى Class الأصلي Class الأساسي (Base Class) أو الأب. يقوم Class الفرعي بوراثة جميع خصائص ودوال Class الأب كما هي، مع إمكانية إضافة خصائص ودوال جديدة أو (تعديل سلوك بعض الدوال) حسب الحاجة. تتم Inheritance في PHP باستخدام الكلمة extends بين اسم Class الفرعي واسم Class الأب. مفهوم Inheritance يساعدنا على إعادة استخدام الكود وهيكلته بصورة منطقية؛ فنضع المشترك بين عدة أصناف في Class أساسي عام، ثم تنشئ Classes فرعية تتشارك في هذا المشترك لكنها تضيف ما يميزها. بهذه الطريقة نتجنب تكرار الشفرة في كل Class.

الأهمية: تسمح Inheritance بإنشاء هرمية للـ Classes تعكس العلاقات بين Objects. على سبيل المثال، يمكن أن يكون لدينا Class أساسي Vehicle (مركبة) يحوي خصائص عامة مثل name وcolor ودالة مثل move()، ثم ننشئ من هذا Class Classes فرعية مثل Car وBoat وPlane ترث كل الصفات والسلوكيات العامة للمركبة وتضيف خصائص أو سلوكيات خاصة بها. هذا يحقق إعادة استخدام فعّالة للكود حيث أننا نعرّف الأشياء المشتركة مرة واحدة فقط في Class الأب. كما تسمح Inheritance بسهولة توسيع البرنامج؛ فإذا أردنا إضافة نوع جديد من المركبات، ننشئ Class جديدًا يرث Vehicle بدلًا من كتابة كل شيء من الصفر.

مثال بسيط: لنعرّف Class أساسي Car يمثل سيارة، ثم Class فرعي ElectricCar يمثل سيارة كهربائية ويرث من Car. سنضيف في Class الفرعي خاصية للبطارية ودالة للشحن، بينما سنستفيد من دوال Class الأساسي:

<?php
// Class أساسي
class Car {
    public $color;

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

    public function showColor() {
        echo "The car color is " . $this->color;
    }
}

// Class فرعي يرث من Car
class ElectricCar extends Car {
    public $batteryLevel = 0;

    public function charge() {
        $this->batteryLevel = 100;
    }
}

// إنشاء Object من ElectricCar واستخدامه
$ecar = new ElectricCar("yellow");
$ecar->charge();
$ecar->showColor(); // The car color is yellow
?>
        

في هذا المثال، ElectricCar يستخدم extends Car وهذا يعني أنه ورث خاصية $color ودالة showColor() من Class Car تلقائيًا. أضفنا في ElectricCar خاصية $batteryLevel (مستوى البطارية) ودالة charge() لشحن البطارية إلى 100%. عندما أنشأنا Object $ecar من ElectricCar، استطعنا تغيير لونه إلى "yellow" عند الإنشاء (باستخدام البناء __construct الموروث من Car)، ثم استدعاء charge() لملء البطارية، وأخيرًا استدعاء showColor() الموروثة من Car لطباعة اللون. نلاحظ أننا لم نعرّف showColor في ElectricCar ولكن Object $ecar استطاع استخدامها لأنها موروثة.

مثال من Laravel: تعتمد أطر العمل مثل Laravel بشكل كبير على مفهوم Inheritance. على سبيل المثال، في Laravel كل Controller تقوم بإنشائه هو في الحقيقة Class يرث من Class أساسي يوفّره الإطار اسمه Controller. هذا Class الأساسي يحتوي على وظائف مشتركة يحتاجها كل الكنترولرز (مثل خصائص وميدلوير middleware وغيرها). عندما تنشئ Class كنترولر خاص بتطبيقك وتجعله extends Controller فإن Controller يرث تلك الوظائف تلقائيًا. الكود التالي يوضح مثالًا مبسطًا لـ Class كنترولر في Laravel يرث من Class الأساسي:

<?php
// مثال على Class Controller في Laravel
use App\Http\Controllers\Controller;

class PostController extends Controller {
    public function show($id) {
        // كود عرض المنشور حسب $id
    }
}
?>
        

هنا PostController يرث من App\Http\Controllers\Controller (Class الأساسي في إطار العمل). وبالتالي PostController يمتلك كل ما يقدمه Class الأساسي من وظائف جاهزة، ونقوم نحن فقط بكتابة الدوال التي تخص منطق تطبيقنا (مثل show() لعرض محتوى منشور معين). هذا الأسلوب يوفر علينا كتابة الكثير من الشفرة المكررة ويسمح بهيكلية واضحة للتطبيق.

5- (Polymorphism)

تعريف: يشير مفهوم Polymorphism إلى قدرة Objects المختلفة (التي تشترك في أصل واحد) على الاستجابة بشكل متنوع لنفس الرسالة أو الاستدعاء. بمعنى آخر، يمكننا استدعاء نفس اسم الدالة على كائنات من أصناف متعددة، فيكون لكل منها تنفيذ مختلف لهذه الدالة حسب نوعه. هذا يسمح بكتابة برامج عامة قادرة على التعامل مع كائنات متنوعة بشكل موحّد. مصطلح "Polymorphism" يُقصد به أن Object يمكن أن يظهر بأشكال متعددة اعتمادًا على السياق، لكن واجهة الاستخدام تكون واحدة.

الأهمية: يوفّر Polymorphism مرونة كبيرة في تصميم البرامج. فبفضله يمكننا استخدام كائنات من أصناف مختلفة بالتبادل إذا كانت تشترك في خصائص أو سلوكيات معينة (مثلاً ترث من نفس Class أو تطبق نفس الواجهة). هذا يعني أنه يمكن كتابة دوال أو خوارزميات تتعامل مع النوع الأب أو مع واجهة interface دون القلق بشأن النوع المحدد للكائن الممرر؛ فالكود سينفذ الدالة الصحيحة المرتبطة بذلك Object تلقائيًا. النتيجة هي تقليل الحاجة لتعليمات شرطية كثيرة للتحقق من نوع Object، وجعل إضافة أنواع جديدة أسهل دون الحاجة لتعديل الكود الموجود.

مثال: لنفترض أن لدينا Class أساسي Vehicle به دالة move()، وقمنا بإنشاء عدة Classes فرعية تمثل أنواع مركبات مختلفة (سيارة، سفينة، طائرة) وكل منها يعيد تعريف (override) دالة move() بشكل يناسب نوع المركبة. سنكتب دالة عامة تجعل أي مركبة تتحرك دون أن تعرف نوعها سلفًا، وستستخدم Polymorphism لاستدعاء السلوك المناسب لكل مركبة:

<?php
class Vehicle {
    public function move() {
        echo "المركبة تتحرك";
    }
}

class Car extends Vehicle {
    public function move() {
        echo "السيارة تسير على الطريق";
    }
}

class Boat extends Vehicle {
    public function move() {
        echo "السفينة تبحر في الماء";
    }
}

class Plane extends Vehicle {
    public function move() {
        echo "الطائرة تطير في الجو";
    }
}

// دالة تقبل أي مركبة وتجعلها تتحرك
function makeVehicleMove(Vehicle $v) {
    $v->move();
}

// اختبار Polymorphism:
makeVehicleMove(new Car());   // السيارة تسير على الطريق
makeVehicleMove(new Boat());  // السفينة تبحر في الماء
makeVehicleMove(new Plane()); // الطائرة تطير في الجو
?>
        

في هذا المثال، جميع الأصناف Car وBoat وPlane ترث من Vehicle وتقوم بإعادة تعريف الدالة move() لتطبع رسالة مختلفة تناسب نوع المركبة. الدالة العامة makeVehicleMove(Vehicle $v) تأخذ معاملًا من نوع Vehicle (أي يمكن أن يكون كائنًا لأي صنف فرعي من Vehicle) وتستدعي $v->move(). بفضل Polymorphism، سيقوم PHP بتحديد أي دالة move() يستدعيها بناءً على النوع الفعلي للكائن الممرر. وهكذا، على الرغم من أننا نستخدم نفس الاستدعاء makeVehicleMove() لكل المركبات، إلا أن النتيجة مختلفة حسب نوع المركبة (سيارة أو سفينة أو طائرة). هذا هو جوهر Polymorphism.

6- (Abstraction)

تعريف: Abstraction هو مبدأ يهدف إلى التركيز على الخصائص والوظائف الأساسية للشيء محل الاهتمام، مع إهمال التفاصيل المعقدة غير الضرورية من أجل تبسيط النموذج. في سياق البرمجة الكائنية، يعني Abstraction تصميم واجهات أو أصناف مجردة تمثل ما يجب أن يفعله Object دون أن تعرض كيف يفعل ذلك. بعبارة أخرى، نحن نفصل بين ما يفعله Object وبين كيف يقوم بتنفيذه. الأصناف والدوال المجردة (abstract) هي التي لا تقدم تفاصيل التنفيذ وإنما تتركها للأصناف الفرعية لتحديدها.

الأهمية: يساعد Abstraction على إدارة تعقيد الأنظمة الكبيرة بتقسيمها إلى طبقات من المفاهيم. فباستخدام Abstraction نستطيع تعريف واجهات (Interfaces) أو Classes مجردة تمثل عقودًا (Contracts) يجب على الأصناف التي تطبقها الالتزام بها. هذا يفيد في تصميم برمجيات مرنة وقابلة للتغيير، حيث يمكن تغيير تفاصيل التنفيذ في الأصناف الفرعية دون التأثير على الأجزاء التي تتعامل مع Class أو الواجهة المجردة. كما يشجّع Abstraction على إعادة استخدام الكود عن طريق فصل العموميات (المجردات) عن الخصوصيات. في PHP، نحقق Abstraction باستخدام الكلمة المفتاحية abstract عند تعريف Class أو دالة مجردة، أو باستخدام الواجهات interface لتعريف مجموعة دوال يجب على الأصناف التي تطبقها توفير تنفيذ لها.

مثال: سنوضح Abstraction باستخدام واجهة Shape تحتوي على تعريف لدالة area() (لحساب المساحة) دون أي تنفيذ. ثم ننشئ صنفين Circle (دائرة) وSquare (مربع) يطبّقان هذه الواجهة ويقدمان تنفيذًا مختلفًا لدالة area() كل حسب معادلته الخاصة. يمكننا بعد ذلك استخدام Object من نوع Shape (عمليًا سيتم تمرير Object Circle أو Square) وندعو الدالة area() دون الاهتمام بالتفاصيل الداخلية لحساب المساحة لكل شكل:

<?php
interface Shape {
    public function area();
}

class Circle implements Shape {
    private $radius;

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

    public function area() {
        return pi() * pow($this->radius, 2);
    }
}

class Square implements Shape {
    private $side;

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

    public function area() {
        return $this->side * $this->side;
    }
}

// مثال استخدام
$circle = new Circle(3);
$square = new Square(4);
echo $circle->area();  // 28.27 (مساحة الدائرة تقريبًا)
echo $square->area();  // 16 (مساحة المربع)
?>
        

لدينا واجهة Shape تُعرّف الوظيفة area() دون تفاصيل. Class Circle وClass Square كلاهما implements Shape أي يلتزمان بتوفير دالة area(). كل منهما يحسب المساحة بطريقته: الدائرة تستخدم الصيغة πr²، والمربع يستخدم الصيغة side * side. في مثال الاستخدام، نلاحظ أننا نستدعي $shape->area() (سواء كان الشكل دائرة أو مربع) فنحصل على نتيجة صحيحة لكل شكل. هذا يبين قوة Abstraction؛ حيث استطعنا التعامل مع أشكال مختلفة من خلال واجهة واحدة مشتركة دون معرفة تفاصيل الحساب لكل شكل. الكثير من أجزاء إطار Laravel (وغيره من الأطر) مبنية على هذا المفهوم، فتجد أنه يعرف واجهات (interfaces) لمكونات مختلفة ويترك للتطبيق الفعلي (أو للمبرمج) مهمة توفير تنفيذ تلك الواجهات بما يتناسب مع احتياجاته.

الخلاصة

المفاهيم الأساسية للبرمجة الكائنية في PHP: Classes ، Objects، Encapsulation، Inheritance، Polymorphism، Abstraction. هذه المبادئ مترابطة وتشكل معًا أساس أسلوب البرمجة بـ Objects . باستخدام Classes Objects يمكننا بناء برامج أكثر تنظيماً ومرونة، وباستخدام Encapsulation نحمي بياناتنا، بينما تمكّننا Inheritance وPolymorphism وAbstraction من إعادة استخدام الكود وكتابة برامج قابلة للتوسع بسهولة. إتقان هذه المفاهيم مهم جدًا، لا سيما عند العمل على مشاريع كبيرة أو استخدام أطر عمل حديثة مثل Laravel التي تعتمد بشكل كبير على البرمجة الكائنية في تصميم هيكلها. حاول تطبيق هذه المبادئ في مشاريعك الخاصة؛ ستلاحظ كيف يصبح الكود أسهل في الفهم والصيانة مع نمو مشروعك.