सभी संगणनाओं के आधार के रूप में वर्ग (Class as the Basis of all Computation)

प्राथमिक कम्प्यूटेशनल इकाई के रूप में वस्तु:

जावा में, गणना पूरी तरह से वस्तुओं के इर्द-गिर्द घूमती है। एक वस्तु एक वास्तविक दुनिया की इकाई या अमूर्त अवधारणा है जिसमें तीन सर्वोत्कृष्ट विशेषताएं होती हैं:

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

एक वस्तु फैक्टरी के रूप में वर्ग (ब्लूप्रिंट):

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

आदिम बनाम उपयोगकर्ता-परिभाषित समग्र प्रकार:

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

जावा में वेरिएबल के तीन स्तर:

परिवर्तनीय दायरे, जीवनकाल और भंडारण स्थान को समझना आईसीएसई कंप्यूटर अनुप्रयोगों में सबसे अधिक बार परीक्षण की जाने वाली अवधारणाओं में से एक है।

वस्तु तात्कालिकता की शारीरिक रचना:

क्लासिक घोषणा और तात्कालिकता कथन पर विचार करें:

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

यह एकल कथन तीन सिंक्रनाइज़ मेमोरी घटनाओं को ट्रिगर करता है:

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

सिंटेक्स और डॉट ऑपरेटर की भूमिका:

डॉट ऑपरेटर (.) जावा में सदस्य एक्सेस ऑपरेटर है। यह स्टैक पर एक संदर्भ चर और हीप ऑब्जेक्ट के अंदर रहने वाले ठोस डेटा फ़ील्ड या सदस्य विधियों के बीच एक डीरेफ़रेंस लिंक स्थापित करता है।

// इंस्टेंस वेरिएबल्स तक पहुंच:
s1.name = "आरव शर्मा";
s1.अंक = 94.5;

// सदस्य विधियों का आह्वान:
s1.गणनाग्रेड();
s1.displayReport();

क्लास नाम के माध्यम से स्थिर सदस्य पहुंच:

क्योंकि स्थैतिक चर और स्थैतिक विधियाँ किसी व्यक्तिगत वस्तु के बजाय संपूर्ण वर्ग से संबंधित हैं, उन्हें किसी वस्तु संदर्भ के बजाय वर्ग नाम का उपयोग करके सीधे लागू किया जाना चाहिए:

// अनुशंसित सर्वोत्तम अभ्यास:
छात्र.स्कूलनाम = "सेंट जेवियर्स स्कूल";
डबल रूट = Math.sqrt(144.0); //गणित कक्षा का नाम है!

किसी वस्तु के जीवन के चार चरण:

1. घोषणा: स्टैक पर एक वैरिएबल नाम को क्लास प्रकार से बांधना।
2. इंस्टैंटिएशन: new ऑपरेटर का उपयोग करके हीप मेमोरी में ऑब्जेक्ट का भौतिक निर्माण।
3. प्रारंभीकरण: इंस्टेंस फ़ील्ड्स को सार्थक स्थिति निर्दिष्ट करने के लिए कंस्ट्रक्टरों का निष्पादन।
4. विनाश और कचरा संग्रहण: जब कोई वस्तु किसी भी सक्रिय संदर्भ चर (उदाहरण के लिए, s1 = null; या पुन: असाइनमेंट s1 = s2;) द्वारा पहुंच योग्य नहीं होती है, तो यह कचरा संग्रहण (GC) के लिए पात्र हो जाती है। JVM का स्वचालित कचरा संग्रहकर्ता समय-समय पर अनाथ हीप मेमोरी को पुनः प्राप्त करता है।

मॉडल प्रोग्राम 1: विधियों के साथ पूर्ण क्लास आर्किटेक्चर

आयात java.util.Scanner;

