वस्तुओं और वर्गों की प्राथमिक अवधारणा (Elementary Concept of Objects and Classes)

ए. किसी वस्तु के तीन अंतर्निहित लक्षण:

जावा में, एक Object एक वास्तविक दुनिया या वैचारिक इकाई को मॉडलिंग करने वाले संबंधित चर और तरीकों का एक सॉफ्टवेयर बंडल है। प्रत्येक वस्तु में तीन मूलभूत विशेषताएं होती हैं:

1. स्थिति (विशेषताएं/विशेषताएं): किसी भी क्षण में वस्तु के पास मौजूद स्थिर और गतिशील डेटा गुण। जावा में, राज्य को इंस्टेंस वेरिएबल्स (फ़ील्ड) में संग्रहीत किया जाता है।
   उदाहरण (छात्र वस्तु): रोल नंबर (101), नाम ("आरव"), अंक (94.5), ग्रेड ('ए')।
2. व्यवहार (कार्य/संचालन): संदेशों के जवाब में वस्तु क्या कर सकती है या वस्तु के साथ क्या किया जा सकता है। जावा में, व्यवहार को सदस्य विधियों (फ़ंक्शन) द्वारा परिभाषित किया जाता है।
   उदाहरण (छात्र वस्तु): गणना ग्रेड(), प्रदर्शन विवरण(), भुगतान शुल्क()।
3. पहचान (अद्वितीय विशिष्टता): अद्वितीय व्यक्तित्व जो किसी वस्तु को कंप्यूटर मेमोरी में अन्य सभी वस्तुओं से अलग करती है, भले ही दो वस्तुओं में समान स्थिति मान हों। जावा में, पहचान ऑब्जेक्ट के अद्वितीय हीप मेमोरी एड्रेस द्वारा स्थापित की जाती है।

ए. किसी क्लास को "ऑब्जेक्ट फ़ैक्टरी" क्यों कहा जाता है:

जिस तरह एक औद्योगिक स्टैम्पिंग डाई या फैक्ट्री मोल्ड एक ही पैटर्न से हजारों समान प्लास्टिक के खिलौने बनाता है, जावा क्लास एक वास्तुशिल्प टेम्पलेट के रूप में कार्य करता है जो मांग पर असीमित संख्या में अलग-अलग ऑब्जेक्ट इंस्टेंस का उत्पादन कर सकता है। इसलिए, एक वर्ग को सार्वभौमिक रूप से ऑब्जेक्ट फ़ैक्टरी.

बी. एक क्लास "उपयोगकर्ता-परिभाषित समग्र डेटा प्रकार" क्यों है:

जावा 8 अंतर्निहित आदिम डेटा प्रकार प्रदान करता है (जैसे int, डबल, char)। हालाँकि, आदिम प्रकार एक जटिल वास्तविक दुनिया इकाई का प्रतिनिधित्व नहीं कर सकते हैं (उदाहरण के लिए, एक कर्मचारी जिसका नाम, वेतन, आयु और विभाग है)। जब एक प्रोग्रामर घोषणा करता है:

वर्ग कर्मचारी {
    स्ट्रिंग नाम;
    int एम्पआईडी;
    दोगुना वेतन;
}

प्रोग्रामर ने कर्मचारी नामक एक नया, कस्टम, समग्र डेटा प्रकार बनाया है। Employee प्रकार का एक वेरिएबल अब एक आदिम वेरिएबल की तरह त्वरित किया जा सकता है: Employee emp1 = new Employee();

C. कक्षा बनाम वस्तु: व्यापक तुलना:

ए. वस्तु निर्माण के तीन चरण:

जावा में एक ऑब्जेक्ट बनाने में तीन अलग-अलग व्याकरणिक और रनटाइम चरण शामिल होते हैं:

छात्र s1 = नया विद्यार्थी();

