Quick Introduction Into Object Oriented Relations

تُعد العلاقات بين الكائنات -Object Oriented Relations- أحد الأعمدة الأساسية في لغات البرمجة المتمحورة حول الكائنات؛ حيث تساعد على تمثيل العلاقات الواقعية بين الـObjects، وتحسن التنظيم وإدارة أشكال متعددة للعلاقة بين الـObjects. في هذا المقال، سنتحدث بالتفصيل عن العلاقات بين الـObjects، وأمثلة توضح تلك العلاقة وكيفية استخدامها.

إن العلاقات بين الكائنات (Object Relationships) تُعد حجرًا أساسيًا في البرمجة المتمحورة حول الكائنات (Object-Oriented Programming)، وتأتي في أشكال عدة، منها: 

1. العلاقات المُركبة – Composite Relationships 
2. العلاقات الارتباطية – Association Relationships 
3. العلاقات التجميعية – Aggregation Relationships 

قبل أن نبدأ التعرف على تلك العلاقات، لنطرق سريعًا إلى ما يسمى بالـCoupled وهو الاقتران أو الارتباط، وهي مقياس لأي درجة يتعلق فيها بكائن آخر. ويكون ذلك على درجتين: 

• الاقتران الضعيف – Loose Coupling
• الاقتران القوي – Tight Coupling 

الاقتران القوي (Tight Coupling)

يحدث الارتباط القوي عندما يعتمد كائن بشكل كبير على آخر في؛ أي تغيير في الكائن الأساسي قد يؤثر على الكائن الذي يعتمد عليه بشكل كبير. ويمكن أن يؤدي هذا النوع من الارتباط إلى زيادة تعقيد البرنامج وصعوبة صيانته وتطويره فيما بعد. مثال على الارتباط القوي:

class Car
{
    public Engine engine { get; set; }
}
class Engine
{
    public string engineType { get; set; }
}

في هذا المثال، يتم استخدام كلاس Car لتمثيل سيارة، ويتم استخدام كلاس Engine لتمثيل المحرك. يتواجد الارتباط القوي هنا في الكلاس Car حيث يتوجب عليه الاعتماد بشكل كبير على كلاس Engine وعلى محتواه. 

الارتباط الضعيف (Loose Coupling)

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

class Engine : IEngine
{
    public string engineType { get; set; }
    public void start()
    {
        // code to start the engine
    }
}

interface IEngine
{
    void start();
}
class Car
{
    private IEngine engine;
    public Car(IEngine engine)
    {
        this.engine = engine;
    }
}

في هذا المثال، يتم استخدام كلاس Car لتمثيل سيارة، ويتم استخدام واجهة IEngine كمدخل لتمثيل المحرك. يتم استخدام الارتباط الضعيف هنا حيث يتم إنشاء كائن Car بمعرف تمرره لواجهة IEngine، ويمكن استخدام أي كائن ينفذ هذه الواجهة. وبهذا يمكن إضافة محركات بشكل مستقل وتغييرها دون التأثير على كائن Car.

بشكل عام، الارتباط الضعيف يعد أفضل للصيانة والتطوير في المستقبل. يتميز ب المرونة والقدرة على التطوير، لذلك يُفضل دائمًا استخدام الارتباط الضعيف في تصميم البرمجيات. ومن الجدير بالذكر أنه يمكن استخدام مزيج من الارتباط الضعيف والقوي حسب حاجة البرنامج وطبيعته.

 العلاقات الارتباطية (Association Relationships)

تُستخدم العلاقات الارتباطية لتمثيل العلاقة بين كائنين مختلفين، حيث يمكن لأي كائن الوصول إلى الكائن الآخر. وتتميز العلاقات الارتباطية بأن الكائنين المرتبطين لا يمتلكان تأثيرًا على بعضهما البعض، ويمكن لكل كائن الوصول إلى الآخر. تعد العلاقة التي تربط المعلم بالطلاب أحد الأمثلة التي توضح طبيعة هذه العلاقة؛ حيث يمكن ربط العديد من الطلاب بمعلم واحد، ويمكن ربط طالب واحد بعدد من المعلمين، ولكن كلاهما له حياته المستقلة. ففي حالة حالة طرد أحد الطلاب من المدرسة لا يتم طرد المعلم الذي كان يقوم بتدريسه، وبالمثل عند مغادرة المعلم المدرسة لا نضطر لطرد طلابه الذين كان يقوم بتدريسهم. مثال آخر على كيفية استخدام هذا النوع من العلاقات:

class Car
{
    public string carName { get; set;}
}
class Person
{
    public string personName { get; set;}
    public Car car { get; set;}
}

في هذا المثال، يتم تعريف كائنين مختلفين ويتم الربط بينهما، حيث يمكن لكائن Person الوصول إلى كائن Car، احيانًا تسمي هذه العلاقة Peer to Peer حيث يعتبر كل كائن هو قرين للآخر، وليس ذو هيمنة عليه.

العلاقات التجميعية (Aggregation Relationships)

تُستخدم العلاقات التجميعية لتمثيل العلاقة بين كائن رئيسي(Parent Object)، وكائنات فرعية(Child Objects) التي يمكن أن تنتمي إلى كائنات رئيسية مختلفة. تتميز العلاقات التجميعية بأن الكائن الرئيسي يمكن أن يحتوي على كائنات فرعية من أكثر من كائن رئيسي. يشكل الكتاب وكاتبه مثال واضح على تلك العلاقة، فكل كتاب لابد له من مؤلف، لكن فقد الكتاب أو كاتبه لا يؤثر على أحدهما -فناء الكتاب، لا يعني فناء الكاتب-. وهنا مثال على كيفية استخدام العلاقات التجميعية:

class University
{
    public List<Student> students { get; set;}
}
class Student
{
    public string studentName { get; set;}
    public int studentId { get; set;}
}

في هذا المثال، يتم تعريف كائن رئيسي (University) وكائنات فرعية (Students) التي يمكن أن تنتمي إلى عدة كائنات رئيسية مختلفة كالمنزل والنادي، وغيره. 

العلاقات المركبة (Composite Relationships)

تُستخدم العلاقات المركبة لتمثيل العلاقة بين كائن رئيسي (Parent Object) وكائنات فرعية (Child Objects) التي تتبع هذا الكائن الرئيسي. تتميز العلاقات المركبة عن تلك التجميعية، بأن الكائن الرئيسي يتحكم في حياة الكائنات الفرعية، بمعنى أنه يقوم بإنشائها وتدميرها وإدارتها.

الغرفة وجدرانها، يعد أحد أقوى الأمثلة على ذلك؛ بهدم الغرفة، تُهدم الجدران. مثال آخر على كيفية استخدام العلاقات المركبة: 

class ParentObject
{
    public ChildObject childObject1 { get; set;}
    public ChildObject childObject2 { get; set;}
}
class ChildObject
{
    public string childObjectName { get; set;}
}

في هذا المثال، يتم تعريف كائن رئيسي يحتوي على كائنات فرعية، حيث يمكن الوصول إلى الكائنات الفرعية باستخدام الكائن المهيمن الرئيسي.

في الختام

يندرج الـComposite و الـAggregation تحت الـAssociation وتتقارب مع الـAggregation في كون أحد طرفيها هو جزء من كُل الآخر، لكنها تختلف عنها حيث يمثل أحد عنصري العلاقة مالك للطرف الآخر بشكل كامل، ويمثل اعتماده على الآخر جزءًا كبيرًا من تواجده. ففي حالة فناء الطرف المهيمن، كُل من كان له علاقة به يُفنى.