Object-Oriented Programming

1.1 البرمجة الكائنية وأهدافها Object-Oriented Programming

الفكرة. البرمجة الكائنية نموذج يصف البرنامج مجموعة كائنات تتفاعل، لا دوالًا منفصلة عن بياناتها. الكائن بنية تحمل حقولًا (fields أو attributes) ودوالًا (methods) تعمل على تلك الحقول، فيبقى السلوك ملاصقًا للبيانات التي يخدمها. كائنات الصنف الواحد تشترك في شكل البيانات والدوال، ويختلف كل كائن بقيمه، ولا تعمل منعزلة: يطلب أحدها من الآخر فعلًا فيُسمّى الطلب message.

Object-Oriented Programming: نموذج برمجة (programming paradigm) يقوم على الكائنات (objects) بوصفها وحدة التنظيم، بدل الدوال المنفصلة عن بياناتها.

Message: طلب تنفيذ فعل يوجّهه كائن إلى كائن آخر ليقوم بعملية ما.

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

ماذا يغطي الفصل.

• الفرق بين البرمجة الوظيفية والكائنية.
• المصطلحات الأساسية وضبط دلالتها.
• أهمية النموذج الكائني وفائدتاه العملية.
• الأعمدة الأربعة التي تجعل اللغة كائنية.
• دعم اللغات الحديثة للنموذج، والأمثلة بلغة Java.
• الأصناف والكائنات ومخطط UML (القسم 1.8).
• البواني ومحددات الوصول (القسم 1.9).

خطة الشريحة 3 (الترتيب الأصلي). أربعة أقسام: Introduction on OOP، ثم Basic Principles of Object Orientation (Abstraction، Encapsulation، Polymorphism، Inheritance)، ثم Objects and Classes، ثم Constructors. الأقسام 1.8 و1.9 هنا تغطي القسمين الأخيرين، والسابقة تغطي الأولين.

التصميم يبدأ من الأشياء. في متجر تُذكر أولًا Store وProduct وCustomer وPayment method، ثم تُوزَّع عليها البيانات والمسؤوليات؛ فالأصناف تسبق الجداول والشاشات في التفكير.

1.2 الكائن والصنف Object, Class, Attribute, Method

الصنف قالب (template وblueprint) لا يحمل قيم كائن بعينه، والكائن نسخة (instance) تحمل الحالة الحالية، وإنشاء النسخة يُسمّى instantiation.

مثال السيارة. داخل صنف car خصائص fuel وmaxspeed، ودوال refuel() وgetFuel() وsetSpeed() وgetSpeed() وdrive()؛ ويُضاف إليها move() وcalculateVehicleAge().

ثلاث نسخ من القالب نفسه، تختلف بالقيم لا بالشكل:

لماذا يهم. هذا التفريق أساس كل ما بعده: القالب يُكتب مرة في الصنف، والقيم تتعدد في الكائنات، وعليه يقوم التغليف ومثال Circle في القسم 1.8.

1.3 البرمجة الوظيفية مقابل الكائنية Functional Programming vs OOP

الفكرة. النموذج الكائني يجمّع البيانات والسلوك داخل كائن هو instance من صنف، فلا تُفصل الحقول عن دوالها. أما البرمجة الوظيفية فتبني البرنامج من دوال: دخل ثم خرج، كما في رسم الشريحة.

x  →  f  →  f(x)

Pure function: دالة بلا آثار جانبية (side-effects)، خرجها تابع لدخلها وحده.

First-class citizen: الدالة عندما يمكن تمريرها وسيطًا أو إرجاعها نتيجة، فتُعامل كأي قيمة أخرى.

لماذا يهم. الفرق بنيوي لا تفضيلي: وحدة التنظيم في النموذج الكائني هي الكائن (بيانات + سلوك)، وفي الوظيفي هي الدالة؛ والمطلوب في الاختبار تمييز النموذج لا الحكم على أحدهما.

1.4 النمذجة والمتطلبات Modeling and Requirements

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

Model: تبسيط للواقع، ووصف مكتمل للنظام من منظور معيّن.

ننمذج كي نُبصر البنية (visualize) ونحدّدها (specify) ونبنيها (construct) ونوثّقها (document)، سواء في المعمارية أو السلوك.

خمسة مبادئ للنمذجة.

1. أحسن اختيار النموذج؛ فاختياره يغيّر تحليل المشكلة وتصميم الحل.
2. النموذج نفسه يُعرض بمستويات دقة متفاوتة.
3. أفضل النماذج متصلة بالواقع: بسّط ولا تخفِ تفصيلًا مهمًا.
4. لا يكفي نموذج واحد لنظام غير تافه.
5. قارِب النظام بمجموعة صغيرة من نماذج شبه مستقلة.

ورسم الشريحة يحذّر من فجوة التواصل: كل حلقة تُدخل تفسيرًا جديدًا، فقد يصل المنتج إلى ما لم يرده المستخدم.

لماذا يهم. المتطلبات مدخل النموذج؛ ومتطلب فُهم خطأً يُنتج صنفًا في غير موضعه. لذلك تُصنَّف المتطلبات قبل التصميم.

1.5 نمذجة EER مقابل OO

الفكرة. نموذج Enhanced Entity–Relationship (أو Extended Entity–Relationship) يعرّف علاقات العمل لقاعدة علائقية، بينما OO data modeling يصمّم الكود. في رسم EER تبقى البيانات في جهة، والدوال Function 1 وFunction 2 وFunction 3 منفصلة عنها؛ وفي النموذج الكائني يحمل كل كائن بياناته ودواله معًا.

مثال الشريحة: PERSON بحقول NAME وPID وAGE، ثم STUDENT ومعه GPA، وEMPLOYEE ومعه SALARY.

والمعادل الكائني يظهر في مخطط UML للدائرة، حيث - تعني private و+ تعني public:

Circle
-------------------------------
- radius: double = 1.0
- color: String = "red"
-------------------------------
+ Circle()
+ Circle(r: double)
+ Circle(r: double, c: String)
+ getRadius(): double
+ getColor(): String
+ getArea(): double

والقالب واحد والقيم تختلف:

• c1: نصف القطر 2.0 واللون "blue".
• c2: نصف القطر 2.0 واللون "red".
• c3: نصف القطر 1.0 واللون "red".

لماذا يهم. اختيار النموذج يحدّد ما يمكن تمثيله: EER لقاعدة علائقية بلا سلوك، وOO لكود فيه حالة وسلوك؛ ومخطط الدائرة هنا أول تطبيق عملي للنموذج الكائني.

1.6 التغليف والتجريد Encapsulation and Abstraction

الفكرة. أربعة مبادئ تجعل اللغة كائنية، وهي أعمدة OOP: التغليف (encapsulation) والتجريد (data abstraction) وتعدد الأشكال (polymorphism) والوراثة (inheritance). وهذا القسم للأولين.

