هندسة البرمجيات والـ Backend الأدلة التقنية

البرمجة الكائنية OOP للمبتدئين: الوراثة أم التركيب؟

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

البرمجة الكائنية OOP للمبتدئين: الوراثة أم التركيب؟

أغلب من تعلم البرمجة الكائنية Object-Oriented Programming تعلمها بمثال الحيوانات: كلاس Animal وتحته Dog وCat، وكل منها يطبع صوته بطريقته. والمثال يشرح الفكرة، ولكنه لا يجهزك لأول مشروع حقيقي، فهناك لن يسألك أحد عن صوت القطة، وإنما سوف يأتيك طلب مثل: «الطالب الذي تخرج وتوظف في الجامعة يجب أن تتغير مدة إعارته من 14 يوماً إلى 30، دون أن يخسر الكتب التي معه»، أو «المعيد طالب وموظف في الوقت نفسه، فأي القاعدتين تطبق عليه؟». وعندها تكتشف أن شجرة الوراثة التي رسمتها في اليوم الأول لا تعرف كيف تجيب، وتبدأ في كتابة if تسأل عن نوع الكائن في كل مكان.

وفي مقال هندسة البرمجيات Software Engineering، وهو أول مقال في هذه المرحلة، ذكرنا أن السؤال الأهم في أي تصميم هو أين يوضع كل قرار يحتمل أن يتغير، والبرمجة الكائنية هي إحدى أكثر الأدوات انتشاراً للإجابة عن هذا السؤال، فهي تجمع البيانات والسلوك الذي يخصها في مكان واحد، وتسمح لك بأن تكتب كوداً يعمل مع أنواع مختلفة دون أن يعرفها. وسوف نتبع في المقال كله مثالاً واحداً، وهو نظام إعارة لمكتبة جامعة فيه أعضاء من الطلاب والموظفين، ولكل نوع حد للكتب ومدة للإعارة وغرامة عن كل يوم تأخير، ونكتبه بلغتين: Python التي تتحقق من الأنواع وقت التشغيل، وJava التي تتحقق منها وقت الترجمة Compile Time، لأن الفرق بينهما يعلمك الكثير عن معنى الواجهة والوراثة.

وسوف نناقش في هذا المقال ما يلي:

  • لماذا ظهرت البرمجة الكائنية، وما مشكلة الحل البسيط بحقل للنوع، وما هو الكائن Object والكلاس Class، وما معنى التغليف Encapsulation.
  • الواجهة Interface كعقد، والفرق بين الواجهة في Java والكلاس المجرد Abstract Class وProtocol في Python.
  • الوراثة Inheritance وتعدد الأشكال Polymorphism، وكيف يختار البرنامج الدالة الصحيحة وقت التشغيل، مع نظرة إلى الداخل في Python وفي الـ Bytecode الخاص بـ Java.
  • ثلاثة طلبات حقيقية لا تستطيع الوراثة أن تجيب عنها، ومبدأ الاستبدال الذي صاغته Barbara Liskov سنة 1987، وأمثلة رسمية من مكتبة Java نفسها.
  • التركيب Composition كما نصح به كتاب Design Patterns سنة 1994، وإعادة هيكلة المثال من الوراثة إلى التركيب والاختبارات نفسها تنجح قبل وبعد.
  • أخطاء المترجم Compiler ووقت التشغيل Runtime الحقيقية في اللغتين، ومتى يظهر كل خطأ.

لماذا ظهرت البرمجة الكائنية OOP؟

في الستينيات كانت البرامج تكتب كدوال تمر عليها البيانات، وكانت البيانات في متغيرات عامة يقرؤها ويعدلها أي جزء من البرنامج. ومع كبر البرامج صار من الصعب أن تعرف من عدل هذا المتغير ولماذا، وأي تعديل في شكل البيانات يجبرك على مراجعة كل دالة تلمسها. وفي النرويج كان Ole-Johan Dahl وKristen Nygaard يكتبان برامج محاكاة، ويحتاجان إلى تمثيل أشياء كثيرة متشابهة، لكل منها حالته وسلوكه، فأضافا إلى لغة Simula فكرة الكلاس والكائن والوراثة في Simula 67. ثم جاءت Smalltalk في السبعينيات من فريق Alan Kay في Xerox PARC، وينسب إليه اسم Object-Oriented، ثم انتشرت الفكرة مع C++ في الثمانينيات وJava في 1995، وصارت اليوم موجودة بشكل ما في أغلب اللغات المشهورة، ومنها Python وC# وKotlin وTypeScript.

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

الحل البسيط: حقل للنوع وجمل if

قبل أن نكتب أي كلاس، لننظر إلى الطريقة التي يكتب بها أغلب المبتدئين نظام الإعارة دون برمجة كائنية: قاموس لكل عضو فيه حقل اسمه type، ودالة لكل سؤال تسأل عن النوع:

def loan_days(member: dict) -> int:
    if member["type"] == "student":
        return 14
    elif member["type"] == "staff":
        return 30
    raise ValueError(member["type"])


def max_loans(member: dict) -> int:
    if member["type"] == "student":
        return 3
    elif member["type"] == "staff":
        return 10
    raise ValueError(member["type"])

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

الكائن Object والكلاس Class: الحالة State والسلوك Behavior

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

كلاس Member في الأعلى كقالب فيه الحقول name وloans والدوال borrow وgive_back، وتحته كائنان: huda ومعها كتاب Clean Code، وali وقائمته فارغة، وكل كائن له حالته الخاصة ويشترك مع الآخر في السلوك
الكلاس يصف، والكائن يحمل الحالة، وكل الكائنات تشترك في سلوك واحد

والكود التالي من التجربة ينشئ عضوين من النسخة الأولى من نظام الإعارة، ويستعير كتاباً لأحدهما:

# Two objects of one class: each has its own state; the class only describes them.
from library import new_student

huda = new_student("Huda")
ali = new_student("Ali")
huda.borrow("Clean Code")
print("huda:", huda.loans, "| ali:", ali.loans)
print("same class:", type(huda) is type(ali), "| same object:", huda is ali)

# nothing stops other code from editing the list directly and skipping the limit
for t in ["A", "B", "C"]:
    huda.loans.append(t)
print("huda now holds", len(huda.loans), "books, limit is", huda.max_loans())

والمخرج سوف يكون كما يلي:

huda: ['Clean Code'] | ali: []
same class: True | same object: False
huda now holds 4 books, limit is 3

في المخرج أعلاه لاحظ التالي:

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

التغليف Encapsulation: من يحق له تعديل الحالة؟

التغليف هو أن يخفي الكائن حالته الداخلية، فلا يغيرها إلا من خلال دواله التي تحافظ على قواعده، مثل حد الكتب. وفي Python لا يوجد منع حقيقي، وإنما اتفاق بين المطورين: الاسم الذي يبدأ بشرطة سفلية مثل _loans يعني «لا تلمسه من الخارج»، كما يشرح دليل الكلاسات في توثيق Python. أما Java فتمنع ذلك بالمترجم، ففي النسخة الأولى من التجربة بلغة Java جعلنا القائمة private، والدالة loans() ترجع نسخة لا تقبل التعديل:

package library;

import java.util.ArrayList;
import java.util.List;

// Version 1: an abstract class, one subclass per member type.
public abstract class Member {
    private final String name;
    private final List<String> loans = new ArrayList<>();

    protected Member(String name) { this.name = name; }

    public abstract int maxLoans();
    public abstract int loanDays();
    public abstract double feePerDay();

    public String name() { return name; }
    public List<String> loans() { return List.copyOf(loans); }

    public int borrow(String title) {
        if (loans.size() >= maxLoans())
            throw new LoanLimitError(name + " already has " + loans.size() + " books");
        loans.add(title);
        return loanDays();
    }

    public double giveBack(String title, int daysLate) {
        loans.remove(title);
        return daysLate * feePerDay();
    }
}

والآن نحاول من كلاس آخر أن نصل إلى القائمة مباشرة كما فعلنا في Python:

package library;

