जावा क्लासेस: अपनी खुद की क्लासेस, कंस्ट्रक्टर्स लिखना

नमस्ते! आज हम जावा में कक्षाओं के बारे में बात करेंगे। आप कह सकते हैं कि कक्षाएं जावा प्रोग्रामिंग की आधारशिला बनाती हैं। जब आप एक प्रोग्रामर बन जाते हैं, तो आपका लगभग पूरा काम आपकी खुद की कक्षाएं लिखना होगा जिनमें विभिन्न कार्य होते हैं। आइए देखें कि इसका क्या मतलब है और यह कैसे काम करता है। :) जैसा कि आप जानते हैं, जावा एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज है। सभी कार्यक्रमों में ऐसी वस्तुएँ होती हैं जो एक या दूसरे तरीके से एक दूसरे से संबंधित होती हैं। एक वर्ग अनिवार्य रूप से एक वस्तु के लिए एक टेम्पलेट है। यह निर्धारित करता है कि वस्तु कैसी दिखेगी और उसके क्या कार्य होंगे। प्रत्येक वस्तु किसी न किसी वर्ग की वस्तु होती है। इस अत्यंत सरल उदाहरण पर विचार करें:

public class Cat {

    String name;
    int age;

}

मान लीजिए कि हम एक ऐसा कार्यक्रम लिख रहे हैं जिसमें किसी कारण से बिल्लियाँ शामिल हैं (उदाहरण के लिए, हमारे पास एक पशु चिकित्सा क्लिनिक है जो एक ऑनलाइन खाते तक पहुँच प्रदान करता है)। हमने एक कैट क्लास बनाया है, और इसमें दो वेरिएबल घोषित किए हैं: स्ट्रिंग नाम और इंट एज । इन सदस्य चरों को क्षेत्र कहा जाता है। अनिवार्य रूप से, यह उन सभी बिल्लियों के लिए एक टेम्प्लेट है जिन्हें हम भविष्य में बनाएंगे। प्रत्येक कैट ऑब्जेक्ट में दो वेरिएबल होंगे: एक नाम और एक उम्र।

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
    }

}

यह ऐसे काम करता है! हम एक बिल्ली बनाते हैं, उसे एक नाम और उम्र देते हैं, और यह सब कंसोल पर प्रदर्शित करते हैं। तुच्छ बात। :) अधिकतर नहीं, कक्षाएं वास्तविक दुनिया में चीजों और घटनाओं का वर्णन करती हैं। एक बिल्ली, एक मेज, एक व्यक्ति, एक बिजली का बोल्ट, एक किताब का एक पृष्ठ, एक पहिया - आप इन सभी चीजों को अपने कार्यक्रमों में अलग-अलग कक्षाओं का उपयोग करके बनाएंगे। अभी के लिए, आइए उन वेरिएबल्स पर ध्यान दें जिन्हें हमने कैट क्लास में घोषित किया था। उन्हें फ़ील्ड या उदाहरण चर कहा जाता है। उनका नाम वास्तव में यह सब कहता है। कैट वर्ग के प्रत्येक उदाहरण (या वस्तु) में ये चर होंगे। हमारे द्वारा बनाई गई प्रत्येक बिल्ली का अपना नाम चर और उसकी अपनी आयु होगीचर। यह समझ में आता है- यह मूल रूप से असली बिल्लियों के साथ कैसा है। :) उदाहरण चर के अलावा, वर्ग चर (स्थैतिक चर) भी हैं। आइए अपना उदाहरण समाप्त करें:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        Cat fluffy = new Cat();
        fluffy.age = 5;
        fluffy.name = "Fluffy";
        count++;

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
        System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);

        System.out.println("Total number of cats = " + count);
    }
}