सार्वजनिक वर्ग छात्र {
    // 1. इंस्टेंस वेरिएबल्स (डेटा सदस्य)
    निजी स्ट्रिंग नाम;
    प्राइवेट इंट रोलनंबर;
    निजी दोहरे अंक1, अंक2, अंक3;
    निजी दोहरा कुल, औसत;
    निजी चार ग्रेड;

    // 2. डेटा इनपुट करने के लिए सदस्य विधि
    सार्वजनिक शून्य स्वीकार() {
        स्कैनर एससी = नया स्कैनर (System.in);
        System.out.print ("छात्र का नाम दर्ज करें:");
        नाम = sc.nextLine();
        System.out.print('रोल नंबर दर्ज करें:');
        रोलनंबर = sc.nextInt();
        System.out.print('3 विषयों में अंक दर्ज करें:');
        मार्क्स1 = एससी.नेक्स्टडबल();
        मार्क्स2 = एससी.नेक्स्टडबल();
        मार्क्स3 = एससी.नेक्स्टडबल();
    }

    // 3. परिणामों की गणना करने के लिए सदस्य विधि
    सार्वजनिक शून्य गणना() {
        कुल = अंक1 + अंक2 + अंक3;
        औसत = कुल / 3.0;
        यदि (औसत>=90) ग्रेड = 'ए';
        अन्यथा यदि (औसत >= 75) ग्रेड = 'बी';
        अन्यथा यदि (औसत>=60) ग्रेड = 'सी';
        अन्यथा यदि (औसत>=40) ग्रेड = 'डी';
        अन्य ग्रेड = 'एफ';
    }

    // 4. स्वरूपित आउटपुट प्रदर्शित करने के लिए सदस्य विधि
    सार्वजनिक शून्य प्रदर्शन() {
        System.out.println(''----- छात्र रिपोर्ट कार्ड -----');
        System.out.println ("रोल नंबर:" + रोल नंबर);
        System.out.println('नाम :' + नाम);
        System.out.println('कुल :' + कुल + '/300');
        System.out.println('औसत :' + औसत + '%');
        System.out.println('ग्रेड :' + ग्रेड);
    }

    // 5. ऑब्जेक्ट को इंस्टेंट करने की मुख्य विधि
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        छात्र ओबीजे = नया छात्र(); // वस्तु निर्माण
        obj.स्वीकार();                // डॉट ऑपरेटर के माध्यम से तरीकों को लागू करना
        obj.compute();
        obj.display();
    }
}

मॉडल प्रोग्राम 2: वास्तविक-विश्व टैरिफ गणना कक्षा

आयात java.util.Scanner;

सार्वजनिक श्रेणी इलेक्ट्रिक बिल {
    निजी स्ट्रिंग n;      // उपभोक्ता का नाम
    निजी पूर्णांक इकाइयाँ;     // उपभोग की गई इकाइयाँ
    निजी दोहरा बिल;   // बिल राशि

    सार्वजनिक शून्य स्वीकार() {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print ("उपभोक्ता नाम दर्ज करें:");
        n = in.nextLine();
        System.out.print('उपभोग की गई इकाइयाँ दर्ज करें:');
        इकाइयाँ = in.nextInt();
    }

    सार्वजनिक शून्य गणना() {
        // स्लैब टैरिफ तर्क
        यदि (इकाइयाँ <= 100) {
            bill = units * 2.0;
        } else if (units <= 300) {
            bill = (100 * 2.0) + ((units - 100) * 3.0);
        } else {
            bill = (100 * 2.0) + (200 * 3.0) + ((units - 300) * 5.0);
            // Surcharge of 2.5% if units exceed 300
            double surcharge = bill * 0.025;
            bill += surcharge;
        }
    }

    public void print() {
        System.out.println("=================================");
        System.out.println("ELECTRICITY CONSUMPTION INVOICE");
        System.out.println("Consumer Name  : " + n);
        System.out.println("Units Consumed : " + units);
        System.out.println("Net Payable    : Rs. " + bill);
        System.out.println("=================================");
    }

    public static void main(String[] args) {
        ElectricBill eb = new ElectricBill();
        eb.accept();
        eb.calculate();
        eb.print();
    }
}