جاوا میں پولیمورفزم

ہائے! آج ہم OOP کے اصولوں پر سبق کا ایک سلسلہ ختم کرتے ہیں۔ اس سبق میں، ہم جاوا پولیمورفزم کے بارے میں بات کریں گے۔ پولیمورفزم کئی اقسام کے ساتھ کام کرنے کی صلاحیت ہے جیسے کہ وہ ایک ہی قسم کے ہوں۔ مزید یہ کہ اشیاء کا طرز عمل ان کی قسم کے لحاظ سے مختلف ہوگا۔ آئیے اس بیان پر گہری نظر ڈالیں۔ آئیے پہلے حصے کے ساتھ شروع کریں: 'کئی اقسام کے ساتھ کام کرنے کی صلاحیت گویا وہ ایک ہی قسم کے ہوں'۔ مختلف اقسام ایک جیسی کیسے ہو سکتی ہیں؟ یہ تھوڑا سا عجیب لگتا ہے :/ حقیقت میں، یہ سب بہت آسان ہے۔ مثال کے طور پر، یہ صورت حال وراثت کے عام استعمال کے دوران پیدا ہوتی ہے۔ آئیے دیکھتے ہیں کہ یہ کیسے کام کرتا ہے۔ فرض کریں کہ ہمارے پاس ایک سادہ کیٹ پیرنٹ کلاس ہے جس میں سنگل رن () طریقہ ہے:

public class Cat {

   public void run() {
       System.out.println("Run!");
   }
}

اب ہم تین طبقے بنائیں گے جو بلی کے وارث ہیں : شیر ، شیر اور چیتا ۔

public class Lion extends Cat {

   @Override
   public void run() {
       System.out.println("Lion runs at 80 km/h");
   }
}

public class Tiger extends Cat {

   @Override
   public void run() {
       System.out.println("Tiger runs at 60 km/h");
   }
}

public class Cheetah extends Cat {

   @Override
   public void run() {
       System.out.println("Cheetah runs at up to 120 km/h");
   }
}

تو ہمارے پاس 3 کلاسز ہیں۔ آئیے اس صورت حال کا نمونہ بنائیں جہاں ہم ان کے ساتھ اس طرح کام کر سکیں جیسے وہ ایک ہی طبقے کے ہوں۔ تصور کریں کہ ہماری ایک بلی بیمار ہے اور اسے ڈاکٹر ڈولیٹل کی مدد کی ضرورت ہے۔ آئیے ایک Dolittle کلاس بنانے کی کوشش کریں جو شیروں، شیروں اور چیتاوں کو ٹھیک کر سکے۔

public class Dolittle {

   public void healLion(Lion lion) {

       System.out.println("Lion is healthy!");
   }

   public void healTiger(Tiger tiger) {

       System.out.println("Tiger is healthy!");
   }

   public void healCheetah(Cheetah cheetah) {

       System.out.println("Cheetah is healthy!");
   }
}

ایسا لگتا ہے کہ مسئلہ حل ہو گیا ہے: کلاس لکھی گئی ہے اور جانے کے لیے تیار ہے۔ لیکن اگر ہم اپنے پروگرام کو بڑھانا چاہتے ہیں تو ہم کیا کریں گے؟ ہمارے پاس فی الحال صرف 3 اقسام ہیں: شیر، شیر اور چیتا۔ لیکن دنیا میں بلیوں کی 40 سے زائد اقسام پائی جاتی ہیں۔ تصور کریں کہ کیا ہو گا اگر ہم مینولز، جیگوارز، مین کونز، گھریلو بلیوں اور باقی سب کے لیے الگ الگ کلاسیں شامل کر لیں۔ پروگرام بذات خود کام کرے گا، لیکن ہمیں ہر قسم کی بلی کو ٹھیک کرنے کے لیے ڈولیٹل کلاس میں مسلسل نئے طریقے شامل کرنے پڑتے ہیں۔ نتیجے کے طور پر، یہ بے مثال سائز میں بڑھ جائے گا. یہ وہ جگہ ہے جہاں پولیمورفزم - "کئی اقسام کے ساتھ کام کرنے کی صلاحیت جیسے کہ وہ ایک ہی قسم کے ہوں" - آتا ہے۔ ہمیں ایک ہی چیز کو کرنے کے لیے بے شمار طریقے بنانے کی ضرورت نہیں ہے - ایک بلی کو ٹھیک کرنا۔ ان سب کے لیے ایک طریقہ کافی ہے:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
   }
}

healCat () طریقہ شیر ، ٹائیگر ، اور چیتا اشیاء کو قبول کر سکتا ہے — وہ تمام مثالیں Cat ہیں :

public class Main {

   public static void main(String[] args) {

       Dolittle dolittle = new Dolittle();

       Lion simba = new Lion();
       Tiger shereKhan = new Tiger();
       Cheetah chester = new Cheetah();

       dolittle.healCat(simba);
       dolittle.healCat(shereKhan);
       dolittle.healCat(chester);
   }
}

