जावा में इनपुट (Input in Java)

ए. डेटा आपूर्ति के दो तरीके:

• 1. संकलन-समय आरंभीकरण: मान सीधे स्रोत कोड के भीतर चर को निर्दिष्ट किए जाते हैं:

  इंट लंबाई = 10;
  पूर्णांक चौड़ाई = 5;
  पूर्णांक क्षेत्रफल = लंबाई * चौड़ाई;

  सीमा: कठोर और गैर-संवादात्मक. किसी भिन्न आयत के क्षेत्रफल की गणना करने के लिए, स्रोत कोड को संशोधित और पुन: संकलित किया जाना चाहिए!
• 2. रन-टाइम इनपुट: प्रोग्राम चलने के दौरान अंतिम-उपयोगकर्ता द्वारा डेटा को गतिशील रूप से आपूर्ति की जाती है, या तो कीबोर्ड स्ट्रीम (Scanner, BufferedReader) या कमांड-लाइन तर्कों के माध्यम से।
  फायदा: अत्यधिक लचीला और इंटरैक्टिव। एक ही संकलित प्रोग्राम स्रोत कोड में बदलाव के बिना अनंत डेटा विविधताओं को संसाधित कर सकता है।

ए. सेटअप प्रोटोकॉल:

Scanner वर्ग java.util पैकेज में रहता है और इसे स्पष्ट रूप से आयात किया जाना चाहिए:

आयात java.util.स्कैनर; // चरण 1: पैकेज आयात करें

सार्वजनिक वर्ग इनपुटडेमो {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in); // चरण 2: ऑब्जेक्ट को त्वरित करें
        // System.in मानक इनपुट स्ट्रीम (कीबोर्ड) का प्रतिनिधित्व करता है
    }
}

बी. संपूर्ण स्कैनर इनपुट पद्धति कैटलॉग:

ए. क्लासिक बफ़र स्किप बग:

System.out.print('रोल नंबर दर्ज करें:');
int रोल = in.nextInt(); // उपयोगकर्ता 105 टाइप करता है और ENTER दबाता है (
)

System.out.print('पूरा नाम दर्ज करें:');
स्ट्रिंग नाम = in.nextLine(); // कीड़ा! बचे हुए को तुरंत खा लेता हूं'
' और छोड़ देता है!

बी. असफल-सुरक्षित समाधान (बफर क्लियरिंग):

पूरी पंक्ति पढ़ने का प्रयास करने से पहले संख्यात्मक या एकल-शब्द इनपुट पढ़ने के तुरंत बाद हमेशा एक अतिरिक्त डमी in.nextLine(); डालें:

System.out.print('रोल नंबर दर्ज करें:');
int रोल = in.nextInt();

in.nextLine(); // बफर फ्लश! उपभोग करता है और अनाथ को त्याग देता है'
'

System.out.print('पूरा नाम दर्ज करें:');
स्ट्रिंग नाम = in.nextLine(); // त्रुटिहीन रूप से काम करता है! वास्तविक उपयोगकर्ता इनपुट के लिए रुकता है.

ए. बफ़र्डरीडर पाइपलाइन:

आयात java.io.BufferedReader;
आयात java.io.InputStreamReader;
आयात java.io.IOException;

पब्लिक क्लास रीडरडेमो {
    सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] args) IOException फेंकता है {
        बफ़रेडरीडर br = नया बफ़रेडरीडर(नया इनपुटस्ट्रीमरीडर(System.in));
        System.out.print('आयु दर्ज करें:');
        int आयु = Integer.parseInt(br.readLine());
    }
}

सॉफ़्टवेयर दोषों की तीन श्रेणियाँ:

1. सिंटैक्स त्रुटियां (संकलन-समय त्रुटियां): निष्पादन से पहले javac द्वारा जावा व्याकरणिक नियमों का उल्लंघन पाया गया। (उदाहरण के लिए, गायब अर्धविराम, बेमेल ब्रेसिज़, गलत वर्तनी वाले कीवर्ड)।
2. तार्किक त्रुटियाँ (बग्स): प्रोग्राम संकलित होता है और क्रैश हुए बिना चलता है, लेकिन त्रुटिपूर्ण एल्गोरिथम डिज़ाइन के कारण गलत आउटपुट उत्पन्न करता है। (उदाहरण के लिए, लंबाई * चौड़ाई के बजाय क्षेत्रफल = लंबाई + चौड़ाई लिखना).
3. रन-टाइम त्रुटियां (अपवाद): कोड वाक्यात्मक रूप से मान्य है, लेकिन एक अवैध ऑपरेशन के कारण निष्पादन के दौरान प्रोग्राम क्रैश हो जाता है। सामान्य इनपुट अपवाद:
   • InputMismatchException: जब nextInt() अंकों की अपेक्षा करता है तो उपयोगकर्ता अक्षर दर्ज करता है।
   • NumberFormatException: Integer.parseInt("abc") गैर-संख्यात्मक स्ट्रिंग्स को पार्स करने में विफल रहता है।
   • ArithmeticException: पूर्णांक को शून्य से विभाजित करने का प्रयास (10 / 0).

