جاوا ڈویلپر کی پوزیشن کے لیے نوکری کے انٹرویو سے سوالات اور جوابات تلاش کرنا۔ حصہ 1

ہائے! CodeGym نے لوگوں کے متنوع گروپ کو اکٹھا کیا ہے۔ ہم میں سے کچھ جاوا ڈویلپر بننے کے علاوہ کچھ نہیں چاہتے ہیں، اور ہم ترقی میں بہت زیادہ وقت اور محنت لگا رہے ہیں۔ دوسرے پہلے ہی جاوا ڈویلپر ہیں۔ دونوں صورتوں میں، آپ کو تکنیکی انٹرویوز میں ٹیسٹ کیے جانے کے لیے تیار رہنے کی ضرورت ہے۔ یہ آسان نہیں ہیں۔ انہیں جذباتی اور تکنیکی تیاری دونوں کی ضرورت ہوتی ہے۔ میں نے حال ہی میں جاوا ڈویلپر کی پوزیشنوں کے لیے انٹرویو کے سوالات کی چند بڑی فہرستوں کو دیکھا۔ سوالات کو مختلف سطحوں میں تقسیم کیا گیا ہے: جونیئر، درمیانی سطح، اور سینئر۔ گھبرائیں نہیں: تمام سوالات آسان نہیں ہیں، لیکن ستارے والے سوالات شاذ و نادر ہی پوچھے جاتے ہیں۔ سوالات اچھے ہیں، اور میں ان میں سے اکثر کا جواب دینے کی کوشش کرنا چاہوں گا۔ واضح طور پر، یہ سب ایک مضمون میں فٹ نہیں ہوگا۔ سب کے بعد، وہاں بہت سارے سوالات ہیں. اس کا مطلب ہے کہ انٹرویو کے ان سوالات کے جوابات کے ساتھ مضامین کی ایک پوری سیریز ہوگی۔ میں فوراً چند نکات پر زور دیتا ہوں: جوابات مختصر ہوں گے، کیونکہ بہت تفصیل سے لکھے گئے جوابات الگ مضمون میں نکالے جا سکتے ہیں۔ اس کے علاوہ، انٹرویوز میں انتہائی تفصیلی اور بڑے جوابات کی ضرورت نہیں ہوتی ہے، کیونکہ آپ کے انٹرویو لینے والے کے پاس ضروری موضوعات پر آپ کا انٹرویو کرنے کے لیے صرف ایک گھنٹہ ہوتا ہے (اور جیسا کہ آپ کو یاد ہوگا، ان میں سے بہت سارے ہیں)۔

جونیئر ڈویلپر پوزیشن کے لیے سوال و جواب

عام سوالات

1. آپ کون سے ڈیزائن پیٹرن جانتے ہیں؟ ہمیں دو ڈیزائن پیٹرن کے بارے میں بتائیں جو آپ نے اپنے کام میں استعمال کیے ہیں۔

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

• بلڈر — اکثر استعمال ہونے والا ٹیمپلیٹ، آبجیکٹ کی تخلیق کے لیے کلاسک اپروچ کا متبادل؛
• حکمت عملی - ایک ایسا نمونہ جو بنیادی طور پر پولیمورفزم کی نمائندگی کرتا ہے۔ یعنی، ہمارے پاس ایک انٹرفیس ہے، لیکن پروگرام کا رویہ فنکشن میں پاس کیے گئے مخصوص انٹرفیس کے نفاذ پر منحصر ہوتا ہے (حکمت عملی کا نمونہ اب جاوا ایپلی کیشنز میں تقریباً ہر جگہ استعمال ہوتا ہے)۔

اگر یہ آپ کے لیے کافی نہیں ہے تو، بہار پر توجہ دیں (اگر آپ پہلے سے ہی اس سے واقف ہیں)، کیونکہ یہ فریم ورک کا ایک پورا پلیٹ فارم ہے، جو بدلے میں، شروع سے آخر تک نمونوں سے بھرا ہوا ہے۔ میں جس کے بارے میں بات کر رہا ہوں اس کی چند مثالیں یہ ہیں:

• فیکٹری — یہ نمونہ ApplicationContext (یا BeanFactory میں) میں پایا جا سکتا ہے؛
• سنگلٹن - تمام پھلیاں بطور ڈیفالٹ سنگل ٹن ہوتی ہیں۔
• پراکسی — بنیادی طور پر، بہار میں ہر چیز اس پیٹرن کو کسی نہ کسی طریقے سے استعمال کرتی ہے، مثال کے طور پر، AOP؛
• ذمہ داری کا سلسلہ - ایک ایسا نمونہ جو بہار کی حفاظت کو تقویت دیتا ہے۔
• سانچہ — بہار JDBC میں استعمال کیا جاتا ہے۔