1. 1. घोषणा (छात्र s1): एक चर नाम (s1) को एक ऑब्जेक्ट प्रकार (छात्र) के साथ जोड़ता है। यह ऑब्जेक्ट संदर्भ चर के लिए Stack पर स्थान आवंटित करता है। इस स्तर पर, s1 में null शामिल है (कुछ नहीं की ओर इशारा करता है)।
2. 2. इंस्टेंटिएशन (new): new ऑपरेटर एक गतिशील मेमोरी आवंटन ऑपरेटर है। यह Student वर्ग के सभी इंस्टेंस वेरिएबल्स को रखने के लिए Heap पर पर्याप्त सन्निहित मेमोरी ब्लॉक आवंटित करता है और उस आवंटित स्थान पर एक संदर्भ (मेमोरी एड्रेस) लौटाता है।
3. 3. इनिशियलाइज़ेशन (स्टूडेंट()): कंस्ट्रक्टर (स्टूडेंट()) को डिफ़ॉल्ट या उपयोगकर्ता-निर्दिष्ट मानों के साथ नव निर्मित ऑब्जेक्ट के इंस्टेंस वेरिएबल को इनिशियलाइज़ करने के लिए मेमोरी आवंटन के तुरंत बाद लागू किया जाता है। लौटाए गए हीप मेमोरी पते को फिर संदर्भ चर s1.
को सौंपा गया है

बी. स्टैक बनाम हीप मेमोरी आर्किटेक्चर:

जावा के रनटाइम मेमोरी लेआउट में:

• स्टैक मेमोरी: आदिम स्थानीय चर और ऑब्जेक्ट संदर्भ चर संग्रहीत करता है (उदाहरण के लिए, s1, s2)। स्टैक आवंटन तेज़ है और सख्त LIFO (लास्ट-इन-फर्स्ट-आउट) विधि दायरे का पालन करता है।
• हीप मेमोरी: विस्तृत मेमोरी पूल जहां सभी वास्तविक ऑब्जेक्ट इंस्टेंस और उनके इंस्टेंस वेरिएबल रहते हैं। जब किसी ऑब्जेक्ट को किसी भी स्टैक वैरिएबल द्वारा संदर्भित नहीं किया जाता है, तो जावा का स्वचालित गारबेज कलेक्टर अपनी ढेर मेमोरी को पुनः प्राप्त करता है।

ए. अंतर-वस्तु संचार (संदेश पासिंग):

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

बी. डॉट ऑपरेटर सिंटैक्स:

डॉट ऑपरेटर (.) किसी ऑब्जेक्ट संदर्भ और उसके आंतरिक सदस्यों (चर और विधियों) के बीच लिंक स्थापित करता है:

• वेरिएबल तक पहुँचना: objectName.variableName; (उदाहरण के लिए, s1.name = "रोहन";)
• एक विधि का आह्वान: ऑब्जेक्टनाम.विधिनाम(तर्क); (उदाहरण के लिए, s1.गणना प्रतिशत(450, 500);)

C. संपूर्ण कार्यशील जावा उदाहरण:

// वर्ग परिभाषा (ब्लूप्रिंट)
वर्ग वृत्त {
    दोहरा त्रिज्या; // इंस्टेंस वैरिएबल (राज्य)

    // त्रिज्या निर्धारित करने के लिए सदस्य विधि
    शून्य सेटरेडियस(डबल आर) {
        त्रिज्या = आर;
    }

    // क्षेत्र (व्यवहार) की गणना करने के लिए सदस्य विधि
    डबल कंप्यूटएरिया() {
        वापसी Math.PI * त्रिज्या * त्रिज्या;
    }
}

// निष्पादन वर्ग
पब्लिक क्लास ज्योमेट्रीडेमो {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        // ऑब्जेक्ट इंस्टेंटेशन
        वृत्त c1 = नया वृत्त();
        वृत्त c2 = नया वृत्त();

        // संदेश डॉट ऑपरेटर के माध्यम से गुजर रहा है
        c1.setRadius(7.0);
        c2.setRadius(14.0);

        System.out.println('सर्कल 1 का क्षेत्र:' + c1.computeArea());
        System.out.println('सर्कल 2 का क्षेत्र:' + c2.computeArea());
    }
}

ए. बैंकअकाउंट क्लास ब्लूप्रिंट:

// ब्लूप्रिंट क्लास एक बैंक खाते का प्रतिनिधित्व करता है
सार्वजनिक वर्ग बैंक खाता {
    // निजी उदाहरण चर (राज्य) - एनकैप्सुलेशन / डेटा छिपाना
    निजी लंबी खाता संख्या;
    निजी स्ट्रिंग खाताधारकनाम;
    निजी डबल करंट बैलेंस;

    // इंस्टेंटेशन पर किसी ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कंस्ट्रक्टर
    सार्वजनिक बैंक खाता (लंबा खाता संख्या, स्ट्रिंग नाम, डबल प्रारंभिक जमा) {
        खाता संख्या = खाता संख्या;
        अकाउंटहोल्डरनाम = नाम;
        करंटबैलेंस = प्रारंभिक जमा;
    }

    //सदस्य पैसा जमा करने का तरीका (व्यवहार)
    सार्वजनिक शून्य जमा (दोगुनी राशि) {
        यदि (राशि > 0) {
            वर्तमान शेष += राशि;
            System.out.println("जमा किया गया ₹" + राशि + " | अद्यतन शेष राशि: ₹" + वर्तमान शेष);
        }अन्यथा{
            System.out.println('त्रुटि: जमा राशि सकारात्मक होनी चाहिए!');
        }
    }

    //सत्यापन के साथ पैसे निकालने की सदस्य विधि
    सार्वजनिक शून्य निकासी (दोगुनी राशि) {
        यदि (राशि > 0 && राशि <= वर्तमान शेष) {
            वर्तमान शेष -= राशि;
            System.out.println("निकासी गई ₹" + राशि + "| शेष शेष: ₹" + वर्तमान शेष);
        }अन्यथा{
            System.out.println('लेन-देन विफल: अपर्याप्त धनराशि या अमान्य राशि!');
        }
    }

    // खाता स्थिति प्रदर्शित करने की विधि
    सार्वजनिक शून्य डिस्प्लेअकाउंटस्टेटमेंट() {
        System.out.println('खाता संख्या :' + खाता संख्या);
        System.out.println('खाता धारक:' + खाताधारकनाम);
        System.out.println('वर्तमान शेष: ₹' + वर्तमान शेष);
        System.out.println(''------------------------------------------------'');
    }
}

बी. मल्टी-ऑब्जेक्ट इंस्टेंटिएशन प्रदर्शन:

पब्लिक क्लास बैंकसिमुलेशन {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        // हीप पर ऑब्जेक्ट 1 बनाना
        BankAccount acc1 = नया BankAccount(100101L, "आरव शर्मा", 15000.0);
        
        // हीप पर ऑब्जेक्ट 2 बनाना (पूरी तरह से स्वतंत्र स्थिति!)
        BankAccount acc2 = नया BankAccount(100102L, "अनन्या सेन", 25000.0);

        // संदेश पासिंग के माध्यम से संचालन करना
        acc1.deposit(5000.0);    // केवल acc1 बैलेंस को संशोधित करता है
        acc2.withdraw(8000.0);   // केवल acc2 बैलेंस को संशोधित करता है

        acc1.displayAccountStatement();
        acc2.displayAccountStatement();
    }
}

ए. जावा में कंस्ट्रक्टर्स:

A Constructor एक विशेष सदस्य विधि है जिसका नाम क्लास के समान है और इसमें कोई रिटर्न प्रकार नहीं है (void भी नहीं)। यह स्वचालित रूप से तब लागू होता है जब किसी ऑब्जेक्ट को उसके इंस्टेंस वेरिएबल को आरंभ करने के लिए new का उपयोग करके इंस्टेंट किया जाता है।

• डिफॉल्ट / गैर-पैरामीटरयुक्त कंस्ट्रक्टर: कोई तर्क नहीं लेता; डिफ़ॉल्ट या शून्य मानों के साथ इंस्टेंस वेरिएबल प्रारंभ करता है। यदि कोई कंस्ट्रक्टर नहीं लिखा गया है, तो जावा कंपाइलर स्वचालित रूप से एक खाली डिफ़ॉल्ट कंस्ट्रक्टर को संश्लेषित करता है।
• पैरामीटरयुक्त कंस्ट्रक्टर: निर्माण के समय कस्टम शुरुआती मूल्यों के साथ अलग-अलग ऑब्जेक्ट को प्रारंभ करने के लिए पैरामीटर स्वीकार करता है।

बी. `this` कीवर्ड:

यह कीवर्ड एक अंतर्निहित संदर्भ चर है जो सीधे वर्तमान कॉलिंग ऑब्जेक्ट की ओर इशारा करता है। जब पैरामीटर नाम उदाहरण चर नामों के समान होते हैं तो यह नाम छायाकरण को हल करता है:

वर्ग पुस्तक {
    निजी स्ट्रिंग शीर्षक;
    निजी दोगुनी कीमत;

    // पैरामीटरयुक्त कंस्ट्रक्टर 'इस' का उपयोग कर रहा है
    सार्वजनिक पुस्तक(स्ट्रिंग शीर्षक, दोगुनी कीमत) {
        यह.शीर्षक = शीर्षक; // 'this.title' उदाहरण चर है; 'शीर्षक' स्थानीय पैरामीटर है
        यह.कीमत = कीमत;
    }

    सार्वजनिक शून्य डिस्प्लेबुक विवरण() {
        System.out.println('पुस्तक शीर्षक :' + यह शीर्षक);
        System.out.println('पुस्तक मूल्य: ₹' + यह.मूल्य);
    }
}

ए. चार जावा एक्सेस विनिर्देशक:

• निजी: विशेष रूप से घोषित वर्ग के भीतर पहुंच योग्य। अधिकतम डेटा छिपाने की गारंटी देता है.
• डिफ़ॉल्ट (पैकेज-निजी): समान पैकेज के भीतर रहने वाले किसी भी वर्ग द्वारा पहुंच योग्य।
• संरक्षित: एक ही पैकेज के भीतर और विरासत के माध्यम से विदेशी पैकेजों में उपवर्गों द्वारा पहुंच योग्य।
• सार्वजनिक: किसी भी पैकेज में किसी भी वर्ग से सार्वभौमिक रूप से पहुंच योग्य।

बी. क्लास डिज़ाइन में विधि ओवरलोडिंग:

मेथड ओवरलोडिंग एक वर्ग को सटीक समान नाम वाले कई तरीकों की अनुमति देता है लेकिन अलग-अलग पैरामीटर सूचियों (तर्कों की विभिन्न संख्या, विभिन्न डेटा प्रकार, या पैरामीटर के विभिन्न अनुक्रम) द्वारा विभेदित होता है। यह संकलन-समय बहुरूपता का उदाहरण देता है।

क्लास शेपकैलकुलेटर {
    डबल कैलकुलेट एरिया (डबल रेडियस) { रिटर्न मैथ.पीआई * रेडियस * रेडियस; }
    डबल कैलकुलेट एरिया (डबल लंबाई, डबल चौड़ाई) { रिटर्न लंबाई * चौड़ाई; }
    डबल कैलकुलेटएरिया(इंट साइड) { रिटर्न साइड * साइड; }
}

ए. स्वचालित मेमोरी प्रबंधन बनाम C/C++:

C++ जैसी भाषाओं में, प्रोग्रामर को malloc() और free() (या new और delete) का उपयोग करके मेमोरी को मैन्युअल रूप से आवंटित और हटा देना चाहिए। मेमोरी को खाली करना भूल जाने से भयावह मेमोरी लीक होती है, जबकि मेमोरी को समय से पहले खाली करने से खतरनाक डैंगलिंग पॉइंटर्स होती है। जावा एक स्वायत्त डेमॉन थ्रेड के माध्यम से दोनों खतरों को पूरी तरह से समाप्त कर देता है: गारबेज कलेक्टर (जीसी).

• कोई वस्तु कचरा संग्रहण के लिए कब योग्य हो जाती है? ढेर पर एक वस्तु कचरा संग्रहण के लिए योग्य हो जाती है जैसे ही यह एप्लिकेशन में किसी भी सक्रिय संदर्भ चर द्वारा पहुंच योग्य नहीं रह जाती है (उदाहरण के लिए, जब एक संदर्भ चर null पर सेट होता है, या जब कोई वस्तु किसी विधि के अंदर स्थानीय रूप से बनाई जाती है और वह विधि निष्पादन समाप्त करती है)।
• जीसी का अनुरोध: प्रोग्रामर विनम्रतापूर्वक सुझाव दे सकते हैं कि जेवीएम System.gc() या Runtime.getRuntime().gc() का उपयोग करके कचरा संग्रहण चलाता है, हालांकि JVM तत्काल निष्पादन की गारंटी नहीं देता है।

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