कंसोल आउटपुट: हमने स्मज नाम की एक बिल्ली बनाई। उसकी उम्र 3 साल है। हमने फ्लफी नाम की एक बिल्ली बनाई। उसकी उम्र 5 है बिल्लियों की कुल संख्या = 2 अब हमारी कक्षा में एक नया वेरिएबल है जिसे काउंट कहा जाता है। यह बनाई गई बिल्लियों की गिनती के लिए जिम्मेदार है। हर बार हम मुख्य रूप से एक बिल्ली बनाते हैंविधि, हम इस चर को 1 से बढ़ाते हैं। इस चर को स्थिर कीवर्ड का उपयोग करके घोषित किया जाता है। इसका मतलब है कि यह वर्ग का है, वर्ग की किसी विशिष्ट वस्तु का नहीं। जो निश्चित रूप से समझ में आता है: प्रत्येक बिल्ली का नाम उस विशिष्ट बिल्ली से संबंधित है, लेकिन हमें एक बिल्ली काउंटर की आवश्यकता है जो उन सभी पर लागू हो। यह ठीक वही है जो कीवर्ड स्टैटिक पूरा करता है: यह सभी बिल्लियों के लिए काउंट वेरिएबल को एक सिंगल वेरिएबल बनाता है। नोट: जब हम वेरिएबल प्रदर्शित करते हैं, तो हम smudge.count या Fluffy.count का उपयोग नहीं कर रहे होते हैं। यह स्मज या फ्लफी से संबंधित नहीं है; यह संपूर्ण कैट वर्ग का है। इसलिए यह केवल गिनती है। आप Cat.count भी लिख सकते हैं। यह भी सही होगा। नाम चर प्रदर्शित करते समय, हम निम्नलिखित नहीं करेंगे:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        System.out.println("We created a cat named " + name + ". His age is " + smudge.age);

        System.out.println("Total number of cats = " + count);
    }
}

यह एक त्रुटि है! प्रत्येक बिल्ली का अपना नाम होता है। संकलक यहाँ भ्रमित हो जाता है। "कंसोल के लिए एक नाम आउटपुट करें? किसका नाम?" :/"

तरीकों

चर के अलावा, प्रत्येक वर्ग में विधियाँ होती हैं। हम उनके बारे में एक अलग पाठ में अधिक विस्तार से बात करेंगे, लेकिन सामान्य सिद्धांत काफी सरल हैं। विधियां आपकी कक्षा की कार्यक्षमता को परिभाषित करती हैं, यानी आपकी कक्षा की कौन सी वस्तुएं कर सकती हैं। आप इन विधियों में से एक से पहले ही परिचित हैं: main() विधि। लेकिन, जैसा कि आपको याद होगा, मुख्य विधि स्थिर है, जिसका अर्थ है कि यह पूरी कक्षा से संबंधित है (तर्क चर के समान है)। हालाँकि, मानक, गैर-स्थैतिक तरीकों को केवल हमारे द्वारा बनाए गए विशिष्ट वस्तुओं पर ही बुलाया जा सकता है। उदाहरण के लिए, यदि हम एक बिल्ली वर्ग लिखना चाहते हैं, तो हमें यह जानना होगा कि हमारे कार्यक्रम में बिल्ली के क्या कार्य होने चाहिए। उस आधार पर, हम अपनी बिल्ली के लिए कुछ तरीके लिखते हैं:

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Pounce!");
    }

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        smudge.sayMeow();
        smudge.jump();

    }
}

इसकी जांच - पड़ताल करें! अब हमारी कक्षा बिल्ली जैसी दिखने के बहुत करीब है! अब हमारे पास सिर्फ एक नाम ("स्मज") और एक उम्र (3) वाली बिल्ली नहीं है। वह म्याऊ भी कह सकता है और कूद भी सकता है! उस "कार्यक्षमता" के बिना यह किस प्रकार की बिल्ली होगी? :) हम एक विशिष्ट वस्तु (स्मज) ले रहे हैं और इसके SayMeow () और जंप () विधियों को कॉल कर रहे हैं। आइए कंसोल को देखें: म्याऊ! झपट! एक असली बिल्ली! :)

अपनी खुद की कक्षाएं बनाना। मतिहीनता

