کلاسز، مثالوں کے ساتھ نیسٹڈ کلاسز کی اقسام

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

کلاس کیا ہے؟

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

public class Student {
    private String name, group, specialty;

    public Student(String name, String group, String specialty) {
       this.name = name;
       this.group = group;
       this.specialty = specialty;
   }

   // getters/setters
}

اس مثال میں، ہم نے ایک جاوا کلاس بنائی ہے جو "طالب علم" ہستی کو بیان کرتی ہے: ہر طالب علم کا ایک نام، گروپ اور خاصیت ہوتی ہے۔ اب، پروگرام میں دوسری جگہوں پر، ہم اس کلاس کی حقیقی مثالیں بنا سکتے ہیں۔ دوسرے لفظوں میں: اگر کلاس Studentاس بات کا پورٹریٹ ہے کہ طالب علم کو کیا ہونا چاہیے، تو تخلیق شدہ مثال خود اصل طالب علم ہے۔ ایک نیا طالب علم بنانے کی ایک مثال: new Student("Ivan", "KI-17-2", "Computer Engineering");آپریٹر newکلاس کو تلاش کرتا ہے Studentاور پھر اس کلاس کے ایک خاص طریقہ (کنسٹرکٹر) کو کال کرتا ہے۔ کنسٹرکٹر ایک ریڈی میڈ کلاس آبجیکٹ واپس کرتا ہے Student- ہمارا پیارا، بھوکا طالب علم بغیر اسکالرشپ کے :))

جاوا میں کلاسز کی اقسام

جاوا میں دوسری کلاس کے اندر 4 قسم کی کلاسیں ہیں:

1. نیسٹڈ اندرونی کلاسیں بیرونی کلاس کے اندر غیر جامد کلاسز ہیں۔

2. نیسٹڈ سٹیٹک کلاسز بیرونی کلاس کے اندر سٹیٹک کلاسز ہیں۔

3. جاوا لوکل کلاسز طریقوں کے اندر کلاسز ہیں۔

4. گمنام جاوا کلاسیں وہ کلاسیں ہیں جو فلائی پر بنائی جاتی ہیں۔

ہم ان میں سے ہر ایک کے بارے میں الگ الگ بات کریں گے۔

بیرونی کلاس کے اندر غیر جامد کلاسز

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

public class Airplane {
    private String name, id, flight;

    public Airplane(String name, String id, String flight) {
        this.name = name;
        this.id = id;
        this.flight = flight;
    }

    // getters/setters
}

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

public class Airplane {
    private String name, id, flight;
    private Wing leftWing = new Wing("Red", "X3"), rightWing = new Wing("Blue", "X3");

    public Airplane(String name, String id, String flight) {
        this.name = name;
        this.id = id;
        this.flight = flight;
    }

    private class Wing {
        private String color, model;

        private Wing(String color, String model) {
            this.color = color;
            this.model = model;
        }

        // getters/setters
    }

    // getters/setters
}

لہذا ہم نے ایک کلاس (ہوائی جہاز) کے اندر ایک غیر جامد نیسٹڈ کلاس Wing(ونگ) بنایا Airplane، اور دو متغیرات شامل کیے - بائیں بازو اور دائیں بازو۔ اور ہر ونگ کی اپنی خصوصیات ہیں (رنگ، ​​ماڈل) جسے ہم تبدیل کر سکتے ہیں۔ اس طرح آپ ڈھانچے کو جتنا آپ کی ضرورت ہے عملہ کر سکتے ہیں۔ اور نوٹ کریں: اس سے پہلے خاکہ پر طیارے کے بہت سارے پرزے تھے، اور درحقیقت، ہم تمام حصوں کو اندرونی کلاسوں میں تقسیم کر سکتے ہیں، لیکن ایسا عمل ہمیشہ مناسب نہیں ہوتا۔ کام کے لحاظ سے ایسے لمحات کا سراغ لگانا ضروری ہے۔ آپ کو مسئلہ کو حل کرنے کے لئے پنکھوں کی ضرورت نہیں ہوسکتی ہے. پھر انہیں کرنے کی ضرورت نہیں۔ یہ کسی شخص کو ٹانگوں، بازوؤں، دھڑ اور سر میں کاٹنے کے مترادف ہے - یہ ممکن ہے، لیکن اگر اس کلاس کو صرف لوگوں کے بارے میں ڈیٹا ذخیرہ کرنے کے لیے استعمال کیا جائے تو کیوں؟ غیر جامد نیسٹڈ جاوا کلاسز کی خصوصیات:

1. وہ صرف اشیاء میں موجود ہیں، لہذا ان کو بنانے کے لیے آپ کو ایک شے کی ضرورت ہے۔ دوسرے الفاظ میں: ہم نے اپنے بازو کو ہوائی جہاز کا حصہ بنانے کے لیے ڈیزائن کیا ہے، اس لیے ایک ونگ بنانے کے لیے ہمیں ہوائی جہاز کی ضرورت ہے، ورنہ ہمیں اس کی ضرورت نہیں ہے۔
2. جاوا کلاس کے اندر جامد متغیرات نہیں ہوسکتے ہیں۔ اگر آپ کو کچھ مستقل یا کسی اور چیز کی ضرورت ہو تو آپ کو انہیں بیرونی طبقے میں منتقل کرنے کی ضرورت ہے۔ یہ غیر جامد نیسٹڈ کلاس کے بیرونی طبقے کے ساتھ قریبی جوڑے کی وجہ سے ہے۔
3. کلاس کو بیرونی طبقے کے تمام نجی شعبوں تک مکمل رسائی حاصل ہے۔ یہ فیچر دو طریقوں سے کام کرتا ہے۔
4. آپ کو ایک بیرونی کلاس کی مثال کا حوالہ مل سکتا ہے۔ مثال: Airplane.this ایک ہوائی جہاز کا لنک ہے، یہ ایک ونگ کا لنک ہے۔

بیرونی طبقے کے اندر جامد کلاسز

اس قسم کی کلاس باقاعدہ آؤٹر کلاس سے مختلف نہیں ہے، سوائے ایک چیز کے: ایسی کلاس کی مثال بنانے کے لیے، آپ کو آؤٹر کلاس سے مطلوبہ تک کے پورے راستے کو ایک نقطے سے الگ کرنے کی ضرورت ہے۔ مثال کے طور پر: Building.Plaftorm platform = new Building.Platform(); متعلقہ کلاسوں کو ساتھ ساتھ رکھنے کے لیے جامد کلاسز کا استعمال کیا جاتا ہے تاکہ منطقی ڈھانچہ کے ساتھ کام کرنا آسان ہو۔ مثال کے طور پر: ہم ایک بیرونی کلاس بنا سکتے ہیں Building، جہاں کلاسوں کی ایک مخصوص فہرست ہوگی جو ایک مخصوص عمارت کی نمائندگی کرے گی۔

public abstract class Building {
    private String name, address, type;

    Building(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public static class Platform extends Building {
        public Platform(String name, String address) {
            super(name, address);
            setType("Platform");
        }

        // some additional logic
    }

    public static class House extends Building {
        public House(String name, String address) {
            super(name, address);
            setType("House");
        }

        // some additional logic
    }

    public static class Shop extends Building {
        public Shop(String name, String address) {
            super(name, address);
            setType("Shop");
        }

        // some additional logic
    }

    // getters/setters
}

یہ مثال ظاہر کرتی ہے کہ کس طرح جامد کلاسز آپ کو منطقی ڈھانچے کو زیادہ آسان شکل میں پیک کرنے کی اجازت دیتی ہیں۔ اگر وہ موجود نہیں تھے تو ہمیں 4 مکمل طور پر مختلف کلاسز بنانے کی ضرورت ہوگی۔ اس نقطہ نظر کے فوائد:

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

نیسٹڈ سٹیٹک کلاس کی مثال بنانے کی ایک مثال:Building.Shop myShop = new Building.Shop(“Food & Fun!”, “Kalyaeva 8/53”); میں یہ بھی نوٹ کرنا چاہوں گا کہ یہ حکمت عملی AWT 2D کلاسوں میں شکلوں کو بیان کرنے کے لیے استعمال ہوتی ہے، جیسے Line2D، Arc2D، Ellipse2D اور دیگر۔

مقامی کلاسز

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

1. مقامی کلاسیں صرف حتمی طریقہ متغیر کے ساتھ کام کر سکتی ہیں۔ بات یہ ہے کہ لوکل کلاسز کی مثالیں طریقہ مکمل ہونے کے بعد ڈھیر میں محفوظ کی جا سکتی ہیں، اور متغیر کو مٹا دیا جا سکتا ہے۔ اگر متغیر کو حتمی قرار دیا جاتا ہے، تو مرتب کرنے والا متغیر کی ایک کاپی آبجیکٹ کے بعد میں استعمال کے لیے محفوظ کر سکتا ہے۔ اور ایک بات: جاوا کے 8+ ورژن کے بعد سے، آپ مقامی کلاسوں میں غیر حتمی متغیرات استعمال کر سکتے ہیں، لیکن صرف اس شرط پر کہ وہ تبدیل نہیں ہوں گے۔
2. رسائی میں ترمیم کرنے والوں کے ساتھ مقامی کلاسوں کا اعلان نہیں کیا جا سکتا۔
3. مقامی کلاسوں کو طریقہ متغیر تک رسائی حاصل ہے۔

مقامی کلاسیں بہت کم ہی مل سکتی ہیں، کیونکہ وہ کوڈ کو پڑھنا مشکل بنا دیتے ہیں اور ان کا کوئی فائدہ نہیں ہوتا، سوائے ایک کے - طریقہ متغیر تک رسائی۔ میں نہیں جانتا کہ مقامی کلاس کی کون سی مثال لی جا سکتی ہے جو ان کے مؤثر استعمال کو ظاہر کرے، لہذا میں صرف اپنی مثال دکھاؤں گا۔ ہم کہتے ہیں کہ ہمارے پاس ایک کلاس ہے Person(یہ سمجھا جائے گا کہ یہ ایک شخص ہے) پراپرٹیز street(گلی)، house(مکان) کے ساتھ۔ ہم صرف اس شخص کے مقام تک رسائی کے لیے کچھ آبجیکٹ واپس کرنا چاہیں گے۔ ایسا کرنے کے لیے، ہم نے AddressContainer انٹرفیس بنایا، جس کا مطلب ہے کسی شخص کے مقام کے بارے میں ڈیٹا کا ذخیرہ۔

public class Person {
    private String name, street, house;