التغليف. إحاطة المحتوى وحمايته كالكبسولة: تُجمَع الخصائص والسلوك في وحدة واحدة هي الصنف، ثم يُقيَّد الوصول إلى الداخل، وهو ما يُسمّى information hiding أو data hiding. لا يكشف الكائن إلا ما يلزم بقية التطبيق، وتقنيته حقول private ودوال وصول public؛ فالحقل private لا يُرى من خارج الصنف. والغلاف حاجز يمنع فساد البيانات، وأكبر فائدته تعديل التنفيذ دون كسر كود من يستخدم الصنف.

وتصوّر الشريحة ذلك بالتلفاز: العميل يرى الواجهة وحدها ولا يرى التنفيذ ولا الحقول الخاصة، ولا يحتاج معرفة كيف يعمل الجهاز.

public class BankAccount {
    private double balance;

    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) balance -= amount;
    }

    public double getBalance() { return balance; }
}

التجريد. تمثيل الجوهر اللازم للوظيفة وإخفاء الزائد، فيقل التعقيد وتزيد إعادة الاستخدام، ويسمح بتسمية ما لا يُنشأ مباشرة لكنه أساس لكائنات تشترك في خصائص. وهو عمومًا تجاهل واعٍ لبعض الجوانب لفهم غيرها، أي تبسيط. وفي التصميم تُعمَّم أشياء مثل Viktor وJohn وRoger في فئة Person، والريموت يوضّح المعنى: أزرار التشغيل والصوت والقناة تكفي بلا معرفة الدارات.

والتحليل والتصميم تجريد: نموذج قاعدة البيانات يتجاهل الواجهة والسلوك، ونموذج المعمارية يتجاهل داخل الوحدات، والكود يجرّد وظائف التطبيق بتراكيب محدودة.

1.7 الوراثة وتعدد الأشكال Inheritance and Polymorphism

الوراثة. آلية تنتقل بها خصائص صنف الأب (attributes وmethods) إلى صنف ابن (subclass)، فيُعاد استخدام المشترك. والابن يتخصص بزيادة ميزات أو تعديلها، وعدة أصناف تُعمَّم في أب واحد يجمع المشترك؛ والتخصيص والتعميم يبنيان شجرة أصناف.

مثال التمديد. JDK 1.8 يمتد إلى JDK 1.9 بثلاث خطوات، والأب لا يُعاد بناؤه من الصفر:

1. جمع ميزات الكائن القائم.
2. إضافة ميزات جديدة.
3. تحديث القائم عند الحاجة.

تعدد الأشكال. للكيان أكثر من شكل، ومن هنا poly. تُصمَّم الكائنات لتشترك في سلوك، فتُطبَّق الدالة نفسها على كائنات من أصناف مختلفة؛ والوراثة تمكّن التعدد، والتعدد يزيد الكود العام (generic code).

في الشريحة صنف Animal فيه picture وfood وhunger وboundaries وlocation، ودوال makeNoise() وeat() وsleep() وroam()؛ والأبناء Lion وHippo وTiger وDog وCat وWolf.

class Animal {
    void makeNoise() { }
}

class Dog extends Animal {
    void makeNoise() { /* barking */ }
}

class Cat extends Animal {
    void makeNoise() { /* Meow */ }
}

// مقتطف: يُكتب داخل main
Animal a = new Dog();
a.makeNoise();   // barking

لماذا يهم. الوراثة تنقل السلوك المشترك مرة واحدة، والتعدد يجعل makeNoise() شكلًا مختلفًا عند Dog وCat دون تغيير اسم الدالة.

1.8 الأصناف والكائنات ومخطط UML Class Diagram

الفكرة. كائنات النوع الواحد تُعرَّف بصنف مشترك هو قالب حقولها ودوالها. والصنف يوفّر بواني (constructors) تُستدعى بـ new لإنشاء الكائن وتهيئة حقوله، ويمكن إنشاء نسخ كثيرة مستقلة.

ترميز مخطط الصنف.

• الحقل: dataFieldName: dataFieldType
• الباني: ClassName(parameterName: parameterType)
• الدالة: methodName(parameterName: parameterType): returnType
• الكائن: name: ClassName ثم قيم الحقول.

Circle
------------------------------------------
- radius: double
------------------------------------------
+ Circle()
+ Circle(newRadius: double)
+ getArea(): double
+ getPerimeter(): double
+ setRadius(newRadius: double): void

ومنه ثلاث نسخ: circle1 بنصف قطر 1، وcircle2 بنصف قطر 25، وcircle3 بنصف قطر 125.

وهذا الصنف تعريف لا برنامج، لأنه بلا main:

public class Circle {
    private double radius;

    public Circle() {
        radius = 1;
    }

    public Circle(double newRadius) {
        radius = newRadius;
    }
}

    public double getArea() {
        return radius * radius * Math.PI;
    }

    public double getPerimeter() {
        return 2 * radius * Math.PI;
    }

    public void setRadius(double newRadius) {
        radius = newRadius;
    }

    public double getRadius() {
        return radius;
    }

public class TestCircle {
    public static void main(String[] args) {
        Circle circle1 = new Circle();
        System.out.println("The area of the circle of radius "
                + circle1.getRadius() + " is " + circle1.getArea());
        Circle circle2 = new Circle(25);
        System.out.println("The area of the circle of radius "
                + circle2.getRadius() + " is " + circle2.getArea());
        Circle circle3 = new Circle(125);
        System.out.println("The area of the circle of radius "
                + circle3.getRadius() + " is " + circle3.getArea());
        circle2.setRadius(100);
        System.out.println("The area of the circle of radius "
                + circle2.getRadius() + " is " + circle2.getArea());
    }
}

The area of the circle of radius 1.0 is 3.141592653589793
The area of the circle of radius 25.0 is 1963.4954084936207
The area of the circle of radius 125.0 is 49087.385212340516
The area of the circle of radius 100.0 is 31415.926535897932

الترجمة. عند ترجمة TestCircle.java يبحث المترجم في مسار الأصناف (classpath) — والمجلد الحالي هو الافتراضي — عن Circle.class. فإن غاب بحث في sourcepath عن Circle.java وترجمه إلى Circle.class، ثم أتمّ ترجمة TestCircle.java.

1.9 البواني ومحددات الوصول Constructor and Access Modifier

الباني. نوع خاص من الدوال لتهيئة الكائن عند new، وله ثلاث سمات تُحفظ:

1. اسمه اسم الصنف نفسه.
2. بلا نوع إرجاع، ولا حتى void.
3. يُستدعى بـ new عند إنشاء الكائن، ودوره تهيئة حقوله.