भविष्य में, आपको अपनी कक्षाएं खुद लिखनी होंगी। उन्हें लिखते समय आपको किन बातों का ध्यान रखना चाहिए? यदि हम वेरिएबल्स के बारे में बात कर रहे हैं, तो आपको एब्सट्रैक्शन नामक किसी चीज़ का उपयोग करने की आवश्यकता होगी। एब्सट्रैक्शन ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के चार बुनियादी सिद्धांतों में से एक है। इसका अर्थ है किसी वस्तु की सबसे महत्वपूर्ण और महत्वपूर्ण विशेषताओं को निकालना, और इसके विपरीत, जो मामूली या महत्वहीन हैं उन्हें अलग करना। उदाहरण के लिए, आइए कंपनी के कर्मचारियों के लिए फाइलिंग कैबिनेट बनाएं। कर्मचारी वस्तु बनाने के लिए, हमने एक कर्मचारी लिखा हैकक्षा। हमारी कंपनी के फाइलिंग कैबिनेट के लिए एक कर्मचारी के कौन से लक्षण महत्वपूर्ण वर्णनकर्ता हैं? नाम, जन्म तिथि, एसएसएन और कर्मचारी आईडी। लेकिन इसकी संभावना नहीं है कि कंपनी के कर्मचारी रिकॉर्ड के लिए हमें कर्मचारी की ऊंचाई, आंखों के रंग या बालों के रंग की आवश्यकता होगी। कंपनियों को इस जानकारी की जरूरत नहीं है। इसलिए, कर्मचारी वर्ग में , हम निम्नलिखित चरों की घोषणा करते हैं: स्ट्रिंग नाम , इंट एज , इंट सोशलसिक्योरिटीनंबर , और इंट एंप्लॉयीआईड. और हम अनावश्यक जानकारी (जैसे आँखों का रंग) को छोड़ देते हैं। दूसरे शब्दों में, हम एक अमूर्तता बनाते हैं। हालाँकि, अगर हम मॉडलिंग एजेंसियों के लिए फाइलिंग कैबिनेट बना रहे हैं, तो स्थिति नाटकीय रूप से बदल जाती है। एक मॉडल की ऊंचाई, आंखों का रंग और बालों का रंग महत्वपूर्ण विशेषताएं हैं, लेकिन उसका एसएसएन हमारे लिए बिल्कुल अप्रासंगिक है। इसलिए, मॉडल वर्ग में , हमें निम्नलिखित चर बनाने की आवश्यकता है: स्ट्रिंग ऊँचाई , स्ट्रिंग बाल , स्ट्रिंग आँखें । अमूर्तता इसी तरह काम करती है—यह आसान है! :)

कंस्ट्रक्टर्स

आइए अपने बिल्ली के उदाहरण पर वापस जाएं।

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();

        System.out.println("Here the program does something for 2 hours...");

        smudge.age = 3;
        smudge.name = "Smudge";

    }
}

इस कोड को देखें और यह पता लगाने की कोशिश करें कि हमारे प्रोग्राम में क्या गलत है। हमारे कार्यक्रम में 2 घंटे तक बिना नाम या उम्र की एक बिल्ली थी! बेशक, यह स्वाभाविक रूप से गलत है। पशु चिकित्सा क्लिनिक के डेटाबेस में बिना जानकारी वाली बिल्लियाँ शामिल नहीं होनी चाहिए। वर्तमान में, हमारी बिल्ली प्रोग्रामर की दया पर है। हमें भरोसा है कि वह नाम और उम्र बताना नहीं भूलेंगे और सब कुछ ठीक हो जाएगा। यदि वह भूल जाता है, तो डेटाबेस में एक समस्या होगी: अनाम बिल्लियाँ। हम इस समस्या का समाधान कैसे कर सकते हैं? हमें किसी तरह बिल्लियों को बिना नाम और उम्र के पैदा होने से रोकना चाहिए। यहां कंस्ट्रक्टर बचाव के लिए आते हैं। आइए एक उदाहरण दें:

public class Cat {

    String name;
    int age;

    // Constructor for the Cat class
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
    }
}

अनिवार्य रूप से, एक कंस्ट्रक्टर एक वर्ग की वस्तुओं के लिए एक टेम्पलेट है। इस मामले में, हम इंगित करते हैं कि प्रत्येक कैट ऑब्जेक्ट के लिए दो तर्क, एक स्ट्रिंग और एक इंट निर्दिष्ट होना चाहिए । अगर हम अभी एक बेनाम बिल्ली बनाने की कोशिश करते हैं, तो यह काम नहीं करेगा।

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

अब जब क्लास में एक कंस्ट्रक्टर है, तो जावा कंपाइलर जानता है कि ऑब्जेक्ट कैसा दिखना चाहिए, और तर्कों को निर्दिष्ट किए बिना ऑब्जेक्ट को बनाने की अनुमति नहीं देता है। अब, इस कीवर्ड की जांच करते हैं, जिसे आप कंस्ट्रक्टर के अंदर देखते हैं। यह आसान भी है। यह कीवर्ड किसी विशेष वस्तु को इंगित करने के लिए है। कंस्ट्रक्टर में कोड

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