ए. इंटरैक्टिव छात्र रिपोर्ट कार्ड जेनरेटर:

आयात java.util.Scanner;

पब्लिक क्लास स्टूडेंटरिपोर्टकार्ड {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);

        System.out.print ("छात्र रोल नंबर दर्ज करें:");
        int रोलनो = in.nextInt();

        in.nextLine(); //बची हुई नई लाइन को साफ़ करने के लिए बफ़र फ्लश!

        System.out.print('छात्र का पूरा नाम दर्ज करें:');
        स्ट्रिंग का पूरा नाम = in.nextLine();

        System.out.print ("अंग्रेज़ी में अंक दर्ज करें (100 में से):");
        डबल अंग्रेजी = in.nextDouble();

        System.out.print ("गणित में अंक दर्ज करें (100 में से):");
        दोहरा गणित = in.nextDouble();

        System.out.print ("विज्ञान में अंक दर्ज करें (100 में से):");
        डबल साइंस = in.nextDouble();

        दोगुना कुल अंक = अंग्रेजी + गणित + विज्ञान;
        दोहरा प्रतिशत = (कुल अंक/300.0) * 100.0;

        चार ग्रेड;
        यदि (प्रतिशत >=90.0) ग्रेड = 'ए';
        अन्यथा यदि (प्रतिशत >=75.0) ग्रेड = 'बी';
        अन्यथा यदि (प्रतिशत >=60.0) ग्रेड = 'सी';
        अन्यथा यदि (प्रतिशत >=40.0) ग्रेड = 'डी';
        अन्य ग्रेड = 'एफ';

        System.out.println("
========== शैक्षणिक रिपोर्ट कार्ड ==========');
        System.out.println('रोल नंबर:' + रोलनंबर);
        System.out.println('छात्र का नाम:' + पूरा नाम);
        System.out.println ("कुल अंक:" + कुल अंक + "/ 300");
        System.out.printf('प्रतिशत : .2f%%
", प्रतिशत);
        System.out.println ("अंतिम ग्रेड:" + ग्रेड);
        System.out.println('==========================================');
    }
}

स्लैब-आधारित वाणिज्यिक टैरिफ कैलकुलेटर:

आयात java.util.Scanner;

सार्वजनिक श्रेणी बिजली बिल {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print ("उपभोक्ता नाम दर्ज करें:");
        स्ट्रिंग नाम = in.nextLine();
        System.out.print('उपभोग की गई इकाइयाँ दर्ज करें:');
        int इकाइयाँ = in.nextInt();

        दोहरा बिलराशि = 0.0;
        // स्लैब-वार गणना:
        // पहली 100 इकाइयाँ: मुफ़्त (₹0)
        // अगली 100 इकाइयाँ (101-200): ₹2.50 प्रति यूनिट
        // अगली 200 इकाइयां (201-400): ₹4.00 प्रति यूनिट
        // 400 यूनिट से ऊपर: ₹6.00 प्रति यूनिट
        यदि (इकाइयाँ <= 100) {
            बिल राशि = 0.0;
        } अन्यथा यदि (इकाइयाँ <= 200) {
            बिलराशि = (इकाइयाँ - 100) * 2.50;
        } अन्यथा यदि (इकाइयाँ <= 400) {
            बिलराशि = (100 * 2.50) + (इकाइयाँ - 200) * 4.00;
        }अन्यथा{
            बिलराशि = (100 * 2.50) + (200 * 4.00) + (यूनिट - 400) * 6.00;
        }

        डबल मीटर किराया = 150.0;
        दोगुना कुल बिल = बिल राशि + मीटर किराया;

        System.out.println("
========== बिजली चालान ========== ");
        System.out.println('उपभोक्ता नाम:' + नाम);
        System.out.println ("उपभोग की गई इकाइयाँ:" + इकाइयाँ + " kWh");
        System.out.println('ऊर्जा शुल्क: ₹' + बिल राशि);
        System.out.println('मीटर किराया: ₹' + मीटररेंट);
        System.out.println('कुल देय : ₹' + totalBill);
        System.out.println('=========================================');
    }
}

