جاوا اندروني ڪلاس

جاوا ۾ ڪجھ طبقن ۾ شامل ٿي سگھن ٿا انھن ۾ ٻيا طبقا. اهڙن طبقن کي نيسٽڊ ڪلاس چئبو آهي. ٻين طبقن ۾ بيان ڪيل ڪلاس عام طور تي ٻن ڀاڱن ۾ ورهايل آهن - جامد ۽ غير جامد. Nested غير جامد طبقن کي اندروني سڏيو ويندو آهي. Nested ڪلاس جيڪي جامد قرار ڏنل آھن تن کي جامد نسٽڊ ڪلاس چئبو آھي. حقيقت ۾، هتي ڪا به پيچيدگي ناهي، جيتوڻيڪ اصطلاحات ڪجهه فزي نظر اچن ٿا ۽ ڪڏهن ڪڏهن هڪ پروفيسر سافٽ ويئر ڊولپر کي به پريشان ڪري سگهي ٿو.

Nested ۽ اندروني طبقن

تنهن ڪري ٻين طبقن جي اندر واقع سڀني طبقن کي Nested ڪلاس سڏيو ويندو آهي.

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

Nested Classes جيڪي جامد نه هوندا آهن انهن کي Inner Classes چئبو آهي ، ۽ جيڪي جامد هوندا آهن تن کي جامد Nested ڪلاس چئبو آهي .

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

اهڙيء طرح، سڀ اندروني ڪلاس Nested آهن، پر سڀ Nested اندروني نه آهن. اهي مکيه وصفون آهن. اندروني ڪلاس جاوا ۾ حفاظتي ميڪانيزم جو هڪ قسم آهن. اسان ڄاڻون ٿا ته هڪ عام طبقو هڪ خانگي رسائي موڊيفائر سان لاڳاپيل نه ٿو ٿي سگهي. بهرحال، جيڪڏهن اسان جو ڪلاس ڪنهن ٻئي طبقي جو ميمبر آهي، ته پوءِ اندروني طبقي کي پرائيويٽ ڪري سگهجي ٿو. ھي خصوصيت پڻ استعمال ڪيو ويندو آھي پرائيويٽ ڪلاس جي ميمبرن تائين پھچڻ لاءِ.

اندروني ڪلاس جو مثال

سو، اچو ته ڪوشش ڪريون ڪجھ ڪلاس، ۽ ان جي اندر - ٻيو ڪلاس. تصور ڪريو ڪجھ قسم جي ماڊلر گیم ڪنسول. اتي هڪ "باڪس" پاڻ آهي، ۽ ڪجهه ماڊلز ان سان ڳنڍيل ٿي سگهي ٿو. مثال طور، هڪ راند ڪنٽرولر، هڪ اسٽيرنگ ويل، هڪ وي آر هيلمٽ، جيڪو ضابطي جي طور تي، ڪنسول کان سواء ڪم نٿو ڪري. هتي اسان وٽ آهي GameConsole ڪلاس. ان ۾ 2 فيلڊز ۽ 1 طريقو آھي - start() . GameCosole ۽ ڪلاس جي وچ ۾ فرق جيڪو اسان استعمال ڪيو ويو آھي اھو آھي اھو ھڪڙو اندروني GameController ڪلاس آھي.

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");
        }

    }

}

هن موقعي تي، توهان شايد حيران ٿي رهيا آهيو: ڇو نه انهن طبقن کي "الڳ" ٺاهيو وڃي؟ اهو ضروري ناهي ته انهن کي ٿلهو ٺاهيو وڃي. حقيقت ۾ اهو ممڪن آهي. بلڪه، اهو انهن جي استعمال جي لحاظ کان طبقن جي صحيح ڊيزائن بابت آهي. اندروني طبقن کي پروگرام ۾ نمايان ڪرڻ لاءِ ٺاهيا ويا آهن هڪ ادارو جيڪو هڪ ٻئي سان جڙيل آهي. هڪ ڪنٽرولر يا، مثال طور، هڪ وي آر هيلمٽ ڪنسول جا حصا آهن. ها، اهي ڪنسول کان الڳ خريد ڪري سگھجن ٿيون، پر ان کان سواء استعمال نه ٿي ڪري سگھجي. جيڪڏھن اسان انھن مڙني طبقن کي الڳ عوامي طبقو بڻايون، ته اسان جو پروگرام ٿي سگھي ٿو، مثال طور، ھيٺ ڏنل ڪوڊ:

