تعدد الأشكال في جافا: واجهة واحدة، أشكال متعددة

مرجع واحد، أنواع متعددة

تعدد الأشكال هو ثمرة الوراثة والواجهات. يعني أن متغيّرًا واحدًا مُعرَّفًا بنوع أب (أو واجهة) يمكنه أن يحمل كائنًا من أي نوع فرعي، وعندما تستدعي دالة عليه، تُنفِّذ جافا النسخة التابعة للفئة الحقيقية للكائن، لا النسخة التي يوحي بها النوع المُعلن للمتغيّر.

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

class Animal {
    String speak() { return "..."; }
}

class Dog extends Animal {
    String speak() { return "Woof"; }
}

class Cat extends Animal {
    String speak() { return "Meow"; }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // مرجع أب يحمل كائنًا ابنًا
        Animal b = new Cat();

        System.out.println(a.speak());   // Woof
        System.out.println(b.speak());   // Meow
    }
}

كلٌّ من a وb مُعلَّن بوصفه Animal، ومع ذلك يطبع كل منهما صوته الخاص. يحدث هذا الاختيار وقت التشغيل بناءً على الكائن الحقيقي.

التوزيع الديناميكي للدوال

الآلية وراء هذا هي التوزيع الديناميكي للدوال (dynamic method dispatch): فمن أجل دالة نسخة مُعاد تعريفها، تنظر آلة جافا الافتراضية (JVM) إلى فئة الكائن وقت التشغيل لتقرر أيّ تنفيذ تستدعي. ولا يتحقق المترجم إلا من أن الدالة موجودة على النوع المُعلن، أما الاختيار الفعلي فيُؤجَّل حتى يعمل البرنامج.

هذا ما يتيح لحلقة واحدة أن تتعامل مع خليط كامل من الأنواع دون أن تسأل قط عن ماهية كل واحد منها:

import java.util.List;

class Shape {
    double area() { return 0; }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double area() { return side * side; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Square(2), new Circle(3));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // كل استدعاء يُوزَّع إلى الفئة الفرعية الحقيقية
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

لا تعرف الحلقة سوى Shape. أضِف Triangle extends Shape لاحقًا وستظل هذه الشيفرة تعمل دون تغيير، وهذا هو جوهر الفكرة. فالشيفرة تعتمد على التجريد، لا على القائمة المحددة للأنواع.

التحويل لأعلى والتحويل لأسفل

تخزين Dog في متغيّر من نوع Animal هو تحويل لأعلى (upcasting): صعود في التسلسل الهرمي نحو نوع أعمّ. وهو آمن دائمًا وتفعله جافا ضمنيًا، لأن كل Dog هو Animal.

السير في الاتجاه المعاكس هو تحويل لأسفل (downcasting): أخذ مرجع أب ومعاملته بوصفه نوعًا فرعيًا محددًا. ولا يكون ذلك صحيحًا إلا إذا كان الكائن فعلًا من ذلك النوع الفرعي، لذا عليك كتابة التحويل صراحةً، وتخاطر بحدوث ClassCastException إن كنت مخطئًا:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal { }

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // تحويل لأعلى - ضمني، آمن

        Dog d = (Dog) a;        // تحويل لأسفل - صريح، صحيح لأن a هو فعلًا Dog
        d.fetch();

        Animal c = new Cat();
        Dog wrong = (Dog) c;    // يُترجَم، لكنه يرمي ClassCastException وقت التشغيل
        wrong.fetch();
    }
}

التحويل الأخير يُترجَم دون مشكلة، إذ لا يستطيع المترجم إثبات خطئه، لكنه ينفجر عند التشغيل لأن Cat ليس Dog. لا تُجرِ تحويلًا لأسفل اعتمادًا على الظن أبدًا.

احمِ التحويل لأسفل باستخدام instanceof

قبل التحويل لأسفل، افحص النوع الحقيقي باستخدام instanceof. تتيح لك جافا الحديثة ربط النتيجة داخل التعبير نفسه (مطابقة الأنماط في instanceof)، فتستغني عن التحويل المنفصل:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal {
    void scratch() { System.out.println("scratching"); }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = { new Dog(), new Cat(), new Dog() };

        for (Animal animal : animals) {
            if (animal instanceof Dog dog) {     // يفحص النوع ويربط dog في آنٍ واحد
                dog.fetch();
            } else if (animal instanceof Cat cat) {
                cat.scratch();
            }
        }
    }
}

يُرجِع instanceof القيمة false من أجل null، لذا يحميك هذا الفحص أيضًا من NullPointerException. ومع ذلك، إن وجدت نفسك تكتب سلاسل طويلة من instanceof، فغالبًا ما يكون ذلك إشارة إلى أن السلوك ينتمي إلى داخل الفئات بوصفه دالة مُعاد تعريفها، فدع تعدد الأشكال يتولى التفرّع عنك.

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

يبدو هذان المفهومان متشابهين لكنهما غير مترابطين، والخلط بينهما مصدر كلاسيكي للالتباس.

إعادة التعريف (overriding) هي أن تستبدل فئة فرعية دالة من الأب بالتوقيع نفسه تمامًا. تُحلّ وقت التشغيل حسب نوع الكائن، وهي تعدد الأشكال الذي ما زلنا نستخدمه.

التحميل الزائد (overloading) هو أن تمتلك فئة واحدة عدة دوال بالاسم نفسه لكن بقوائم معاملات مختلفة. ويُحلّ وقت الترجمة حسب أنواع المعطيات، دون أي توزيع وقت التشغيل:

public class Main {
    static String describe(int x)    { return "int: " + x; }
    static String describe(double x) { return "double: " + x; }
    static String describe(String x) { return "String: " + x; }

    public static void main(String[] args) {
        System.out.println(describe(5));      // int: 5
        System.out.println(describe(5.0));    // double: 5.0
        System.out.println(describe("five")); // String: five
    }
}

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

خطأ شائع: الحقول ليست متعددة الأشكال

تُوزَّع دوال النسخ (instance methods) فقط وقت التشغيل. أما الحقول والدوال الساكنة (static methods) فتُحلّ حسب النوع المُعلن، وهو ما يُربك كثيرين:

class Parent {
    String label = "parent";
    String name() { return "Parent"; }
}

class Child extends Parent {
    String label = "child";          // يُخفي، لا يُعيد التعريف
    String name() { return "Child"; }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.label);    // parent  - الحقل يستخدم النوع المُعلن
        System.out.println(p.name());   // Child   - الدالة تستخدم النوع وقت التشغيل
    }
}

ينفّذ p.name() نسخة Child (تعدد الأشكال)، لكن p.label يقرأ حقل Parent، لأن الحقول تُخفى ولا تُعاد تعريفها. والحل بسيط: اجعل الحقول private وصِل إليها عبر الدوال فقط، كي يفوز الاستدعاء متعدد الأشكال دائمًا.

التالي: محددات الوصول

لا يعمل تعدد الأشكال بنظافة إلا حين تستطيع الفئات الفرعية رؤية الأعضاء المناسبين وإعادة تعريفها، بينما يعجز بقية شيفرتك عن التطفّل عليها وكسر الثوابت. ويُضبَط هذا التوازن عبر الوصول public وprotected وprivate والوصول على مستوى الحزمة، أي محددات الوصول، وهي موضوعنا التالي.