    public Person(String name, String street, String house) {
        this.name = name;
        this.street = street;
        this.house = house;
    }

    private interface AddressContainer {
        String getStreet();
        String getHouse();
    }

    public AddressContainer getAddressContainer() {
        class PersonAddressContainer implements AddressContainer {
            final String street = Person.this.street, house = Person.this.house;

            @Override
            public String getStreet() {
                return this.street;
            }

            @Override
            public String getHouse() {
                return this.house;
            }
        }

        return new PersonAddressContainer();
    }

    public static void main(String[] args) {
        Person person = new Person("Nikita", "Sholohova", "17");

        AddressContainer address = person.getAddressContainer();

        System.out.println("Address: street - " + address.getStreet() + ", house - " + address.getHouse());
    }

    // getters/setters
}

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

گمنام کلاسز

ہڈ کے نیچے، گمنام کلاسز صرف باقاعدہ غیر مستحکم نیسٹڈ کلاسز ہیں۔ ان کی خاصیت ان کے استعمال میں آسانی ہے۔ دوسری کلاس کی مثال بناتے وقت آپ اپنی کلاس کو براہ راست لکھ سکتے ہیں۔

public class Animal {
    public void meow() {
        System.out.println("Meow!");
    }

    public static void main(String[] args) {
        Animal anonTiger = new Animal() {
            @Override
            public void meow() {
                System.out.println("Raaar!");
            }
        };

        Animal notAnonTiger = new Animal().new Tiger();

        anonTiger.meow(); // будет выведено Raaar!
        notAnonTiger.meow(); // будет выведено Raaar!
    }

    private class Tiger extends Animal {
        @Override
        public void meow() {
            System.out.println("Raaar!");
        }
    }
}

بنیادی طور پر، ہم صرف دو چیزوں کو ایک جگہ جمع کر رہے ہیں: ایک کلاس ( ) کی مثال بنانا اور اس کے وارث اندرونی طبقے ( ) Animalکی مثال بنانا ۔ Tigerبصورت دیگر، ہمیں الگ سے کلاس بنانے کی ضرورت ہے اور ایک ہی نتیجہ حاصل کرنے کے لیے طویل تعمیرات کا استعمال کرنا ہوگا۔ گمنام کلاسز کا استعمال بہت سے معاملات میں جائز ہے، خاص طور پر جب:

• کلاس باڈی بہت مختصر ہے؛
• کلاس کی صرف ایک مثال درکار ہے۔
• کلاس کا استعمال اس جگہ پر کیا جاتا ہے جہاں اسے بنایا گیا تھا یا اس کے فوراً بعد؛
• کلاس کا نام اہم نہیں ہے اور یہ کوڈ کو سمجھنے میں آسان نہیں بناتا ہے۔

گمنام کلاسیں اکثر GUIs میں ایونٹ ہینڈلرز بنانے کے لیے استعمال ہوتی ہیں۔ مثال کے طور پر، ایک بٹن بنانا اور اس کے کلک پر ردعمل ظاہر کرنا:

JButton b2 = new JButton("Click");
b2.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Кнопка нажата!");
    }
});

تاہم، جاوا 8 کے بعد انہوں نے لیمبڈا ایکسپریشنز کا استعمال کرنا شروع کیا، لیکن پھر بھی ورژن 8 سے پہلے بہت سارے کوڈ لکھے گئے تھے اور آپ کو اس طرح کے نوشتہ جات (اور جاوا رش میں آپ کی تربیت کے دوران ان کا سامنا کرنا پڑے گا) ہو سکتا ہے۔\ analogue with lambdas

JButton b2 = new JButton("Click");
b2.addActionListener(e -> System.out.println("Кнопка нажата!"));

مضمون کا اختتام آپ کی توجہ کے لیے آپ سب کا شکریہ اور مجھے امید ہے کہ آپ نے کچھ نیا سیکھا ہو یا کچھ سمجھا ہو جسے آپ پہلے نہیں سمجھتے تھے۔ میں یہ بھی واضح کرنا چاہوں گا کہ یہ مضمون "تفصیل پر توجہ" کے زمرے سے تعلق رکھتا ہے ۔ یہ میرا پہلا کام ہے، اس لیے مجھے امید ہے کہ یہ کسی کے لیے مفید تھا۔ مستقبل قریب میں جب نئے آئیڈیاز آئیں گے تو کچھ اور لکھنے کی کوشش کروں گا، میرے پاس صرف ایک آئیڈیا ہے... پروگرامنگ میں کامیابی اور کامیابی سب کو مبارک ہو :)