लगभग शब्दशः व्याख्या की जा सकती है: "इस बिल्ली का नाम (जिसे हम बना रहे हैं) = कंस्ट्रक्टर के नाम पैरामीटर के लिए पास किया गया तर्क। इस बिल्ली की उम्र (जिसे हम बना रहे हैं) = कंस्ट्रक्टर के लिए पास किया गया तर्क उम्र का पैमाना।" कंस्ट्रक्टर के चलने के बाद, आप यह सत्यापित कर सकते हैं कि सभी आवश्यक मान हमारी बिल्ली को सौंपे गए हैं:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        System.out.println(smudge.name);
        System.out.println(smudge.age);
    }
}

कंसोल आउटपुट: स्मज 5 जब कंस्ट्रक्टर को कॉल किया गया था:

Cat smudge = new Cat("Smudge", 5);

वास्तव में आंतरिक रूप से यही हुआ है:

this.name = "Smudge";
this.age = 5;

और कंस्ट्रक्टर को पास किए गए तर्कों के मूल्यों को स्मज ऑब्जेक्ट को सौंपा गया था (यह इस मामले में संदर्भित है)। वास्तव में, भले ही आप किसी वर्ग में कोई कंस्ट्रक्टर घोषित न करें, फिर भी वह एक कंस्ट्रक्टर को कॉल करेगा! लेकिन यह कैसे संभव है? О_О क्योंकि, सभी जावा कक्षाओं में एक तथाकथित डिफ़ॉल्ट कंस्ट्रक्टर होता है। यह कोई तर्क नहीं लेता है, लेकिन हर बार जब आप किसी भी वर्ग का कोई ऑब्जेक्ट बनाते हैं तो इसे लागू किया जाता है।

public class Cat {

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

पहली नज़र में, यह स्पष्ट नहीं हो सकता है। हमने एक वस्तु बनाई, तो क्या? कन्स्ट्रक्टर यहां कुछ भी कहां कर रहा है? इसे देखने के लिए, आइए स्पष्ट रूप से कैट क्लास के लिए एक खाली कंस्ट्रक्टर लिखें। इसके अंदर, हम कंसोल में कुछ वाक्यांश आउटपुट करेंगे। यदि वाक्यांश प्रदर्शित होता है, तो कन्स्ट्रक्टर का आह्वान किया गया था।

public class Cat {

