عند النظر إلى الشيفرة التي قدمتها، يظهر أن لديك تسلسل من الفئات (Classes) حيث تم التركيب (Inheritance) بينها. لديك الفئة A والفئة B التي ترث من A، وفي الوقت نفسه، الفئة C ترث من B.

عند إنشاء كائن من الفئة C باستخدام C a = new C();، يحدث تسلسل من استدعاء الconstructors. يبدأ الأمر بفئة A، ثم B، وأخيرًا C. هذا هو التصرف الافتراضي في لغة البرمجة C# عند استخدام التركيب.

السبب الذي يؤدي إلى استدعاء constructor الفئة الأساس (Base class) هو أن كل constructor يقوم بتنفيذ تهيئة للجزء الخاص به من الكائن، بما في ذلك الجزء الذي يرث من الفئة الأساس. حتى إذا كنت لا تستخدم أي متغير من الفئة الأساس، يتعين على constructor للفئة المشتقة تنفيذ constructor للفئة الأساس لضمان أن الجزء الأساسي من الكائن قد تم تهيئته بشكل صحيح.

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

في النهاية، يمكنك أن تفكر في هذا التصرف الافتراضي على أنه جزء من مبدأ “التهيئة الكاملة” (Complete Initialization) حيث يضمن لكل جزء من الكائن أن يتم تهيئته بشكل صحيح، بدايةً من الجزء الأساسي وصولاً إلى الجزء المشتق.

عند التحدث عن استدعاء constructors في التركيب والتوريث في لغة البرمجة C#، يمكننا توسيع النقاش لفهم المزيد حول عدة مفاهيم هامة.

في البداية، يجب أن نتعمق في مفهوم التوريث (Inheritance) وكيف يعمل في C#. التوريث يسمح لك بإنشاء فئة جديدة تأخذ خصائص وسلوكيات فئة موجودة، وهي فئة الأساس (Base class). في المثال الذي قدمته، فإن فئة B ترث من فئة A، وفئة C ترث من فئة B.

عند إنشاء كائن من الفئة المشتقة (مثل C في حالتك)، يتم تنفيذ constructors بترتيب تصاعدي (من الأعلى إلى الأسفل في الهرم). هذا يسمح لك بضمان أن جميع الأجزاء اللازمة من الكائن تم تهيئتها بشكل صحيح.

مفهوم آخر مهم هو constructor الافتراضي (Default constructor). إذا لم تقم بتعريف constructor لفئة معينة، سيتم إنشاء constructor افتراضي تلقائيًا يقوم بتهيئة الفئة. في حالتك، يمكنك رؤية أن constructor الافتراضي لكل فئة فارغ (بدون أي تنفيذ).

للسيطرة على تنفيذ constructor الفئة الأساس، يمكن استخدام الكلمة المفتاحية base كما ذكرت سابقًا. يمكن أيضًا استخدام الكلمة المفتاحية this للإشارة إلى constructor في نفس الفئة.

من المهم أن تكون على دراية بكيفية تأثير هذه العمليات على تصميم البرامج وأداءها. يُشجع على فهم مفهوم التوريث والتركيب بشكل شامل للتمكن من كتابة كود قابل للصيانة وفهم التفاعلات بين الفئات.

في عالم برمجة الحاسوب، تعتبر التعددية الشكلية (Polymorphism) من المفاهيم الأساسية والقوية التي تسهم في تحسين هيكلة وفاعلية البرمجة. في بايثون 3، يُمثل التعددية الشكلية واحدة من أهم المفاهيم التي يُمكن للمطورين الاستفادة منها لتحسين جودة وكفاءة الشفرة.

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

في البداية، يُمكن تعريف واجهة (Interface) تحتوي على الدوال الظاهرية التي يُرغب في تحقيقها في الفئات الفرعية. على سبيل المثال:

pythonCopy code
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

في هذا المثال، تم تعريف واجهة تسمى Shape تحتوي على دوال ظاهرية هي area و perimeter. الآن، يُمكن تعريف فئات فرعية تحقق هذه الواجهة بطرق مختلفة. مثلاً:

pythonCopy code
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14 * self.radius

class Square(Shape):
    def __init__(self, side_length):
        self.side_length = side_length

    def area(self):
        return self.side_length ** 2

    def perimeter(self):
        return 4 * self.side_length

في هذا المثال، تم تعريف فئتين فرعيتين (Circle و Square) تحقق كل واحدة منهما واجهة Shape بطريقتها الخاصة. الآن، يُمكن استخدام الكائنات من هاتين الفئتين بطريقة متجانسة باستخدام الواجهة المشتركة:

pythonCopy code
circle = Circle(radius=5)
square = Square(side_length=4)

shapes = [circle, square]

for shape in shapes:
    print(f"Area: {shape.area()}, Perimeter: {shape.perimeter()}")

هذا المثال يوضح كيف يُمكن استخدام قائمة من الكائنات التي تنتمي إلى فئات مختلفة بشكل متجانس باستخدام واجهة مشتركة. يُظهر الكود نتائج حساب مساحة ومحيط كل كائن.

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

بالطبع، دعونا نوسع على الموضوع ونستكشف بعض النقاط الأخرى المهمة حول تطبيق التعددية الشكلية في بايثون 3.

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

2. توسيع الواجهة:
   يُمكن توسيع الواجهة لتضم المزيد من الدوال الظاهرية حسب الحاجة. على سبيل المثال، يمكن إضافة دالة draw لتمثيل رسم الشكل.

   pythonCopy code
   class Shape(ABC):
       @abstractmethod
       def area(self):
           pass
   
       @abstractmethod
       def perimeter(self):
           pass
   
       @abstractmethod
       def draw(self):
           pass
   

   ومن ثم، يُمكن تعديل الفئات الفرعية لتنسيق الرسم وفقًا لنوع الشكل.

3. استخدام التعديل الزمني (Duck Typing):
   في بايثون، يُمكن استخدام التعديل الزمني لتحقيق التعددية الشكلية دون الحاجة إلى استخدام الواجهات أو الوراثة. هذا يعني أن الكائنات يُمكن أن تتفاعل مع بعضها البعض استنادًا إلى وجود الدوال المطلوبة بدون النظر إلى النوع.

   pythonCopy code
   def print_shape_info(shape):
       print(f"Area: {shape.area()}, Perimeter: {shape.perimeter()}")
   
   # يمكن استخدام الوظيفة مع أي كائن يحتوي على دوال area و perimeter
   print_shape_info(circle)
   print_shape_info(square)
   

   هنا، يمكن للدالة print_shape_info العمل مع أي كائن يحتوي على الدوال area و perimeter بغض النظر عن نوعه.

4. التعددية الشكلية مع الوراثة:
   يُمكن استخدام التعددية الشكلية بشكل متزامن مع الوراثة. يمكن للفئات الفرعية أن ترث من فئات أخرى وفي الوقت نفسه تحقق واجهات جديدة.

   pythonCopy code
   class ThreeDimensionalShape(Shape):
       @abstractmethod
       def volume(self):
           pass
   

   يمكن للفئات الفرعية مثل Sphere تمديد هذه الواجهة والتحقق من الدوال الظاهرية المطلوبة.

   pythonCopy code
   class Sphere(ThreeDimensionalShape):
       def __init__(self, radius):
           self.radius = radius
   
       def area(self):
           return 4 * 3.14 * self.radius ** 2
   
       def perimeter(self):
           return 2 * 3.14 * self.radius
   
       def volume(self):
           return (4 / 3) * 3.14 * self.radius ** 3
   

   هكذا، يُمكن للفئة Sphere أن تحقق كل من واجهة Shape و ThreeDimensionalShape في الوقت نفسه.

5. الاستفادة من المزيد من المفاهيم:
   يُمكن دمج التعددية الشكلية مع مفاهيم أخرى في بايثون مثل التركيب (Composition) والتوريث المتعدد (Multiple Inheritance) للوصول إلى هياكل أكثر تعقيدًا وفعالية.

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