public class Main {

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

هن معاملي ۾ ڇا ٿئي ٿو واضح ناهي، ڇاڪاڻ ته ڪنٽرولر پاڻ کي ڪنسول کان سواء ڪم نٿو ڪري. اسان هڪ راند ڪنسول اعتراض ٺاهيو آهي. اسان ان جو ذيلي اعتراض ٺاهيو - راند ڪنٽرولر. ۽ ھاڻي اسان کيڏي سگھون ٿا، بس ساڄي ڪنجي کي دٻايو. طريقن جي اسان کي ضرورت آهي صحيح شيون تي سڏيو ويندو آهي. هر شي سادي ۽ آسان آهي. هن مثال ۾، گيم ڪنٽرولر کي ڪڍڻ انڪپسوليشن کي وڌائيندو آهي (اسان ڪنسول حصن جي تفصيل کي لاڳاپيل طبقي اندر لڪائيندا آهيون)، ۽ وڌيڪ تفصيلي تجزيه جي اجازت ڏئي ٿي. پر جيڪڏھن اسان، مثال طور، ھڪڙو پروگرام ٺاھيو آھي جيڪو ھڪڙو اسٽور ٺاھي ٿو جتي توھان الڳ الڳ خريد ڪري سگھوٿا وي آر ھيلمٽ يا ڪنٽرولر، اھو مثال ناڪام ٿيندو. اتي اهو بهتر آهي ته هڪ راند ڪنٽرولر الڳ الڳ ٺاهي. اچو ته هڪ ٻيو مثال وٺون. اسان مٿي ذڪر ڪيو آهي ته اسان اندروني طبقي کي نجي ڪري سگهون ٿا ۽ اڃا به ان کي ٻاهرئين طبقي مان سڏين ٿا. هيٺ ڏنل ڪلاسن جو هڪ مثال آهي.

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() اهو طريقو آهي جنهن جي اندر اسان انڊر ڪلاس جو اعتراض ٺاهي رهيا آهيون. هاڻي اچو ته هڪ مکيه طريقي سان هڪ ڊيمو ڪلاس لکون جتي اسان ڊسپلي () ميٿڊ کي سڏڻ وارا آهيون .

public class OuterDemoMain {

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

           outer.display();
       }
}

جيڪڏهن توهان هن پروگرام کي هلائيندا آهيو، توهان هيٺ ڏنل نتيجا حاصل ڪندا:

اندروني طبقن جي درجه بندي

اندروني طبقو پاڻ يا اندريون غير جامد طبقو ٽن گروهن ۾ ورهايل آهي.

• اندروني طبقو جيئن آهي. صرف هڪ غير جامد ڪلاس ٻئي اندر اندر جيئن اسان مٿي بيان ڪيو آهي GameConsole ۽ GameController مثال سان.
• طريقو- مقامي اندروني طبقو هڪ طريقو اندر هڪ طبقو آهي.
• گمنام اندروني ڪلاس.

طريقو مقامي اندروني ڪلاس

جاوا ۾ توهان هڪ طريقي جي اندر هڪ ڪلاس لکي سگهو ٿا ۽ اهو هڪ مقامي قسم آهي. مقامي متغير وانگر، اندروني طبقي جو دائرو هڪ طريقي سان محدود آهي. هڪ طريقو- مقامي اندروني ڪلاس صرف ان طريقي ۾ ٺاهي سگهجي ٿو جتي اندروني طبقي جي وضاحت ڪئي وئي آهي. اچو ته ظاھر ڪريون ته ڪيئن استعمال ڪجي مقامي طريقو اندروني طبقي کي.

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();
   }
}

ھاڻي اسان ھڪ مکيه طريقي سان ھڪڙو ڊيمو ڪلاس لکڻ وارا آھيون جتي اسان ٻاهرين () طريقي کي سڏڻ وارا آھيون .

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!";
               }
           });
       }
}

پيداوار هتي آهي: جيڪو توهان سکيو ان کي مضبوط ڪرڻ لاءِ، اسان توهان کي اسان جي جاوا ڪورس مان هڪ وڊيو سبق ڏسڻ جي صلاح ڏيون ٿا