جاوا کور

2. جاوا میں ڈیٹا کی کونسی قسمیں ہیں؟

جاوا میں درج ذیل قدیم ڈیٹا کی اقسام ہیں:

• بائٹ - -128 سے 127 تک کے عدد، 1 بائٹ لیتا ہے۔
• مختصر — -32768 سے 32767 تک کے عدد، 2 بائٹس لیتا ہے۔
• int — -2147483648 سے لے کر 2147483647 تک کے عدد، 4 بائٹس لیتا ہے۔
• طویل — 9223372036854775808 سے لے کر 9223372036854775807 تک کے عدد 8 بائٹس لیتے ہیں۔
• فلوٹ — فلوٹنگ پوائنٹ نمبر -3.4E+38 سے 3.4E+38 تک، 4 بائٹس لیتا ہے۔
• ڈبل — فلوٹنگ پوائنٹ نمبر -1.7E+308 سے 1.7E+308 تک، 8 بائٹس لیتا ہے۔
• char — UTF-16 میں واحد حروف، 2 بائٹس لیتا ہے۔
• بولین صحیح/غلط اقدار، 1 بائٹ لیتا ہے۔

اور حوالہ جات کی قسمیں ہیں جو ڈھیر پر موجود اشیاء کی طرف اشارہ کرتی ہیں۔

3. ایک آبجیکٹ قدیم ڈیٹا کی اقسام سے کیسے مختلف ہے؟

پہلا فرق میموری کی مقدار کا ہے: قدیم چیزیں بہت کم لیتی ہیں کیونکہ ان میں صرف ان کی اپنی قدر ہوتی ہے، لیکن اشیاء میں بہت سی مختلف قدریں شامل ہو سکتی ہیں — دونوں قدیم اور دوسری اشیاء کے حوالے۔ دوسرا فرق یہ ہے: جاوا ایک آبجیکٹ پر مبنی زبان ہے، لہذا جاوا میں کام کرنے والی ہر چیز اشیاء کے درمیان تعامل ہے۔ قدیم یہاں بہت اچھی طرح سے فٹ نہیں ہوتے ہیں۔ درحقیقت، اسی لیے جاوا 100% آبجیکٹ پر مبنی زبان نہیں ہے۔ تیسرا فرق، جو دوسرے سے آتا ہے وہ یہ ہے کہ چونکہ جاوا آبجیکٹ کے تعاملات پر مرکوز ہے، اس لیے اشیاء کے انتظام کے لیے بہت سے مختلف میکانزم موجود ہیں۔ مثال کے طور پر، کنسٹرکٹرز، طریقے، مستثنیات (جو بنیادی طور پر اشیاء کے ساتھ کام کرتے ہیں) وغیرہ۔ اور اس آبجیکٹ پر مبنی ماحول میں کسی نہ کسی طرح پرائمیٹو کو کام کرنے کی اجازت دینے کے لیے، جاوا کے تخلیق کار قدیم اقسام کے لیے ریپرز لے کر آئے ( انٹیجر ، کریکٹر ، ڈبل ، بولین ...)

4. حوالہ اور قدر کے لحاظ سے دلائل پاس کرنے میں کیا فرق ہے؟

پرائمیٹو فیلڈز اپنی ویلیو محفوظ کرتے ہیں: مثال کے طور پر، اگر ہم int i = 9 سیٹ کریں؛ پھر i فیلڈ ویلیو 9 کو اسٹور کرتا ہے۔ جب ہمارے پاس کسی چیز کا حوالہ ہوتا ہے، اس کا مطلب ہے کہ ہمارے پاس آبجیکٹ کے حوالے سے ایک فیلڈ ہے۔ دوسرے الفاظ میں، ہمارے پاس ایک فیلڈ ہے جو میموری میں آبجیکٹ کا پتہ محفوظ کرتا ہے۔

Cat cat = new Cat();

