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

سب کو ہیلو، خواتین و حضرات، سافٹ ویئر انجینئرز! آئیے انٹرویو کے سوالات کے بارے میں بات کرتے ہیں۔ آپ کو کس چیز کی تیاری کرنی ہے اور آپ کو کیا جاننے کی ضرورت ہے۔ پہلی بار ان نکات کا جائزہ لینے یا ان کا مطالعہ کرنے کا یہ بہترین وقت ہے۔ میں نے OOP، جاوا نحو، جاوا استثناء، مجموعہ، اور ملٹی تھریڈنگ کے بارے میں اکثر پوچھے گئے سوالات کے ایک وسیع مجموعے کے ساتھ ختم کیا، جسے میں سہولت کے لیے کئی حصوں میں تقسیم کروں گا۔ ایک ساتھ ہر چیز کا احاطہ کرنا مشکل ہے، لیکن مجھے امید ہے کہ یہ مواد ان لوگوں کے لیے ایک اچھی بنیاد فراہم کرے گا جو بطور پروگرامر اپنی پہلی نوکری تلاش کرنے کی تیاری کر رہے ہیں۔ بہترین تفہیم اور برقرار رکھنے کے لیے، میں دوسرے ذرائع سے بھی کنگھی کرنے کا مشورہ دیتا ہوں۔ آپ کئی مختلف زاویوں سے کسی تصور تک پہنچ کر اس کی گہری گرفت حاصل کر سکتے ہیں۔ اہم:ہم صرف ورژن 8 سے پہلے جاوا کے بارے میں بات کریں گے۔ 9، 10، 11، 12، اور 13 کے ورژن میں آنے والی تمام اختراعات پر یہاں غور نہیں کیا جائے گا۔ جوابات کو بہتر بنانے کے طریقے کے بارے میں کوئی بھی خیالات/تبصرے خوش آئند ہیں ۔ اپنے پڑھنے سے لطف اٹھائیں۔ چلو!

جاوا انٹرویو: OOP کے بارے میں سوالات

1. جاوا کی خصوصیات کیا ہیں؟

جواب:

1. OOP تصورات:

   1. آبجیکٹ واقفیت
   2. وراثت
   3. encapsulation
   4. پولیمورفزم
   5. تجری

2. کراس پلیٹ فارم: جاوا پروگرام کسی بھی پلیٹ فارم پر بغیر کسی تبدیلی کے چلایا جا سکتا ہے۔ بلاشبہ، اس کے لیے انسٹال کردہ JVM (جاوا ورچوئل مشین) کی ضرورت ہے۔

3. اعلی کارکردگی: جسٹ ان ٹائم (جے آئی ٹی) کمپائلر اعلی کارکردگی کو ممکن بناتا ہے۔ جے آئی ٹی کمپائلر بائیک کوڈ کو مشین کوڈ میں تبدیل کرتا ہے اور پھر JVM عملدرآمد شروع کرتا ہے۔

4. ملٹی تھریڈنگ: JVM عملدرآمد کا ایک دھاگہ بناتا ہے جسے main thread. ایک پروگرامر تھریڈ کلاس سے اخذ کرکے یا Runnableانٹرفیس کو لاگو کرکے متعدد تھریڈز بنا سکتا ہے۔

2. وراثت کیا ہے؟

وراثت کا مطلب یہ ہے کہ ایک کلاس دوسری کلاس کو وراثت میں لے سکتی ہے ( ایکسٹینڈ کی ورڈ کا استعمال کرتے ہوئے)۔ اس کا مطلب ہے کہ آپ اس کلاس سے کوڈ دوبارہ استعمال کر سکتے ہیں جسے آپ وراثت میں حاصل کرتے ہیں۔ موجودہ کلاس کو کے نام سے جانا جاتا ہے superclassاور نئی تخلیق شدہ کلاس ہے subclass۔ لوگ یہ بھی کہتے ہیں کہ اصطلاحات والدین اور استعمال کریں child۔

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

کہاں Animalہے parentاور Dogکہاں ہے child؟

3. encapsulation کیا ہے؟

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

4. پولیمورفزم کیا ہے؟

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

List<Animal> animals = Arrays.asList(new Cat(), new Dog(), new Cat());
animals.forEach(animal -> animal.makeSound());