// Other code tries to reach the list inside a member.
class Encapsulation1 {
    public static void main(String[] args) {
        Member huda = Members.newStudent("Huda");
        huda.loans.add("A");
    }
}
javac -d /tmp/o v1/library/*.java errors/Encapsulation1.java

والمخرج سوف يكون كما يلي:

errors/Encapsulation1.java:7: error: loans has private access in Member
        huda.loans.add("A");
            ^
1 error

ثم نجرب الطريق الآخر، وهو أن نأخذ القائمة من الدالة العامة ونضيف إليها:

package library;

// The getter returns a copy that cannot be changed.
class Encapsulation2 {
    public static void main(String[] args) {
        Member huda = Members.newStudent("Huda");
        huda.borrow("Clean Code");
        System.out.println(huda.loans());
        huda.loans().add("A");
    }
}
[Clean Code]
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:159)
	at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.add(ImmutableCollections.java:164)
	at library.Encapsulation2.main(Encapsulation2.java:9)

الخطأ الأول ظهر قبل أن يعمل البرنامج أصلاً، والثاني ظهر وقت التشغيل لأن List.copyOf ترجع قائمة ثابتة Immutable، وفي الحالتين لم يستطع أحد أن يتجاوز حد الكتب. وقد يتساءل البعض: هل يعني هذا أن Python لا تصلح للتغليف؟ لا، والفرق أن الحماية في Python مسؤوليتك أنت: تسمي الحقل _loans وتعرض للخارج نسخة منه، مثل tuple(self._loans)، ثم يلتزم الفريق بالاتفاق، ويساعده المدقق Ruff بقاعدة SLF001 التي تنبه عند الوصول إلى اسم يبدأ بشرطة سفلية من خارج الكلاس. وفي التجربة تركنا القائمة عامة في نسختي Python لنبقي الكود قصيراً، وهذا تمرين جيد في نهاية المقال.

الواجهة Interface: عقد Contract بلا تفاصيل

الواجهة تقول ماذا يستطيع الكائن أن يفعل، ولا تقول كيف. ففي نظام الإعارة يحتاج العضو أن يسأل عن ثلاثة أشياء فقط: كم كتاباً يحق له، وكم يوماً، وكم الغرامة اليومية، ولا يهمه هل هذه الأرقام ثابتة أم محسوبة من قاعدتين أم ممددة في الإجازة. وهذه الأسئلة الثلاثة هي العقد. وفي Java نكتب العقد بالكلمة interface كما في دليل Oracle للواجهات:

package library;

// The interface: what the rules of a member must answer, nothing about how.
public interface LoanPolicy {
    int maxLoans();
    int loanDays();
    double feePerDay();
}

وأي كلاس يكتب implements LoanPolicy يجب أن يعطي الدوال الثلاث، وإلا رفض المترجم البرنامج. وفي Python هناك طريقتان للعقد:

  • الكلاس المجرد Abstract Class من الوحدة abc: تكتب دوالاً عليها @abstractmethod، وكل كلاس يرث منه يجب أن يعطيها، وإلا رفضت Python إنشاء كائن منه. وهذا ما استخدمناه في النسخة الأولى.
  • البروتوكول Protocol من الوحدة typing، وجاء في PEP 544 مع Python 3.8: تصف شكل الكائن فقط، وأي كائن له هذه الدوال يطابق العقد حتى لو لم يذكر اسم البروتوكول أبداً، وهذا ما يسمى المطابقة البنيوية Structural Typing، وهو ما استخدمناه في النسخة الثانية.

والفرق بين الطريقتين هو الفرق بين الأنواع الاسمية Nominal والبنيوية Structural الذي شرحناه في مقال أنظمة الأنواع: Java تسأل «هل قلت إنك تطبق هذه الواجهة؟»، وProtocol في Python يسأل «هل عندك هذه الدوال؟». والصورة التالية تبين الواجهة في النسخة الثانية والكلاسات التي تطبقها:

الكلاس Member في اليمين يعرف الواجهة LoanPolicy فقط، وفيها ثلاث دوال max_loans وloan_days وfee_per_day، وتحت الواجهة ثلاثة تطبيقات: FixedPolicy بأرقام ثابتة للطالب والموظف والزائر، وBestOf التي تجمع قاعدتين، وHolidayExtension التي تضيف أياماً لقاعدة أخرى
العضو يعرف العقد فقط، وأي كائن يفي بالعقد يمكن أن يوضع مكانه

الواجهات في لغات أخرى Other Languages

اللغتان في هذا المقال تمثلان طرفين، وبقية اللغات المشهورة تقع بينهما، ومعرفة موقع لغتك يخبرك متى تنبهك إلى العقد الناقص:

  • Go: لا توجد فيها وراثة أصلاً، والواجهة فيها بنيوية مثل Protocol، فأي نوع له الدوال المطلوبة يطابق الواجهة دون أن يذكرها، ولكن المترجم يتحقق من ذلك وقت الترجمة، أي أنها تجمع مرونة Python وأمان Java. وقد شرحنا ذلك في الأنواع والواجهات في Go، والتركيب فيها هو الطريقة الوحيدة لإعادة الاستخدام عبر التضمين Embedding.
  • TypeScript: الأنواع فيها بنيوية أيضاً، والمترجم يتحقق منها قبل التشغيل، ثم تحذف الأنواع كلها في JavaScript الناتج، فلا يبقى منها شيء وقت التشغيل، كما شرحنا في TypeScript للمطورين.
  • C# وKotlin: مثل Java في الواجهات الاسمية وفي منع الوراثة من أكثر من كلاس، وKotlin تجعل كل كلاس مغلقاً أمام الوراثة افتراضياً، فلا يرث منه أحد إلا إذا كتبت open، وهذا قرار تصميم صريح يفضل التركيب.

متى تكتشف أنك خالفت العقد؟

هنا يظهر الفرق العملي بين اللغتين. لنفرض أن مطوراً كتب على عجل قاعدة جديدة للصيف، ونسي دالة الغرامة. في Java يكتب:

package library;

// A new policy written in a hurry: it forgot feePerDay.
class SummerPolicy implements LoanPolicy {
    public int maxLoans() { return 5; }
    public int loanDays() { return 60; }
}

والمترجم يرفضه قبل أن يعمل أي شيء:

errors/SummerPolicy.java:4: error: SummerPolicy is not abstract and does not override abstract method feePerDay() in LoanPolicy
class SummerPolicy implements LoanPolicy {
^
1 error

وفي Python يكتب الشيء نفسه دون أن يذكر البروتوكول، ويستخدمه مع العضو:

# A new policy written in a hurry: it forgot fee_per_day. Python only notices when that line runs.
from library import Member


class SummerPolicy:
    def max_loans(self) -> int: return 5
    def loan_days(self) -> int: return 60


m = Member("Huda", SummerPolicy())
print("borrow:", m.borrow("Dune"))
m.borrow("SICP")
print("late:", m.give_back("SICP", days_late=3))

والمخرج سوف يكون كما يلي:

borrow: 60
Traceback (most recent call last):
  File "/lab/errors/e5_protocol.py", line 13, in <module>
    print("late:", m.give_back("SICP", days_late=3))
                   ~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^
  File "/lab/v2/library.py", line 61, in give_back
    return days_late * self.policy.fee_per_day()
                       ^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'SummerPolicy' object has no attribute 'fee_per_day'

لاحظ أن الاستعارة الأولى نجحت وطبعت 60، والاستعارة الثانية نجحت أيضاً، والخطأ لم يظهر إلا عندما أرجع العضو كتاباً متأخراً واحتاج البرنامج الغرامة، أي أن البرنامج كان سيعمل أياماً في الإنتاج قبل أن يظهر الخطأ عند أول تأخير. ولكن Python تعطيك طريقة لتكتشفه قبل التشغيل، وهي مدقق الأنواع mypy الذي يفهم Protocol:

MYPYPATH=/lab/v2 mypy errors/e5_protocol.py
errors/e5_protocol.py:10: error: Argument 2 to "Member" has incompatible type "SummerPolicy"; expected "LoanPolicy"  [arg-type]
errors/e5_protocol.py:10: note: "SummerPolicy" is missing following "LoanPolicy" protocol member:
errors/e5_protocol.py:10: note:     fee_per_day
Found 1 error in 1 file (checked 1 source file)

وهذه رسالة مفيدة جداً: تذكر الدالة الناقصة بالاسم، وفي السطر الذي أنشأنا فيه العضو، وليس في السطر الذي سوف يفشل فيه البرنامج بعد أيام. وقد واجهنا في التجربة مشكلة صغيرة هنا: عندما شغلنا mypy مع المتغير PYTHONPATH بدلاً من MYPYPATH رفض فحص الملف برسالة module is installed, but missing library stubs or py.typed marker، لأن mypy يعامل ما يجده عبر PYTHONPATH كمكتبة مثبتة لا يثق بأنواعها، فإذا كان الكود كودك فأعطه المسار عبر MYPYPATH أو إعداد mypy_path.

خط زمني من كتابة الكود إلى الإنتاج، وعليه ثلاث نقاط يظهر فيها خطأ الدالة الناقصة: Java عند javac قبل التشغيل، وPython مع mypy قبل التشغيل، وPython دون mypy عند أول إرجاع متأخر في الإنتاج برسالة AttributeError
الخطأ نفسه يظهر في ثلاثة أوقات مختلفة، وكلما ظهر أبكر كان أرخص

الوراثة Inheritance: علاقة «هو نوع من» is-a

الوراثة تعني أن كلاساً جديداً، يسمى الابن Subclass، يأخذ حقول كلاس آخر، يسمى الأب Superclass، ودواله، ثم يضيف إليها أو يغير بعضها. وهي تعبر عن علاقة «هو نوع من»: الطالب هو نوع من الأعضاء، والموظف هو نوع من الأعضاء. وفي النسخة الأولى من التجربة كتبنا العضو كلاساً مجرداً فيه السلوك المشترك، أي الاستعارة والإرجاع، وترك الأرقام الثلاثة للأبناء:

"""Library members, version 1: one subclass per member type (inheritance)."""
from abc import ABC, abstractmethod


class LoanLimitError(Exception):
    pass


class Member(ABC):
    def __init__(self, name: str):
        self.name = name
        self.loans: list[str] = []

    @abstractmethod
    def max_loans(self) -> int: ...

    @abstractmethod
    def loan_days(self) -> int: ...

    @abstractmethod
    def fee_per_day(self) -> float: ...

    def borrow(self, title: str) -> int:
        if len(self.loans) >= self.max_loans():
            raise LoanLimitError(f"{self.name} already has {len(self.loans)} books")
        self.loans.append(title)
        return self.loan_days()

    def give_back(self, title: str, days_late: int = 0) -> float:
        self.loans.remove(title)
        return days_late * self.fee_per_day()


class Student(Member):
    def max_loans(self): return 3
    def loan_days(self): return 14
    def fee_per_day(self): return 0.5


class Staff(Member):
    def max_loans(self): return 10
    def loan_days(self): return 30
    def fee_per_day(self): return 1.0


# the public API the rest of the system (and the tests) use
def new_student(name: str) -> Member:
    return Student(name)


def new_staff(name: str) -> Member:
    return Staff(name)

ولاحظ الدالتين new_student وnew_staff في آخر الملف: بقية النظام والاختبارات تنشئ الأعضاء من خلالهما وليس من الكلاسات مباشرة، وسوف ترى بعد قليل لماذا كان هذا القرار الصغير هو ما جعل الاختبارات تنجح دون تعديل بعد إعادة الهيكلة. والنسخة نفسها بلغة Java فيها كلاس مجرد Member رأيته أعلاه، وكلاسان صغيران:

package library;

public class Student extends Member {
    public Student(String name) { super(name); }
    @Override public int maxLoans() { return 3; }
    @Override public int loanDays() { return 14; }
    @Override public double feePerDay() { return 0.5; }
}

والكلاس Staff مثله بالأرقام 10 و30 و1.0. وإذا نسي أحد الأبناء دالة مجردة فإن اللغتين ترفضانه، ولكن في وقتين مختلفين كما رأينا مع الواجهة. ففي Java يرفض المترجم الكلاس Visitor الذي نسي feePerDay:

errors/Visitor.java:4: error: Visitor is not abstract and does not override abstract method feePerDay() in Member
class Visitor extends Member {
^
1 error

وفي Python يقبل تعريف الكلاس نفسه، ولا يظهر الخطأ إلا عند إنشاء أول كائن منه:

class defined, nothing failed yet
Traceback (most recent call last):
  File "/lab/errors/e1_missing_method.py", line 11, in <module>
    v = Visitor("guest")
TypeError: Can't instantiate abstract class Visitor without an implementation for abstract method 'fee_per_day'

وهذا أفضل من AttributeError في منتصف العمل، لأن الخطأ يظهر عند الإنشاء وليس عند أول استخدام للدالة الناقصة، وهذه فائدة ABC على الوراثة من كلاس عادي.

تعدد الأشكال Polymorphism: استدعاء واحد وسلوكيات مختلفة

تعدد الأشكال هو أن تكتب كوداً يعمل مع النوع العام، والبرنامج يختار وقت التشغيل السلوك المناسب للكائن الفعلي. وفي التجربة الاختبار التالي يمر على قائمة فيها طالب وموظف، ويستدعي borrow على كل منهما دون أن يسأل عن نوعه:

def test_polymorphism_one_loop_for_all_members():
    members = [new_student("Huda"), new_staff("Omar")]
    assert [m.borrow("Dune") for m in members] == [14, 30]

والدالة borrow مكتوبة مرة واحدة في الأب، ولكنها تستدعي self.loan_days()، وهنا يحدث الاختيار: في Python يبحث المفسر عن loan_days في كلاس الكائن الفعلي أولاً ثم في آبائه، بالترتيب الذي يسمى ترتيب حل الدوال Method Resolution Order واختصاراً MRO، فيجد Student.loan_days للأول وStaff.loan_days للثاني. وفي Java يترجم الاستدعاء إلى تعليمة invokevirtual في الـ Bytecode، والآلة الافتراضية JVM تختار وقت التشغيل الدالة من كلاس الكائن الفعلي، وهذا ما يسمى الربط المتأخر Dynamic Dispatch. والصورة التالية تبين الطريقين:

حلقة واحدة تستدعي m.borrow على عضوين، والدالة borrow في الكلاس الأب تستدعي loan_days، فيذهب الاستدعاء للطالب إلى Student.loan_days ويرجع 14، وللموظف إلى Staff.loan_days ويرجع 30
الكود الذي يستدعي لا يعرف النوع، والكائن نفسه يحدد أي دالة تعمل

وفائدة هذا أن إضافة نوع جديد من الأعضاء لا تحتاج تعديل الحلقة ولا تعديل borrow، وهذا هو الوعد الكبير للبرمجة الكائنية: أضف نوعاً، ولا تلمس الكود الذي يستخدم الأنواع. والاختبارات الخمسة للنسخة الأولى تنجح في اللغتين، وهذا مخرج Python:

============================= test session starts ==============================
platform linux -- Python 3.13.18, pytest-9.2.0, pluggy-1.7.0 -- /usr/local/bin/python3.13
rootdir: /lab
collecting ... collected 5 items

tests/test_library.py::test_student_borrows_for_14_days PASSED           [ 20%]
tests/test_library.py::test_staff_borrows_for_30_days PASSED             [ 40%]
tests/test_library.py::test_student_cannot_borrow_a_fourth_book PASSED   [ 60%]
tests/test_library.py::test_late_fee_depends_on_member_type PASSED       [ 80%]
tests/test_library.py::test_polymorphism_one_loop_for_all_members PASSED [100%]

============================== 5 passed in 0.10s ===============================

كيف يعمل هذا من الداخل؟ How It Works Inside

قد يتساءل البعض: إذا كانت borrow مكتوبة مرة واحدة في الأب، فأين توجد في الذاكرة، وكيف تعرف أي loan_days تستدعي؟ والتجربة التالية تجيب عن ذلك في Python، فهي تطبع أين توجد بيانات الكائن ودواله:

# Where do the data and the methods of an object live?
from library import Student, new_student

huda = new_student("Huda")
huda.borrow("Clean Code")
print("instance dict:", vars(huda))
print("loan_days in Student:", "loan_days" in vars(Student), "| borrow in Student:", "borrow" in vars(Student))
print("MRO:", [c.__name__ for c in type(huda).__mro__])
bound = huda.borrow
print("bound method:", bound.__self__ is huda, bound.__func__.__qualname__)
instance dict: {'name': 'Huda', 'loans': ['Clean Code']}
loan_days in Student: True | borrow in Student: False
MRO: ['Student', 'Member', 'ABC', 'object']
bound method: True Member.borrow

في المخرج أعلاه لاحظ التالي:

  • القاموس الخاص بالكائن vars(huda) فيه البيانات فقط: الاسم والقائمة، ولا توجد فيه أي دالة، فالدوال مكانها الكلاس، وتشترك فيها كل الكائنات.
  • loan_days موجودة في قاموس Student نفسه، أما borrow فليست فيه، لأنها في Member، وPython تجدها بالمرور على قائمة MRO بالترتيب: Student ثم Member ثم ABC ثم object.
  • عندما تكتب huda.borrow دون أقواس ترجع Python دالة مربوطة Bound Method، وهي الدالة Member.borrow ومعها الكائن huda جاهزاً ليمرر في المعامل self، وهذا هو سبب وجود self في كل دالة.

وفي Java يمكن أن ترى الشيء نفسه في الـ Bytecode الذي يخرجه المترجم، فالأداة javap -c التي تأتي مع JDK تعرض تعليمات الدالة borrow في الكلاس Member:

javac -d /tmp/o v1/library/*.java
javap -c -p -cp /tmp/o library.Member
  public int borrow(java.lang.String);
    Code:
         0: aload_0
         1: getfield      #10                 // Field loans:Ljava/util/List;
         4: invokeinterface #26,  1           // InterfaceMethod java/util/List.size:()I
         9: aload_0
        10: invokevirtual #30                 // Method maxLoans:()I
        13: if_icmplt     42
        16: new           #33                 // class library/LoanLimitError
        19: dup
        20: aload_0
        21: getfield      #16                 // Field name:Ljava/lang/String;
        24: aload_0
        25: getfield      #10                 // Field loans:Ljava/util/List;
        28: invokeinterface #26,  1           // InterfaceMethod java/util/List.size:()I
        33: invokedynamic #35,  0             // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;I)Ljava/lang/String;
        38: invokespecial #39                 // Method library/LoanLimitError."<init>":(Ljava/lang/String;)V
        41: athrow
        42: aload_0
        43: getfield      #10                 // Field loans:Ljava/util/List;
        46: aload_1
        47: invokeinterface #42,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        52: pop
        53: aload_0
        54: invokevirtual #46                 // Method loanDays:()I
        57: ireturn

في المخرج أعلاه لاحظ التالي:

  • السطر 10 invokevirtual #30 // Method maxLoans:()I: المترجم لا يعرف أي maxLoans سوف تعمل، فهو يكتب تعليمة تقول «استدع maxLoans على الكائن الموجود في this»، والآلة الافتراضية تختار وقت التشغيل الدالة من كلاس الكائن الفعلي، وتسرع ذلك بجدول دوال لكل كلاس.
  • السطر 4 invokeinterface ... List.size: الحقل loans مكتوب بنوع الواجهة List، فالاستدعاء عبر الواجهة له تعليمة خاصة، وهذا هو «البرمجة على الواجهة» في مستوى الـ Bytecode: الكلاس لا يعرف أنه ArrayList.
  • السطر 38 invokespecial لإنشاء الاستثناء، وهذه تعليمة لا تختار وقت التشغيل، لأن المنشئ Constructor يحدد دائماً بالاسم.

والخلاصة أن تعدد الأشكال ليس سحراً في اللغتين، وإنما بحث عن الدالة في كلاس الكائن الفعلي وقت الاستدعاء، والفرق أن Java تعرف وقت الترجمة أن الدالة موجودة حتماً في كل الأبناء، بينما Python تكتشف ذلك عند البحث.

عندما لا تكفي الوراثة: ثلاثة طلبات حقيقية

النسخة الأولى نظيفة وتنجح اختباراتها، والآن تأتي طلبات من إدارة المكتبة كما تأتي في أي مشروع، وكل طلب منها يكشف حداً من حدود الوراثة. والصورة التالية تبين شجرة الوراثة والطلبات الثلاثة:

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

المعيد طالب وموظف معاً: الوراثة المتعددة Multiple Inheritance

المعيد يدرس الماجستير ويعمل في الجامعة، فهو طالب وموظف. والحل الذي يخطر أولاً أن يرث من الكلاسين. وفي Java هذا غير ممكن أصلاً، لأن مواصفة اللغة تسمح لكل كلاس بأب واحد فقط بعد الكلمة extends:

package library;

// A teaching assistant is a student and a staff member at the same time.
class TeachingAssistant extends Student, Staff {
    TeachingAssistant(String name) { super(name); }
}
errors/TeachingAssistant.java:4: error: '{' expected
class TeachingAssistant extends Student, Staff {
                                       ^
1 error

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

# A teaching assistant is a student and a staff member at the same time.
from library import Staff, Student


class TeachingAssistant(Student, Staff):
    pass


ta = TeachingAssistant("Sara")
print("MRO:", [c.__name__ for c in TeachingAssistant.__mro__])
print("max_loans:", ta.max_loans(), " loan_days:", ta.loan_days())
MRO: ['TeachingAssistant', 'Student', 'Staff', 'Member', 'ABC', 'object']
max_loans: 3  loan_days: 14

البرنامج عمل بلا أي خطأ، وأعطى المعيد حد الطالب ومدته، أي 3 كتب و14 يوماً، لأن Student جاء أولاً في ترتيب MRO الذي تحسبه Python بخوارزمية اسمها C3، كما يشرح توثيق MRO. ولو كتبت (Staff, Student) لحصل على قواعد الموظف. أي أن قاعدة العمل الحقيقية، وهي «يأخذ الأفضل من الدورين»، لم يكتبها أحد، وإنما قررها ترتيب الأسماء في سطر التعريف.

الطالب تخرج وتوظف: الكائن لا يغير كلاسه

الطلب الثاني أن الطالبة التي تخرجت وتوظفت تبقى العضو نفسه، بالكتب التي معها، ولكن بقواعد الموظف. والوراثة تثبت نوع الكائن عند إنشائه، فلا يوجد في Java طريق لتحويل كائن Student إلى Staff، والمحاولة بالتحويل Cast تمر من المترجم ثم تفشل وقت التشغيل:

package library;

// A student graduates: can the same object become Staff?
class Graduation {
    public static void main(String[] args) {
        Member huda = Members.newStudent("Huda");
        huda.borrow("Clean Code");
        Staff asStaff = (Staff) huda;
        System.out.println(asStaff.loanDays());
    }
}
Exception in thread "main" java.lang.ClassCastException: class library.Student cannot be cast to class library.Staff (library.Student and library.Staff are in unnamed module of loader 'app')
	at library.Graduation.main(Graduation.java:8)

والتحويل في Java لا يغير الكائن، وإنما يطلب من الآلة الافتراضية أن تتعامل معه كنوع آخر، وهي تتحقق من نوعه الحقيقي فترفض. وفي Python هناك طريقان، وكلاهما سيئ:

# A student graduates and becomes staff while holding two books.
from library import Staff, new_student

huda = new_student("Huda")
huda.borrow("Clean Code")
huda.borrow("SICP")
desk = {"Clean Code": huda, "SICP": huda}   # other code holds references to the member object

# option 1: a new object; the loans and every reference must be moved by hand
new_huda = Staff(huda.name)
print("new object loans:", new_huda.loans, "| desk still points to:", type(desk["SICP"]).__name__)

# option 2: change the class of a live object (Python allows it, Java does not)
huda.__class__ = Staff
print("after __class__ swap:", type(huda).__name__, huda.loan_days(), huda.loans)
new object loans: [] | desk still points to: Student
after __class__ swap: Staff 30 ['Clean Code', 'SICP']

في الطريق الأول أنشأنا كائناً جديداً، فخرج بقائمة فارغة، وكل جزء من النظام كان يحمل مرجعاً إلى الكائن القديم، مثل سجل الإعارة desk، ما زال يرى طالبة. وفي الطريق الثاني غيرنا كلاس الكائن الحي بالسطر huda.__class__ = Staff، وPython قبلت ذلك بصمت، وصارت مدة الإعارة 30 والكتب باقية. وقد يبدو هذا حلاً، ولكنه يعمل فقط لأن الكلاسين لهما الحقول نفسها، فإذا أضاف أحد حقلاً في Staff فسوف يكون مفقوداً في الكائن المحول دون أي رسالة. وهذه هي الطريقة الأسوأ على الإطلاق: تعمل اليوم وتتعطل غداً بصمت.

الزائر لا يستعير: مبدأ الاستبدال Liskov Substitution

الطلب الثالث أن المكتبة تريد تسجيل الزوار الذين يقرؤون داخلها ولا يستعيرون. والحل السريع كلاس ابن يرمي استثناء عند الاستعارة:

# A visitor may read in the library but not borrow: the "easy" subclass.
from library import Member, new_staff, new_student


class Visitor(Member):
    def max_loans(self): return 0
    def loan_days(self): return 0
    def fee_per_day(self): return 0.0

    def borrow(self, title):
        raise NotImplementedError("visitors cannot borrow")


members = [new_student("Huda"), Visitor("guest"), new_staff("Omar")]
for m in members:
    print(m.name, m.borrow("Dune"))
Huda 14
Traceback (most recent call last):
  File "/lab/errors/e4_visitor.py", line 16, in <module>
    print(m.name, m.borrow("Dune"))
                  ~~~~~~~~^^^^^^^^
  File "/lab/errors/e4_visitor.py", line 11, in borrow
    raise NotImplementedError("visitors cannot borrow")
NotImplementedError: visitors cannot borrow

الحلقة التي كانت تعمل مع كل الأعضاء توقفت عند الزائر، والموظف عمر لم يصل إليه الدور أصلاً. والمشكلة ليست في الحلقة، وإنما في أن الابن خالف وعد الأب: الأب يعد بأن borrow إما أن تعيد عدد الأيام أو ترمي LoanLimitError عند الوصول إلى الحد، والابن رمى نوعاً آخر من الاستثناء لم يتوقعه أي كود يستخدم الأب.

وهذا بالضبط ما وصفته Barbara Liskov في كلمتها الافتتاحية Data Abstraction and Hierarchy في مؤتمر OOPSLA سنة 1987: النوع S يكون نوعاً فرعياً من T إذا كان أي برنامج مكتوب للنوع T يتصرف بالطريقة نفسها عندما تعطيه كائناً من S. ثم صاغته مع Jeannette Wing صياغة أدق في ورقة A Behavioral Notion of Subtyping سنة 1994، وصار اسمه مبدأ الاستبدال، وهو حرف L في SOLID الذي شرحناه في مبادئ التصميم. ولاحظ أن الزائر «هو نوع من» الأعضاء في الكلام، ولكنه ليس نوعاً فرعياً بمعنى Liskov، لأنه لا يفي بسلوك الأب، وهذا هو الفخ: علاقة «هو نوع من» في اللغة لا تكفي، والمطلوب أن يكون الابن قابلاً للاستبدال في السلوك.

💡
في مكتبة Java نفسها مثالان مشهوران على وراثة ندم عليها مصمموها منذ الإصدار 1.0. فالكلاس Properties يرث من Hashtable، وتوثيقه الرسمي يقول إن الدالتين put وputAll الموروثتين يمكن استدعاؤهما عليه، وإن استخدامهما غير مستحسن بشدة لأنهما تسمحان بإدخال مفاتيح أو قيم ليست نصوصاً، وبعدها تفشل دوال الحفظ والعرض على كائن Properties الذي دخلته قيمة غير نصية. والكلاس Stack يرث من Vector، فيستطيع أي أحد أن يدخل عنصراً في منتصف المكدس، وتوثيقه ينصح باستخدام الواجهة Deque بدلاً منه. وكلاهما بقي كما هو منذ عقود لأن تغيير الأب كان سيعطل كل كود يعتمد عليه.

التركيب Composition: الكائن «يملك» بدلاً من «هو» has-a

في سنة 1994 نشر Erich Gamma وRichard Helm وRalph Johnson وJohn Vlissides كتاب Design Patterns، ويسمونهم عصابة الأربعة Gang of Four، ووضعوا في الفصل الأول مبدأين قبل أي نمط: برمج على الواجهة وليس على التطبيق، وفضل تركيب الكائنات على وراثة الكلاسات. وشرحوا أن الوراثة تكشف للابن تفاصيل الأب، فأي تغيير في الأب قد يغير الابن، وأن العلاقة تتحدد وقت كتابة الكود ولا تتغير وقت التشغيل، أما التركيب فيعتمد على الواجهة فقط، ويمكن أن يتغير وقت التشغيل.

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

"""Library members, version 2: one Member class that HAS a loan policy (composition)."""
from dataclasses import dataclass
from typing import Protocol


class LoanLimitError(Exception):
    pass


class LoanPolicy(Protocol):
    """The interface: anything with these three methods is a loan policy."""
    def max_loans(self) -> int: ...
    def loan_days(self) -> int: ...
    def fee_per_day(self) -> float: ...


@dataclass(frozen=True)
class FixedPolicy:
    loans: int
    days: int
    fee: float

    def max_loans(self) -> int: return self.loans
    def loan_days(self) -> int: return self.days
    def fee_per_day(self) -> float: return self.fee


@dataclass(frozen=True)
class BestOf:
    """A member with two roles gets the more generous rule of each."""
    a: LoanPolicy
    b: LoanPolicy

    def max_loans(self) -> int: return max(self.a.max_loans(), self.b.max_loans())
    def loan_days(self) -> int: return max(self.a.loan_days(), self.b.loan_days())
    def fee_per_day(self) -> float: return min(self.a.fee_per_day(), self.b.fee_per_day())


STUDENT = FixedPolicy(loans=3, days=14, fee=0.5)
STAFF = FixedPolicy(loans=10, days=30, fee=1.0)
VISITOR = FixedPolicy(loans=0, days=0, fee=0.0)


class Member:
    def __init__(self, name: str, policy: LoanPolicy):
        self.name = name
        self.policy = policy
        self.loans: list[str] = []

    def change_policy(self, policy: LoanPolicy) -> None:
        self.policy = policy          # same object, same loans, new rules

    def borrow(self, title: str) -> int:
        if len(self.loans) >= self.policy.max_loans():
            raise LoanLimitError(f"{self.name} already has {len(self.loans)} books")
        self.loans.append(title)
        return self.policy.loan_days()

    def give_back(self, title: str, days_late: int = 0) -> float:
        self.loans.remove(title)
        return days_late * self.policy.fee_per_day()


def new_student(name: str) -> Member:
    return Member(name, STUDENT)


def new_staff(name: str) -> Member:
    return Member(name, STAFF)

في الكود أعلاه لاحظ التالي:

  • LoanPolicy بروتوكول فيه ثلاث دوال، وMember لا يعرف غيره، فهو لا يعرف أي كلاس قاعدة بالاسم.
  • FixedPolicy كلاس بيانات Dataclass ثابت frozen بثلاثة أرقام، والطالب والموظف والزائر صاروا ثلاث قيم منه وليس ثلاثة كلاسات.
  • BestOf قاعدة مركبة من قاعدتين، تأخذ الأكبر في العدد والمدة والأصغر في الغرامة، وهذا هو المعيد: قاعدة عمل مكتوبة بوضوح بدلاً من ترتيب MRO.
  • change_policy تغير القاعدة والكائن نفسه باق بكتبه، وهذا هو التخرج.
  • الدالتان new_student وnew_staff بقيتا بالتوقيع نفسه، فالكود الذي يستخدمهما لا يعرف أن ما بداخلهما تغير.

والنسخة نفسها بلغة Java تستخدم Record، وهو كلاس بيانات ثابت جاء في Java 16 مع JEP 395، ويطبق الواجهة مباشرة لأن أسماء حقوله هي أسماء دوال الواجهة:

package library;

public record FixedPolicy(int maxLoans, int loanDays, double feePerDay) implements LoanPolicy {
    public static final FixedPolicy STUDENT = new FixedPolicy(3, 14, 0.5);
    public static final FixedPolicy STAFF = new FixedPolicy(10, 30, 1.0);
    public static final FixedPolicy VISITOR = new FixedPolicy(0, 0, 0.0);
}
package library;

// A member with two roles gets the more generous rule of each.
public record BestOf(LoanPolicy a, LoanPolicy b) implements LoanPolicy {
    public int maxLoans() { return Math.max(a.maxLoans(), b.maxLoans()); }
    public int loanDays() { return Math.max(a.loanDays(), b.loanDays()); }
    public double feePerDay() { return Math.min(a.feePerDay(), b.feePerDay()); }
}
package library;

import java.util.ArrayList;
import java.util.List;

// Version 2: one class that HAS a policy (composition).
public final class Member {
    private final String name;
    private final List<String> loans = new ArrayList<>();
    private LoanPolicy policy;

    public Member(String name, LoanPolicy policy) { this.name = name; this.policy = policy; }

    public String name() { return name; }
    public List<String> loans() { return List.copyOf(loans); }
    public LoanPolicy policy() { return policy; }
    public void changePolicy(LoanPolicy policy) { this.policy = policy; }

    public int borrow(String title) {
        if (loans.size() >= policy.maxLoans())
            throw new LoanLimitError(name + " already has " + loans.size() + " books");
        loans.add(title);
        return policy.loanDays();
    }

    public double giveBack(String title, int daysLate) {
        loans.remove(title);
        return daysLate * policy.feePerDay();
    }
}

والصورة التالية تبين التصميم الجديد:

كلاس Member واحد فيه فتحة اسمها policy، وتتصل بها في أوقات مختلفة قواعد مختلفة: STUDENT ثم STAFF بعد التخرج، وBestOf من STUDENT وSTAFF للمعيد، وVISITOR بحد صفر للزائر، والسهم change_policy يبين تبديل القاعدة والكائن نفسه باق بكتبه
القاعدة صارت قطعة تبدل وقت التشغيل، والعضو بقي كائناً واحداً بكتبه

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

تجربة عملية Lab: من الوراثة إلى التركيب والاختبارات خضراء

الهدف من هذه التجربة أن نعيد هيكلة Refactoring نظام الإعارة من الوراثة إلى التركيب، ونثبت بالاختبارات أن السلوك القديم لم يتغير، ثم نضيف الطلبات الثلاثة. وكل الأوامر تعمل داخل Containers، وملفات التجربة كاملة في مجلد lab مع المقال: مجلد python ومجلد java، وفي كل منهما v1 وv2 والاختبارات وملفات الأخطاء.

التجهيز Setup

بيئة Python فيها pytest وmypy بنسخ ثابتة:

FROM python:3.13.18-slim
RUN pip install --no-cache-dir pytest==9.2.0 mypy==2.4.1
WORKDIR /lab

وبيئة Java فيها JDK 25 من Eclipse Temurin، ومعها مشغل JUnit 6 في ملف JAR واحد، حتى لا نحتاج Maven أو Gradle في تجربة صغيرة:

FROM eclipse-temurin:25-jdk-alpine
ADD https://repo1.maven.org/maven2/org/junit/platform/junit-platform-console-standalone/6.1.3/junit-platform-console-standalone-6.1.3.jar /opt/junit.jar
WORKDIR /lab

والسكربت التالي يترجم نسخة من الكود مع مجلدات الاختبار التي تعطيها له، ثم يشغل JUnit:

#!/bin/sh
# usage: sh run-tests.sh v1|v2 [test dirs...]  compiles one version with the tests and runs JUnit.
set -e
v=$1; shift
rm -rf /tmp/out && mkdir -p /tmp/out
javac -d /tmp/out -cp /opt/junit.jar $(find /lab/$v -name '*.java') $(for d in "$@"; do find /lab/$d -name '*.java'; done)
java -jar /opt/junit.jar execute --class-path /tmp/out --scan-class-path --details=tree --disable-banner --disable-ansi-colors
docker build -t sw1-oop-py:lab python
docker build -t sw1-oop-java:lab java
docker run --rm -v "$PWD/python:/lab" -e PYTHONPATH=/lab/v1 sw1-oop-py:lab pytest -v tests/test_library.py
docker run --rm -v "$PWD/java:/lab" sw1-oop-java:lab sh run-tests.sh v1 test

ولاحظ أن الاختبارات لا تستورد من مجلد النسخة مباشرة، وإنما من وحدة اسمها library، والمتغير PYTHONPATH هو الذي يحدد أي نسخة تجدها، فنشغل ملف الاختبارات نفسه على النسختين دون أي تعديل.

اختبارات السلوك قبل إعادة الهيكلة

القاعدة الأولى في إعادة الهيكلة أن تكتب الاختبارات قبلها، وأن تكون على السلوك الذي يراه من يستخدم الكود، وليس على الكلاسات الداخلية. لذلك تستخدم الاختبارات الدالتين new_student وnew_staff فقط، ولا تذكر Student ولا Staff أبداً:

"""Behaviour tests: they use only the public API, so they run on v1 and v2 unchanged."""
import pytest

from library import LoanLimitError, new_staff, new_student


def test_student_borrows_for_14_days():
    assert new_student("Huda").borrow("Clean Code") == 14


def test_staff_borrows_for_30_days():
    assert new_staff("Omar").borrow("SICP") == 30


def test_student_cannot_borrow_a_fourth_book():
    s = new_student("Huda")
    for title in ["A", "B", "C"]:
        s.borrow(title)
    with pytest.raises(LoanLimitError):
        s.borrow("D")


def test_late_fee_depends_on_member_type():
    s, t = new_student("Huda"), new_staff("Omar")
    s.borrow("A")
    t.borrow("A")
    assert s.give_back("A", days_late=4) == 2.0
    assert t.give_back("A", days_late=4) == 4.0


def test_polymorphism_one_loop_for_all_members():
    members = [new_student("Huda"), new_staff("Omar")]
    assert [m.borrow("Dune") for m in members] == [14, 30]

وملف Java يحمل الاختبارات الخمسة نفسها بأسماء Java:

package library;

import static library.Members.newStaff;
import static library.Members.newStudent;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.util.List;
import org.junit.jupiter.api.Test;

// Behaviour tests on the public API only: the same file runs on v1 and v2.
class LibraryTest {
    @Test void studentBorrowsFor14Days() { assertEquals(14, newStudent("Huda").borrow("Clean Code")); }

    @Test void staffBorrowsFor30Days() { assertEquals(30, newStaff("Omar").borrow("SICP")); }

    @Test void studentCannotBorrowAFourthBook() {
        var s = newStudent("Huda");
        for (var t : List.of("A", "B", "C")) s.borrow(t);
        assertThrows(LoanLimitError.class, () -> s.borrow("D"));
    }

    @Test void lateFeeDependsOnMemberType() {
        var s = newStudent("Huda");
        var t = newStaff("Omar");
        s.borrow("A");
        t.borrow("A");
        assertEquals(2.0, s.giveBack("A", 4));
        assertEquals(4.0, t.giveBack("A", 4));
    }

    @Test void polymorphismOneLoopForAllMembers() {
        var days = List.of(newStudent("Huda"), newStaff("Omar")).stream().map(m -> m.borrow("Dune")).toList();
        assertEquals(List.of(14, 30), days);
    }
}

وتشغيله على النسخة الأولى يعطي:

╷
├─ JUnit Platform Suite ✔
├─ JUnit Jupiter ✔
│  └─ LibraryTest ✔
│     ├─ studentCannotBorrowAFourthBook() ✔
│     ├─ staffBorrowsFor30Days() ✔
│     ├─ polymorphismOneLoopForAllMembers() ✔
│     ├─ studentBorrowsFor14Days() ✔
│     └─ lateFeeDependsOnMemberType() ✔
└─ JUnit Vintage ✔

Test run finished after 387 ms
[         4 containers found      ]
[         0 containers skipped    ]
[         4 containers started    ]
[         0 containers aborted    ]
[         4 containers successful ]
[         0 containers failed     ]
[         5 tests found           ]
[         0 tests skipped         ]
[         5 tests started         ]
[         0 tests aborted         ]
[         5 tests successful      ]
[         0 tests failed          ]

بعد إعادة الهيكلة: الاختبارات نفسها على النسخة الثانية

نضيف ملف اختبارات ثانياً للطلبات الثلاثة، وهو يستخدم أسماء النسخة الثانية:

"""The three requests that inheritance could not handle; they run on v2 only."""
import pytest

from library import STAFF, STUDENT, VISITOR, BestOf, LoanLimitError, Member, new_student


def test_graduation_keeps_the_same_member_and_its_loans():
    huda = new_student("Huda")
    huda.borrow("Clean Code")
    huda.change_policy(STAFF)
    assert huda.loans == ["Clean Code"]
    assert huda.borrow("SICP") == 30


def test_teaching_assistant_gets_the_better_rule_of_both_roles():
    sara = Member("Sara", BestOf(STUDENT, STAFF))
    assert (sara.policy.max_loans(), sara.borrow("A"), sara.give_back("A", 2)) == (10, 30, 1.0)


def test_visitor_keeps_the_borrow_contract():
    with pytest.raises(LoanLimitError):
        Member("guest", VISITOR).borrow("Dune")
docker run --rm -v "$PWD/python:/lab" -e PYTHONPATH=/lab/v2 sw1-oop-py:lab pytest -v tests
docker run --rm -v "$PWD/java:/lab" sw1-oop-java:lab sh run-tests.sh v2 test test-new

ومخرج Python:

============================= test session starts ==============================
platform linux -- Python 3.13.18, pytest-9.2.0, pluggy-1.7.0 -- /usr/local/bin/python3.13
rootdir: /lab
collecting ... collected 8 items

tests/test_library.py::test_student_borrows_for_14_days PASSED           [ 12%]
tests/test_library.py::test_staff_borrows_for_30_days PASSED             [ 25%]
tests/test_library.py::test_student_cannot_borrow_a_fourth_book PASSED   [ 37%]
tests/test_library.py::test_late_fee_depends_on_member_type PASSED       [ 50%]
tests/test_library.py::test_polymorphism_one_loop_for_all_members PASSED [ 62%]
tests/test_new_rules.py::test_graduation_keeps_the_same_member_and_its_loans PASSED [ 75%]
tests/test_new_rules.py::test_teaching_assistant_gets_the_better_rule_of_both_roles PASSED [ 87%]
tests/test_new_rules.py::test_visitor_keeps_the_borrow_contract PASSED   [100%]

============================== 8 passed in 0.16s ===============================

ومخرج Java:

╷
├─ JUnit Platform Suite ✔
├─ JUnit Jupiter ✔
│  ├─ NewRulesTest ✔
│  │  ├─ graduationKeepsTheSameMemberAndItsLoans() ✔
│  │  ├─ visitorKeepsTheBorrowContract() ✔
│  │  └─ teachingAssistantGetsTheBetterRuleOfBothRoles() ✔
│  └─ LibraryTest ✔
│     ├─ studentCannotBorrowAFourthBook() ✔
│     ├─ staffBorrowsFor30Days() ✔
│     ├─ polymorphismOneLoopForAllMembers() ✔
│     ├─ studentBorrowsFor14Days() ✔
│     └─ lateFeeDependsOnMemberType() ✔
└─ JUnit Vintage ✔

Test run finished after 423 ms
[         5 containers found      ]
[         0 containers skipped    ]
[         5 containers started    ]
[         0 containers aborted    ]
[         5 containers successful ]
[         0 containers failed     ]
[         8 tests found           ]
[         0 tests skipped         ]
[         8 tests started         ]
[         0 tests aborted         ]
[         8 tests successful      ]
[         0 tests failed          ]

في المخرجين أعلاه لاحظ التالي:

  • الاختبارات الخمسة القديمة نجحت على النسخة الثانية دون تعديل حرف واحد فيها، مع أن الكلاسين Student وStaff لم يعودا موجودين، وهذا دليل أن إعادة الهيكلة لم تغير السلوك.
  • الاختبارات الثلاثة الجديدة نجحت: المعيد أخذ 10 كتب و30 يوماً وغرامة 0.5 لكل يوم، فدفع 1.0 عن تأخير يومين، والطالبة المتخرجة احتفظت بكتابها، والزائر رفض بالاستثناء المتوقع LoanLimitError الذي يعرفه كل من يستخدم borrow.
  • ترتيب الاختبارات في تقرير JUnit يختلف عن ترتيبها في الملف، لأن JUnit يرتبها بطريقة ثابتة ولكنها غير واضحة عمداً، وهذا سبب إضافي لكي لا يعتمد اختبار على آخر.

وللتأكد من أن الاختبارات الجديدة تختبر شيئاً لم يكن موجوداً، نشغلها على النسخة الأولى. وفي Python يفشل الملف عند الاستيراد:


==================================== ERRORS ====================================
___________________ ERROR collecting tests/test_new_rules.py ___________________
ImportError while importing test module '/lab/tests/test_new_rules.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/local/lib/python3.13/importlib/__init__.py:88: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/test_new_rules.py:4: in <module>
    from library import STAFF, STUDENT, VISITOR, BestOf, LoanLimitError, Member, new_student
E   ImportError: cannot import name 'STAFF' from 'library' (/lab/v1/library.py). Did you mean: 'Staff'?
=========================== short test summary info ============================
ERROR tests/test_new_rules.py
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 0.20s

وفي Java يرفض المترجم سبعة أسطر، وهذه بدايتها:

/lab/test-new/library/NewRulesTest.java:14: error: cannot find symbol
        huda.changePolicy(FixedPolicy.STAFF);
                          ^
  symbol:   variable FixedPolicy
  location: class NewRulesTest
...
/lab/test-new/library/NewRulesTest.java:27: error: Member is abstract; cannot be instantiated
        assertThrows(LoanLimitError.class, () -> new Member("guest", FixedPolicy.VISITOR).borrow("Dune"));
                                                 ^
7 errors

ولاحظ الخطأ الأخير Member is abstract; cannot be instantiated: في النسخة الأولى لا يمكن أن يوجد عضو إلا من نوع ابن، وهذا يلخص الفرق بين التصميمين.

ماذا لو؟ What If: تمديد الإعارة في الإجازة الصيفية

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

# What if: during the summer break every member gets 7 extra days, whatever the type.
from dataclasses import dataclass

from library import STAFF, STUDENT, BestOf, LoanPolicy, Member


@dataclass(frozen=True)
class HolidayExtension:
    base: LoanPolicy
    extra_days: int = 7

    def max_loans(self) -> int: return self.base.max_loans()
    def loan_days(self) -> int: return self.base.loan_days() + self.extra_days
    def fee_per_day(self) -> float: return self.base.fee_per_day()


members = [Member("Huda", STUDENT), Member("Omar", STAFF), Member("Sara", BestOf(STUDENT, STAFF))]
for m in members:
    m.change_policy(HolidayExtension(m.policy))
print([(m.name, m.borrow("Dune")) for m in members])

for m in members:                       # the break ends: unwrap
    m.change_policy(m.policy.base)
print([(m.name, m.borrow("SICP")) for m in members])

وعند التشغيل ثم الفحص بـ mypy كان المخرج كما يلي:

[('Huda', 21), ('Omar', 37), ('Sara', 37)]
[('Huda', 14), ('Omar', 30), ('Sara', 30)]
whatif_holiday_first_try.py:23: error: "LoanPolicy" has no attribute "base"  [attr-defined]
Found 1 error in 1 file (checked 1 source file)

البرنامج عمل وأعطى الأرقام الصحيحة، فالطالبة 14 + 7 = 21 يوماً والموظف والمعيد 37، ثم عادت القواعد، ولكن mypy اعترض على السطر الذي يرجع القاعدة الأصلية. والسبب أن نوع m.policy هو الواجهة LoanPolicy، والواجهة لا تعرف حقلاً اسمه base، فهذا الحقل موجود في HolidayExtension فقط. وهذا هو معنى «برمج على الواجهة»: ما دمت تحمل الكائن بنوع الواجهة فلا تستطيع أن تصل إلى تفاصيل تطبيق معين، وPython سمحت لك بذلك وقت التشغيل لأنها لا تتحقق من الأنواع، ولو كانت القاعدة الحالية لأحد الأعضاء ليست HolidayExtension لفشل البرنامج بـ AttributeError. والحل الأنظف أن نحفظ القواعد الأصلية قبل التمديد، ونرجعها بعده:

# What if: during the summer break every member gets 7 extra days, whatever the type.
from dataclasses import dataclass

from library import STAFF, STUDENT, BestOf, LoanPolicy, Member


@dataclass(frozen=True)
class HolidayExtension:
    base: LoanPolicy
    extra_days: int = 7

    def max_loans(self) -> int: return self.base.max_loans()
    def loan_days(self) -> int: return self.base.loan_days() + self.extra_days
    def fee_per_day(self) -> float: return self.base.fee_per_day()


members = [Member("Huda", STUDENT), Member("Omar", STAFF), Member("Sara", BestOf(STUDENT, STAFF))]
saved = {m.name: m.policy for m in members}   # remember the real policies
for m in members:
    m.change_policy(HolidayExtension(m.policy))
print([(m.name, m.borrow("Dune")) for m in members])

for m in members:                       # the break ends: restore
    m.change_policy(saved[m.name])
print([(m.name, m.borrow("SICP")) for m in members])
[('Huda', 21), ('Omar', 37), ('Sara', 37)]
[('Huda', 14), ('Omar', 30), ('Sara', 30)]
Success: no issues found in 2 source files

والقاعدة الجديدة كلها 8 أسطر، ولم نغير Member ولا أي قاعدة موجودة، والمعيد حصل على التمديد فوق قاعدته المركبة دون أن يكتب أحد حالة خاصة له، وهذا ما يعنيه أن التركيب «يتركب».

النتائج في جدول Results

الطلبالوراثة في Pythonالوراثة في Javaالتركيب في اللغتين
الاختبارات الخمسة الأساسية5 نجحت5 نجحت5 نجحت دون تعديل
المعيد طالب وموظفيعمل بصمت بقواعد الطالب بسبب MROخطأ ترجمة '{' expectedBestOf: قاعدة مكتوبة صراحة
التخرج مع بقاء الكتبكائن جديد بلا كتب، أو تغيير __class__ClassCastException وقت التشغيلchange_policy على الكائن نفسه
الزائرNotImplementedError يوقف الحلقةالمشكلة نفسها إذا رمى UnsupportedOperationExceptionقاعدة بحد صفر وLoanLimitError المتوقع
تمديد الإجازةكلاس لكل نوعكلاس لكل نوعقاعدة من 8 أسطر تلف أي قاعدة
دالة ناقصة في تطبيق جديدعند إنشاء الكائن مع ABCعند الترجمةJava عند الترجمة، وPython مع mypy قبل التشغيل أو AttributeError عند الاستخدام
جدول ملون للطلبات الأربعة والنسختين: الاختبارات الأساسية خضراء في النسختين، والمعيد والتخرج والزائر والإجازة حمراء أو صفراء في نسخة الوراثة وخضراء في نسخة التركيب، و8 اختبارات ناجحة في كل لغة بعد إعادة الهيكلة
الاختبارات القديمة بقيت خضراء، والطلبات الجديدة صارت قواعد صغيرة بدل كلاسات جديدة

التنظيف Cleanup

docker rmi sw1-oop-py:lab sw1-oop-java:lab eclipse-temurin:25-jdk-alpine

متى تكون الوراثة هي الاختيار الصحيح؟

بعد كل هذا قد يظن القارئ أن الوراثة خطأ دائماً، وهذا غير صحيح، فالنصيحة «فضل» التركيب وليست «امنع» الوراثة. والوراثة مناسبة في الحالات التالية:

  • العلاقة ثابتة ولا تتغير وقت التشغيل: الاستثناءات مثال جيد، فـ LoanLimitError في التجربة يرث من Exception في Python ومن RuntimeException في Java، ولن يتحول استثناء إلى نوع آخر أبداً.
  • الأب صمم ليورث منه: أطر العمل Frameworks تعطيك كلاساً أباً تكمل دوالاً محددة فيه، مثل TestCase في unittest أو HttpServlet في Java، وتوثيقها يحدد ما يحق لك تغييره.
  • مجموعة الأنواع مغلقة ومعروفة: في Java الحديثة تستطيع أن تكتب sealed interface وتحدد الأبناء المسموحين، مثل أنواع الأحداث في نظام، والمترجم يتأكد أنك تعاملت مع كل نوع في switch.
  • الابن قابل للاستبدال فعلاً: كل وعد في الأب يفي به الابن، دون استثناءات جديدة ولا شروط أقوى على المدخلات.

وفي المقابل، إشارات الخطر هي: ابن يرمي NotImplementedError أو UnsupportedOperationException لدالة ورثها، وكود يسأل عن النوع بـ isinstance أو instanceof ليقرر السلوك، وشجرة تتضاعف كلاساتها مع كل خاصية جديدة، وحاجة إلى أن يغير الكائن نوعه وهو يعمل. وأنماط التصميم التي بنيت على التركيب، مثل Strategy التي تشبه قاعدة الإعارة هنا وDecorator التي تشبه تمديد الإجازة، شرحناها في أنماط التصميم التي تقابلها فعلاً.

السؤالإذا كانت الإجابة نعم
هل يمكن أن يتغير «النوع» وكائنه حي؟تركيب: القاعدة قطعة تبدل
هل يمكن أن يجتمع نوعان في كائن واحد؟تركيب: قاعدة مركبة
هل سوف يرفض الابن بعض سلوك الأب؟تركيب، أو واجهة أصغر
هل الأب صمم ليورث ويوثق ما يحق للابن تغييره؟وراثة مقبولة
هل العلاقة ثابتة والابن قابل للاستبدال في كل وعد؟وراثة مقبولة

أخطاء شائعة Common Mistakes

  • تصميم الشجرة من الأسماء وليس من السلوك: «المعيد هو طالب» صحيح في اللغة، ولكن السؤال هو هل يتصرف كطالب في كل وعد، والإجابة غالباً لا.
  • الوراثة لإعادة استخدام الكود فقط: إذا أردت دالة من كلاس آخر فاستدعها من كائن تملكه، ولا ترث كل ما فيه، كما حدث مع Properties وStack.
  • ابن يرمي استثناء جديداً لدالة موروثة: هذه مخالفة مباشرة لمبدأ الاستبدال، وستوقف أي حلقة تتعامل مع الأب.
  • الاعتماد على ترتيب الآباء في Python: MRO يقرر بصمت أي دالة تعمل، فإذا احتجت قاعدة دمج فاكتبها صراحة.
  • تغيير __class__ لكائن حي: يعمل اليوم ويفقد حقولاً غداً دون رسالة، ولا ينصح باستخدامه إطلاقاً.
  • اختبارات تنشئ الكلاسات الداخلية مباشرة: عندها لا تستطيع إعادة الهيكلة دون إعادة كتابة الاختبارات، واجعل الاختبارات تستخدم واجهة عامة ثابتة مثل new_student.
  • واجهة كبيرة لكل شيء: كلما زادت دوال الواجهة صعب أن يفي بها تطبيق جديد، والواجهة الجيدة تحمل ما يحتاجه من يستخدمها فقط، مثل الدوال الثلاث هنا.
  • الكلاس الإله God Class: كلاس اسمه LibraryManager أو SystemService فيه الإعارة والغرامات والتقارير والبريد، فكل تعديل يمر عليه وكل مطور يعدله في الوقت نفسه. قسمه حسب المسؤوليات، كما سنفعل مع OrderManager في مقال الاقتران والتماسك.
  • كائنات بلا سلوك Anemic Objects: كلاسات فيها حقول فقط، وكل القواعد في دوال خارجية تعدل الحقول، وهذا هو الحل البسيط بحقل النوع وجمل if بشكل كلاسات، فالقاعدة «لا تتجاوز حد الكتب» يجب أن تكون داخل borrow وليس في كل مكان يستعير.
  • Protocol دون مدقق أنواع: البروتوكول في Python وصف فقط، وفائدته الحقيقية تظهر عندما يعمل mypy أو Pyright في خط CI.

قائمة تحقق Checklist

  • كل كلاس يحمي حالته، ولا تعدل الحالة إلا دواله التي تحافظ على قواعده.
  • الكود يعتمد على واجهات صغيرة، وليس على كلاسات محددة.
  • كل ابن يفي بكل وعود الأب: القيم المرجعة والاستثناءات وشروط المدخلات.
  • ما يتغير وقت التشغيل، مثل الدور أو القاعدة أو السعر، كائن يملكه الكائن الأساسي وليس نوعه.
  • لا يوجد isinstance أو instanceof يقرر السلوك في منطق العمل.
  • الاختبارات تستخدم الواجهة العامة، فتبقى صالحة بعد إعادة الهيكلة.
  • في Python يعمل mypy أو Pyright على الكود الذي يستخدم Protocol، وفي Java تعالج تحذيرات المترجم.
  • الوراثة مستخدمة فقط حيث العلاقة ثابتة والأب مصمم ليورث.

تدريب عملي Practice

  • في نسخة Python الثانية غير الحقل loans إلى _loans، وأضف خاصية loans ترجع tuple، ثم عدل الاختبار الذي يقارن بقائمة، وشغل Ruff بالقاعدة SLF001 على ملف يحاول الوصول إلى _loans.
  • أضف إلى نسخة Java قاعدة HolidayExtension كـ Record يلف LoanPolicy، واكتب لها اختباراً في JUnit.

ماذا تقرأ بعد ذلك؟ Next Steps

التركيب حل مشكلة العلاقة بين الكلاسات، والخطوة التالية هي العلاقة بين الوحدات Modules: كم تعتمد كل وحدة على غيرها، وكيف تقيس ذلك بأدوات حقيقية، وهذا موضوع المقال التالي في المرحلة. وبعده تأتي مبادئ SOLID التي تعمم ما رأيته هنا.

دليلهندسة البرمجيات Software Engineering: من كود يعمل إلى نظامما الذي يتغير عندما يعيش الكود سنوات ويعدله غيرك، مع تجربة على سكربت تقرير يصبح وحدة مختبرة لها خط CI وأرقام حقيقية للتعقيد والاختبارات.دليلالاقتران Coupling والتماسك Cohesion: كيف تقسم الكود؟ما هو الاقتران والتماسك ودرجاتهما، وكيف تقيسهما بأدوات pydeps وimport-linter وLCOM على متجر صغير ثم تعيد تقسيمه فتنخفض الأرقام والاختبارات نفسها خضراء.دليلمبادئ التصميم Design Principles بأمثلة قبل وبعدلماذا يعطل تعديل صغير في الفاتورة شيئاً في المحاسبة، وكيف تساعدك مبادئ مثل SOLID وDRY على كود يتغير دون مفاجآت.دليلأنماط التصميم Design Patterns التي تقابلها فعلاًأشهر أنماط التصميم التي تقابلها في كل مشروع، والمشكلة التي يحلها كل نمط، ومتى يصبح عبئاً على من يعدل الكود بعدك.

الخلاصة Summary

وصلنا لنهاية الموضوع، وأهم ما فيه:

  • الكائن يجمع الحالة والسلوك، والتغليف يجعل تعديل الحالة يمر بقواعد الكائن فقط: Java تفرضه بالمترجم، وPython تتركه لاتفاق الفريق والمدقق.
  • الواجهة عقد بلا تفاصيل، وتعدد الأشكال يجعل كوداً واحداً يعمل مع كل من يفي بالعقد، والبرنامج يختار الدالة من نوع الكائن الفعلي وقت التشغيل.
  • الخطأ نفسه يظهر في Java عند الترجمة، وفي Python مع mypy قبل التشغيل، أو في الإنتاج دونه.
  • الوراثة تثبت النوع عند الإنشاء، لذلك لا تتعامل مع أدوار تتغير أو تجتمع، والابن الذي يرفض سلوك الأب يخالف مبدأ Liskov ويوقف الكود الذي يثق بالأب.
  • التركيب يجعل ما يتغير قطعة يملكها الكائن، فصارت الطلبات الأربعة قواعد صغيرة، والاختبارات الخمسة القديمة نجحت دون تعديل.
  • الوراثة مناسبة حين تكون العلاقة ثابتة والأب مصمماً ليورث، مثل الاستثناءات وأطر العمل.

سجل التحديثات Changelog

  • 18 نوفمبر 2026: كتابة المقال، وتنفيذ التجربة على Docker Engine 29.8.0 مع Python 3.13.18 (python:3.13.18-slim) وpytest 9.2.0 وmypy 2.4.1، وOpenJDK 25.0.5 (eclipse-temurin:25-jdk-alpine) وJUnit Platform Console 6.1.3.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.