ويُحمَّل تحميلاً زائداً (overloaded) لبناء كائنات بقيم ابتدائية مختلفة، كما في Circle() وCircle(double). وإن لم يُعرَّف أي باني، توفّر اللغة ضمنياً بانياً عاماً بلا وسطاء وجسمه فارغ، اسمه default constructor، ولا يُضاف إلا إذا لم يُكتب أي باني صراحة؛ وصنف Circle في القسم السابق كتب بانيين، فلا يوجد ثالث ضمني.

محددات الوصول. الصنف public مرئي لكل الحزم، والصنف بلا محدد (package-private) مرئي داخل حزمته فقط، حتى من ملف آخر في الحزمة نفسها. وعلى الأعضاء:

وجدول الرؤية الكامل كما في الشريحة:

ورسم الشريحة يضع في الحزمة الأولى color وshape وrectangle وcircle وsquare، وفي الثانية number وletter وEnglish وArabic وصنفًا فرعيًا. والقراءة العملية: الفرع خارج الحزمة يرى public وprotected فقط.

لماذا يهم. كل خطأ وصول في الاختبار يعود إلى هذا الجدول: private لا يعبر حدّ الصنف، وdefault لا يعبر حدّ الحزمة، وprotected يعبر إلى الفرع خارجها.

1.10 المصطلحات والأخطاء الشائعة Glossary and Common Pitfalls

جدول يجمع مصطلحات الفصل في مكان واحد للمراجعة السريعة.

أخطاء شائعة.

• معاملة الصنف كأنه يحمل قيم الكائن، وظن أن circle2.setRadius(100) يغيّر circle1؛ والصواب أن القيم في الكائن والكائنات مستقلة.
• كتابة void للباني أو إرجاع قيمة منه؛ والصواب: لا نوع إرجاع مطلقًا.
• توقع default constructor بعد كتابة Circle(double)؛ والصواب أنه يختفي فور وجود أي باني.
• حساب المساحة بـ 2 * radius * Math.PI؛ والصواب أنها للمحيط.
• تعديل balance أو radius من خارج الصنف وهما private؛ والصواب المرور بدالة عامة.
• خلط abstraction مع encapsulation؛ الأول اختيار الجوهر، والثاني حماية الحالة وفرض الواجهة.
• نسبة السلوك إلى EER؛ والصواب أنه يورّث الخصائص فقط.
• تشغيل ملف Circle لأنه «البرنامج»؛ والصواب أن التشغيل لصنف فيه main.
• اعتبار العضو أو الصنف بلا كلمة مفتاحية public؛ والصواب package-private.

2.1 المتغيرات والثوابت والدوال الثابتة Static Variables, Constants, and Methods

لكل كائن نسخته الخاصة من instance variable، ولا تُستدعى instance method إلا على كائن موجود عبر متغير مرجع. أما العضو المعلَن بـstatic فنسخة واحدة في الذاكرة يشترك فيها كل كائنات الصنف، ويُستخدم باسم الصنف قبل وجود أي كائن أو بعده. ويجوز الوصول إليه عبر مرجع كائن أيضاً (c1.numberOfObjects) لأنه مشروع، لكن المستحسن باسم الصنف لأنه ليس ملك كائن بعينه.

static: معدّل يربط العضو بالصنف لا بالمثيل، ويُسطَّر في UML للدلالة عليه. والمثيل instance كائن واحد ناتج عن instantiate.

مخطط الصنف في UML يكشف الفرق بالتسطير:

Circle
------------------------------------
  radius          : double
  numberOfObjects : int         <- static (underlined)
------------------------------------
  getArea()            : double
  getNumberOfObjects() : int    <- static (underlined)

public class CircleWithStaticMembers {
  double radius;
  static int numberOfObjects = 0;

  CircleWithStaticMembers() {
    radius = 1;
    numberOfObjects++;
  }

  CircleWithStaticMembers(double newRadius) {
    radius = newRadius;
    numberOfObjects++;
  }

  static int getNumberOfObjects() { return numberOfObjects; }
  double getArea() { return radius * radius * Math.PI; }
}

// مقتطف: يُكتب داخل main
CircleWithStaticMembers c1 = new CircleWithStaticMembers(); // radius 1.0
CircleWithStaticMembers c2 = new CircleWithStaticMembers(5); // radius 5.0
c1.radius = 9;                                               // لا يمس c2
System.out.println(CircleWithStaticMembers.numberOfObjects); // 2

Before creating objects
The number of Circle objects is 0
After creating c1
c1: radius (1.0) and number of Circle objects (1)
After creating c2 and modifying c1
c1: radius (9.0) and number of Circle objects (2)
c2: radius (5.0) and number of Circle objects (2)

لماذا يهم: العدادات والثوابت ودوال الأدوات مثل Math.pow مكانها الصنف، وبيانات الكائن مثل نصف القطر مكانها المثيل؛ فموضع الإعلان هو ما يحدد أهذا العضو مشترك أم خاص بكائن واحد.

2.2 قيود العضو الثابت Static Method Cautions

الدالة المثيلية تصل إلى الحقول والدوال المثيلية والثابتة معاً، لأن معها كائناً هو this ومعها الصنف. أما الدالة الثابتة فلا كائن مستقبِل لها عند الاستدعاء، فلا تصل إلى عضو مثيلي مباشرةً، بل عبر مرجع كائن صريح مثل a.i وa.m1().

الاستدعاء الثابت: استدعاء يحدث بلا مستقبِل كائن؛ ولهذا يرفض المترجم استخدام عضو مثيلي من سياق static إلى أن يُنشأ كائن ويُستخدم مرجعه.

public class A {
  int i = 5;
  static int k = 2;

  public static void main(String[] args) {
    int j = i;   // خطأ: i حقل مثيلي
    m1();        // خطأ: m1 دالة مثيلية
  }

  public void m1() {
    i = i + k + m2(i, k);   // مشروع: السياق مثيلي
  }

  static int m2(int i, int j) {
    return (int) Math.pow(i, j);
  }
}

التصحيح بإنشاء كائن ثم الوصول من مرجعه:

public static void main(String[] args) {
  A a = new A();
  int j = a.i;              // مشروع
  a.m1();                   // مشروع
  System.out.println(a.i);  // 32
}

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

2.3 محددات الوصول Visibility Modifiers

visibility modifier ويسمّى أيضاً access specifier يحدد من يرى الصنف وأعضاءه. على الصنف: public يجعله متاحاً لأي كود في أي حزمة، وبلا معدّل يبقى محصوراً في حزمته. وعلى العضو: public يُرى من داخل الصنف وخارجه، وprivate من دوال الصنف نفسه فقط، وبلا معدّل يُرى داخل الحزمة كلها.