دوسرے لفظوں میں، پولیمورفزم مددگار ہے۔ اور یہ پولیمورفک (اوور لوڈڈ) طریقوں پر بھی لاگو ہوتا ہے۔ پولیمورفزم کا استعمال کیسے کریں۔

جاوا نحو کے بارے میں انٹرویو کے سوالات

5. جاوا میں کنسٹرکٹر کیا ہے؟

تعمیر کنندگان میں درج ذیل خصوصیات ہیں:

1. جب کوئی نیا آبجیکٹ بنایا جاتا ہے، تو پروگرام اسے بنانے کے لیے مناسب کنسٹرکٹر کا استعمال کرتا ہے۔
2. کنسٹرکٹر ایک طریقہ کی طرح ہے۔ اس کی مخصوص خصوصیات اس حقیقت میں مضمر ہیں کہ واپسی کی کوئی قیمت نہیں ہے (بشمول باطل) اور یہ کہ اس کا نام کلاس کے نام جیسا ہی ہے۔
3. اگر کوئی کنسٹرکٹر واضح طور پر نہیں بنایا گیا ہے تو، ایک خالی کنسٹرکٹر خود بخود بن جاتا ہے۔
4. کنسٹرکٹر کو اوور رائڈ کیا جا سکتا ہے۔
5. اگر آپ پیرامیٹرز کے ساتھ کنسٹرکٹر کا اعلان کرتے ہیں لیکن پیرامیٹر کے بغیر بھی ایک کی ضرورت ہے، تو آپ کو اسے الگ سے بنانا ہوگا، کیونکہ یہ خود بخود نہیں بنے گا۔

6. کون سی دو کلاسیں آبجیکٹ کے وارث نہیں ہیں؟

چال والے سوالات سے بیوقوف نہ بنیں — ایسی کوئی کلاسیں نہیں ہیں۔ تمام کلاسز آبجیکٹ کلاس کو براہ راست یا باپ دادا کے ذریعے وراثت میں حاصل کرتے ہیں!

7. مقامی متغیر کیا ہے؟

یہ جاوا ڈویلپرز کے لیے انٹرویو کا ایک اور مقبول سوال ہے۔ ایک مقامی متغیر ایک متغیر ہے جو ایک طریقہ کے اندر بیان کیا جاتا ہے اور اس وقت تک موجود رہتا ہے جب تک کہ طریقہ کار پر عمل درآمد کیا جا رہا ہو۔ جیسے ہی عملدرآمد ختم ہوتا ہے، مقامی متغیر کا وجود ختم ہو جاتا ہے۔ یہ ایک پروگرام ہے جو مین() طریقہ میں ہیلو میسج نامی مقامی متغیر کا استعمال کرتا ہے۔

public static void main(String[] args) {
   String helloMessage;
   helloMessage = "Hello, World!";
   System.out.println(helloMessage);
}

8. ایک مثال متغیر کیا ہے؟

ایک مثال متغیر ایک متغیر ہے جو کلاس کے اندر اعلان کیا جاتا ہے. یہ اس وقت تک موجود ہے جب تک کوئی چیز موجود ہے۔ مثال کے طور پر، ہمارے پاس ایک Bee کلاس ہے، جس میں دو مثالی متغیر ہیں - نیکٹر لوڈ اور میکس نیکٹر لوڈ:

public class Bee {

   /**
    * Current nectar load
    */
   private double nectarLoad;

   /**
    * Maximum nectar that can the bee can collect.
    */
   private double maxNectarLoad = 20.0;
 
  ...
}

9. رسائی میں ترمیم کرنے والے کیا ہیں؟

رسائی میں ترمیم کرنے والے کلاسز، طریقوں اور متغیرات تک رسائی کو حسب ضرورت بنانے کا طریقہ کار ہیں۔ درج ذیل ترمیم کار موجود ہیں، جو رسائی بڑھانے کے لیے درج ہیں:

1. private- یہ رسائی موڈیفائر طریقوں، فیلڈز اور کنسٹرکٹرز پر استعمال ہوتا ہے۔ رسائی اس کلاس تک محدود ہے جس میں ان کا اعلان کیا گیا ہے۔
2. package-private (default)— یہ کلاسز کے لیے پہلے سے طے شدہ رسائی کی سطح ہے۔ رسائی مخصوص پیکیج تک محدود ہے جس میں کلاس، طریقہ، متغیر، یا کنسٹرکٹر کا اعلان کیا گیا ہے۔
3. protected- یہ رسائی موڈیفائر ایک ہی رسائی کی سطح پیش کرتا ہے جیسا کہ package-privateکلاسوں کے لیے رسائی کے اضافے کے ساتھ جو protectedترمیم کنندہ کے ساتھ ایک کلاس کو وراثت میں حاصل کرتی ہے۔
4. public- رسائی کی یہ سطح کلاسز کے لیے بھی استعمال ہوتی ہے۔ اس رسائی کی سطح کا مطلب ہے کہ پوری درخواست میں مکمل رسائی ہے۔

10. طریقہ اوور رائیڈنگ کیا ہے؟

جب چائلڈ کلاس اپنے پیرنٹ کلاس کے رویے کو تبدیل کرنا چاہتی ہے تو ہم طریقوں کو اوور رائیڈ کر دیتے ہیں۔ اگر ہمیں بھی وہی کرنا ہے جو والدین کے طریقہ کار میں ہے، تو ہم بچے میں super.methodName() استعمال کرسکتے ہیں، جو والدین کے طریقہ کار کو انجام دے گا۔ اس کے بعد ہم اپنی اضافی منطق شامل کر سکتے ہیں۔ تقاضے جن کا مشاہدہ کرنا ضروری ہے:

• طریقہ دستخط ایک جیسا ہونا چاہیے۔
• واپسی کی قیمت ایک جیسی ہونی چاہیے۔

11. طریقہ کار کے دستخط کیا ہیں؟

طریقہ کا دستخط طریقہ کے نام اور طریقہ کار کے دلائل کا مجموعہ ہے۔ طریقوں کو اوور لوڈ کرنے پر طریقہ دستخط ایک طریقہ کا منفرد شناخت کنندہ ہے۔

12. طریقہ اوورلوڈنگ کیا ہے؟

طریقہ اوورلوڈنگ پولیمورفزم کی ایک خصوصیت ہے جس میں ہم ایک ہی عمل کو انجام دینے والے متعدد طریقے بنانے کے لیے طریقہ کار کے دستخط کو تبدیل کرتے ہیں:

• ایک ہی نام
• مختلف دلائل
• واپسی کی مختلف اقسام ہو سکتی ہیں۔

مثال کے طور پر، ArrayListکلاس کا add()طریقہ اوورلوڈ کیا جا سکتا ہے، جو ہمیں ان پٹ آرگیومنٹس کے لحاظ سے مختلف طریقوں سے شامل کرنے کی اجازت دیتا ہے:

• add(Object o)- یہ طریقہ صرف ایک چیز کو جوڑتا ہے۔
• add(int index, Object o)- یہ طریقہ ایک مخصوص انڈیکس میں کسی چیز کو جوڑتا ہے۔
• add(Collection<Object> c)- یہ طریقہ اشیاء کی فہرست کا اضافہ کرتا ہے۔
• add(int index, Collection<Object> c)- یہ طریقہ ایک مخصوص انڈیکس سے شروع ہونے والی اشیاء کی فہرست کا اضافہ کرتا ہے۔

13. انٹرفیس کیا ہے؟

جاوا متعدد وراثت کی حمایت نہیں کرتا ہے۔ اس حد کو دور کرنے کے لیے، انٹرفیس کو اس شکل میں شامل کیا گیا جو ہم جانتے ہیں اور پسند کرتے ہیں؛) ایک طویل عرصے سے، انٹرفیس کے پاس بغیر کسی عمل کے صرف طریقے تھے۔ اس جواب کے تناظر میں آئیے ان کے بارے میں بات کرتے ہیں۔ مثال کے طور پر:

public interface Animal {
   void makeSound();
   void eat();
   void sleep();
}

اس سے کچھ تفصیلات درج ذیل ہیں:

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

اس طرح:

public class Cat implements Animal {
   public void makeSound() {
       // Method implementation
   }

   public void eat() {
       // Implementation
   }

   public void sleep() {
       // Implementation
   }
}

14. انٹرفیس میں ڈیفالٹ طریقہ کیا ہے؟

