IGNOU MCS-024 Solved Question Paper PDF Download

Q1. (a) एक क्लास और एक ऑब्जेक्ट को परिभाषित करें। क्लास के साथ डेटा मेम्बर और मेम्बर फंक्शन होने का क्या फायदा है? (b) एक्सेप्शन और एरर शब्दों को परिभाषित करें। एक्सेप्शन रूटीन हमें असामान्य प्रोग्राम समाप्ति से निपटने में कैसे मदद करते हैं? (c) प्रक्रियाओं की तुलना में थ्रेड्स ‘लाइटवेट’ कैसे होते हैं? अपने उत्तर को सही ठहराएं। (d) ऑब्जेक्ट-सीरियलाइज़ेशन किसी ऑब्जेक्ट की स्थिति को बचाने में कैसे मदद करता है? (e) उदाहरणों के साथ जावा में स्ट्रिंग-क्लास की प्रमुख विशेषताओं पर चर्चा करें। (f) एक एप्लेट और एप्लीकेशन प्रोग्राम के बीच उनके जीवन चक्र के साथ अंतरों को सूचीबद्ध करें। (g) कंटेनर और कंपोनेंट क्लास के संबंध में लेआउटमैनेजर की भूमिका की व्याख्या करें। (h) एक डायग्राम के साथ 3-टियर मॉडल में JDBC-आर्किटेक्चर की व्याख्या करें।

Ans.

(a) क्लास और ऑब्जेक्ट

एक क्लास (Class) ऑब्जेक्ट बनाने के लिए एक ब्लूप्रिंट या टेम्पलेट है। यह गुणों (डेटा मेम्बर्स) और व्यवहारों (मेम्बर फंक्शन्स) को परिभाषित करता है जो क्लास के सभी ऑब्जेक्ट्स के लिए सामान्य हैं। उदाहरण के लिए, एक `Car` क्लास में रंग, मॉडल जैसे गुण और `start()`, `stop()` जैसे व्यवहार हो सकते हैं।

एक ऑब्जेक्ट (Object) एक क्लास का एक इंस्टेंस है। यह एक वास्तविक-विश्व की इकाई है जिसमें स्थिति (state) और व्यवहार (behavior) होता है। जब एक क्लास से एक ऑब्जेक्ट बनाया जाता है, तो यह क्लास में परिभाषित डेटा मेम्बर्स के लिए मेमोरी आवंटित करता है। उदाहरण के लिए, `myCar` `Car` क्लास का एक ऑब्जेक्ट हो सकता है।

डेटा मेम्बर और मेम्बर फंक्शन के लाभ:

क्लास के भीतर डेटा मेम्बर्स (वेरिएबल्स) और मेम्बर फंक्शन्स (मेथड्स) को एक साथ बंडल करने की अवधारणा को एनकैप्सुलेशन (Encapsulation) कहा जाता है। इसके प्रमुख लाभ हैं:

• डेटा हाइडिंग (Data Hiding): यह क्लास के बाहर से डेटा तक सीधी पहुंच को प्रतिबंधित करता है, जिससे डेटा की अखंडता और सुरक्षा में सुधार होता है। डेटा को केवल क्लास के मेम्बर फंक्शन्स के माध्यम से ही एक्सेस और संशोधित किया जा सकता है।
• मॉड्यूलरिटी (Modularity): यह कोड को आत्मनिर्भर और प्रबंधनीय इकाइयों में व्यवस्थित करने में मदद करता है। प्रत्येक क्लास एक अलग इकाई के रूप में कार्य करती है, जिससे कोड को समझना, बनाए रखना और डीबग करना आसान हो जाता है।
• पुन: प्रयोज्यता (Reusability): एक बार परिभाषित की गई क्लास का उपयोग विभिन्न प्रोग्रामों में कई ऑब्जेक्ट बनाने के लिए किया जा सकता है, जिससे कोड पुन: प्रयोज्यता को बढ़ावा मिलता है।

(b) एक्सेप्शन और एरर

एक्सेप्शन (Exception): एक एक्सेप्शन एक ऐसी घटना है जो प्रोग्राम के निष्पादन के दौरान होती है और प्रोग्राम के निर्देशों के सामान्य प्रवाह को बाधित करती है। ये ऐसी स्थितियाँ हैं जिनसे एक अच्छी तरह से लिखा गया एप्लिकेशन उबरने का प्रयास कर सकता है। उदाहरण: `FileNotFoundException`, `ArithmeticException`।

एरर (Error): एक एरर एक गंभीर समस्या को इंगित करता है जिससे एक सामान्य एप्लिकेशन को उबरने का प्रयास नहीं करना चाहिए। ये समस्याएं असामान्य होती हैं और आमतौर पर JVM में या सिस्टम स्तर पर होती हैं, जैसे `OutOfMemoryError` या `StackOverflowError`।

एक्सेप्शन रूटीन की भूमिका:

एक्सेप्शन हैंडलिंग रूटीन, आमतौर पर `try-catch-finally` ब्लॉक का उपयोग करके कार्यान्वित किए जाते हैं, प्रोग्राम को असामान्य समाप्ति से बचाने में मदद करते हैं।

• जब एक `try` ब्लॉक के भीतर एक एक्सेप्शन होता है, तो प्रोग्राम का सामान्य प्रवाह बाधित हो जाता है और JVM संबंधित `catch` ब्लॉक की तलाश करता है।
• यदि एक मैचिंग `catch` ब्लॉक मिलता है, तो उसमें मौजूद कोड निष्पादित होता है। यह प्रोग्रामर को समस्या को संभालने, उपयोगकर्ता को सूचित करने, संसाधनों को साफ करने या वैकल्पिक कार्रवाई करने का अवसर देता है।
• यदि कोई एक्सेप्शन हैंडल नहीं किया जाता है, तो JVM डिफ़ॉल्ट एक्सेप्शन हैंडलर का उपयोग करता है, जो स्टैक ट्रेस प्रिंट करता है और प्रोग्राम को समाप्त कर देता है।

इस तंत्र का उपयोग करके, एक्सेप्शन रूटीन यह सुनिश्चित करते हैं कि प्रोग्राम अचानक क्रैश न हो, जिससे यह अधिक मजबूत और उपयोगकर्ता-अनुकूल बन जाता है। (c) थ्रेड्स बनाम प्रक्रियाएं

थ्रेड्स को प्रक्रियाओं (processes) की तुलना में ‘लाइटवेट’ माना जाता है क्योंकि वे अपने पैरेंट प्रक्रिया के संसाधनों को साझा करते हैं। औचित्य इस प्रकार है:

• साझा मेमोरी स्पेस (Shared Memory Space): एक प्रक्रिया के भीतर बनाए गए सभी थ्रेड्स समान मेमोरी स्पेस (डेटा और हीप सेगमेंट) साझा करते हैं। इसके विपरीत, प्रत्येक प्रक्रिया का अपना अलग मेमोरी स्पेस होता है। इससे थ्रेड्स के बीच संचार (inter-thread communication) बहुत तेज हो जाता है क्योंकि वे सीधे डेटा साझा कर सकते हैं।
• संसाधन ओवरहेड (Resource Overhead): एक नई प्रक्रिया बनाने में एक नया मेमोरी स्पेस, फाइल डिस्क्रिप्टर, और अन्य सिस्टम संसाधन आवंटित करना शामिल है, जो एक महंगा और समय लेने वाला ऑपरेशन है। एक थ्रेड बनाने में बहुत कम ओवरहेड होता है क्योंकि यह मौजूदा प्रक्रिया के संसाधनों का उपयोग करता है।
• संदर्भ स्विचिंग (Context Switching): थ्रेड्स के बीच स्विच करना प्रक्रियाओं के बीच स्विच करने की तुलना में तेज है। ऐसा इसलिए है क्योंकि थ्रेड स्विच के लिए केवल थ्रेड-विशिष्ट डेटा (जैसे प्रोग्राम काउंटर, स्टैक पॉइंटर) को सहेजना और पुनर्स्थापित करना आवश्यक है, जबकि प्रोसेस स्विच के लिए मेमोरी मैनेजमेंट यूनिट (MMU) जानकारी सहित बहुत अधिक संदर्भ को बदलना पड़ता है।