اس کا مطلب یہ ہے کہ کسی شے کے حوالے سے فیلڈز بھی اقدار کو ذخیرہ کرتی ہیں ۔ ان کی اقدار میموری ایڈریس ہیں۔ یعنی کیٹ نئے Cat() آبجیکٹ کا میموری ایڈریس اسٹور کرتی ہے ۔ جب ہم کسی طریقہ کو دلیل دیتے ہیں، تو اس کی قدر کاپی ہو جاتی ہے۔ قدیم کی صورت میں، قدیم کی قدر نقل کی جاتی ہے۔ اس کے مطابق، طریقہ نقل کے ساتھ کام کرتا ہے. جب کاپی کو تبدیل کیا جاتا ہے، تو اصل متاثر نہیں ہوتا ہے۔ حوالہ کی قسم کی صورت میں، میموری ایڈریس کی قدر کاپی کی جاتی ہے۔ اس کے مطابق، دونوں حوالہ متغیر ایک ہی آبجیکٹ کی طرف اشارہ کرنے والے پتوں کو محفوظ کریں گے۔ اور اگر ہم اس نئے حوالہ کو آبجیکٹ کو تبدیل کرنے کے لیے استعمال کریں تو ہمیں معلوم ہوگا کہ یہ پرانے حوالے کے لیے بھی تبدیل کیا گیا ہے۔ سب کے بعد، وہ دونوں ایک ہی اعتراض کی طرف اشارہ کرتے ہیں.

5. JVM، JDK، اور JRE کیا ہے؟

جے وی ایم کا مطلب ہے جاوا ورچوئل مشین ، جو کمپائلر کے ذریعہ پہلے سے تیار کردہ جاوا بائیک کوڈ چلاتی ہے۔ JRE کا مطلب Java Runtime Environment ہے ۔ بنیادی طور پر، یہ جاوا ایپلی کیشنز کو چلانے کا ماحول ہے۔ اس میں JVM، معیاری لائبریریاں، اور جاوا پروگرامنگ زبان میں لکھے گئے ایپلٹس اور ایپلیکیشنز کو چلانے کے لیے دیگر اجزاء شامل ہیں۔ دوسرے الفاظ میں، JRE ہر چیز کا ایک پیکج ہے جو ایک مرتب کردہ جاوا پروگرام کو چلانے کے لیے درکار ہے، لیکن اس میں ٹولز اور یوٹیلیٹیز شامل نہیں ہیں جیسے کمپائلرز یا ڈیبگرز ایپلی کیشنز تیار کرنے کے لیے۔ JDK کا مطلب جاوا ڈویلپمنٹ کٹ ہے، جو JRE کی توسیع ہے ۔ یعنی یہ نہ صرف جاوا ایپلی کیشنز کو چلانے کے لیے بلکہ ان کو تیار کرنے کے لیے بھی ایک ماحول ہے۔ JDK JRE میں موجود ہر چیز پر مشتمل ہے، نیز مختلف اضافی ٹولز — کمپائلرز اور ڈیبگرز — جاوا ایپلی کیشنز بنانے کے لیے درکار ہیں (بشمول جاوا دستاویزات)۔

6. JVM کیوں استعمال کریں؟

جیسا کہ اوپر بتایا گیا ہے، جاوا ورچوئل مشین ایک ورچوئل مشین ہے جو جاوا بائیک کوڈ چلاتی ہے جو کمپائلر کے ذریعہ پہلے سے تیار کی گئی ہے۔ اس کا مطلب ہے کہ JVM جاوا سورس کوڈ کو نہیں سمجھتا ہے۔ تو، پہلے، ہم .java فائلیں مرتب کرتے ہیں۔ مرتب کی گئی فائلوں میں .class کی توسیع ہے اور اب یہ بائیک کوڈ کی شکل میں ہیں، جسے JVM سمجھتا ہے۔ JVM ہر OS کے لیے مختلف ہے۔ جب JVM بائیک کوڈ فائلوں کو چلاتا ہے، تو یہ انہیں اس OS کے لیے ڈھال لیتا ہے جس پر یہ چل رہا ہے۔ درحقیقت، چونکہ مختلف JVMs ہیں، JDK (یا JRE) بھی مختلف OS کے لیے مختلف ہوتے ہیں (ہر ورژن کو اپنی JVM کی ضرورت ہوتی ہے)۔ آئیے یاد رکھیں کہ دیگر پروگرامنگ زبانوں میں ترقی کیسے کام کرتی ہے۔ آپ ایک پروگرام لکھتے ہیں، پھر اس کا کوڈ ایک مخصوص OS کے لیے مشین کوڈ میں مرتب کیا جاتا ہے، اور پھر آپ اسے چلا سکتے ہیں۔ دوسرے الفاظ میں، آپ کو ہر پلیٹ فارم کے لیے پروگرام کے مختلف ورژن لکھنے کی ضرورت ہے۔ لیکن جاوا کی کوڈ کی ڈبل پروسیسنگ (بائٹ کوڈ میں سورس کوڈ کی تالیف، اور پھر JVM کے ذریعے بائیک کوڈ کی پروسیسنگ) آپ کو کراس پلیٹ فارم حل کے فوائد سے لطف اندوز کرنے دیتی ہے۔ ہم ایک بار کوڈ بناتے ہیں اور اسے بائی کوڈ میں مرتب کرتے ہیں۔ پھر ہم اسے کسی بھی OS پر لے جا سکتے ہیں، اور مقامی JVM اسے چلانے کے قابل ہے۔ اور یہ بالکل جاوا کی افسانوی تحریر ایک بار، کہیں بھی چلائیں خصوصیت ہے۔