الرؤية: حكم على مكان الكود لا على «صاحب الكائن»؛ فكود داخل الصنف يرى أعضاءه الخاصة حتى عبر مرجع لكائن آخر من الصنف نفسه.

مثال الشريحة: الصنف C1 في الحزمة p1 فيه x عام وy بلا معدّل وz خاص، ودوال m1 عامة وm2 بلا معدّل وm3 خاصة. من يصل إلى ماذا من الكائن o:

أي أن C3 تصل إلى o.x وo.m1() فقط. وعلى مستوى الصنف نفسه: class C1 بلا public تراها C2 في p1 ولا تراها C3 في p2، بينما public class C2 تراها C3.

public class C {
  private boolean x;

  public static void main(String[] args) {
    C c = new C();
    System.out.println(c.x);         // مشروع: الكود داخل C
    System.out.println(c.convert()); // -1
  }

  private int convert() {
    return x ? 1 : -1;
  }
}

public class Test {
  public static void main(String[] args) {
    C c = new C();
    System.out.println(c.x);         // خطأ ترجمة
    System.out.println(c.convert()); // خطأ ترجمة
  }
}

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

2.4 تغليف حقول البيانات Data Field Encapsulation

جعل الحقول private يحميها ويسهّل صيانة الصنف: العميل لا يعتمد على تمثيل الحقل الداخلي، والصنف يرفض القيم غير المقبولة في مكان واحد. من يحتاج القراءة يأخذ getter، ومن يحتاج التعديل يأخذ setter.

getter / accessor: public returnType getPropertyName()، وإن كان النوع boolean فالعُرف public boolean isPropertyName(). setter / mutator: public void setPropertyName(dataType value). وفي UML الإشارة - تعني private و+ تعني public.

CircleWithPrivateDataFields
-----------------------------------------------
- radius: double
- numberOfObjects: int          <- private + static
-----------------------------------------------
+ Circle()
+ Circle(newRadius: double)
+ getRadius(): double
+ setRadius(newRadius: double): void
+ getNumberOfObjects(): int     <- static
+ getArea(): double

public class CircleWithPrivateDataFields {
  private double radius = 1;
  private static int numberOfObjects = 0;

  public CircleWithPrivateDataFields() {
    numberOfObjects++;
  }

  public CircleWithPrivateDataFields(double newRadius) {
    radius = newRadius;
    numberOfObjects++;
  }

  public double getRadius() {
    return radius;
  }

  public void setRadius(double newRadius) {
    radius = (newRadius >= 0) ? newRadius : 0;
  }

  public static int getNumberOfObjects() {
    return numberOfObjects;
  }

  public double getArea() {
    return radius * radius * Math.PI;
  }
}

// مقتطف: يُكتب داخل main
CircleWithPrivateDataFields myCircle =
    new CircleWithPrivateDataFields(5);
System.out.println("The area of the circle of radius "
    + myCircle.getRadius() + " is " + myCircle.getArea());
myCircle.setRadius(myCircle.getRadius() * 1.1);
System.out.println("The area of the circle of radius "
    + myCircle.getRadius() + " is " + myCircle.getArea());
System.out.println("The number of objects created is "
    + CircleWithPrivateDataFields.getNumberOfObjects());

The area of the circle of radius 5.0 is 78.53981633974483
The area of the circle of radius 5.5 is 95.03317777109125
The number of objects created is 1

لماذا يهم: تغيير شرط صحة نصف القطر يتم داخل setRadius وحده دون تعديل أي عميل، وهذا هو مكسب التغليف العملي.

2.5 تمرير الكائنات إلى الدوال Passing Objects to Methods

تمرير كائن إلى دالة هو تمرير مرجعه لا الكائن نفسه. والأسلوب pass-by-value ينسخ القيمة الممرَّرة: إن كانت عدداً نُسخ العدد، وإن كانت مرجعاً نُسخت نسخة من العنوان، ويبقى الكائن واحداً على الـheap.

activation record: إطار الدالة على الـstack، يحوي معاملاتها ومتغيراتها المحلية؛ في المخطط إطار printArea فيه times نسخة مستقلة، وc نسخة من المرجع تشير إلى كائن main نفسه.

stack                        heap
--------------------------   --------------------------
main frame                   Circle object  (@A)
  n           = 5              radius = 1.0
  myCircle    = @A

printArea frame
  times       = 5   (copy of n)
  c           = @A  (copy of the reference)

public class Test {
  public static void main(String[] args) {
    Circle circle1 = new Circle(1);
    Circle circle2 = new Circle(2);

    swap1(circle1, circle2);
    System.out.println("After swap1: circle1 = "
        + circle1.radius + " circle2 = " + circle2.radius);

    swap2(circle1, circle2);
    System.out.println("After swap2: circle1 = "
        + circle1.radius + " circle2 = " + circle2.radius);
  }

  public static void swap1(Circle x, Circle y) {
    Circle temp = x;
    x = y;
    y = temp;
  }

  public static void swap2(Circle x, Circle y) {
    double temp = x.radius;
    x.radius = y.radius;
    y.radius = temp;
  }
}

class Circle {
  double radius;

  Circle(double newRadius) {
    radius = newRadius;
  }
}

After swap1: circle1 = 1.0 circle2 = 2.0
After swap2: circle1 = 2.0 circle2 = 1.0

لماذا يهم: أي دالة تستقبل كائناً وتعدّل حقوله تعدّل كائن المستدعي، وهذا يفسّر كثيراً من النتائج التي تبدو غير متوقعة في أسئلة التتبع.

2.6 المرجع this The this Reference

this يشير إلى الكائن الذي استُدعيت عليه الدالة المثيلية. وthis.radius وradius متكافئان ما دام اسم الحقل غير محجوب، أما الاستعمال الحاسم فتمييز حقل الصنف من وسيط يحمل الاسم نفسه.

this: مرجع ثابت نحو المستقبِل الحالي؛ يصلح لقراءة حقول الكائن واستدعاء دواله مثل this.getArea()، ولا معنى له في دالة static لأنه لا كائن مستقبِل في سياق static.

public class Circle {
  private double radius;

  public double getArea() {
    return this.radius * this.radius * Math.PI;
  }

  public String toString() {
    return "radius: " + this.radius + ", area: " + this.getArea();
  }
}

الصورة المكافئة تحذف this ما دام الحقل غير محجوب: return radius * radius * Math.PI; و", area: " + getArea().

public class Circle {
  private double radius;

  Circle() {
    radius = 1;
  }

  Circle(double radius) {
    this.radius = radius;   // لا تكتب radius = radius
  }
}

لماذا يهم: التتبع الذي يساوي ناتج الباني بالوسيط الممرَّر يفشل إن غاب this ويصيب إن وُجد، وهو أول ما يُختبر من أثر الحجب.