इन कारणों से, थ्रेड्स उन अनुप्रयोगों के लिए एक कुशल समाधान प्रदान करते हैं जिन्हें समवर्ती (concurrent) निष्पादन की आवश्यकता होती है, विशेष रूप से I/O-बाउंड या GUI-आधारित अनुप्रयोगों में। (d) ऑब्जेक्ट-सीरियलाइज़ेशन

ऑब्जेक्ट-सीरियलाइज़ेशन जावा में एक तंत्र है जिसके द्वारा किसी ऑब्जेक्ट की स्थिति को बाइट स्ट्रीम में परिवर्तित किया जा सकता है। यह बाइट स्ट्रीम तब एक फ़ाइल में सहेजी जा सकती है, नेटवर्क पर प्रेषित की जा सकती है, या डेटाबेस में संग्रहीत की जा सकती है। बाद में, इस बाइट स्ट्रीम का उपयोग ऑब्जेक्ट की स्थिति को फिर से बनाने के लिए किया जा सकता है, इस प्रक्रिया को डी-सीरियलाइज़ेशन (deserialization) कहा जाता है।

यह निम्नलिखित तरीकों से किसी ऑब्जेक्ट की स्थिति को बचाने में मदद करता है:

• दृढ़ता (Persistence): सीरियलाइज़ेशन किसी ऑब्जेक्ट की स्थिति को डिस्क पर सहेजने की अनुमति देता है। जब एप्लिकेशन को पुनरारंभ किया जाता है, तो ऑब्जेक्ट को उसकी पिछली स्थिति में पुनर्स्थापित किया जा सकता है, जिससे एप्लिकेशन को वहीं से फिर से शुरू करने में सक्षम बनाया जा सकता है जहां से उसने छोड़ा था।
• संचार (Communication): रिमोट मेथड इनवोकेशन (RMI) जैसे वितरित सिस्टम में, ऑब्जेक्ट्स को सीरियलाइज़ किया जाता है और नेटवर्क पर एक JVM से दूसरे में भेजा जाता है। प्राप्त करने वाला JVM ऑब्जेक्ट को डी-सीरियलाइज़ करता है और उसका उपयोग करता है।

जावा में एक ऑब्जेक्ट को सीरियलाइज़ करने योग्य बनाने के लिए, उसकी क्लास को `java.io.Serializable` इंटरफ़ेस को लागू करना होगा। यह एक मार्कर इंटरफ़ेस है, जिसका अर्थ है कि इसमें कोई मेथड नहीं है। वास्तविक सीरियलाइज़ेशन और डी-सीरियलाइज़ेशन `ObjectOutputStream` और `ObjectInputStream` क्लास द्वारा किया जाता है। (e) जावा में स्ट्रिंग-क्लास की विशेषताएं

जावा में `java.lang.String` क्लास की कई प्रमुख विशेषताएं हैं:

• अपरिवर्तनीयता (Immutability): स्ट्रिंग ऑब्जेक्ट अपरिवर्तनीय होते हैं। एक बार जब एक स्ट्रिंग ऑब्जेक्ट बना दिया जाता है, तो उसकी सामग्री को बदला नहीं जा सकता है। कोई भी ऑपरेशन जो एक स्ट्रिंग को संशोधित करता प्रतीत होता है, जैसे `concat()` या `substring()`, वास्तव में एक नया स्ट्रिंग ऑब्जेक्ट बनाता है। उदाहरण: `String s = “Java”; s.concat(” World”);` `s` अभी भी “Java” को संदर्भित करेगा। परिणाम को पकड़ने के लिए, आपको `s = s.concat(” World”);` करना होगा, जो `s` को एक नए ऑब्जेक्ट को संदर्भित करने के लिए बनाता है।
• स्ट्रिंग पूल (String Pool): जावा मेमोरी बचाने के लिए हीप में एक विशेष क्षेत्र में एक “स्ट्रिंग कॉन्स्टेंट पूल” बनाए रखता है। जब एक स्ट्रिंग लिटरल बनाया जाता है, तो JVM पहले पूल की जाँच करता है। यदि स्ट्रिंग पहले से मौजूद है, तो नए ऑब्जेक्ट बनाने के बजाय मौजूदा इंस्टेंस का एक संदर्भ लौटाया जाता है।
• शाब्दिक निर्माण (Literal Creation): स्ट्रिंग्स को `new` कीवर्ड का उपयोग किए बिना सीधे बनाया जा सकता है, जैसे `String name = “John”;`। यह स्ट्रिंग पूल तंत्र का उपयोग करता है।
• रिच एपीआई (Rich API): `String` क्लास स्ट्रिंग मैनिपुलेशन के लिए बड़ी संख्या में उपयोगी मेथड प्रदान करती है, जैसे `length()`, `charAt(int index)`, `substring(int beginIndex, int endIndex)`, `equals(Object anObject)`, `equalsIgnoreCase(String anotherString)`, `trim()`, और `split(String regex)`।

(f) एप्लेट बनाम एप्लीकेशन प्रोग्राम

एप्लेट और एप्लीकेशन जावा प्रोग्राम लिखने के दो अलग-अलग तरीके हैं। उनके बीच मुख्य अंतर नीचे दिए गए हैं:

• निष्पादन (Execution):
  • एप्लीकेशन: ये स्टैंडअलोन प्रोग्राम हैं जो JVM द्वारा सीधे निष्पादित होते हैं। उन्हें एक `public static void main(String[] args)` मेथड की आवश्यकता होती है जो निष्पादन का प्रवेश बिंदु है।
  • एप्लेट: ये छोटे जावा प्रोग्राम हैं जो एक वेब ब्राउज़र के भीतर या एक एप्लेट व्यूअर टूल में चलने के लिए डिज़ाइन किए गए हैं। उनमें `main()` मेथड नहीं होता है।
• जीवन चक्र (Life Cycle):
  • एप्लीकेशन: इनका एक सरल जीवन चक्र होता है, जो `main()` मेथड से शुरू होता है और जब `main()` समाप्त होता है या `System.exit()` कॉल किया जाता है तो समाप्त होता है।
  • एप्लेट: इनका एक जटिल, ईवेंट-संचालित जीवन चक्र होता है जिसे ब्राउज़र द्वारा प्रबंधित किया जाता है। प्रमुख मेथड हैं: `init()`, `start()`, `paint()`, `stop()`, और `destroy()`।
• सुरक्षा (Security):
  • एप्लीकेशन: डिफ़ॉल्ट रूप से, इनके पास स्थानीय सिस्टम के संसाधनों (जैसे फाइलें, नेटवर्क कनेक्शन) तक पूर्ण पहुंच होती है।
  • एप्लेट: ये एक प्रतिबंधित वातावरण में चलते हैं जिसे “सैंडबॉक्स” कहा जाता है। यह उन्हें स्थानीय फाइल सिस्टम तक पहुंचने या नेटवर्क कनेक्शन बनाने जैसे खतरनाक ऑपरेशन करने से रोकता है।
