ماهو polymorphism

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

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

وهذا ينطبق تماما على  الكائنات في البرمجة الشيئية

وهذا مثال عملي على كيفية عمل polymorphism   في java

// الفئة الأم (الأشكال)
class Shapes {
  public void area() {
    System.out.println("The formula for area of ");
  }
}

// فئة المثلثات
class Triangle extends Shapes {
  public void area() {
    System.out.println("Triangle is ½ * base * height ");
  }
}
// فئة الدوائر
class Circle extends Shapes {
  public void area() {
    System.out.println("Circle is 3.14 * radius * radius ");
  }
}
class Main {
  public static void main(String[] args) {
    Shapes myShape = new Shapes();  //  إنشاء كائن الأشكال
    Shapes myTriangle = new Triangle();  // إنشاء كائن المثلثات
    Shapes myCircle = new Circle();  //  إنشاء كائن الدوائر  
    myShape.area();
    myTriangle.area();
    myShape.area();
    myCircle.area();
  }

نلاحظ أنه في كل كائن نستعمل الدالة ()area بشكل مختلف حسب طبيعة الكائن و هذا ما يسمى ب  polymorphism   

يمكنك الإطلاع على المزيد حول هذا الموضوع في مقالة حسوب على الرابط التالي

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

• static polymorphism او Compile time Polymorphism يُعرف أيضًا باسم تعدد الأشكال الثابت. يتم تحقيق هذا النوع من تعدد الأشكال عن طريق التحميل الزائد للوظيفة (Method overloading) أو التحميل الزائد للعوامل (operator overloading) . لكن Java لا تدعم التحميل الزائد للعوامل.
  Method Overloading: عندما تكون هناك وظائف متعددة بنفس الاسم ولكن مع وسائط مختلفة ، يُقال إن هذه الوظائف محملة بشكل زائد. يمكن زيادة تحميل الوظائف عن طريق التغيير في عدد الوسائط اوالتغيير في نوع الوسائط.

مثال: بإستخدام نوع مختلف للوسائط

class MultiplyFun {

  // Method with 2 parametera type int
  static int multiply(int a, int b)
  {
    return a * b;
  }

  // Method with the same name but 2 double parameters
  static double multiply(double a, double b)
  {
    return a * b;
  }
}

class Main {
  public static void main(String[] args)
  {

    System.out.println(MultiplyFun.multiply(3, 2)); // 6

    System.out.println(MultiplyFun.multiply(5.5, 6.3)); // 34.65
  }
}

مثال بإستخدام عدد مختلف من الوسائط:

class MultiplyFun {
  
    // Method with 2 parameter
    static int multiply(int a, int b)
    {
        return a * b;
    }
  
    // Method with the same name but 3 parameter
    static int multiply(int a, int b, int c)
    {
        return a * b * c;
    }
}
  
class Main {
    public static void main(String[] args)
    {
        System.out.println(MultiplyFun.multiply(2, 4)); // 8
  
        System.out.println(MultiplyFun.multiply(2, 3, 4)); // 24
    }
}

لاحظ أنه في كل من المثالين وصلنا إلى أشكال مختلفة لكن من نفس الشيء و هو الوظيفة multiply. يُسمى هذا النوع ب  Compile time Polymorphism لانه في وقت الترجمة المُترجم يكون لديه القدرة على تحديد الوظيفة التي ستتنفذ.

• Runtime polymorphism او يُعرف أيضًا باسم إرسال الوظيفة الديناميكية. وهي عملية يتم فيها حل استدعاء الدالة في وقت التشغيل. يتم تحقيق هذا النوع من تعدد الأشكال عن طريق إعادة تعريف الدوال (Method Overriding).
  Method Overriding: يحدث عندما يكون للفئة المشتقة (derived class) تعريف لإحدى الوظائف في الفئة الأساسية (base class). يقال إن هذه الوظيفة الأساسية تمت إعادة تعريفها او تم تجاوزها:

class Parent {