اب ہم پہلے سے طے شدہ طریقوں کے بارے میں بات کرتے ہیں۔ وہ کس لیے ہیں؟ وہ کس کے لیے ہیں؟ یہ طریقے "دونوں ہاتھوں" کی خدمت کے لیے شامل کیے گئے تھے۔ میں کس بارے میں بات کر رہا ہوں؟ ٹھیک ہے، ایک طرف، نئی فعالیت کو شامل کرنے کی ضرورت تھی: لیمبڈاس اور اسٹریم API۔ دوسری طرف، جاوا جس چیز کے لیے مشہور ہے اسے برقرار رکھنا ضروری تھا - پیچھے کی طرف مطابقت۔ ایسا کرنے کے لیے، انٹرفیس کو کچھ نئے ریڈی میڈ حل کی ضرورت تھی۔ اس طرح پہلے سے طے شدہ طریقے ہمارے پاس آئے۔ پہلے سے طے شدہ طریقہ ایک انٹرفیس میں لاگو کیا گیا طریقہ ہے، جسے defaultمطلوبہ الفاظ کے ساتھ نشان زد کیا گیا ہے۔ stream()مثال کے طور پر، انٹرفیس میں معروف طریقہ Collection. مجھ پر یقین کریں، یہ انٹرفیس اتنا آسان نہیں جتنا لگتا ہے۔ یا انٹرفیس میں بھی اتنا ہی مشہور forEach()طریقہ Iterable۔ یہ اس وقت تک موجود نہیں تھا جب تک کہ پہلے سے طے شدہ طریقے شامل نہ کیے جائیں۔ ویسے، آپ یہاں CodeGym پر بھی اس کے بارے میں پڑھ سکتے ہیں ۔

15. پھر ہم دو ایک جیسے پہلے سے طے شدہ طریقے کیسے حاصل کرتے ہیں؟

پہلے سے طے شدہ طریقہ کیا ہے اس کے بارے میں پچھلا جواب ایک اور سوال پیدا کرتا ہے۔ اگر آپ انٹرفیس میں طریقوں کو لاگو کرسکتے ہیں، تو نظریاتی طور پر آپ ایک ہی طریقہ کے ساتھ دو انٹرفیس کو نافذ کرسکتے ہیں۔ ہم ایسا کیسے کریں؟ یہاں ایک ہی طریقہ کے ساتھ دو مختلف انٹرفیس ہیں:

interface A {
   default void foo() {
       System.out.println("Foo A");
   }
}

interface B {
   default void foo() {
       System.out.println("Foo B");
   }
}

اور ہمارے پاس ایک کلاس ہے جو ان دو انٹرفیس کو نافذ کرتی ہے۔ لیکن ہم انٹرفیس A یا B میں ایک مخصوص طریقہ کا انتخاب کیسے کریں؟ مندرجہ ذیل خصوصی تعمیر اس کی اجازت دیتا ہے A.super.foo():

public class C implements A, B {
   public void fooA() {
       A.super.foo();
   }

   public void fooB() {
       B.super.foo();
   }
}

اس طرح، طریقہ انٹرفیس کا fooA()ڈیفالٹ طریقہ استعمال کرے گا ، جبکہ طریقہ انٹرفیس کا طریقہ استعمال کرے گا ۔ foo()AfooB()foo()B

16. تجریدی طریقے اور کلاسز کیا ہیں؟

جاوا میں، abstractایک محفوظ لفظ ہے۔ یہ تجریدی کلاسوں اور طریقوں کو ظاہر کرنے کے لیے استعمال ہوتا ہے۔ سب سے پہلے، ہمیں تعریف کی ضرورت ہے. ایک تجریدی طریقہ ایک ایسا طریقہ ہے جو abstractکلیدی لفظ کا استعمال کرتے ہوئے کسی خلاصہ کلاس میں نفاذ کے بغیر اعلان کیا جاتا ہے۔ یعنی، یہ ایک طریقہ ہے جیسا کہ ایک انٹرفیس میں ہے، لیکن مطلوبہ الفاظ کے اضافے کے ساتھ، مثال کے طور پر:

public abstract void foo();

ایک خلاصہ کلاس ایک کلاس ہے جسے abstractکلیدی لفظ کے ساتھ بھی نشان زد کیا گیا ہے:

public abstract class A {

}

خلاصہ کلاس میں کئی خصوصیات ہیں:

• آپ تجریدی کلاس کی کوئی چیز نہیں بنا سکتے
• اس میں تجریدی طریقے ہو سکتے ہیں۔
• اس میں تجریدی طریقے بھی نہیں ہوسکتے ہیں۔

تجرید کے لیے تجریدی کلاسز کی ضرورت ہوتی ہے (تعزیت کے لیے معذرت) جس میں عام طرز عمل اور حالتوں کا ایک مجموعہ ہوتا ہے (یعنی طریقے اور متغیرات)۔ حقیقی زندگی مثالوں سے بھری پڑی ہے۔ ہمارے آس پاس کی ہر چیز۔ "جانور"، "کار"، "جیومیٹرک فگر" وغیرہ۔

17. String، StringBuilder اور StringBuffer میں کیا فرق ہے؟

Stringاقدار ایک مستقل سٹرنگ پول میں محفوظ ہیں۔ جیسے ہی کوئی تار بنتا ہے، وہ اس پول میں ظاہر ہوتا ہے۔ اور آپ اسے حذف نہیں کر سکتے۔ مثال کے طور پر:

String name = "book";

متغیر مستقل سٹرنگ پول کی طرف اشارہ کرے گا نام کے متغیر کو مختلف قدر پر سیٹ کرنا، ہمارے پاس ہے:

name = "pen";

مستقل سٹرنگ پول اس طرح نظر آتا ہے: دوسرے لفظوں میں، دونوں قدریں وہیں رہتی ہیں۔ سٹرنگ بفر:

• Stringاقدار ایک اسٹیک میں محفوظ ہیں. اگر کسی قدر کو تبدیل کیا جاتا ہے، تو نئی قدر پرانی کی جگہ لے لے گی۔
• String Bufferمطابقت پذیر ہے اور اس وجہ سے تھریڈ محفوظ ہے۔
• دھاگے کی حفاظت کی وجہ سے اس کی کارکردگی خراب ہے۔

مثال:

StringBuffer name = “book”;

جیسے ہی نام کے متغیر کی قدر میں تبدیلی آتی ہے، اسٹیک میں قدر بدل جاتی ہے: StringBuilder بالکل اسی طرح ہے StringBuffer، صرف یہ تھریڈ محفوظ نہیں ہے۔ نتیجے کے طور پر، یہ نمایاں طور پر تیز ہے StringBuffer.

18. تجریدی کلاس اور انٹرفیس میں کیا فرق ہے؟

خلاصہ کلاس:

• خلاصہ کلاسوں میں ڈیفالٹ کنسٹرکٹر ہوتا ہے۔ جب بھی تجریدی طبقے کی اولاد پیدا ہوتی ہے اسے کہا جاتا ہے۔
• ان میں تجریدی طریقے اور غیر تجریدی دونوں شامل ہو سکتے ہیں۔ عام طور پر، ایک تجریدی کلاس میں تجریدی طریقوں کی ضرورت نہیں ہے۔
• ایک طبقہ جو تجریدی وراثت میں ملتا ہے اسے صرف تجریدی طریقوں کو لاگو کرنا چاہئے۔
• ایک تجریدی کلاس میں مثال کے متغیر ہوسکتے ہیں (سوال نمبر 5 دیکھیں)۔

انٹرفیس:

• انٹرفیس کا کوئی کنسٹرکٹر نہیں ہے اور اسے شروع نہیں کیا جا سکتا۔
• صرف تجریدی طریقے شامل کیے جا سکتے ہیں (سوائے طے شدہ طریقوں کے)۔
• انٹرفیس کو نافذ کرنے والی کلاسوں کو تمام طریقوں کو لاگو کرنا چاہیے (سوائے ڈیفالٹ طریقوں کے)۔
• انٹرفیس میں صرف مستقل ہو سکتے ہیں۔

19. ایک صف O(1) میں کسی عنصر تک رسائی کیوں ہے؟