• आवश्यकताएँ (Requirements):
  • एप्लीकेशन: इन्हें चलाने के लिए केवल JRE की आवश्यकता होती है।
  • एप्लेट: इन्हें चलाने के लिए जावा-सक्षम वेब ब्राउज़र या एप्लेट व्यूअर की आवश्यकता होती है।

(g) लेआउटमैनेजर की भूमिका

AWT (Abstract Window Toolkit) और स्विंग में, một `LayoutManager` एक इंटरफ़ेस है जो एक कंटेनर के भीतर कंपोनेंट्स की स्थिति और आकार का निर्धारण करने के लिए जिम्मेदार है। एक `Container` (जैसे `JFrame`, `JPanel`) एक या एक से अधिक `Component` (जैसे `JButton`, `JTextField`) ऑब्जेक्ट्स को रखता है।

लेआउटमैनेजर की भूमिका महत्वपूर्ण है क्योंकि यह निम्नलिखित कार्य करता है:

• प्लेटफ़ॉर्म स्वतंत्रता (Platform Independence): यह GUI के लेआउट को प्लेटफ़ॉर्म-विशिष्ट विवरणों से अलग करता है। विभिन्न ऑपरेटिंग सिस्टम में अलग-अलग फॉन्ट साइज, स्क्रीन रिज़ॉल्यूशन और विंडो डेकोरेशन हो सकते हैं। लेआउटमैनेजर स्वचालित रूप से इन भिन्नताओं को समायोजित करता है, यह सुनिश्चित करता है कि लेआउट विभिन्न प्लेटफार्मों पर प्रयोग करने योग्य बना रहे।
• स्वचालित पुन: आकार देना (Automatic Resizing): जब कंटेनर का आकार बदला जाता है, तो लेआउटमैनेजर स्वचालित रूप से भीतर के कंपोनेंट्स को अपनी नीति के अनुसार पुन: व्यवस्थित और पुन: आकार देता है। यह निरपेक्ष स्थिति (absolute positioning) के विपरीत है, जहां कंपोनेंट्स अपने आकार और स्थिति को बनाए रखते हैं, जिससे कंटेनर का आकार बदलने पर अजीब लेआउट हो सकता है।
• उपयोग में आसानी (Ease of Use): डेवलपर्स को प्रत्येक कंपोनेंट के लिए पिक्सेल-सटीक निर्देशांक की गणना करने की आवश्यकता नहीं है। इसके बजाय, वे एक उपयुक्त लेआउटमैनेजर (जैसे `FlowLayout`, `BorderLayout`, `GridLayout`, `GridBagLayout`) चुन सकते हैं और कंटेनर में कंपोनेंट्स जोड़ सकते हैं, और मैनेजर बाकी का ध्यान रखता है।

संक्षेप में, `LayoutManager` कंटेनर और कंपोनेंट क्लास के बीच एक मध्यस्थ के रूप में कार्य करता है, जो गतिशील, मजबूत और क्रॉस-प्लेटफ़ॉर्म GUI लेआउट के निर्माण को सरल बनाता है। (h) 3-टियर मॉडल में JDBC-आर्किटेक्चर

3-टियर आर्किटेक्चर एक क्लाइंट-सर्वर आर्किटेक्चर है जिसमें प्रेजेंटेशन, एप्लिकेशन प्रोसेसिंग और डेटा मैनेजमेंट तार्किक रूप से अलग-अलग प्रक्रियाएं हैं। JDBC (Java Database Connectivity) का उपयोग अक्सर इस मॉडल के एप्लिकेशन टियर में डेटाबेस के साथ संचार करने के लिए किया जाता है।

तीन टियर हैं:

1. टियर 1: क्लाइंट टियर (प्रेजेंटेशन लेयर)
   • यह यूजर इंटरफेस है। यह एक वेब ब्राउज़र हो सकता है जो HTML पेज प्रदर्शित करता है, या एक डेस्कटॉप एप्लिकेशन जो स्विंग या AWT का उपयोग करके बनाया गया है।
   • इसका मुख्य काम उपयोगकर्ता से इनपुट लेना और परिणामों को प्रदर्शित करना है। यह सीधे डेटाबेस से इंटरैक्ट नहीं करता है।
2. टियर 2: एप्लिकेशन सर्वर टियर (बिजनेस लॉजिक लेयर)
   • यह आर्किटेक्चर का “मध्य” हिस्सा है। यह क्लाइंट से अनुरोध प्राप्त करता है।
   • यह बिजनेस लॉजिक को लागू करता है और क्लाइंट से प्राप्त डेटा को संसाधित करता है।
   • यह टियर डेटाबेस के साथ संचार करने के लिए JDBC API का उपयोग करता है। यह JDBC ड्राइवर के माध्यम से SQL क्वेरी भेजता है और डेटाबेस से परिणाम प्राप्त करता है।
   • यह परिणामों को संसाधित करता है और उन्हें क्लाइंट टियर को वापस भेजता है (अक्सर HTML, XML, या JSON प्रारूप में)।
3. टियर 3: डेटा सोर्स टियर (डेटा लेयर)
   • यह वास्तविक डेटाबेस मैनेजमेंट सिस्टम (DBMS) जैसे MySQL, Oracle, या PostgreSQL है।
   • इसका काम डेटा को स्टोर और पुनर्प्राप्त करना है। यह एप्लिकेशन सर्वर से SQL कमांड प्राप्त करता है, उन्हें निष्पादित करता है, और डेटा वापस करता है।

डायग्राम विवरण:

(क्लाइंट) — [HTTP/नेटवर्क] —> (एप्लिकेशन सर्वर) — [JDBC] —> (डेटाबेस)

फ्लो:

1. उपयोगकर्ता क्लाइंट टियर पर इंटरैक्ट करता है (जैसे, एक फॉर्म सबमिट करता है)।
2. क्लाइंट टियर एप्लिकेशन सर्वर टियर को एक अनुरोध भेजता है।
3. एप्लिकेशन सर्वर बिजनेस लॉजिक को निष्पादित करता है और JDBC का उपयोग करके डेटाबेस टियर पर एक क्वेरी भेजता है।
4. डेटाबेस क्वेरी को संसाधित करता है और परिणाम एप्लिकेशन सर्वर को वापस करता है।
5. एप्लिकेशन सर्वर परिणामों को प्रारूपित करता है और उन्हें क्लाइंट टियर पर वापस भेजता है, जहां वे उपयोगकर्ता को प्रस्तुत किए जाते हैं।

यह पृथक्करण मापनीयता, लचीलापन और सुरक्षा में सुधार करता है।

Q2. (a) जावा में मेथड्स की ओवरलोडिंग की अवधारणा को एक उदाहरण के साथ समझाएं। (b) जावा भाषा में गारबेज कलेक्शन प्रक्रिया की व्याख्या करें। अन्य भाषाओं की तुलना में इसके प्रमुख लाभ क्या हैं?

Ans.

(a) जावा में मेथड ओवरलोडिंग

मेथड ओवरलोडिंग जावा में संकलन-समय बहुरूपता (compile-time polymorphism) का एक रूप है। यह एक ही क्लास में एक ही नाम के कई मेथड रखने की अनुमति देता है, जब तक कि उनके पैरामीटर अलग-अलग हों। कंपाइलर मेथड के नाम और पास किए गए तर्कों की संख्या और प्रकार के आधार पर यह निर्धारित करता है कि कौन सा मेथड कॉल करना है।

मेथड सिग्नेचर (नाम और पैरामीटर सूची) अलग होना चाहिए। पैरामीटर सूची में अंतर निम्नलिखित तरीकों से हो सकता है:

1. पैरामीटर्स की संख्या में अंतर।
2. पैरामीटर्स के डेटा प्रकार में अंतर।
3. पैरामीटर्स के प्रकारों के क्रम में अंतर।