کنسول آؤٹ پٹ: مریض صحت مند ہے! مریض صحت مند ہے! مریض صحت مند ہے! تو ہماری Dolittle کلاس مختلف اقسام کے ساتھ کام کرتی ہے جیسے کہ وہ ایک ہی قسم کے ہوں۔ اب دوسرے حصے سے نمٹتے ہیں: "مزید برآں، اشیاء کا طرز عمل ان کی قسم کے لحاظ سے مختلف ہوگا"۔ یہ سب بہت آسان ہے۔ فطرت میں، ہر بلی مختلف طریقے سے چلتی ہے. کم از کم، وہ مختلف رفتار سے چلتے ہیں. ہماری تین بلیوں میں، چیتا سب سے تیز ہے، جب کہ شیر اور شیر آہستہ دوڑتے ہیں۔ دوسرے لفظوں میں ان کا رویہ مختلف ہے۔ پولیمورفزم صرف اس سے زیادہ نہیں کرتا ہے کہ ہم مختلف اقسام کو بطور ایک استعمال کریں۔ یہ ہمیں ان کے اختلافات کو یاد رکھنے دیتا ہے، ان میں سے ہر ایک کے لیے مخصوص رویے کو محفوظ رکھتا ہے۔ مندرجہ ذیل مثال اس کی وضاحت کرتی ہے۔ فرض کریں کہ ہماری بلیوں نے، کامیاب صحت یابی کے بعد، تھوڑی دوڑ سے لطف اندوز ہونے کا فیصلہ کیا۔ ہم اسے اپنی Dolittle کلاس میں شامل کریں گے:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
       cat.run();
   }
}

آئیے تین جانوروں کے علاج کے لیے ایک ہی کوڈ کو چلانے کی کوشش کریں:

public static void main(String[] args) {

   Dolittle dolittle = new Dolittle();

   Lion simba = new Lion();
   Tiger shereKhan = new Tiger();
   Cheetah chester = new Cheetah();

   dolittle.healCat(simba);
   dolittle.healCat(shereKhan);
   dolittle.healCat(chester);
}

اور یہاں نتائج کی طرح نظر آتے ہیں: مریض صحت مند ہے! شیر 80 کلومیٹر فی گھنٹہ کی رفتار سے دوڑتا ہے۔ مریض صحت مند ہے! ٹائیگر 60 کلومیٹر فی گھنٹہ کی رفتار سے دوڑتا ہے۔ مریض صحت مند ہے! چیتا 120 کلومیٹر فی گھنٹہ کی رفتار سے دوڑتا ہے یہاں ہم واضح طور پر دیکھتے ہیں کہ اشیاء کے مخصوص رویے کو محفوظ رکھا گیا ہے، حالانکہ ہم نے تینوں جانوروں کو بلی کو 'عام کرنے' کے بعد اس طریقہ کار پر منتقل کر دیا ہے ۔ پولیمورفزم کی وجہ سے، جاوا کو اچھی طرح یاد ہے کہ یہ صرف کوئی تین بلیاں نہیں ہیں۔ وہ ایک شیر، ایک شیر اور ایک چیتا ہیں، جو ہر ایک مختلف طریقے سے چلاتے ہیں۔ یہ پولیمورفزم کے بنیادی فائدے کی وضاحت کرتا ہے: لچک۔ جب ہمیں بہت سی اقسام کے اشتراک کردہ کچھ فعالیت کو نافذ کرنے کی ضرورت ہوتی ہے، تو شیر، شیر اور چیتا صرف 'بلیاں' بن جاتے ہیں۔ تمام جانور مختلف ہوتے ہیں، لیکن کچھ حالات میں بلی بلی ہوتی ہے، قطع نظر اس کی نسل کچھ بھی ہو :) یہاں آپ کے لیے کچھ ویڈیو تصدیق ہے۔ جب یہ 'جنرلائزیشن' ناپسندیدہ ہوتی ہے اور ہمیں اس کے بجائے ہر نوع کو مختلف طریقے سے برتاؤ کرنے کی ضرورت ہوتی ہے، تو ہر قسم اپنا کام کرتی ہے۔ پولیمورفزم کی بدولت، آپ کلاسوں کی ایک وسیع رینج کے لیے ایک ہی انٹرفیس (طریقوں کا سیٹ) بنا سکتے ہیں۔ یہ پروگراموں کو کم پیچیدہ بناتا ہے۔ یہاں تک کہ اگر ہم 40 قسم کی بلیوں کو سپورٹ کرنے کے لیے پروگرام کو بڑھاتے ہیں، تب بھی ہمارے پاس سب سے آسان انٹرفیس ہوگا: تمام 40 بلیوں کے لیے ایک ہی رن() طریقہ۔