یہ سوال میرے آخری انٹرویو میں لفظی طور پر پوچھا گیا تھا۔ جیسا کہ میں نے بعد میں سیکھا، اس سوال کا مقصد یہ دیکھنا ہے کہ انسان کیسا سوچتا ہے۔ واضح طور پر، اس علم میں بہت کم عملی قدر ہے۔ صرف جاننا ہی کافی ہے۔ سب سے پہلے، ہمیں یہ واضح کرنے کی ضرورت ہے کہ O(1) ایک "مستقل وقت" الگورتھم کی وقتی پیچیدگی کے لیے اشارہ ہے۔ دوسرے لفظوں میں، یہ عہدہ سب سے تیزی سے عملدرآمد کے وقت کی نشاندہی کرتا ہے۔ اس سوال کا جواب دینے کے لیے، ہمیں اس بات پر غور کرنے کی ضرورت ہے کہ ہم صفوں کے بارے میں کیا جانتے ہیں۔ ایک intصف بنانے کے لیے، ہمیں درج ذیل لکھنا چاہیے:

int[] intArray = new int[100];

اس ترکیب سے کئی نتائج اخذ کیے جا سکتے ہیں:

1. جب ایک صف کا اعلان کیا جاتا ہے، تو اس کی قسم معلوم ہوتی ہے۔ اگر قسم معلوم ہے، تو صف میں ہر سیل کا سائز معلوم ہوتا ہے۔
2. پوری صف کا سائز معلوم ہے۔

اس لیے یہ معلوم ہوتا ہے کہ کس سیل کو لکھنا ہے، ہمیں صرف حساب لگانا ہوگا کہ میموری کے کس حصے کو لکھنا ہے۔ ایک کمپیوٹر کے لئے، یہ آسان peasy ہے. کمپیوٹر جانتا ہے کہ مختص میموری کہاں سے شروع ہوتی ہے، عناصر کی تعداد، اور ہر سیل کا سائز۔ اس سب کا مطلب یہ ہے کہ لکھنے کی جگہ ارے کے شروع ہونے والی جگہ کے برابر ہوگی + ہر سیل کے سائز کو انڈیکس سے ضرب۔

تو ایک ArrayList میں اشیاء تک رسائی حاصل کرتے وقت ہم O(1) پر کیسے پہنچیں گے؟

یہ سوال فوری طور پر پچھلے ایک کی پیروی کرتا ہے۔ سچ تو یہ ہے کہ جب ایک ایسی صف کے ساتھ کام کر رہے ہو جس میں پرائمیٹو ہو، ہم پہلے سے جانتے ہیں (تخلیق کے وقت) عنصر کی قسم کا سائز۔ لیکن ہم کیا کریں اگر ہمارے پاس اس طرح کی وراثت کا درجہ بندی ہے اور ہم قسم A کے عناصر کے لئے ایک مجموعہ بنانا چاہتے ہیں اور مختلف نفاذات (B، C، اور D) شامل کرنا چاہتے ہیں:

List<A> list = new ArrayList();
list.add(new B());
list.add(new C());
list.add(new D());
list.add(new B());

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

21. آٹو باکسنگ اور ان باکسنگ

تاریخی پس منظر: آٹو باکسنگ اور ان باکسنگ JDK 5 میں کچھ اہم اختراعات ہیں۔ آٹو باکسنگ ایک قدیم قسم سے متعلقہ ریپر کلاس میں خودکار تبدیلی کا عمل ہے۔ ان باکسنگ آٹو باکسنگ کے بالکل برعکس ہے۔ یہ ایک ریپر کلاس کو قدیم میں تبدیل کرنے کا عمل ہے۔ لیکن اگر ایک ریپر کی قدر ہے null، تو NullPointerExceptionان باکسنگ کے دوران a کو پھینک دیا جائے گا۔

قدیم اور ان سے متعلقہ ریپر

// آٹو باکسنگ ہوتی ہے:

• جب ریپر کلاس کے حوالے سے پرائمٹیو تفویض کرتے ہیں:

  جاوا 5 سے پہلے:

  
  // Manual boxing (the way it was BEFORE Java 5).
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // And so on for other types
  }
  
  After Java 5:
  // Automatic boxing (the way it became in Java 5).
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // And so on for other types
  }

• جب ایک پرائمٹیو کو کسی ایسے طریقہ کی دلیل کے طور پر منظور کیا جاتا ہے جس سے ریپر کی توقع ہوتی ہے:

  
  public void exampleOfAutoboxing() {
     long age = 3;
     setAge(age);
  }
  
  public void setAge(Long age) {
     this.age = age;
  }

// ان باکسنگ ہوتی ہے:

• جب ہم پرائمیٹو متغیر کو ریپر کلاس کی مثال تفویض کرتے ہیں:

  
  // BEFORE Java 5:
  int intValue = new Integer(4).intValue();
  double doubleValue = new Double(2.3).doubleValue();
  char c = new Character((char) 3).charValue();
  boolean b = Boolean.TRUE.booleanValue();
  
  // And after JDK 5:
  int intValue = new Integer(4);
  double doubleValue = new Double(2.3);
  char c = new Character((char) 3);
  boolean b = Boolean.TRUE;

• ریاضی کی کارروائیوں کے دوران۔ آپریشنز صرف قدیم اقسام پر لاگو ہوتے ہیں، لہذا پرائمیٹو کو ان باکس کرنا ضروری ہے۔

  
  // BEFORE Java 5:
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // A comparison used to require this:
  integerBox1.intValue() > integerBox2.intValue()
        
  // In Java 5
  integerBox1 > integerBox2

• ریپر کلاس کی مثال کو کسی ایسے طریقہ پر منتقل کرتے وقت جو متعلقہ پرائمٹیو لیتا ہے:

  
  public void exampleOfAutoboxing() {
     Long age = new Long(3);
     setAge(age);
  }
  
  public void setAge(long age) {
     this.age = age;
  }

22. حتمی مطلوبہ لفظ کیا ہے اور یہ کہاں استعمال ہوتا ہے؟

کلیدی finalلفظ متغیرات، طریقوں اور کلاسوں پر استعمال کیا جا سکتا ہے۔

1. حتمی متغیر کی قدر کو شروع کرنے کے بعد تبدیل نہیں کیا جا سکتا۔
2. ایک آخری کلاس جراثیم سے پاک ہے :) اس میں بچے نہیں ہو سکتے۔
3. ایک حتمی طریقہ اولاد کے ذریعہ اوور رائڈ نہیں کیا جاسکتا۔

ہم نے اعلیٰ سطحی چیزوں کا احاطہ کیا ہے۔ اب مزید گہرائی میں ڈوبتے ہیں۔

حتمی متغیرات

جاوا ہمیں متغیر کا اعلان کرنے اور اسے قدر تفویض کرنے کے دو طریقے فراہم کرتا ہے:

1. آپ متغیر کا اعلان کر سکتے ہیں اور اسے بعد میں شروع کر سکتے ہیں۔
2. آپ متغیر کا اعلان کر سکتے ہیں اور فوراً ایک قدر تفویض کر سکتے ہیں۔

یہاں ایک مثال ہے جو حتمی متغیرات کے ان استعمال کو ظاہر کرتی ہے:

public class FinalExample {

   // A static final variable that is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";

   // A final variable that is not initialized, but will only work if you
   // initialize it in the constructor:
   final long creationTime;

   public FinalExample() {
       this.creationTime = System.currentTimeMillis();
   }

   public static void main(String[] args) {
       FinalExample finalExample = new FinalExample();
       System.out.println(finalExample.creationTime);

       // The final FinalExample.FINAL_EXAMPLE_NAME field cannot be accessed
//    FinalExample.FINAL_EXAMPLE_NAME = "Not you're not!";

       // The final Config.creationTime field cannot be accessed
//    finalExample.creationTime = 1L;
   }
}

کیا حتمی متغیر کو مستقل سمجھا جا سکتا ہے؟

چونکہ ہم حتمی متغیرات کو نئی قدریں تفویض نہیں کر سکتے، ایسا لگتا ہے کہ یہ مستقل متغیرات ہیں۔ لیکن صرف پہلی نظر میں: اگر متغیر کی ڈیٹا کی قسم ہے immutable، تو، ہاں، یہ ایک مستقل ہے۔ لیکن اگر ڈیٹا کی قسم ہے mutable، یعنی قابل تبدیلی، تو یہ ممکن ہو گا کہ متغیر کے ذریعے حوالہ کردہ آبجیکٹ کی قدر کو تبدیل کرنے کے لیے طریقوں اور متغیرات کا استعمال کیا جائے final۔ اس وجہ سے اسے مستقل نہیں کہا جا سکتا۔ مندرجہ ذیل مثال سے پتہ چلتا ہے کہ کچھ حتمی متغیر واقعی مستقل ہیں، جبکہ دیگر نہیں ہیں، کیونکہ انہیں تبدیل کیا جا سکتا ہے۔

public class FinalExample {

