अंकगणितीय संक्रियाएँ — Java

यह क्या है और क्यों?

कल्पना करो कि तुम एक मिठाई की दुकान पर कैशियर हो। तुम्हारे पास 10 चॉकलेट का एक डिब्बा है, और एक ग्राहक आया जो 3 खरीदना चाहता है। कितनी बचेंगी? और अगर कल 10 चॉकलेट के 5 और डिब्बे आ जाएँ — तो कुल कितनी होंगी? यह गिनने के लिए हर मिठाई को उंगली से गिनने की ज़रूरत नहीं है। बस अंकगणितीय संक्रियाएँ करनी होंगी — जोड़, घटाव, गुणा और भाग।

Java में ये संक्रियाएँ गणित की तरह ही दिखती हैं, बस गुणा के चिह्न «×» की जगह हम * लिखते हैं और भाग के चिह्न «÷» की जगह / लिखते हैं। कंप्यूटर भी वही कैशियर है, बस बहुत तेज़ और कभी गलती नहीं करता (अगर तुम कमांड में गलती न करो)।

प्रोग्रामिंग में इसकी क्या ज़रूरत है? कल्पना करो कि तुम एक गेम बना रहे हो जहाँ हीरो सिक्के इकट्ठा करता है। हर सेकंड उसके स्कोर में इकट्ठा किए गए सिक्कों की संख्या जोड़नी होती है। या तुम गणित के पाठों के लिए कैलकुलेटर बना रहे हो। या कोई प्रोग्राम जो नए साल में बचे दिनों की गणना करता है। हर जगह अंकगणितीय संक्रियाओं की ज़रूरत होती है।

Java में 5 मुख्य अंकगणितीय संक्रियाएँ हैं:

• + — जोड़ (गणित की तरह)
• - — घटाव
• * — गुणा
• / — भाग (बस Java में पूर्णांकों के साथ एक तरकीब है)
• % — भाग का शेष (यह नया है! यह दिखाता है कि पूर्ण भाग करने पर कितना बचता है)

चलो अब ही तय कर लें: Java में, Python की तरह, डेटा प्रकार होते हैं। संख्याओं के लिए अक्सर int (पूर्णांक, जैसे 5, -3, 100) और double (दशमलव संख्याएँ, जैसे 3.14, -0.5) का उपयोग होता है। अगर तुम एक ही संक्रिया में दोनों को मिलाओगे — Java खुद समझ जाएगा, लेकिन कभी-कभी इससे अप्रत्याशित परिणाम आते हैं (हम इस पर त्रुटियों में चर्चा करेंगे)।

Python के विपरीत, जहाँ तुम बस print(2 + 3) लिख सकते हो और सब काम करेगा, Java में पहले एक क्लास और main मेथड बनाना होता है। डरो मत — यह तुम्हारे प्रोग्राम के लिए बस एक «कंटेनर» है। नीचे दिए गए सभी उदाहरण ऐसे ही कंटेनर के अंदर होंगे।

कोड उदाहरण स्पष्टीकरण के साथ

उदाहरण 1: जोड़ और घटाव (जीवन की तरह)

कल्पना करो कि तुम्हारे पास 15 रुपये थे, तुम्हें 7 और मिले, और फिर तुमने आइसक्रीम पर 10 खर्च कर दिए। कितने बचे?

public class Main {
    public static void main(String[] args) {
        // वेरिएबल घोषित करना — ये लेबल वाले डिब्बे हैं
        int bylo = 15;          // 15 रुपये थे
        int nashel = 7;         // 7 रुपये मिले
        int potratil = 10;      // 10 रुपये खर्च किए

        // गणना: थे + मिले - खर्च किए
        int ostalos = bylo + nashel - potratil;

        // परिणाम स्क्रीन पर दिखाना
        // Java में आउटपुट के लिए System.out.println() का उपयोग करते हैं
        System.out.println("तुम्हारे पास बचे: " + ostalos + " रुपये");
        // स्क्रीन पर दिखेगा: तुम्हारे पास बचे: 12 रुपये
    }
}