2.7 جدول المصطلحات Terminology

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

3.1 الوراثة وعلاقة is-a

Inheritance: اشتقاق صنف جديد من صنف موجود، فيرث بياناته ودواله ويضيف أو يعدّل. الصنف الموجود superclass (أو parent class / base class)، والمشتق subclass (أو child class).

دائرة ومستطيل يتشاركان اللون والامتلاء وتاريخ الإنشاء، ويختلفان في نصف القطر أو في العرض والارتفاع. نضع المشترك في Shape، ونشتق منه Circle وRectangle بدل نسخ الحقول في كل صنف.

الوراثة السليمة علاقة is-a: الدائرة شكل، وليست «الشكل دائرة». في مخطط UML (الشريحتان 4 و6) يظهر الأب أعلى الابن، والسهم المثلث يتجه من الابن إلى الأب.

class Vehicle {
    protected String plate;
    public void start() { System.out.println("Engine on"); }
}

class Car extends Vehicle {
    private int doors;   // إضافة الابن
}

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

3.2 الصنف الأب والصنف الابن Superclass and Subclass

extends: الكلمة المحجوزة التي تربط الابن بالأب. بواني الأب لا تُورَّث؛ تُستدعى صراحةً بـsuper أو ضمناً عند البناء.

Shape يخزّن color وfilled وdateCreated، ويوفّر بانياً بلا وسطاء وبانياً باللون والامتلاء. الحقول private، والقيمة الافتراضية للون "white"، والشكل لا يُملأ حتى يُضبط.

public class Shape {
    private String color = "white";
    private boolean filled;
    private java.util.Date dateCreated;

    public Shape() {
        dateCreated = new java.util.Date();
    }

    public Shape(String color, boolean filled) {
        dateCreated = new java.util.Date();
        this.color = color;
        this.filled = filled;
    }

    public void setColor(String color) { this.color = color; }
    public String getColor() { return color; }
    public void setFilled(boolean filled) { this.filled = filled; }
    public boolean isFilled() { return filled; }
    public java.util.Date getDateCreated() { return dateCreated; }

    @Override
    public String toString() {
        return "created on " + dateCreated + "\ncolor: " + color + " and filled: " + filled;
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle() { }

    public Circle(double radius) {
        this.radius = radius;
    }

    public Circle(double radius, String color, boolean filled) {
        this.radius = radius;
        setColor(color);   // color خاص في الأب
        setFilled(filled);
    }
}

Rectangle يضيف width وheight مع المساحة والمحيط، وبانيه يأخذ العرض والارتفاع ثم اللون والامتلاء. في UML الإشارة - خاص و+ عام.

لماذا يهم: التخصيص يكون بالدوال الموروثة لا بالوصول المباشر؛ لذلك يبقى تغليف الأب سليماً.

3.3 مرجع super وصحّة بواني الأب The super Reference

super(...): استدعاء باني الأب، ويجب أن يكون أول جملة في باني الابن. غياب الاستدعاء الصريح يعني super() ضمنياً، بشرط وجود باني أب بلا وسطاء.

إن لم يُعرّف الأب أي بانٍ، أدرج المترجم باني default فارغاً فينجح الاستدعاء الضمني. إن عرّف الأب بواني بوسطاء فقط فلا باني فارغ، ويفشل super() الضمني بخطأ ترجمة.

public Circle() {
    super("Red", true); // يجب أن يسبق أي جملة أخرى
}

لماذا يهم: الابن مسؤول عن بناء أبيه؛ بانٍ لا يجد باني أب مطابقاً لا يُترجم، وترتيب الجملة الأولى شرط يسبق أي إسناد.

3.4 سلسلة البناء وتتبع التنفيذ Constructor Chaining

Constructor chaining: إنشاء كائن يستدعي بواني كل الأجداد على سلسلة الوراثة، من الأعلى إلى الأسفل، قبل أن يعمل جسم باني الابن.

عند دخول بانٍ يبدأ بـthis(...) ينتقل إلى بانٍ آخر في الصنف نفسه ولا يستدعي الأب بعد؛ والباني الذي لا يبدأ بـthis يبدأ بـsuper صريحاً أو ضمنياً.

public class Faculty extends Employee {
    public static void main(String[] args) {
        new Faculty();
    }
    public Faculty() {
        System.out.println("(4) Faculty's no-arg constructor is invoked");
    }
}
class Employee extends Person {
    public Employee() {
        this("(2) Invoke Employee's overloaded constructor");
        System.out.println("(3) Employee's no-arg constructor is invoked");
    }
    public Employee(String s) {
        System.out.println(s);
    }
}

class Person {
    public Person() {
        System.out.println("(1) Person's no-arg constructor is invoked");
    }
}

ترتيب النداء ثم الطباعة (خطوات الشرائح 19–27):

1. البدء من main ثم new Faculty().
2. دخول Faculty() وفي أوله super() نحو Employee().
3. Employee() يبدأ بـthis(String) لا بـsuper.
4. Employee(String) يستدعي ضمنياً Person().
5. تنفيذ طباعة Person ثم الرجوع.
6. طباعة الوسيط في Employee(String).
7. الرجوع إلى Employee() وطباعة السطر (3).
8. الرجوع إلى Faculty() وطباعة السطر (4).

المخرجات:

(1) Person's no-arg constructor is invoked
(2) Invoke Employee's overloaded constructor
(3) Employee's no-arg constructor is invoked
(4) Faculty's no-arg constructor is invoked

لماذا يهم: جسم الباني لا يعمل قبل اكتمال بناء الأب، وأي طباعة في الابن تظهر بعد طباعات الأجداد.

3.5 إعادة التعريف والتحميل الزائد Overriding vs Overloading

الابن يصنع أربع حركات: يرث أعضاء الأب، ويضيف حقولاً (radius)، ويضيف دوالاً (getArea وgetDiameter وgetPerimeter وprintCircle)، ويعيد تعريف دالة الأب (toString).

Method overriding: دالة غير ساكنة (instance method) في الابن تطابق اسم دالة الأب وأنواع وسطائها. التعليق @Override يعلن النية؛ فإن لم توجد دالة مطابقة فشل الترجمة.

public class Circle extends Shape {
    private double radius;

    public double getRadius() { return radius; }
    public void setRadius(double radius) { this.radius = radius; }
    public double getArea() { return radius * radius * Math.PI; }
    public double getDiameter() { return 2 * radius; }
    public double getPerimeter() { return 2 * radius * Math.PI; }
}

    public void printCircle() {
        System.out.println("The circle is created " + getDateCreated()
                + " and the radius is " + radius);
    }

    @Override
    public String toString() {
        return "The circle is created " + super.toString()
                + " and the radius is " + radius;
    }
}