7. بائیک کوڈ کیا ہے؟

جیسا کہ میں نے اوپر کہا، کمپائلر جاوا کوڈ کو انٹرمیڈیٹ بائیک کوڈ میں تبدیل کرتا ہے (ہم .java ایکسٹینشن والی فائلوں سے کلاس ایکسٹینشن والی فائلوں میں جاتے ہیں)۔ بہت سے طریقوں سے، بائی کوڈ مشین کوڈ سے ملتا جلتا ہے، سوائے اس کے کہ اس کا انسٹرکشن سیٹ اصلی پروسیسر کے لیے نہیں ہے، بلکہ ایک ورچوئل ہے۔ اس نے کہا، اس میں جے آئی ٹی کمپائلر کے لیے ڈیزائن کیے گئے حصے شامل ہو سکتے ہیں، جو اصل پروسیسر کے لیے کمانڈ پر عمل درآمد کو بہتر بناتا ہے جس پر پروگرام چل رہا ہے۔ جے آئی ٹی کمپلیشن، جسے آن دی فلائی کمپلیشن بھی کہا جاتا ہے، ایک ایسی ٹیکنالوجی ہے جو بائٹ کوڈ کو مشین کوڈ یا کسی اور فارمیٹ میں مرتب کرکے پروگرام کے چلتے وقت بائٹ کوڈ پروگرام کی کارکردگی کو بڑھاتی ہے۔ جیسا کہ آپ نے اندازہ لگایا ہوگا، JVM JIT کمپائلر استعمال کرتا ہے جب یہ بائیک کوڈ چلاتا ہے۔ آئیے کچھ نمونے بائی کوڈ پر ایک نظر ڈالتے ہیں: زیادہ پڑھنے کے قابل نہیں، ہے؟ اچھی خبر یہ ہے کہ یہ ہدایت ہمارے لیے نہیں ہے۔ یہ JVM کے لیے ہے۔

8. جاوا بین کی خصوصیات کیا ہیں؟

JavaBean ایک جاوا کلاس ہے جو کچھ اصولوں پر عمل کرتی ہے۔ JavaBean لکھنے کے کچھ اصول یہ ہیں :

1. کلاس میں پبلک ایکسیس موڈیفائر کے ساتھ ایک خالی (بغیر دلیل) کنسٹرکٹر کا ہونا ضروری ہے۔ یہ کنسٹرکٹر بغیر کسی غیر ضروری مسائل کے کلاس کا ایک آبجیکٹ بنانا ممکن بناتا ہے (تاکہ دلائل کے ساتھ کوئی غیر ضروری ہلچل نہ ہو)۔

2. داخلی فیلڈز تک رسائی حاصل اور سیٹ مثال کے طریقوں کے ذریعے کی جاتی ہے، جس کا معیاری نفاذ ہونا چاہیے۔ مثال کے طور پر، اگر ہمارے پاس نام کی فیلڈ ہے، تو ہمارے پاس getName اور setName وغیرہ ہونا چاہیے ۔ یہ مختلف ٹولز (فریم ورک) کو بغیر کسی دشواری کے بینز کے مواد کو خود بخود حاصل کرنے اور سیٹ کرنے کی اجازت دیتا ہے۔

3. کلاس کو equals() ، hashCode() ، اور toString() طریقوں کو اوور رائیڈ کرنا چاہیے۔

4. کلاس کو سلسلہ وار ہونا چاہیے۔ یعنی، اس میں سیریلائز ایبل مارکر انٹرفیس ہونا چاہیے یا Externalizable انٹرفیس کو لاگو کرنا چاہیے۔ یہ اس لیے ہے تاکہ بین کی حالت کو قابل اعتماد طریقے سے محفوظ، ذخیرہ اور بحال کیا جا سکے۔

9. OutOfMemoryError کیا ہے؟