   // Immutable final variables
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
   final static Integer FINAL_EXAMPLE_COUNT  = 10;

   // Mutable final variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("Constant?");
}

مقامی حتمی متغیرات

جب finalایک طریقہ کے اندر ایک متغیر بنایا جاتا ہے، تو اسے local finalمتغیر کہا جاتا ہے:

public class FinalExample {

   public static void main(String[] args) {
       // You can do this
       final int minAgeForDriveCar = 18;

       // Or you can do this, in a for-each loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

ہم حتمی مطلوبہ الفاظ کو لوپ کے لیے بہتر میں استعمال کر سکتے ہیں، کیونکہ لوپ کے ہر تکرار کے بعد ایک نیا متغیر بنایا جاتا ہے۔ ذہن میں رکھیں کہ یہ ایک نارمل فار لوپ پر لاگو نہیں ہوتا ہے، لہذا ہمیں کمپائل ٹائم ایرر ملے گا۔

// The final local j variable cannot be assigned
for (final int i = 0; i < args.length; i ++) {
   System.out.println(args[i]);
}

فائنل کلاس

ایک کلاس جس کا اعلان کیا گیا ہے اسے finalبڑھایا نہیں جا سکتا۔ اسے مزید سادہ الفاظ میں کہیں تو کوئی دوسرا طبقہ اس کا وارث نہیں ہو سکتا۔ finalJDK میں کلاس کی ایک بہترین مثال String ہے۔ ایک ناقابل تغیر کلاس بنانے کا پہلا قدم اسے بطور نشان زد کرنا ہے final، اس طرح اسے بڑھایا جانے سے روکنا ہے:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

حتمی طریقے

جب کسی طریقہ کو حتمی نشان زد کیا جاتا ہے، تو اسے حتمی طریقہ کہا جاتا ہے (معنی ہے، ٹھیک ہے؟) بچوں کی کلاس میں حتمی طریقہ کو اوور رائڈ نہیں کیا جا سکتا۔ اتفاق سے، آبجیکٹ کلاس کے wait() اور notify() طریقے حتمی ہیں، اس لیے ہمارے پاس ان کو اوور رائڈ کرنے کی صلاحیت نہیں ہے۔

public class FinalExample {
   public final String generateAddress() {
       return "Some address";
   }
}

class ChildOfFinalExample extends FinalExample {

   // Compilation error!
   @Override
   public String generateAddress() {
       return "My OWN Address";
   }
}

جاوا میں فائنل کیسے اور کہاں استعمال کریں۔

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

23. تغیر پذیر اور ناقابل تغیر قسمیں کیا ہیں؟

تغیر پذیر

تغیر پذیر آبجیکٹ ایسی اشیاء ہیں جن کی حالت اور متغیرات تخلیق کے بعد تبدیل کی جا سکتی ہیں۔ تغیر پذیر کلاسوں کی مثالوں میں StringBuilder اور StringBuffer شامل ہیں۔ مثال:

public class MutableExample {

   private String address;

   public MutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // This setter can change the name field
   public void setAddress(String address) {
       this.address = address;
   }

   public static void main(String[] args) {

       MutableExample obj = new MutableExample("First address");
       System.out.println(obj.getAddress());

       // We are updating the name field, so this is a mutable object
       obj.setAddress("Updated address");
       System.out.println(obj.getAddress());
   }
}

ناقابل تغیر

ناقابل تغیر آبجیکٹ وہ اشیاء ہیں جن کی حالت اور متغیرات کو آبجیکٹ بننے کے بعد تبدیل نہیں کیا جا سکتا۔ HashMap کے لیے ایک بہترین کلید، کیا آپ نہیں سوچتے؟ :) مثال کے طور پر، String، Integer، Double، وغیرہ۔ مثال:

// We'll make this class final so no one can change it
public final class ImmutableExample {

   private String address;

   ImmutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // We remove the setter

   public static void main(String[] args) {

       ImmutableExample obj = new ImmutableExample("Old address");
       System.out.println(obj.getAddress());

       // There is no way to change this field, so it is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

اگلے حصے میں، ہم مجموعوں کے بارے میں سوالات اور جوابات پر غور کریں گے۔ جاوا کور کے لیے GitHub ٹاپ 50 جاب انٹرویو کے سوالات اور جوابات پر میرا پروفائل۔ حصہ 2