super.method() تستدعي نسخة الأب من دالة أُعيد تعريفها، وsuper يصل إلى الحقول والدوال العامة أو protected فقط.

مثال الشريحة: الصنف B فيه p(double) تطبع i * 2، والابن A يعرّف إمّا p(double) أو p(int). الاستدعاءان a.p(10) وa.p(10.0):

class B {
    public void p(double i) { System.out.println(i * 2); }
}
class A extends B {
    @Override
    public void p(double i) { System.out.println(i); } // إعادة تعريف
}
class Test {
    public static void main(String[] args) {
        A x = new A();
        x.p(10);   // 10.0
        x.p(10.0); // 10.0
    }
}

class B {
    public void p(double i) { System.out.println(i * 2); }
}
class A extends B {
    public void p(int i) { System.out.println(i); } // تحميل زائد، لا @Override
}
class Test {
    public static void main(String[] args) {
        A x = new A();
        x.p(10);   // 10
        x.p(10.0); // 20.0
    }
}

class P { public static void m() { System.out.println("P"); } }
class C extends P { public static void m() { System.out.println("C"); } }
class Test {
    public static void main(String[] args) {
        P ref = new C();
        ref.m(); // P: النسختان موجودتان والاختيار بنوع المرجع
    }
}

لماذا يهم: الخلط بين التحميل وإعادة التعريف يغيّر المخرجات مع أن الاستدعاء في main واحد، والفرق كله في التوقيع وفي نوع الكائن.

3.6 محددات الوصول Access Modifiers

Access modifiers: من الأضيق إلى الأوسع private ثم default (بلا كلمة) ثم protected ثم public. الرمز # في UML يعني protected.

عمودا «الحزمة» و«صنف غير ابن في حزمة أخرى» يقيسان الوصول من صنف غير ابن: الأول داخل الحزمة والثاني خارجها، فـprotected يقول Yes في الحزمة وNo خارجها بلا تناقض.

تطبيق الشريحة على C1 في الحزمة p1: x عام، y محمي، z بلا معدّل، u خاص، وm() محمية.

دقة جافا: الابن في حزمة أخرى يصل إلى العضو المحمي عبر كائن من نوعه هو (this أو مرجع من نوع الابن)، لا عبر مرجع من نوع الأب؛ ولذلك o.y حيث o من نوع C1 داخل C4 خطأ ترجمة، بخلاف this.y.

لماذا يهم: protected هو معدّل الوراثة: الابن في حزمة أخرى يرى العضو، والصنف الغريب في تلك الحزمة لا يراه. والإضعاف يكسر من كان يستدعي الدالة عبر مرجع الأب.

3.7 المعدّل النهائي وصنف الجذر final and Object

final يجمد ثلاثة أشياء مختلفة، وكل صنف في جافا سليل java.lang.Object؛ فإن لم تُكتب extends فالأب هو Object.

toString(): تُرجع تمثيلاً نصياً للكائن. التنفيذ الافتراضي في Object: اسم الصنف ثم @ ثم عدد يمثل الكائن.

// مقتطف: يُكتب داخل main
Loan loan = new Loan();
System.out.println(loan.toString());
System.out.println(loan); // تستدعي toString ضمنياً

class Circle { }                    // الأب الفعلي: Object
// الصورة المكافئة نفسها، ولا تُكتب مع السطر السابق:
// class Circle extends Object { }

لماذا يهم: إعادة تعريف toString قرار مقروئية وأداة تنقيح، وfinal قرار تصميم يمنع تخصيصاً غير آمن في السلسلة.

3.8 المراجع متعددة الأشكال Polymorphism and Dynamic Binding

Polymorphism: إشارة مرجع الأب إلى كائن ابن، فيُختار عند التشغيل النسخة المعاد تعريفها حسب نوع الكائن لا نوع المرجع. المرجع الذي يبدّل نوع الكائن عبر الزمن polymorphic reference، والربط المؤجَّل dynamic binding.

القط حيوان، فيجوز لمرجع Animal أن يشير إلى كائن Cat؛ كل الحيوانات تصدر صوتاً، لكن لكل نوع صوته.

// مقتطف: يُكتب داخل main
Animal animal = new Cat(); // توسيع
animal.sound();            // صوت القط
animal = new Duck();
animal.sound();            // صوت البط؛ الدالة تتبدل من نداء إلى نداء

Person per = new Student(); // widening: إسناد كائن ابن إلى مرجع جد بلا قسر
Student s1 = new Student();
per = s1;                   // widening أيضاً
Student s2 = (Student) per; // narrowing، القسر واجب

مصفوفة متعددة الأشكال (polymorphic array): نوع العناصر هو الأب، وكل خانة كائن ابن.

// مقتطف: يُكتب داخل main
Animal[] animals = new Animal[3];
animals[0] = new Cat();
animals[1] = new Dog();
animals[2] = new Wolf();
System.out.println("-----------------------");
animals[0].eat();
animals[0].move();
animals[0].sounds();

Animal يعرّف eat وmove وsounds بنصوص عامة (Animal can eat وما يقابلها). Cat وDog يعيدان تعريف الثلاث بـ@Override؛ وWolf يعيد تعريف eat وsounds فقط فتبقى move نسخة الأب، ولهذا وُضع على الشريحة تعليق No overriding عند animals[2].move().

public class Wolf extends Animal {
    @Override
    public void eat() {
        System.out.println("I am Wolf, I can eat");
    }
    @Override
    public void sounds() {
        System.out.println("I am Wolf, I can make sounds");
    }
}

المخرجات:

-----------------------
I am Cat, I can eat
I am Cat, I can move
I am Cat, I can make sounds
-----------------------
I am Dog, I can eat
I am Dog, I can move
I am Dog, I can make sounds
-----------------------
I am Wolf, I can eat
Animal can move
I am Wolf, I can make sounds

لماذا يهم: حلقة واحدة على Animal[] تشغّل سلوكاً مختلفاً لكل عنصر دون سؤال عن النوع الفعلي، فتُضاف أنواع جديدة بلا تعديل الحلقة.

3.9 جدول المصطلحات Glossary

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

3.11 خريطة الشرائح Slide Map

4.1 لماذا نُبقي الصنف الأب؟ Motivation

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

abstract class: صنف مسبوق بالكلمة المفتاحية abstract، يمنع إنشاء كائن منه بـ new، ويبقى قابلاً للوراثة.

لماذا نُبقي الأب إذن؟ لسببين لا ثالث لهما: أن ينفّذ السلوك المشترك مرة واحدة مثل setLogin وgetLogin بدل تكراره في كل ابن، وأن نتعامل مع كل الطلاب عبر النوع Student بـ polymorphism بغضّ النظر عن الابن الفعلي.

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

4.2 الصنف المجرد وبناؤه Abstract Class