OutOfMemoryError جاوا ورچوئل مشین (JVM) سے متعلق رن ٹائم کی ایک اہم غلطی ہے۔ یہ خرابی اس وقت ہوتی ہے جب JVM کسی چیز کو مختص نہیں کرسکتا کیونکہ اس کے لیے کافی میموری نہیں ہے، اور کوڑا اٹھانے والا زیادہ میموری مختص نہیں کرسکتا ہے۔ OutOfMemoryError کی چند اقسام :

• آؤٹ آف میموری ایرر: جاوا ہیپ اسپیس — ناکافی میموری کی وجہ سے جاوا ہیپ پر آبجیکٹ کو مختص نہیں کیا جاسکتا۔ یہ خرابی میموری لیک ہونے کی وجہ سے ہو سکتی ہے یا پہلے سے طے شدہ ہیپ سائز کی وجہ سے ہو سکتی ہے جو موجودہ ایپلیکیشن کے لیے بہت چھوٹا ہے۔

• آؤٹ آف میموری ایرر: جی سی اوور ہیڈ کی حد سے تجاوز کر گیا — کیونکہ ایپلی کیشن کا ڈیٹا بمشکل ہی ڈھیر میں فٹ بیٹھتا ہے، کوڑا اٹھانے والا ہر وقت چلتا ہے، جس کی وجہ سے جاوا پروگرام بہت آہستہ چلتا ہے۔ نتیجے کے طور پر، کوڑا اٹھانے والے اوور ہیڈ کی حد سے تجاوز کر گئی ہے اور اس خرابی کے ساتھ ایپلیکیشن کریش ہو جاتی ہے۔

• OutOfMemoryError: درخواست کردہ سرنی کا سائز VM کی حد سے زیادہ ہے — اس سے ظاہر ہوتا ہے کہ ایپلیکیشن نے ہیپ سائز سے زیادہ ہونے والی صف کے لیے میموری مختص کرنے کی کوشش کی۔ ایک بار پھر، اس کا مطلب یہ ہو سکتا ہے کہ پہلے سے طے شدہ طور پر ناکافی میموری مختص کی گئی تھی۔

• OutOfMemoryError: Metaspace — ہیپ میٹا ڈیٹا کے لیے مختص جگہ سے باہر ہو گیا (میٹا ڈیٹا کلاسز اور طریقوں کے لیے ہدایات ہیں)۔

• OutOfMemoryError: وجہ سے سائز بائٹس کی درخواست کریں۔ سویپ کی جگہ سے باہر — ہیپ سے میموری کو مختص کرنے کی کوشش کرتے وقت کچھ خرابی واقع ہوئی، اور نتیجے کے طور پر، ہیپ میں کافی جگہ نہیں ہے۔

10. اسٹیک ٹریس کیا ہے؟ میں اسے کیسے حاصل کروں؟

اسٹیک ٹریس ان کلاسز اور طریقوں کی فہرست ہے جو کسی ایپلیکیشن کے عمل میں اس وقت تک طلب کیے گئے ہیں۔ آپ یہ کر کے ایپلیکیشن میں کسی خاص مقام پر اسٹیک ٹریس حاصل کر سکتے ہیں:

StackTraceElement[] stackTraceElements =Thread.currentThread().getStackTrace();

اس سے ہمیں Last In First Out (LIFO) آرڈر میں ترتیب دیئے گئے StackTraceElements کی ایک صف ملتی ہے ۔ جاوا میں، جب لوگ اسٹیک ٹریس کے بارے میں بات کرتے ہیں، تو ان کا مطلب عام طور پر کنسول پر ظاہر ہونے والے اسٹیک ٹریس سے ہوتا ہے جب کوئی غلطی (یا استثناء) ہوتی ہے۔ آپ اس طرح کے مستثنیات سے اسٹیک ٹریس حاصل کرسکتے ہیں:

StackTraceElement[] stackTraceElements;
try{
                ...
} catch (Exception e) {
   stackTraceElements = e.getStackTrace();
}

اور اگر ہم کنسول پر ایک استثناء کے اسٹیک ٹریس کو ظاہر کرنا چاہتے ہیں:

try{
                ...
} catch (Exception e) {
  e.printStackTrace();
}

مزید برآں، اگر کوئی خرابی، غیر چیک شدہ استثناء، یا بغیر ہینڈل شدہ چیک شدہ استثناء واقع ہوتا ہے، تو ہمیں ایپلیکیشن کے کریش ہونے پر کنسول پر استثنیٰ کا اسٹیک ٹریس خود بخود مل جاتا ہے۔ یہاں کنسول پر اسٹیک ٹریس کی ایک چھوٹی سی مثال ہے: اور اس نوٹ پر، ہم آج اس موضوع پر اپنی بحث کو ختم کریں گے۔