ध्यान दें: मेथड ओवरलोडिंग केवल मेथड के रिटर्न प्रकार को बदलकर प्राप्त नहीं किया जा सकता है।

लाभ:

• यह प्रोग्राम की पठनीयता (readability) को बढ़ाता है।
• यह कोड की पुन: प्रयोज्यता (reusability) में सुधार करता है।
• यह लचीलापन प्रदान करता है, जिससे एक ही ऑपरेशन को विभिन्न प्रकार के डेटा पर किया जा सकता है।

उदाहरण:

नीचे दिए गए उदाहरण में, `Calculator` क्लास में एक `add` मेथड है जिसे विभिन्न प्रकार के तर्कों के साथ ओवरलोड किया गया है।

class Calculator { // दो पूर्णांकों को जोड़ने के लिए मेथड public int add(int a, int b) { System.out.println(“दो int जोड़ने के लिए मेथड को कॉल किया गया”); return a + b; } // तीन पूर्णांकों को जोड़ने के लिए मेथड public int add(int a, int b, int c) { System.out.println(“तीन int जोड़ने के लिए मेथड को कॉल किया गया”); return a + b + c; } // दो डबल्स को जोड़ने के लिए मेथड public double add(double a, double b) { System.out.println(“दो double जोड़ने के लिए मेथड को कॉल किया गया”); return a + b; } } public class OverloadingExample { public static void main(String[] args) { Calculator calc = new Calculator(); // पहले मेथड को कॉल करता है (int, int) System.out.println(“Sum of 2 and 3 is: ” + calc.add(2, 3)); // दूसरे मेथड को कॉल करता है (int, int, int) System.out.println(“Sum of 2, 3, and 4 is: ” + calc.add(2, 3, 4)); // तीसरे मेथड को कॉल करता है (double, double) System.out.println(“Sum of 2.5 and 3.5 is: ” + calc.add(2.5, 3.5)); } }

इस उदाहरण में, `calc.add(…)` के लिए प्रत्येक कॉल पर, जावा कंपाइलर तर्कों के प्रकार और संख्या के आधार पर सही `add` मेथड का चयन करता है। (b) जावा में गारबेज कलेक्शन

गारबेज कलेक्शन (GC) जावा वर्चुअल मशीन (JVM) द्वारा प्रदान की जाने वाली स्वचालित मेमोरी प्रबंधन (automatic memory management) की प्रक्रिया है। इसका मुख्य उद्देश्य उन ऑब्जेक्ट्स द्वारा कब्जा की गई मेमोरी को पुनः प्राप्त करना है जो अब प्रोग्राम द्वारा उपयोग में नहीं हैं या संदर्भित नहीं हैं।

गारबेज कलेक्शन प्रक्रिया:

प्रक्रिया में आम तौर पर दो चरण होते हैं:

1. पहचान (Identification): गारबेज कलेक्टर उन ऑब्जेक्ट्स की पहचान करता है जो अभी भी उपयोग में हैं और जो नहीं हैं। एक ऑब्जेक्ट को “गारबेज” माना जाता है यदि वह अब किसी भी सक्रिय थ्रेड या किसी अन्य जीवित ऑब्जेक्ट से पहुंच योग्य नहीं है। यह आमतौर पर “पहुंच क्षमता” (reachability) का विश्लेषण करके किया जाता है, जो प्रोग्राम के रूट (जैसे, स्टैक पर स्थानीय चर) से शुरू होता है और उन सभी ऑब्जेक्ट्स को चिह्नित करता है जिन्हें वहां से पहुंचा जा सकता है।
2. पुनर्प्राप्ति (Reclamation): पहचान चरण के बाद, गारबेज कलेक्टर उन सभी अचिह्नित (unmarked) या गैर-पहुंच योग्य (unreachable) ऑब्जेक्ट्स द्वारा कब्जा की गई मेमोरी को हटा देता है। यह मेमोरी फिर हीप (heap) में वापस कर दी जाती है और भविष्य के ऑब्जेक्ट आवंटन के लिए उपलब्ध हो जाती है।

JVM में विभिन्न गारबेज कलेक्शन एल्गोरिदम (जैसे, मार्क-एंड-स्वीप, कॉपीइंग, जनरेशनल) होते हैं, और डेवलपर प्रदर्शन ट्यूनिंग के लिए विभिन्न कलेक्टर चुन सकते हैं।

अन्य भाषाओं की तुलना में लाभ:

C और C++ जैसी भाषाओं में, प्रोग्रामर को `malloc`/`free` या `new`/`delete` का उपयोग करके मैन्युअल रूप से मेमोरी आवंटित और डी-आवंटित करनी पड़ती है। जावा की स्वचालित गारबेज कलेक्शन कई महत्वपूर्ण लाभ प्रदान करती है:

• मेमोरी लीक की रोकथाम (Prevents Memory Leaks): मैन्युअल मेमोरी प्रबंधन में, यदि कोई प्रोग्रामर किसी ऑब्जेक्ट को डी-आवंटित करना भूल जाता है जिसकी अब आवश्यकता नहीं है, तो यह मेमोरी लीक का कारण बनता है। GC स्वचालित रूप से अप्रयुक्त ऑब्जेक्ट्स को साफ करके इस सामान्य बग को समाप्त करता है।
• डैंगलिंग पॉइंटर्स से बचाव (Avoids Dangling Pointers): डैंगलिंग पॉइंटर एक पॉइंटर होता है जो एक मेमोरी स्थान को संदर्भित करता है जिसे पहले ही मुक्त कर दिया गया है। ऐसे पॉइंटर का उपयोग करने से अप्रत्याशित व्यवहार या क्रैश हो सकता है। चूंकि जावा में कोई स्पष्ट डी-आवंटन नहीं है, इसलिए डैंगलिंग पॉइंटर्स की समस्या समाप्त हो जाती है।
• सरलीकृत विकास (Simplified Development): प्रोग्रामर्स को जटिल मेमोरी प्रबंधन कोड लिखने और डीबग करने की आवश्यकता नहीं होती है। यह उन्हें एप्लिकेशन के मुख्य तर्क पर ध्यान केंद्रित करने की अनुमति देता है, जिससे विकास का समय कम होता है और बग की संभावना कम हो जाती है।
• बढ़ी हुई सुरक्षा और मजबूती (Increased Safety and Robustness): मेमोरी प्रबंधन त्रुटियों को स्वचालित रूप से संभालकर, GC जावा अनुप्रयोगों को अधिक स्थिर और सुरक्षित बनाने में मदद करता है।

Q3. (a) उपयुक्त उदाहरणों के साथ जावा में चेक्ड और अनचेक्ड एक्सेप्शन के बीच अंतर करें। (b) एक फाइल I/O जावा प्रोग्राम लिखें जो उपयोगकर्ता से टेक्स्ट की एक लाइन पढ़ता है और इसे ‘Myfile.txt’ नामक फाइल में लिखता है। इसके अलावा, प्रोग्राम ‘Myfile.txt’ फाइल को पढ़ता है और इसकी सामग्री को आउटपुट स्क्रीन पर प्रदर्शित करता है।

Ans.

(a) चेक्ड बनाम अनचेक्ड एक्सेप्शन

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

चेक्ड एक्सेप्शन (Checked Exceptions):

• ये वे एक्सेप्शन हैं जिन्हें कंपाइलर संकलन-समय (compile-time) पर जाँचता है।
• यदि कोई मेथड चेक्ड एक्सेप्शन फेंक सकता है, तो उसे या तो इसे `try-catch` ब्लॉक का उपयोग करके हैंडल करना चाहिए या इसे अपने सिग्नेचर में `throws` कीवर्ड का उपयोग करके घोषित करना चाहिए।
• ये आमतौर पर प्रोग्राम के नियंत्रण से बाहर की स्थितियों का प्रतिनिधित्व करते हैं, जैसे कि नेटवर्क या फ़ाइल सिस्टम के साथ समस्याएं। एक अच्छी तरह से लिखा गया एप्लिकेशन इनसे उबर सकता है।
• ये `java.lang.Exception` के प्रत्यक्ष उपवर्ग हैं लेकिन `java.lang.RuntimeException` के उपवर्ग नहीं हैं।
• उदाहरण: `IOException`, `SQLException`, `FileNotFoundException`, `ClassNotFoundException`।

उदाहरण (चेक्ड एक्सेप्शन):

import java.io.File; import java.io.FileReader; import java.io.FileNotFoundException; public class CheckedExceptionExample { public static void main(String[] args) { File file = new File(“non_existent_file.txt”); try { // यह लाइन FileNotFoundException फेंक सकती है, जो एक चेक्ड एक्सेप्शन है। FileReader fr = new FileReader(file); } catch (FileNotFoundException e) { // कंपाइलर हमें इसे पकड़ने या घोषित करने के लिए मजबूर करता है। System.out.println(“File not found: ” + e.getMessage()); } } }

अनचेक्ड एक्सेप्शन (Unchecked Exceptions):

• ये वे एक्सेप्शन हैं जिन्हें कंपाइलर संकलन-समय पर नहीं जाँचता है।
• एक मेथड को इन एक्सेप्शन को हैंडल करने या घोषित करने की आवश्यकता नहीं होती है।
• ये आमतौर पर प्रोग्रामिंग त्रुटियों या बग्स का परिणाम होते हैं, जैसे कि अमान्य तर्क, अशक्त पॉइंटर्स, या एरे सीमा से बाहर पहुंचना।
• ये `java.lang.RuntimeException` और उसके उपवर्ग हैं। `Error` और उसके उपवर्ग भी अनचेक्ड होते हैं।
• उदाहरण: `NullPointerException`, `ArrayIndexOutOfBoundsException`, `ArithmeticException`, `IllegalArgumentException`।

उदाहरण (अनचेक्ड एक्सेप्शन):

public class UncheckedExceptionExample { public static void main(String[] args) { String text = null; try { // यह लाइन NullPointerException फेंकेगी। // कंपाइलर हमें इसे पकड़ने के लिए मजबूर नहीं करता है। System.out.println(text.length()); } catch (NullPointerException e) { // इसे पकड़ना एक अच्छा अभ्यास है, लेकिन अनिवार्य नहीं है। System.out.println(“Caught NullPointerException: The string is null.”); }

int[] arr = {1, 2, 3}; // यह ArrayIndexOutOfBoundsException फेंकेगा। // System.out.println(arr[3]); } }

संक्षेप में, मुख्य अंतर यह है कि चेक्ड एक्सेप्शन को संकलन-समय पर अनिवार्य रूप से हैंडल किया जाना चाहिए, जबकि अनचेक्ड एक्सेप्शन को नहीं। (b) फाइल I/O जावा प्रोग्राम

यह जावा प्रोग्राम उपयोगकर्ता से इनपुट लेता है, उसे ‘Myfile.txt’ में लिखता है, और फिर उस फ़ाइल की सामग्री को पढ़कर कंसोल पर प्रदर्शित करता है। यह I/O संचालन के लिए `try-with-resources` स्टेटमेंट का उपयोग करता है, जो यह सुनिश्चित करता है कि संसाधन (जैसे फ़ाइल स्ट्रीम) स्वचालित रूप से बंद हो जाएं।

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; public class FileIOProgram { public static void main(String[] args) { String fileName = “Myfile.txt”; // चरण 1: उपयोगकर्ता से टेक्स्ट की एक लाइन पढ़ें और इसे फ़ाइल में लिखें writeToFile(fileName); // चरण 2: फ़ाइल पढ़ें और इसकी सामग्री को स्क्रीन पर प्रदर्शित करें readFromFile(fileName); } /

उपयोगकर्ता से इनपुट पढ़ता है और इसे निर्दिष्ट फ़ाइल में लिखता है।

*/ private static void writeToFile(String fileName) { // try-with-resources यह सुनिश्चित करेगा कि writer और reader स्वचालित रूप से बंद हो जाएं try ( // कंसोल से पढ़ने के लिए BufferedReader बनाएं BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));

// फ़ाइल में लिखने के लिए BufferedWriter बनाएं BufferedWriter writer = new BufferedWriter(new FileWriter(fileName)) ) { System.out.print(“Enter a line of text to write to the file: “);

// उपयोगकर्ता से टेक्स्ट की एक लाइन पढ़ें String textFromUser = consoleReader.readLine();

// टेक्स्ट को फ़ाइल में लिखें writer.write(textFromUser);

// एक नई लाइन जोड़ें (वैकल्पिक, लेकिन अच्छी प्रथा) writer.newLine();

System.out.println(“Successfully wrote to the file ‘” + fileName + “‘.”);

} catch (IOException e) { System.err.println(“An error occurred during file writing: ” + e.getMessage()); e.printStackTrace(); } } /

निर्दिष्ट फ़ाइल को पढ़ता है और इसकी सामग्री को कंसोल पर प्रदर्शित करता है।

*/ private static void readFromFile(String fileName) { System.out.println(“\nReading content from the file ‘” + fileName + “‘:”);

// try-with-resources यह सुनिश्चित करेगा कि reader स्वचालित रूप से बंद हो जाए try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) { String currentLine; // फ़ाइल को लाइन-दर-लाइन पढ़ें जब तक कि अंत न हो जाए while ((currentLine = reader.readLine()) != null) { System.out.println(currentLine); } } catch (IOException e) { System.err.println(“An error occurred during file reading: ” + e.getMessage()); e.printStackTrace(); } } }

कैसे चलाएं: 1. कोड को `FileIOProgram.java` के रूप में सहेजें। 2. इसे `javac FileIOProgram.java` का उपयोग करके संकलित करें। 3. इसे `java FileIOProgram` का उपयोग करके चलाएं। 4. प्रोग्राम आपको टेक्स्ट की एक लाइन दर्ज करने के लिए संकेत देगा। कुछ टेक्स्ट टाइप करें और एंटर दबाएं। 5. प्रोग्राम पुष्टि करेगा कि उसने फ़ाइल में लिखा है, और फिर उसी फ़ाइल से सामग्री को वापस पढ़कर आपको दिखाएगा।

Q4. (a) एक डायग्राम के साथ सभी फंक्शन्स/मेथड्स के साथ एक थ्रेड के जीवन चक्र की व्याख्या करें। थ्रेड प्राथमिकता की भी व्याख्या करें। (b) प्रिंटस्ट्रीम क्लास के विशेष संदर्भ में कैरेक्टर स्ट्रीम क्लास की विशेषताओं की व्याख्या करें।

Ans.

(a) थ्रेड का जीवन चक्र और प्राथमिकता

जावा में एक थ्रेड अपने जीवनकाल में विभिन्न अवस्थाओं से गुजरता है। थ्रेड के जीवन चक्र को इन अवस्थाओं और उनके बीच संक्रमण द्वारा परिभाषित किया गया है।

थ्रेड की अवस्थाएँ:

1. New (नई): जब एक थ्रेड ऑब्जेक्ट का एक नया इंस्टेंस `new Thread(…)` का उपयोग करके बनाया जाता है, तो यह नई अवस्था में होता है। इस बिंदु पर, थ्रेड अभी तक जीवित नहीं है और सिस्टम ने इसके लिए कोई संसाधन आवंटित नहीं किया है।
2. Runnable (चलाने योग्य): जब थ्रेड पर `start()` मेथड को कॉल किया जाता है, तो यह नई अवस्था से चलाने योग्य अवस्था में चला जाता है। इस अवस्था में एक थ्रेड निष्पादन के लिए पात्र है, लेकिन यह थ्रेड शेड्यूलर द्वारा सीपीयू समय आवंटित किए जाने की प्रतीक्षा कर रहा है। इसमें “रनिंग” और “रेडी” दोनों उप-अवस्थाएं शामिल हैं।
3. Blocked/Waiting (अवरुद्ध/प्रतीक्षारत): एक थ्रेड इस अवस्था में प्रवेश करता है जब वह अस्थायी रूप से निष्क्रिय होता है। एक थ्रेड कई कारणों से अवरुद्ध हो सकता है:
   • यह `sleep(milliseconds)` मेथड के कॉल के कारण एक निर्दिष्ट समय के लिए निलंबित है।
   • यह एक I/O ऑपरेशन के पूरा होने की प्रतीक्षा कर रहा है।
   • यह एक `synchronized` ब्लॉक/मेथड में प्रवेश करने की कोशिश कर रहा है जो वर्तमान में दूसरे थ्रेड द्वारा लॉक है।
   • यह `wait()` मेथड को कॉल करने के कारण प्रतीक्षा कर रहा है। यह तब तक प्रतीक्षा करता है जब तक कोई अन्य थ्रेड उसी ऑब्जेक्ट पर `notify()` या `notifyAll()` को कॉल नहीं करता।
   • यह `join()` मेथड को कॉल करने के कारण दूसरे थ्रेड के समाप्त होने की प्रतीक्षा कर रहा है।
4. Terminated (समाप्त): एक थ्रेड इस अवस्था में प्रवेश करता है जब वह अपना कार्य पूरा कर लेता है। यह तब होता है जब उसका `run()` मेथड सामान्य रूप से बाहर निकल जाता है या जब कोई अनकॉट एक्सेप्शन के कारण यह अचानक समाप्त हो जाता है। एक बार समाप्त हो जाने के बाद, एक थ्रेड को फिर से शुरू नहीं किया जा सकता है।

जीवन चक्र का डायग्राम:

[ New ] — `start()` –> [ Runnable ] <–> [ Running ]

[ Running ] — I/O, `sleep()`, `wait()`, `join()` –> [ Blocked/Waiting ]

[ Blocked/Waiting ] — I/O complete, `sleep()` timeout, `notify()`, joined thread dies –> [ Runnable ]

[ Running ] — `run()` completes –> [ Terminated ]

थ्रेड प्राथमिकता (Thread Priority):

जावा में प्रत्येक थ्रेड की एक प्राथमिकता होती है। प्राथमिकताएं 1 और 10 के बीच की संख्याएं होती हैं। एक उच्च संख्या का अर्थ उच्च प्राथमिकता है। थ्रेड शेड्यूलर इन प्राथमिकताओं का उपयोग यह तय करने के लिए करता है कि कौन सा थ्रेड अगले निष्पादित किया जाना है।

• `Thread.MIN_PRIORITY` (मान 1)
• `Thread.NORM_PRIORITY` (मान 5, डिफ़ॉल्ट)
• `Thread.MAX_PRIORITY` (मान 10)

सिद्धांत रूप में, जब कई थ्रेड चलाने के लिए तैयार होते हैं, तो उच्चतम प्राथमिकता वाले थ्रेड को सीपीयू समय मिलने की संभावना सबसे अधिक होती है। हालांकि, थ्रेड शेड्यूलिंग का सटीक व्यवहार JVM और अंतर्निहित ऑपरेटिंग सिस्टम पर अत्यधिक निर्भर है। इसलिए, प्रोग्राम की शुद्धता के लिए थ्रेड प्राथमिकता पर निर्भर रहना उचित नहीं है; इसे केवल प्रदर्शन को प्रभावित करने के लिए एक संकेत के रूप में इस्तेमाल किया जाना चाहिए। आप `setPriority(int)` मेथड का उपयोग करके थ्रेड की प्राथमिकता सेट कर सकते हैं और `getPriority()` का उपयोग करके इसे प्राप्त कर सकते हैं। (b) कैरेक्टर स्ट्रीम क्लास और प्रिंटस्ट्रीम

जावा I/O API को दो मुख्य श्रेणियों में बांटा गया है: बाइट स्ट्रीम और कैरेक्टर स्ट्रीम।

कैरेक्टर स्ट्रीम क्लास की विशेषताएं:

• उद्देश्य: कैरेक्टर स्ट्रीम क्लास विशेष रूप से टेक्स्टुअल डेटा (कैरेक्टर्स) को पढ़ने और लिखने के लिए डिज़ाइन की गई हैं। वे आंतरिक रूप से 16-बिट यूनिकोड कैरेक्टर्स को संभालते हैं, जो उन्हें अंतर्राष्ट्रीयकरण (internationalization) के लिए उपयुक्त बनाता है।
• बेस क्लास: सभी कैरेक्टर इनपुट स्ट्रीम `java.io.Reader` एब्स्ट्रैक्ट क्लास से प्राप्त होती हैं, और सभी कैरेक्टर आउटपुट स्ट्रीम `java.io.Writer` एब्स्ट्रैक्ट क्लास से प्राप्त होती हैं।
• एनकोडिंग: वे कैरेक्टर्स और बाइट्स के बीच स्वचालित रूप से अनुवाद करते हैं, एक निर्दिष्ट या डिफ़ॉल्ट कैरेक्टर सेट (जैसे UTF-8, ISO-8859-1) का उपयोग करते हैं। यह उन्हें टेक्स्ट फ़ाइलों को संभालने के लिए बाइट स्ट्रीम की तुलना में अधिक सुविधाजनक और विश्वसनीय बनाता है।
• उदाहरण: `FileReader`, `FileWriter`, `BufferedReader`, `BufferedWriter`, `PrintWriter`।

बाइट स्ट्रीम, इसके विपरीत, रॉ 8-बिट बाइट्स के साथ काम करती हैं और बाइनरी डेटा (जैसे इमेज, ऑडियो) या निम्न-स्तरीय I/O के लिए उपयुक्त हैं।

`PrintStream` क्लास पर विशेष संदर्भ:

हालांकि `PrintStream` का उपयोग अक्सर टेक्स्ट आउटपुट के लिए किया जाता है (सबसे प्रसिद्ध उदाहरण `System.out` है, जो एक `PrintStream` है), यह एक ऐतिहासिक विसंगति है और वास्तव में एक बाइट स्ट्रीम है, कैरेक्टर स्ट्रीम नहीं । यह `java.io.OutputStream` का एक उपवर्ग है।

`PrintStream` की मुख्य विशेषताएं हैं:

1. बाइट-ओरिएंटेड: यह एक आउटपुट स्ट्रीम है जो बाइट्स लिखती है। जब आप इसे कैरेक्टर या स्ट्रिंग्स पास करते हैं, तो यह उन्हें डिफ़ॉल्ट प्लेटफ़ॉर्म एनकोडिंग का उपयोग करके बाइट्स में परिवर्तित करता है। यह विभिन्न प्लेटफार्मों पर अप्रत्याशित व्यवहार का कारण बन सकता है यदि डिफ़ॉल्ट एनकोडिंग मेल नहीं खाती है।
2. स्वरूपित आउटपुट: इसका मुख्य लाभ `print()`, `println()`, और `printf()` जैसे सुविधाजनक मेथड प्रदान करना है जो विभिन्न आदिम डेटा प्रकारों और ऑब्जेक्ट्स को एक पठनीय टेक्स्ट प्रारूप में परिवर्तित करते हैं।
3. कोई `IOException` नहीं फेंकता: `PrintStream` को सुविधा के लिए डिज़ाइन किया गया है। यह अपने किसी भी सार्वजनिक मेथड से `IOException` नहीं फेंकता है। इसके बजाय, यदि कोई I/O त्रुटि होती है, तो यह एक आंतरिक त्रुटि ध्वज सेट करता है। आप `checkError()` मेथड को कॉल करके इस ध्वज की स्थिति की जांच कर सकते हैं। यह कंसोल आउटपुट के लिए सुविधाजनक है जहां एक I/O त्रुटि की संभावना नहीं है, लेकिन विश्वसनीय फ़ाइल या नेटवर्क लेखन के लिए इसे अनुपयुक्त बनाता है।
4. ऑटो-फ्लशिंग: `PrintStream` को एक `boolean` ध्वज के साथ बनाया जा सकता है जो ऑटो-फ्लशिंग को सक्षम करता है। यदि `true` है, तो जब भी एक नई लाइन (`\n`) वर्ण लिखा जाता है या `println()` मेथड में से एक को कॉल किया जाता है, तो बफर स्वचालित रूप से फ्लश हो जाएगा।

`PrintWriter` के साथ तुलना:

`PrintWriter` कैरेक्टर-ओरिएंटेड समकक्ष है। यह `Writer` का एक उपवर्ग है और `PrintStream` के समान स्वरूपित आउटपुट मेथड प्रदान करता है। टेक्स्ट फ़ाइलों को लिखने के लिए, `PrintWriter` का उपयोग `PrintStream` पर पसंद किया जाता है क्योंकि यह कैरेक्टर एनकोडिंग को सही ढंग से संभालता है और प्लेटफ़ॉर्म-स्वतंत्र है।

Q5. (a) निम्नलिखित को प्रदर्शित करने के लिए एक जावा प्रोग्राम लिखें: (i) ‘Yes’ और ‘No’ लेबल वाले बटन। (ii) ‘Name’ लेबल के साथ नाम दर्ज करने के लिए टेक्स्ट फ़ील्ड। (iii) ‘Submit’ टेक्स्ट वाला सबमिट बटन। (b) java.net पैकेज के तरीकों के साथ जावा में TCP/IP प्रोग्रामिंग की अवधारणा की व्याख्या करें।

Ans.

(a) जावा स्विंग GUI प्रोग्राम

यह जावा प्रोग्राम स्विंग फ्रेमवर्क का उपयोग करके एक ग्राफिकल यूजर इंटरफेस (GUI) बनाता है। यह एक विंडो (`JFrame`) प्रदर्शित करेगा जिसमें निर्दिष्ट कंपोनेंट्स होंगे: दो लेबल वाले बटन, एक लेबल के साथ एक टेक्स्ट फ़ील्ड, और एक सबमिट बटन।

कोड स्विंग कंपोनेंट्स के निर्माण और व्यवस्था को प्रदर्शित करता है।

import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JTextField; import java.awt.FlowLayout; // लेआउट मैनेजर के लिए public class SimpleGUI { public static void main(String[] args) { // एक नया फ्रेम (विंडो) बनाएं JFrame frame = new JFrame(“Simple GUI Example”); // जब विंडो बंद हो तो प्रोग्राम को समाप्त करने के लिए ऑपरेशन सेट करें frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // फ्रेम का आकार सेट करें frame.setSize(400, 150); // एक लेआउट मैनेजर सेट करें। FlowLayout कंपोनेंट्स को बाएं से दाएं लाइन में व्यवस्थित करता है। frame.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 20)); // (i) ‘Yes’ और ‘No’ लेबल वाले बटन JButton yesButton = new JButton(“Yes”); JButton noButton = new JButton(“No”); // (ii) ‘Name’ लेबल के साथ नाम दर्ज करने के लिए टेक्स्ट फ़ील्ड JLabel nameLabel = new JLabel(“Name:”); JTextField nameTextField = new JTextField(15); // 15 कॉलम चौड़ा // (iii) ‘Submit’ टेक्स्ट वाला सबमिट बटन JButton submitButton = new JButton(“Submit”);

// कंपोनेंट्स को फ्रेम में जोड़ें frame.add(yesButton); frame.add(noButton); frame.add(nameLabel); frame.add(nameTextField); frame.add(submitButton); // फ्रेम को दिखाई दें frame.setVisible(true); } }

कोड का स्पष्टीकरण:

• `JFrame` : यह मुख्य विंडो है जिसमें अन्य सभी GUI कंपोनेंट्स रखे जाते हैं।
• `setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)` : यह सुनिश्चित करता है कि जब उपयोगकर्ता विंडो के क्लोज बटन पर क्लिक करता है तो एप्लिकेशन बंद हो जाता है।
• `setLayout(new FlowLayout(…))` : यह `FlowLayout` मैनेजर को फ्रेम में कंपोनेंट्स को व्यवस्थित करने के लिए सेट करता है। कंपोनेंट्स एक पंक्ति में रखे जाते हैं, और यदि पंक्ति भर जाती है तो वे अगली पंक्ति में चले जाते हैं।
• `JButton` : एक मानक क्लिक करने योग्य बटन बनाता है।
• `JLabel` : टेक्स्ट या छवियों का एक स्थिर प्रदर्शन क्षेत्र बनाता है।
• `JTextField` : उपयोगकर्ता को टेक्स्ट की एक पंक्ति दर्ज करने और संपादित करने की अनुमति देता है।
• `frame.add(…)` : निर्दिष्ट कंपोनेंट को विंडो में जोड़ता है।
• `frame.setVisible(true)` : विंडो और उसके कंपोनेंट्स को स्क्रीन पर प्रदर्शित करता है।

यह प्रोग्राम केवल GUI का दृश्य भाग बनाता है; बटन क्लिक या टेक्स्ट प्रविष्टि को संभालने के लिए, आपको इवेंट श्रोताओं (event listeners) को जोड़ने की आवश्यकता होगी। (b) जावा में TCP/IP प्रोग्रामिंग

TCP/IP (ट्रांसमिशन कंट्रोल प्रोटोकॉल/इंटरनेट प्रोटोकॉल) इंटरनेट पर संचार के लिए मूलभूत प्रोटोकॉल सूट है। जावा `java.net` पैकेज के माध्यम से TCP/IP नेटवर्क प्रोग्रामिंग के लिए मजबूत समर्थन प्रदान करता है। TCP एक विश्वसनीय, कनेक्शन-ओरिएंटेड प्रोटोकॉल है, जिसका अर्थ है कि डेटा भेजने से पहले दो अनुप्रयोगों के बीच एक कनेक्शन स्थापित किया जाता है, और यह गारंटी देता है कि डेटा क्रम में और त्रुटियों के बिना वितरित किया जाएगा।

जावा में TCP/IP प्रोग्रामिंग आमतौर पर एक क्लाइंट-सर्वर मॉडल का अनुसरण करती है।

सर्वर साइड (Server Side): सर्वर एक विशिष्ट पोर्ट पर क्लाइंट कनेक्शन के लिए सुनता है।

1. एक `ServerSocket` बनाएं: सर्वर एक `ServerSocket` ऑब्जेक्ट बनाकर शुरू होता है, जो एक विशिष्ट पोर्ट नंबर से बंधा होता है। यह सर्वर को उस पोर्ट पर आने वाले कनेक्शन अनुरोधों को सुनने की अनुमति देता है। मेथड: `ServerSocket serverSocket = new ServerSocket(portNumber);`
2. एक कनेक्शन स्वीकार करें: सर्वर तब `accept()` मेथड को कॉल करता है। यह एक ब्लॉकिंग कॉल है, जिसका अर्थ है कि प्रोग्राम का निष्पादन तब तक रुक जाता है जब तक कि कोई क्लाइंट उस पोर्ट से कनेक्ट नहीं हो जाता। मेथड: `Socket clientSocket = serverSocket.accept();`
3. एक `Socket` प्राप्त करें: जब कोई क्लाइंट कनेक्ट होता है, तो `accept()` मेथड एक `Socket` ऑब्जेक्ट लौटाता है। यह नया `Socket` ऑब्जेक्ट उस विशिष्ट क्लाइंट के साथ संचार के लिए समर्पित है। सर्वर अब अन्य क्लाइंट्स से कनेक्शन स्वीकार करने के लिए अपने `ServerSocket` पर `accept()` को फिर से कॉल करने के लिए स्वतंत्र है (अक्सर एक नए थ्रेड में)।
4. संचार करें: `Socket` ऑब्जेक्ट से, सर्वर `getInputStream()` और `getOutputStream()` का उपयोग करके इनपुट और आउटपुट स्ट्रीम प्राप्त कर सकता है ताकि क्लाइंट से डेटा पढ़ सके और उसे डेटा भेज सके।

क्लाइंट साइड (Client Side): क्लाइंट एक सर्वर से कनेक्शन शुरू करता है।

1. एक `Socket` बनाएं: क्लाइंट एक `Socket` ऑब्जेक्ट बनाता है, जो सर्वर के IP पते और पोर्ट नंबर को निर्दिष्ट करता है जिससे वह कनेक्ट होना चाहता है। मेथड: `Socket socket = new Socket(“server_ip_address”, portNumber);`
2. संचार करें: यदि कनेक्शन सफलतापूर्वक स्थापित हो जाता है, तो क्लाइंट भी `getInputStream()` और `getOutputStream()` का उपयोग करके स्ट्रीम प्राप्त कर सकता है ताकि सर्वर के साथ डेटा का आदान-प्रदान कर सके।

`java.net` पैकेज के मुख्य मेथड और क्लास:

• `java.net.Socket` : यह क्लास एक संचार समापन बिंदु का प्रतिनिधित्व करती है। एक क्लाइंट एक `Socket` बनाता है और एक सर्वर से कनेक्ट होता है। एक सर्वर प्रत्येक क्लाइंट कनेक्शन के लिए एक `Socket` प्राप्त करता है।
  • `getInputStream()`: इस सॉकेट के लिए एक `InputStream` लौटाता है।
  • `getOutputStream()`: इस सॉकेट के लिए एक `OutputStream` लौटाता है।
  • `close()`: सॉकेट कनेक्शन को बंद करता है।
• `java.net.ServerSocket` : यह क्लास सर्वर-साइड सॉकेट के लिए है। यह क्लाइंट्स से कनेक्शन के लिए सुनता है।
  • `ServerSocket(int port)`: एक सर्वर सॉकेट बनाता है जो निर्दिष्ट पोर्ट से बंधा होता है।
  • `accept()`: एक कनेक्शन के लिए सुनता है और उसे स्वीकार करता है।
  • `close()`: सर्वर सॉकेट को बंद करता है।
• `java.net.InetAddress` : यह क्लास IP पते का प्रतिनिधित्व करती है। इसका उपयोग होस्टनाम को IP पते में हल करने के लिए किया जा सकता है।

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

class Calculator { // Method to add two integers public int add(int a, int b) { System.out.println("Called method to add two ints"); return a + b; }
 // Method to add three integers public int add(int a, int b, int c) { System.out.println("Called method to add three ints"); return a + b + c; }
 // Method to add two doubles public double add(double a, double b) { System.out.println("Called method to add two doubles"); return a + b; }}
public class OverloadingExample { public static void main(String[] args) { Calculator calc = new Calculator();
 // Calls the first method (int, int) System.out.println("Sum of 2 and 3 is: " + calc.add(2, 3));
 // Calls the second method (int, int, int) System.out.println("Sum of 2, 3, and 4 is: " + calc.add(2, 3, 4));
 // Calls the third method (double, double) System.out.println("Sum of 2.5 and 3.5 is: " + calc.add(2.5, 3.5)); }}

import java.io.File;import java.io.FileReader;import java.io.FileNotFoundException;
public class CheckedExceptionExample { public static void main(String[] args) { File file = new File("non_existent_file.txt"); try { // This line can throw FileNotFoundException, which is a checked exception. FileReader fr = new FileReader(file); } catch (FileNotFoundException e) { // The compiler forces us to either catch or declare it. System.out.println("File not found: " + e.getMessage()); } }}

public class UncheckedExceptionExample { public static void main(String[] args) { String text = null; try { // This line will throw a NullPointerException. // The compiler does not force us to catch it. System.out.println(text.length()); } catch (NullPointerException e) { // It's good practice to catch it, but not mandatory. System.out.println("Caught NullPointerException: The string is null."); } int[] arr = {1, 2, 3}; // This would throw an ArrayIndexOutOfBoundsException. // System.out.println(arr[3]); }}

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;
public class FileIOProgram {
 public static void main(String[] args) { String fileName = "Myfile.txt";
 // Step 1: Read a line of text from the user and write it to the file writeToFile(fileName);
 // Step 2: Read the file and display its content to the screen readFromFile(fileName); }
 /
Reads input from the user and writes it to the specified file.
     */    private static void writeToFile(String fileName) {        // try-with-resources will ensure the writer and reader are closed automatically        try (            // Create a BufferedReader to read from the console            BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));            // Create a BufferedWriter to write to the file            BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))        ) {            System.out.print("Enter a line of text to write to the file: ");            // Read a line of text from the user            String textFromUser = consoleReader.readLine();            // Write the text to the file            writer.write(textFromUser);            // Add a new line (optional, but good practice)            writer.newLine();            System.out.println("Successfully wrote to the file '" + fileName + "'.");        } catch (IOException e) {            System.err.println("An error occurred during file writing: " + e.getMessage());            e.printStackTrace();        }    }
 /
Reads the specified file and displays its content on the console.
     */    private static void readFromFile(String fileName) {        System.out.println("\nReading content from the file '" + fileName + "':");        // try-with-resources will ensure the reader is closed automatically        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {            String currentLine;            // Read the file line-by-line until the end is reached            while ((currentLine = reader.readLine()) != null) {                System.out.println(currentLine);            }        } catch (IOException e) {            System.err.println("An error occurred during file reading: " + e.getMessage());            e.printStackTrace();        }    }}

import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JTextField;import java.awt.FlowLayout; // For the layout manager
public class SimpleGUI {
 public static void main(String[] args) { // Create a new frame (window) JFrame frame = new JFrame("Simple GUI Example");
 // Set the operation to terminate the program when the window is closed frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 // Set the size of the frame frame.setSize(400, 150);
 // Set a layout manager. FlowLayout arranges components in a line, left to right. frame.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 20));
 // (i) Buttons with Label 'Yes' and 'No' JButton yesButton = new JButton("Yes"); JButton noButton = new JButton("No");
 // (ii) Text field to enter name with Label 'Name' JLabel nameLabel = new JLabel("Name:"); JTextField nameTextField = new JTextField(15); // 15 columns wide
 // (iii) Submit button with text 'Submit' on it JButton submitButton = new JButton("Submit"); // Add the components to the frame frame.add(yesButton); frame.add(noButton); frame.add(nameLabel); frame.add(nameTextField); frame.add(submitButton);
 // Make the frame visible frame.setVisible(true); }}