  void print()
  {
    System.out.println("Parent class");
  }
}

class Child1 extends Parent {

  void print()
  {
    System.out.println("Child 1 class");
  }
}

class Child2 extends Parent {

  void print()
  {
    System.out.println("Child 2 class");
  }
}

class TestPolymorphism {
  public static void main(String[] args)
  {

    Parent a;

    a = new Child1();
    a.print(); // Child 1 class

    a = new Child2();
    a.print(); // Child 2 class
  }
}

لاحظ أن الوظيفة print تم إعادة تعريفها في الفئات الأبناء و الكائن a الذي أنشأناه هو كائن من النوع Parent و سيتم تحديد أي وظيفة print سيتم إستدعاؤها وقت التشغيل لذلك يُسمى هذا النوع ب Runtime polymorphism.

يُمكنك الإطلاع على هذا المقال للحصول على معلومات أكثر: الوراثة والتعددية الشكلية (Polymorphism) والأصناف المجردة (Abstract Classes) في جافا

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

class Human { ….. }
class Student extends Human { ……. }
//العبارات التالية صحيحة
Human H ; //مقبض من الصف الأب
H = new Human() ; // المقبض يشير إلى كائن من نفس الصف
H = new Student () ; // المقبض يشير إلى كائن من الصف الابن
// العبارات التالية خاطئة
Student st = new Human ; // مقبض من الصف الابن يشير الى كائن من الصف الأب (لايجوز)

الآن لفهم الكلام السابق سنعطي مثال ، نشرحه ثم نكتب كود برمجي يعبرعنه ..
لنفرض مثلاً لدينا شاحنة ونريد نقل مجموعة سيارات بحيث كل شاحنة تتسع ل 10  سيارات ، وتنقل نوع واحد من السيارات .. ( يمكن تشبيه الشاحنة بمصفوفة تضم عناصر من نمط واحد ) ..
لنفرض لدينا نوعين من السيارات نريد أن ننقلهم 4:BMW   و  4:AUDI
حسب الشروط المفروضة سنحتاج شاحنتين في كل واحدة سنضع 4  من نفس النوع ..
الفكرة أن الشاحنة الواحدة (مصفوفة ) لا تحمل نوعين لكنها  تتسع للعدد الكلي ، أي أننا قمنا بعملية نقل صحيحة لكنها مكلفة ( حجزنا شاحنة ويوجد أماكن فارغة بالأولى  + ماذا  لو كان لدينا أكثر من نوعين .. )
الحل : يجب أن نبحث عن شاحنة ( مصفوفة)  تحمل النوعين .. ونعلم أن المصفوفة لا تحمل الا نوع واحد .. ما العمل
هنا تأتي " تعددية الأشكال" بأن نعرف صف أب للصفين السابقين وليكن Carونرث منه الصفين BMW و AUDI ونأخذ مصفوفة مقابض من Car ( نمط واحد ) وكل عنصر (مقبض) نجعله يشير الى الكائن المطلوب .. BMW أو AUDI ..
وهكذا نكون قد حللنا المشكلة و خزنا كائنات من صفوف مختلفة بمصفوفة واحدة
مثال : (يمكن نسخ الكود وتنفيذه لملاحظة النتائج):

package javaapplication29;
class Car {
void type () { System.out.println("car");}
}
class BMW extends Car {
@Override
void type () { System.out.println("BMW");}
}
class AUDI extends Car {
@Override
void type () { System.out.println("AUDI");}
}
public class JavaApplication29 {

public static void main(String[]args ){
Car[]c =new Car[8];
//نعبئ أربع سيارات BMW
for( int  i=0; i<4 ; ++i )
    c[i] = new BMW();
//نعبئ أربع سيارات AUDI
for( int  i=4; i<8 ; ++i )
    c[i] = new AUDI();
//تعليمة طباعة للتأكد من أنه تم تعبئة النوعين  
for( int  i=0; i<8 ; ++i ) c[i].type();
}
}