المنع يخص new فقط. الصنف المجرد ما زال يُورَّث، ويملك حقولاً ودوالاً ذات جسم وبنّائين. الابن غير المسبوق بـ abstract يُسمّى concrete class، مثل PhdStudent.

public abstract class Student {
    protected String login, department, name;

    public Student() {
        login = "";
        department = "";
        name = "";
    }

    public void setLogin(String login) {
        this.login = login;
    }

    public String getLogin() {
        return login;
    }
}

public class PhdStudent extends Student { // concrete class
    private String supervisor;

    public PhdStudent() {
        super(); // يستدعي بنّاء Student
    }

    public void setSupervisor(String login) {
        supervisor = login;
    }
}

مثال الفرق: new Student() خطأ ترجمة، بينما new PhdStudent() صحيح ويشغّل بنّاء Student أولاً ثم جسم بنّاء الابن.

لماذا يهم: الصنف المجرد يغلق النوع العام ويُبقي شيفرته للأبناء. حذف البنّاء منه يقطع سلسلة التهيئة، فتصل حقول الأب إلى الابن غير مهيّأة.

4.3 الصنف المجرد نوعاً للبيانات Abstract Class as a Data Type

منع الإنشاء لا يمنع استخدام الاسم نوعاً لمرجع أو لمصفوفة. العناصر الفعلية تكون من أبناء ملموسين، والمرجع يبقى من نوع الأب.

data type: الصنف المجرد والواجهة يصلحان نوعاً مرجعياً (reference type) لمتغيّر أو مصفوفة أو معامل دالة، ولا يصلحان لإنشاء كائن.

// مقتطف: يُكتب داخل main
Shape[] geo = new Shape[10]; // صحيح: النوع مجرد، وكل عنصر null
geo[0] = new Circle(5);      // صحيح: Circle ابن ملموس
geo[1] = new Shape();        // خطأ ترجمة: لا new على الصنف المجرد

لماذا يهم: هذه هي الآلية التي تسمح بمعالجة الأشكال كلها في حلقة واحدة: المرجع من نوع الأب، والكائن من نوع الابن، والدالة تُستدعى بـ polymorphism فتصل إلى تنفيذ الابن.

4.4 الدالة المجردة Abstract Method

كما يُصرَّح المتغيّر Person p; بلا كائن، تُصرَّح الدالة بلا جسم. Shape لا يستطيع حساب مساحة «شكل اعتباطي»، فيُترك الحساب للابن ويُجبر عليه.

abstract method: دالة مُعلنة غير معرَّفة: ترويسة كاملة بأقواس معاملاتها، ثم ; بدل الجسم بين { }، مثل public abstract void draw(int size);.

public abstract class Shape {
    final static int BLACK = 0;
    private int color;

    public Shape() {
        color = BLACK;
    }

    public void setColor(int c) {
        this.color = c;
    }

    public abstract double getArea(); // بلا جسم
}

public class Circle extends Shape {
    final static double PI = 3.14159;
    private int radius;

    public Circle(int r) {
        radius = r;
    }

    public double getArea() {
        return radius * radius * PI;
    }
}

لماذا يهم: الدالة المجردة في الأب عقد: لا شكل ملموس بلا مساحة. وهي أيضاً شرط قانونية الاستدعاء عبر مرجع الأب، كما سيأتي في القسم 4.6.

4.5 مخطط UML وقواعد التجريد UML and Abstract Rules

الشريحة 13 تعرض GeometricObject مجرداً، وCircle وRectangle ابنين يحدّد كلٌّ منهما المساحة والمحيط بطريقته.

                    GeometricObject
        ----------------------------------------
        - color : int
        - filled : boolean
        - dateCreated : Date
        ----------------------------------------
        # GeometricObject()
        # GeometricObject(color, filled)
        + getColor() : int
        + setColor(color) : void
        + isFilled() : boolean
        + setFilled(filled) : void
        + getDateCreated() : Date
        + toString() : String
        + getArea() : double        (abstract)
        + getPerimeter() : double   (abstract)

الخط المائل في اسم الصنف أو الدالة يعني abstract. الحقول خاصة، والبنّاءان محميّان protected، والدالتان المائلتان مجردتان، وبقية الدوال ملموسة. المخطط لا يرسم دوال الأب داخل صندوق الابن اختصاراً، لكن Circle وRectangle ملزمان بتنفيذ getArea وgetPerimeter. وCircle يضيف getDiameter() وهي خاصة بالابن لا يعرفها مرجع GeometricObject.

• إن نفّذ الابن كل الدوال المجردة الموروثة فهو مكتمل concrete ويُنشأ بـ new.
• إن ترك واحدة، فهو مجرد أيضاً ولا يُنشأ.
• الابن الملموس ينفّذ كل الدوال المجردة حتى التي لا يستخدمها.

لماذا يهم: السؤال الخادع يقلب الاتجاه. احفظ الجملة الواحدة: «دالة مجردة ⇒ صنف مجرد» صحيحة، و«صنف مجرد ⇒ فيه دالة مجردة» خاطئة.

4.6 ما يراه نوع المرجع Class Knows Its Superclass

المرجع من نوع الأب لا يرى إلا ما عُرّف في الأب أو فوقه. الدالة المكتوبة في الابن وحده غير مرئية عبر مرجع الأب، حتى لو كان الكائن الفعلي من ذلك الابن. السبب بجملة الشريحة: الصنف يعرف صنفه الأب لا أصناف أبنائه، والمترجم ينظر إلى نوع المرجع.

class Shape { }
class Star extends Shape {
    public void draw() { }
}

class Demo {
    public static void main(String[] args) {
        Shape someShape = new Star(); // قانوني: Star هو Shape
        someShape.draw();             // خطأ ترجمة: Shape لا يعرف draw
    }
}

الحل المباشر: التحويل قبل الاستدعاء، ((Star) someShape).draw();. يُقبل عند الترجمة لأن Star ابن لـ Shape، لكنه قد يرمي ClassCastException وقت التشغيل إن لم يكن الكائن Star فعلاً.

الحل المعتمد (الشريحة 17): رفع draw إلى Shape دالة مجردة، فيصير الاستدعاء قانونياً بلا تحويل، ويصير new Shape() ممنوعاً.

abstract class Shape {
    public abstract void draw();
}
class Star extends Shape {
    public void draw() { }
}
class Crescent extends Shape {
    public void draw() { }
}

class Demo {
    public static void main(String[] args) {
        Shape someShape = new Star(); // قانوني
        someShape.draw();             // قانوني: كل كائن فعلي ينفّذ draw
        Shape bad = new Shape();      // لم يعد قانونياً
    }
}

لماذا يهم: هذا هو مبرّر وضع دالة في الأب بلا جسم: ليس لحساب نتيجة هناك، بل ليكون الاستدعاء المتعدد الأشكال قانونياً.