ए. प्रिंटफ() विधि और प्रारूप विनिर्देशक:

System.out.printf("फ़ॉर्मेट स्ट्रिंग", तर्क) C:

• %d: दशमलव पूर्णांकों को प्रारूपित करता है (बाइट, लघु, पूर्णांक, लंबा)।
• %f: फ़्लोटिंग-पॉइंट संख्याओं को प्रारूपित करता है। 2 दशमलव स्थानों तक पूर्णांकित करने के लिए %.2f का उपयोग करें।
• %c: एकल वर्ण को प्रारूपित करता है।
• %s: वर्णों की एक स्ट्रिंग को प्रारूपित करता है।
• %n: प्लेटफ़ॉर्म-स्वतंत्र न्यूलाइन.

दोगुनी कीमत = 129.4567;
System.out.printf("आइटम: %s | मूल्य: ₹%%%n", "वैज्ञानिक कैलकुलेटर", मूल्य);
// आउटपुट: आइटम: वैज्ञानिक कैलकुलेटर | कीमत: ₹129.46

ए. स्ट्रिंग[] मुख्य में ऐरे को तर्क देती है():

जावा किसी एप्लिकेशन को लॉन्च करते समय टर्मिनल ऑपरेटिंग सिस्टम कमांड लाइन से सीधे इनपुट मानों की आपूर्ति की अनुमति देता है:

पब्लिक क्लास CommandLineDemo {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        // 'जावा कमांडलाइनडेमो' के बाद टाइप किए गए मान आर्ग्स में संग्रहीत हैं[]
        यदि (args.length >= 2) {
            स्ट्रिंग नाम = args[0];
            पूर्णांक आयु = पूर्णांक.parseInt(args[1]);
            System.out.println("हैलो " + नाम + ", 5 साल में आप " + (उम्र + 5)) हो जायेंगे;
        }
    }
}

टर्मिनल से निष्पादन: जावा कमांडलाइनडेमो आरव 15 → args[0] = "आरव" और args[1] = "15".

ए. स्पेस-डीलिमिटेड मल्टी-टोकन इनपुट:

डिफ़ॉल्ट रूप से, जावा का Scanner वर्ग टोकन सीमांकक के रूप में व्हाइटस्पेस (रिक्त स्थान, टैब और न्यूलाइन) का उपयोग करता है। यह उपयोगकर्ताओं को रिक्त स्थान द्वारा अलग की गई एक पंक्ति पर एकाधिक डेटा मान दर्ज करने में सक्षम बनाता है:

System.out.print('रिक्त स्थान से अलग किए गए तीन पूर्णांक दर्ज करें:');
int a = in.nextInt();
int b = in.nextInt();
int c = in.nextInt();
पूर्णांक योग = ए + बी + सी;
System.out.println("तीन संख्याओं का योग = " + योग);

यदि उपयोगकर्ता प्रवेश करता है: 10 20 30 उसके बाद ENTER, a 10 प्राप्त करता है, b 20 प्राप्त करता है, और c 30 प्राप्त करता है। स्कैनर अलग इनपुट की आवश्यकता के बिना प्रत्येक पूर्णांक को क्रमिक रूप से पार्स करता है पंक्तियाँ.

ए. hasNext():

डायनेमिक उपयोगकर्ता इनपुट स्वीकार करते समय InputMismatchException रनटाइम क्रैश को रोकने के लिए, रक्षात्मक प्रोग्रामर स्कैनर के निरीक्षण तरीकों का उपयोग करते हैं: in.hasNextInt() और in.hasNextDouble() पढ़ने से पहले:

System.out.print('एक पूर्णांक दर्ज करें:');
अगर (in.hasNextInt()) {
    int संख्या = in.nextInt();
    System.out.println ("आपने दर्ज किया:" + संख्या);
}अन्यथा{
    System.out.println('अमान्य इनपुट! पूर्णांक नहीं।');
}

उत्पादन सॉफ़्टवेयर में, सिस्टम इनपुट स्ट्रीम को सावधानी से प्रबंधित किया जाना चाहिए। in.close() को लागू करने से अंतर्निहित ऑपरेटिंग सिस्टम संसाधन जारी होते हैं। हालाँकि, System.in का उपयोग करते समय, स्कैनर को बंद करने से पूरे वर्चुअल मशीन सत्र के लिए मानक इनपुट स्ट्रीम भी बंद हो जाती है, इसलिए इसे केवल अंतिम समाप्ति पर ही बंद करें।

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