جاوا اندرونی کلاسز

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

نیسٹڈ اور اندرونی کلاسز

لہذا دیگر کلاسوں کے اندر موجود تمام کلاسوں کو نیسٹڈ کلاسز کہا جاتا ہے۔

class OuterClass {
    ...
    class NestedClass {
        ...
    }
}

نیسٹڈ کلاسز جو کہ جامد نہیں ہیں انر کلاسز کہلاتی ہیں ، اور جو سٹیٹک ہیں وہ سٹیٹک نیسٹڈ کلاسز کہلاتی ہیں ۔

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

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

اندرونی کلاس کی مثال

تو، آئیے کچھ کلاس بنانے کی کوشش کریں، اور اس کے اندر ایک اور کلاس۔ کسی قسم کے ماڈیولر گیم کنسول کا تصور کریں۔ خود ایک "باکس" ہے، اور کچھ ماڈیول اس سے منسلک ہو سکتے ہیں۔ مثال کے طور پر، ایک گیم کنٹرولر، ایک اسٹیئرنگ وہیل، ایک VR ہیلمیٹ، جو کہ ایک اصول کے طور پر، کنسول کے بغیر کام نہیں کرتا ہے۔ یہاں ہمارے پاس گیم کنسول کلاس ہے۔ اس میں 2 فیلڈز اور 1 طریقہ ہے - start() ۔ گیم کوسول اور کلاس کے درمیان فرق یہ ہے کہ اس میں ایک اندرونی گیم کنٹرولر کلاس ہے۔

public class GameConsole {
    private String model;
    private int weight;

    public void run() {
        System.out.println("Game console is on");
    }


    public class GameController {

        private String color;

        public void start() {
            System.out.println("start button is pressed");
        }

        public void x() {
            System.out.println("x button is pressed");
        }

        public void y() {
            System.out.println("y button is pressed");
        }
        public void a() {
            System.out.println("a button is pressed");
        }

        public void b() {
            System.out.println("b button is pressed");
        }
        public void mover() {
            System.out.println("mover button is pressed");
        }

    }

}

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

public class Main {

   public static void main(String[] args) {
       GameController controller = new GameController();
       controller.x();
   }
}

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

class OuterClass {

   // inner class
   private class InnerClass {
       public void print() {
           System.out.println("We are in the inner class...");
       }
   }

   // method of outer class. We are create an inner class from the method of outer one
   void display() {
       InnerClass inner = new InnerClass();
       inner.print();
   }
}

یہاں OuterClass بیرونی کلاس ہے، InnerClass اندرونی کلاس ہے، display() وہ طریقہ ہے جس کے اندر ہم اندرونی کلاس کا ایک آبجیکٹ بنا رہے ہیں۔ اب ایک اہم طریقہ کے ساتھ ایک ڈیمو کلاس لکھتے ہیں جہاں ہم display() طریقہ استعمال کرنے جا رہے ہیں۔

public class OuterDemoMain {

       public static void main(String args[]) {
           // create an object of the outer class
           OuterDemo outer = new OuterDemo();

           outer.display();
       }
}

اگر آپ اس پروگرام کو چلاتے ہیں، تو آپ کو درج ذیل نتیجہ ملے گا:

اندرونی طبقات کی درجہ بندی

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

• اندرونی طبقہ جیسا ہے۔ دوسرے کے اندر صرف ایک غیر جامد کلاس جیسا کہ ہم نے گیم کنسول اور گیم کنٹرولر کی مثال کے ساتھ اوپر دکھایا ہے۔
• طریقہ-مقامی اندرونی کلاس طریقہ کے اندر ایک کلاس ہے۔
• گمنام اندرونی کلاس۔

مقامی اندرونی کلاس کا طریقہ

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

public class OuterDemo2 {

   //instance method of the outer class OuterDemo2
   void myMethod() {
       String str = "and it's a value from OuterDemo2 class' myMethod ";

       // method-local inner class
       class methodInnerDemo {
           public void print() {
               System.out.println("Here we've got a method inner class... " );
               System.out.println(str);

           }
       }

       // Access to the inner class
       methodInnerDemo inn = new methodInnerDemo();
       inn.print();
   }
}

اب ہم ایک اہم طریقہ کے ساتھ ایک ڈیمو کلاس لکھنے جا رہے ہیں جہاں ہم outer() طریقہ کو استعمال کرنے جا رہے ہیں۔

public class OuterDemoMain {


   public static void main(String args[]) {
       OuterDemo2 outer = new OuterDemo2();
       outer.myMethod();
   }
}

آؤٹ پٹ ہے:

گمنام اندرونی طبقہ

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

abstract class OuterDemo3 {
   public abstract void method();

}
   class outerClass {

       public static void main(String args[]) {
           OuterDemo3 inner = new OuterDemo3() {
               public void method() {
                   System.out.println("Here we've got an example of an  anonymous inner class");
               }
           };
           inner.method();
       }
   }

آؤٹ پٹ یہاں ہے:

گمنام اندرونی کلاس بطور دلیل

آپ طریقہ کی دلیل کے طور پر ایک گمنام اندرونی کلاس بھی پاس کر سکتے ہیں۔ یہاں ایک مثال ہے۔

interface OuterDemo4 {
       String hello();
   }

   class NewClass {
       // accepts the object of interface
       public void displayMessage(OuterDemo4 myMessage) {
           System.out.println(myMessage.hello());
           System.out.println("example of anonymous inner class as an argument");
       }

       public static void main(String args[]) {
           NewClass newClass = new NewClass();

           //here we pass an anonymous inner class as an argument
           newClass.displayMessage(new OuterDemo4() {
               public String hello() {
                   return "Hello!";
               }
           });
       }
}

آؤٹ پٹ یہاں ہے: جو کچھ آپ نے سیکھا ہے اس کو تقویت دینے کے لیے، ہمارا مشورہ ہے کہ آپ ہمارے جاوا کورس سے ایک ویڈیو سبق دیکھیں