4.7 تعريف الواجهة وجسمها Interface

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

interface: جسمها تصريحات دوال كل تصريح ينتهي بـ ; وبلا تنفيذ، وحقولها ثوابت فقط. في هذا المقرر كل حقل public static final وكل دالة public abstract، ويجوز حذف هذه المعدّلات لأنها مفروضة.

public interface StockWatcher {
    final String sunTicker = "SUNW";
    final String oracleTicker = "ORCL";
    final String ciscoTicker = "CSCO";

    void valueChanged(String tickerSymbol, double newValue);
}

public interface T {
    public static final int K = 1; // الصيغة الكاملة
    public abstract void p();
}

interface U {   // الصيغة المختصرة المكافئة
    int K = 1;  // المعدّلات المحذوفة تبقى سارية
    void p();
}

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

4.8 التنفيذ بـ implements ومثال Edible

قاعدة الملف: في ملف واحد لا يُسمح إلا بنوع public واحد، وكل نوع public يوضع في ملف يحمل اسمه. الأمثلة أدناه تُقرأ على هذا الأساس.

الصنف يلتزم الواجهة بكلمة implements، ويكتب كل دوالها بالتوقيع نفسه ونوع الإرجاع نفسه. ويستطيع أن يمتد من صنف واحد وينفّذ واجهة في الوقت ذاته. في الترميز، «interface» يسم الواجهة، والخط المتقطع مع المثلث الفارغ يعني علاقة تنفيذ، بينما الخط المتصل مع المثلث يعني وراثة صنف.

public class StockApplet extends Applet implements StockWatcher {
    public void valueChanged(String tickerSymbol, double newValue) {
        // التنفيذ الكامل الذي يجعل الصنف concrete
    }
}

supertype: النوع الأعلى الذي يُشار به إلى عدة أنواع. في مثال الشرائح 25–28: Edible نوع أعلى لـ Chicken وFruit، وAnimal نوع أعلى لـ Chicken وTiger، وFruit نوع أعلى لـ Orange وApple.

public interface Edible {
    /** Describe how to eat */
    public abstract String howToEat();
}

class Animal {
    // الحقول والبنّاؤون والدوال محذوفة في الشريحة
}

class Chicken extends Animal implements Edible {
    public String howToEat() {
        return "Chicken: Fry it";
    }
}

class Tiger extends Animal { }

abstract class Fruit implements Edible {
    // بلا howToEat، لذا abstract
}

class Apple extends Fruit {
    public String howToEat() {
        return "Apple: Make apple cider";
    }
}

class Orange extends Fruit {
    public String howToEat() {
        return "Orange: Make orange juice";
    }
}

public class TestEdible {
    public static void main(String[] args) {
        Object[] objects = {new Tiger(), new Chicken(), new Apple()};
        for (int i = 0; i < objects.length; i++) {
            if (objects[i] instanceof Edible) {
                System.out.println(((Edible) objects[i]).howToEat());
            }
        }
    }
}

instanceof: معامل يفحص هل الكائن من النوع المذكور: صنفاً أو ابناً أو واجهة، ويُعيد true أو false.

Chicken: Fry it
Apple: Make apple cider

Tiger يُتخطى لأنه ليس Edible، وOrange لا يدخل المصفوفة فلا يُطبع. نقاش الشريحة 28 يذكر استدعاء sound لعناصر Animal، لكن الكود المعروض في الشريحة 27 لا يستدعيه، فالمخرج سطران فقط.

لماذا يهم: الواجهة هنا صفة لا شجرة نسب. الدجاجة ليست فاكهة، وكلتاهما تُؤكل، فجمعتهما واجهة واحدة بلا وراثة بينهما.

4.9 الواجهة مقابل الصنف المجرد Interface vs Abstract Class

الاثنان لا يُنشآن بـ new ويُستخدمان نوعين. الفرق في ما يُسمح بوضعه داخل كل منهما، وفي عدد الآباء.

public class NewClass extends BaseClass
        implements Interface1, Interface2, InterfaceN {
}

public interface NewInterface
        extends Interface1, Interface2, InterfaceN {
    // ثوابت ودوال مجردة إضافية
}

subinterface: واجهة تمتد من واجهات أخرى فترث ثوابتها وتواقيع دوالها، وتضيف عليها. NewInterface في المقطع أعلاه مثالها.

مخطط الشريحة 31، والمثلث يشير إلى النوع الأعلى:

Object
  ↑
Class1 ──▷ Interface1 ──▷ Interface1_1
  ↑            └────────▷ Interface1_2
Class2 ──▷ Interface2_1
       └──▷ Interface2_2

• Class1 يمتد من Object، وينفّذ Interface1.
• Interface1 تمتد من Interface1_1 ومن Interface1_2.
• Class2 يمتد من Class1، وينفّذ Interface2_1 وInterface2_2 مباشرة، ولا تظهر واجهة باسم Interface2.

لماذا يهم: أسئلة instanceof على هذا المخطط تُحل بتتبّع الأسهم صعوداً: وراثة الأصناف على الخط المتصل، والواجهات على المتقطع، ثم واجهات الآباء.

4.10 متى الواجهة ومتى الوراثة؟ When to Use an Interface

الاثنان يصوغان المشترك، والاختيار يتبع قوة العلاقة لا ذوق الكتابة.

لماذا يهم: لو جعلنا Edible صنفاً أباً لـ Fruit وChicken لاستهلك الاثنان مقعد extends الوحيد، فحُرمت الدجاجة من وراثة Animal. الواجهة لا تستهلك هذا المقعد.

4.11 جدول المصطلحات

4.12 أخطاء شائعة

4.13 خريطة الشرائح

1 الكلمات المفتاحية والمعدّلات Keywords & Modifiers

2 صلاحيات الوصول Access Modifiers

3 التحميل الزائد مقابل إعادة التعريف Overloading vs Overriding

4 الصنف المجرد مقابل الواجهة Abstract Class vs Interface

5 العضو الثابت مقابل المثيلي static vs instance

6 المساواة المرجعية والمنطقية == vs equals()

7 التوسيع والتضييق Upcasting / Downcasting

8 اثنتا عشرة قاعدة ذهبية Golden Rules

9 أخطاء تُفقدك الدرجة Costly Mistakes

10 تسلسل تنفيذ البواني Constructor Chaining

class Person {
  Person() { System.out.println("(1) Person"); }
}
class Employee extends Person {
  Employee() {
    this("(2) Employee overloaded");
    System.out.println("(3) Employee no-arg");
  }
  Employee(String s) { System.out.println(s); }
}
class Faculty extends Employee {
  Faculty() { System.out.println("(4) Faculty"); }
}