    public Cat() {
        System.out.println("A cat has been created!");
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

कंसोल आउटपुट: एक बिल्ली बनाई गई है! वहाँ पुष्टि है। डिफ़ॉल्ट कंस्ट्रक्टर हमेशा आपकी कक्षाओं में अदृश्य रूप से मौजूद होता है। लेकिन आपको इसके बारे में एक और बात जानने की जरूरत है। एक बार जब आप तर्कों के साथ एक कंस्ट्रक्टर बनाते हैं, तो डिफॉल्ट कंस्ट्रक्टर को क्लास से हटा दिया जाता है। वास्तव में, हम इसका प्रमाण पहले ही ऊपर देख चुके हैं। यह इस कोड में था:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

हम नाम और उम्र के बिना कैट नहीं बना सकते, क्योंकि हमने स्ट्रिंग और इंट पैरामीटर के साथ कैट कंस्ट्रक्टर घोषित किया था। इससे डिफॉल्ट कन्स्ट्रक्टर तुरंत कक्षा से गायब हो गया। इसलिए यह याद रखना सुनिश्चित करें कि यदि आपको अपनी कक्षा में कई कंस्ट्रक्टरों की आवश्यकता है, जिसमें बिना तर्क वाले कंस्ट्रक्टर भी शामिल हैं, तो आपको इसे अलग से घोषित करना होगा। हमारा क्लिनिक अच्छे काम करना चाहता है और बेघर बिल्ली के बच्चों की मदद करना चाहता है जिनके नाम और उम्र अज्ञात है। तब हमारा कोड इस तरह दिखना चाहिए:

public class Cat {

    String name;
    int age;

    // For cats with owners
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // For street cats
    public Cat() {
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        Cat streetCat = new Cat();
    }
}

अब जब हमने एक स्पष्ट डिफ़ॉल्ट कंस्ट्रक्टर निर्दिष्ट किया है, तो हम दोनों प्रकार की बिल्लियाँ बना सकते हैं। कंस्ट्रक्टर में, आप सीधे मान असाइन कर सकते हैं। आपको उन्हें हमेशा तर्कों से लेने की ज़रूरत नहीं है। उदाहरण के लिए, हम टेम्पलेट के रूप में "स्ट्रीट कैट नंबर <काउंट>" का उपयोग करके डेटाबेस में सभी स्ट्रीट कैट्स को लेबल कर सकते हैं। :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat No. " + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

हमारे पास एक काउंट वेरिएबल है, जो हमारी स्ट्रीट कैट्स को काउंट करता है। हर बार डिफॉल्ट कंस्ट्रक्टर निष्पादित होने पर, हम 1 से गिनती बढ़ाते हैं और इस नंबर को बिल्ली के नाम से जोड़ देते हैं। कंस्ट्रक्टर्स के लिए तर्कों का क्रम बहुत महत्वपूर्ण है। आइए हमारे कंस्ट्रक्टर को पास किए गए नाम और उम्र के तर्कों की अदला-बदली करें।

public class Cat {

    String name;
    int age;

    public Cat(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 10); // Error!
    }
}

हमें एक त्रुटि मिली! कंस्ट्रक्टर स्पष्ट रूप से निर्धारित करता है कि जब एक कैट ऑब्जेक्ट बनाया जाता है, तो उसे इस क्रम में एक संख्या और एक स्ट्रिंग पास करनी होगी। इसलिए, हमारा कोड काम नहीं करता है। अपनी कक्षाओं की घोषणा करते समय इस नियम को याद रखना और उसका सम्मान करना सुनिश्चित करें:

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

ये दो बिल्कुल अलग रचनाकार हैं! अब, सामग्री की अपनी समझ को मजबूत करने के लिए कुछ कार्यों को पूरा करें। :)

पुरावशेषों का संग्रहालय।

आपका काम एक आर्टिफैक्ट क्लास डिजाइन करना है ।
संग्रहालय में तीन तरह की कलाकृतियां रखी हुई हैं।
हम पहले प्रकार के बारे में कुछ नहीं जानते सिवाए संग्रहालय द्वारा दिए गए सीरियल नंबर के (उदाहरण के लिए: 212121)।
दूसरे प्रकार के लिए, हम सीरियल नंबर और इसे बनाने वाली संस्कृति को जानते हैं (उदाहरण के लिए: 212121, "एज़्टेक")।
तीसरे प्रकार के लिए, हम सीरियल नंबर, इसे बनाने वाली संस्कृति और इसे बनाने वाली सदी को जानते हैं (उदाहरण के लिए: 212121, "एज़्टेक", 12)।

एक आर्टिफैक्ट क्लास बनाएं जो संग्रहालय में रखे पुरावशेषों का वर्णन करे, और क्लास के लिए कंस्ट्रक्टर्स के आवश्यक सेट को लिखें। फिर, मुख्य () विधि में, प्रत्येक प्रकार की एक कलाकृति बनाएँ।
```
public class Artifact {

    // Write your code here

    public static void main(String[] args) {
        // Write your code here
    }
}
```
डेटिंग वेबसाइट

आइए एक डेटिंग वेबसाइट के लिए एक उपयोगकर्ता डेटाबेस बनाएं।
लेकिन यहाँ समस्या है: आप तर्कों का आवश्यक क्रम भूल गए हैं, और कोई तकनीकी दस्तावेज उपलब्ध नहीं है।
एक उपयोगकर्ता वर्ग डिज़ाइन करें, जिसमें निम्नलिखित फ़ील्ड होंगे: नाम ( स्ट्रिंग ), आयु ( लघु ), और ऊंचाई ( इंट )।
उचित संख्या में कंस्ट्रक्टर बनाएं, ताकि किसी भी क्रम में नाम, आयु और ऊंचाई निर्दिष्ट की जा सके।
```
public class User {

    String name;
    short age;
    int height;

    // Write your code here

    public static void main(String[] args) {

    }
}
```

आपने जो सीखा है उसे सुदृढ़ करने के लिए, हमारा सुझाव है कि आप हमारे जावा कोर्स से एक वीडियो सबक देखें

अधिक पढ़ना:
अनाम वर्ग स्टेटिक नेस्टेड क्लासेस नेस्टेड आंतरिक कक्षाएं वर्गों के बीच संबंध। वंशानुक्रम, रचना और एकत्रीकरण सार वर्गों और इंटरफेस के बीच का अंतर