यह कैसे काम करता है: Java गणित की तरह बाएँ से दाएँ क्रियाएँ करता है। पहले 15 + 7 = 22, फिर 22 - 10 = 12। परिणाम ostalos वेरिएबल में सेव होता है। System.out.println में + चिह्न टेक्स्ट और संख्याओं को जोड़ने के लिए उपयोग होता है — इसे कॉन्केटनेशन कहते हैं। Python में इसके लिए कॉमा या f-स्ट्रिंग का उपयोग होता है, जबकि Java में प्लस चिह्न का।

उदाहरण 2: गुणा (कमरे का क्षेत्रफल निकालना)

तुमने अपने कमरे का वर्ग मीटर निकालने का फैसला किया। लंबाई — 6 मीटर, चौड़ाई — 4 मीटर।

public class Main {
    public static void main(String[] args) {
        int dlina = 6;
        int shirina = 4;

        // गुणा: क्षेत्रफल = लंबाई * चौड़ाई
        int ploshad = dlina * shirina;

        System.out.println("कमरे का क्षेत्रफल: " + ploshad + " वर्ग मीटर");
        // आउटपुट: कमरे का क्षेत्रफल: 24 वर्ग मीटर

        // अब परिमाप निकालते हैं: (लंबाई + चौड़ाई) * 2
        int perimetr = (dlina + shirina) * 2;
        System.out.println("कमरे का परिमाप: " + perimetr + " मीटर");
        // आउटपुट: कमरे का परिमाप: 20 मीटर
    }
}

कोष्ठकों पर ध्यान दो! Java में, गणित की तरह, पहले कोष्ठकों के अंदर की क्रियाएँ होती हैं। अगर हम dlina + shirina * 2 लिखते, तो पहले 4 को 2 से गुणा होता (8 मिलता), फिर 6 जुड़ता — कुल 14, न कि 20। कोष्ठक क्रम बदल देते हैं!

Python में कोष्ठक बिल्कुल उसी तरह काम करते हैं — यह सभी प्रोग्रामिंग भाषाओं का सामान्य नियम है।

उदाहरण 3: भाग और शेष (पिज़्ज़ा बाँटना)

तुम्हारे पास पिज़्ज़ा के 23 टुकड़े हैं, और 5 दोस्त हैं। बराबर बाँटने पर प्रत्येक को कितने टुकड़े मिलेंगे? तुम्हारे लिए कितने बचेंगे?

public class Main {
    public static void main(String[] args) {
        int kuskov = 23;
        int druzei = 5;

        // पूर्णांक भाग: 23 / 5 = 4 (शेष 3)
        // Java भिन्नात्मक भाग को हटा देता है अगर दोनों संख्याएँ पूर्णांक हों!
        int kazhdomu = kuskov / druzei;
        System.out.println("प्रत्येक दोस्त को: " + kazhdomu + " टुकड़े");
        // आउटपुट: प्रत्येक दोस्त को: 4 टुकड़े

        // भाग का शेष: 23 % 5 = 3
        int ostatok = kuskov % druzei;
        System.out.println("तुम्हारे लिए बचे: " + ostatok + " टुकड़े");
        // आउटपुट: तुम्हारे लिए बचे: 3 टुकड़े

        // जाँच: 4 * 5 + 3 = 23 — बिल्कुल सही!
    }
}

महत्वपूर्ण बात: Java में, अगर तुम पूर्णांक को पूर्णांक से भाग देते हो, तो परिणाम भी पूर्णांक होगा — भिन्नात्मक भाग बस हटा दिया जाता है (गोल नहीं किया जाता, बस हटा दिया जाता है!)। 23 / 5 = 4, न कि 4.6। अगर भिन्नात्मक परिणाम चाहिए, तो कम से कम एक संख्या भिन्नात्मक होनी चाहिए (जैसे, 23.0 / 5 या 23 / 5.0)। Python 3 में पूर्णांकों का भाग डिफ़ॉल्ट रूप से भिन्नात्मक परिणाम देता है, और पूर्णांक भाग के लिए // का उपयोग होता है। Java में ऐसा कोई ऑपरेटर नहीं है — प्रकार स्पष्ट रूप से बताना होता है।

ऑपरेटर % (शेष) बहुत उपयोगी है: इसकी मदद से तुम जाँच सकते हो कि संख्या सम है या विषम (अगर число % 2 == 0, तो सम), या किसी संख्या को किसी अन्य संख्या से विभाजित करने पर कितना बचता है।