जावा - त्वरित गाइड

जावा प्रोग्रामिंग भाषा मूल रूप से सन माइक्रोसिस्टम्स द्वारा विकसित की गई थी जिसे जेम्स गोसलिंग द्वारा शुरू किया गया था और 1995 में सन माइक्रोसिस्टम्स के जावा प्लेटफॉर्म (जावा 1.0 [J2SE]) के मुख्य घटक के रूप में जारी किया गया था।

जावा मानक संस्करण की नवीनतम रिलीज़ जावा एसई 8 है। जावा की उन्नति और इसकी व्यापक लोकप्रियता के साथ, विभिन्न प्रकार के प्लेटफार्मों के अनुरूप कई कॉन्फ़िगरेशन बनाए गए थे। उदाहरण के लिए: एंटरप्राइज़ एप्लिकेशन के लिए J2EE, मोबाइल एप्लिकेशन के लिए J2ME।

नए J2 संस्करणों को क्रमशः जावा एसई, जावा ईई और जावा एमई नाम दिया गया। जावा होने की गारंटी हैWrite Once, Run Anywhere.

जावा है -

  • Object Oriented- जावा में, सब कुछ एक वस्तु है। जावा को आसानी से बढ़ाया जा सकता है क्योंकि यह ऑब्जेक्ट मॉडल पर आधारित है।

  • Platform Independent- सी और सी ++ सहित कई अन्य प्रोग्रामिंग भाषाओं के विपरीत, जब जावा संकलित किया जाता है, तो इसे प्लेटफ़ॉर्म विशिष्ट मशीन में संकलित नहीं किया जाता है, बल्कि प्लेटफ़ॉर्म स्वतंत्र बाइट कोड में। यह बाइट कोड वेब पर वितरित किया जाता है और वर्चुअल मशीन (JVM) द्वारा इसे जिस भी प्लेटफॉर्म पर चलाया जा रहा है, उसकी व्याख्या की जाती है।

  • Simple- जावा को सीखना आसान बनाया गया है। यदि आप OOP जावा की मूल अवधारणा को समझते हैं, तो मास्टर करना आसान होगा।

  • Secure- जावा की सुरक्षित सुविधा के साथ यह वायरस-मुक्त, छेड़छाड़-मुक्त सिस्टम विकसित करने में सक्षम बनाता है। प्रमाणीकरण तकनीक सार्वजनिक कुंजी एन्क्रिप्शन पर आधारित है।

  • Architecture-neutral - जावा कंपाइलर एक आर्किटेक्चर-न्यूट्रल ऑब्जेक्ट फाइल फॉर्मेट बनाता है, जो जावा रनटाइम सिस्टम की उपस्थिति के साथ कई प्रोसेसर पर संकलित कोड को निष्पादन योग्य बनाता है।

  • Portable- आर्किटेक्चर-न्यूट्रल होना और स्पेसिफिकेशन का कोई इम्प्लीमेंटेशन डिपेंडेंट पहलू नहीं होना जावा को पोर्टेबल बनाता है। जावा में कंपाइलर ANSI C में एक साफ पोर्टेबिलिटी सीमा के साथ लिखा गया है, जो कि POSIX सबसेट है।

  • Robust - जावा मुख्य रूप से कम्पाइल टाइम एरर चेकिंग और रनटाइम चेकिंग पर जोर देकर त्रुटि प्रवण स्थितियों को खत्म करने का प्रयास करता है।

  • Multithreaded- जावा के मल्टीथ्रेडेड फीचर के साथ ऐसे प्रोग्राम लिखना संभव है जो एक साथ कई कार्य कर सकते हैं। यह डिज़ाइन सुविधा डेवलपर्स को इंटरैक्टिव अनुप्रयोगों का निर्माण करने की अनुमति देती है जो आसानी से चल सकते हैं।

  • Interpreted- जावा बाइट कोड को मूल मशीन निर्देशों के लिए मक्खी पर अनुवादित किया जाता है और इसे कहीं भी संग्रहीत नहीं किया जाता है। लिंकिंग वृद्धिशील और हल्के वजन की प्रक्रिया के बाद से विकास प्रक्रिया अधिक तीव्र और विश्लेषणात्मक है।

  • High Performance - जस्ट-इन-टाइम संकलक के उपयोग के साथ, जावा उच्च प्रदर्शन को सक्षम करता है।

  • Distributed - जावा इंटरनेट के वितरित वातावरण के लिए डिज़ाइन किया गया है।

  • Dynamic- जावा को C या C ++ से अधिक गतिशील माना जाता है क्योंकि इसे एक विकसित वातावरण के अनुकूल बनाया गया है। जावा प्रोग्राम रन-टाइम जानकारी का व्यापक मात्रा में उपयोग कर सकते हैं जो रन-टाइम पर वस्तुओं तक पहुंच को सत्यापित करने और हल करने के लिए उपयोग किया जा सकता है।

जावा का इतिहास

जेम्स गोसलिंग ने जून 1991 में अपनी कई सेट-टॉप बॉक्स परियोजनाओं में से एक में उपयोग के लिए जावा भाषा परियोजना शुरू की। भाषा, जिसे शुरू में 'ओक' कहा जाता था, एक ओक के पेड़ के बाद, जो गोसलिंग के कार्यालय के बाहर खड़ा था, जिसे 'ग्रीन' नाम से भी जाना जाता है और बाद में जावा को यादृच्छिक शब्दों की सूची से नाम दिया गया।

सन ने 1995 में जावा 1.0 के रूप में पहला सार्वजनिक कार्यान्वयन जारी किया। यह वादा किया था Write Once, Run Anywhere (कार्य), लोकप्रिय प्लेटफार्मों पर नो-कॉस्ट रन-टाइम प्रदान करना।

13 नवंबर, 2006 को, Sun ने GNU जनरल पब्लिक लाइसेंस (GPL) की शर्तों के तहत मुक्त और ओपन सोर्स सॉफ़्टवेयर के रूप में जावा का अधिकांश भाग जारी किया।

8 मई, 2007 को, सन ने इस प्रक्रिया को समाप्त कर दिया, जिससे सभी जावा के कोर कोड को स्वतंत्र और ओपन-सोर्स बना दिया, जो कोड के एक छोटे से हिस्से से अलग हो गया, जिसमें सूर्य ने कॉपीराइट नहीं रखा था।

उपकरण आप की आवश्यकता होगी

इस ट्यूटोरियल में चर्चा की गई उदाहरणों के प्रदर्शन के लिए, आपको न्यूनतम 64 एमबी रैम (128 एमबी रैम अनुशंसित) के साथ एक पेंटियम 200-मेगाहर्ट्ज कंप्यूटर की आवश्यकता होगी।

आपको निम्न सॉफ्टवेयर्स की भी आवश्यकता होगी -

  • लिनक्स 7.1 या विंडोज एक्सपी / 7/8 ऑपरेटिंग सिस्टम
  • जावा JDK 8
  • Microsoft नोटपैड या कोई अन्य टेक्स्ट एडिटर

यह ट्यूटोरियल जावा का उपयोग करके जीयूआई, नेटवर्किंग और वेब एप्लिकेशन बनाने के लिए आवश्यक कौशल प्रदान करेगा।

आगे क्या है?

अगला अध्याय आपको निर्देशित करेगा कि आप जावा और उसके प्रलेखन को कैसे प्राप्त कर सकते हैं। अंत में, यह आपको बताता है कि जावा को कैसे स्थापित किया जाए और जावा अनुप्रयोगों को विकसित करने के लिए एक वातावरण तैयार किया जाए।

इस अध्याय में, हम जावा के लिए जन्मजात वातावरण स्थापित करने के विभिन्न पहलुओं पर चर्चा करेंगे।

स्थानीय पर्यावरण सेटअप

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

जावा एसई डाउनलोड जावा से लिंक से स्वतंत्र रूप से उपलब्ध है । आप अपने ऑपरेटिंग सिस्टम के आधार पर एक संस्करण डाउनलोड कर सकते हैं।

जावा डाउनलोड करने और चलाने के लिए निर्देशों का पालन करें .exeअपनी मशीन पर जावा स्थापित करने के लिए। एक बार जब आपने अपनी मशीन पर जावा स्थापित कर लिया, तो आपको इंस्टॉलेशन निर्देशिकाओं को सही करने के लिए पर्यावरण चर सेट करना होगा -

विंडोज के लिए पथ की स्थापना

मान लें कि आपने c: \ Program Files \ java \ jdk निर्देशिका में Java स्थापित किया है -

  • 'मेरा कंप्यूटर' पर राइट-क्लिक करें और 'गुण' चुनें।

  • 'उन्नत' टैब के अंतर्गत 'पर्यावरण चर' बटन पर क्लिक करें।

  • अब, 'Path' वैरिएबल को बदल दें ताकि इसमें जावा एक्जीक्यूटेबल का पथ भी शामिल हो। उदाहरण के लिए, यदि पथ वर्तमान में 'C: \ WINDOWS \ SYSTEM32' पर सेट है, तो 'C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin' पढ़ने के लिए अपना पथ परिवर्तित करें।

लिनक्स, यूनिक्स, सोलारिस, फ्रीबीएसडी के लिए पथ की स्थापना

जावा चर को स्थापित करने के लिए पर्यावरण चर पथ को निर्धारित किया जाना चाहिए। यदि आपको ऐसा करने में परेशानी होती है, तो अपने शेल दस्तावेज़ देखें।

उदाहरण, यदि आप अपने शेल के रूप में बैश का उपयोग करते हैं, तो आप अपने '.bashrc: PATH = / path / to / java: $ PATH' के अंत में निम्नलिखित पंक्ति जोड़ेंगे।

लोकप्रिय जावा संपादक

अपने जावा प्रोग्राम लिखने के लिए, आपको एक टेक्स्ट एडिटर की आवश्यकता होगी। बाजार में और भी अधिक परिष्कृत IDE उपलब्ध हैं। लेकिन अभी के लिए, आप निम्नलिखित में से एक पर विचार कर सकते हैं -

  • Notepad - विंडोज मशीन पर, आप किसी भी साधारण पाठ संपादक जैसे नोटपैड (इस ट्यूटोरियल के लिए अनुशंसित), टेक्स्टपैड का उपयोग कर सकते हैं।

  • Netbeans - एक जावा आईडीई जो ओपन-सोर्स और फ्री है जिसे डाउनलोड किया जा सकता है https://www.netbeans.org/index.html।

  • Eclipse - ग्रहण ओपन-सोर्स समुदाय द्वारा विकसित एक जावा आईडीई और से डाउनलोड किया जा सकता है https://www.eclipse.org/।

आगे क्या है?

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

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

  • Object- वस्तुओं में राज्य और व्यवहार होते हैं। उदाहरण: एक कुत्ते में राज्य होते हैं - रंग, नाम, नस्ल और व्यवहार जैसे कि उनकी पूंछ को भटकाना, भौंकना, खाना। एक वस्तु एक वर्ग का एक उदाहरण है।

  • Class - एक वर्ग को एक टेम्पलेट / खाका के रूप में परिभाषित किया जा सकता है जो उस व्यवहार / स्थिति का वर्णन करता है जो उसके प्रकार का उद्देश्य समर्थन करता है।

  • Methods- एक विधि मूल रूप से एक व्यवहार है। एक क्लास में कई तरीके हो सकते हैं। यह उन तरीकों में है जहां लॉजिक्स लिखा जाता है, डेटा में हेरफेर किया जाता है और सभी कार्यों को निष्पादित किया जाता है।

  • Instance Variables- प्रत्येक ऑब्जेक्ट के उदाहरण चर का एक अनूठा सेट है। ऑब्जेक्ट का राज्य इन उदाहरण चरों में निर्दिष्ट मानों द्वारा बनाया जाता है।

पहला जावा प्रोग्राम

आइए हम एक सरल कोड देखें जो शब्दों को प्रिंट करेगा Hello World

उदाहरण

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

आइए देखें कि फ़ाइल को कैसे सहेजा जाए, संकलन करें और कार्यक्रम चलाएं। कृपया बाद के चरणों का पालन करें -

  • नोटपैड खोलें और ऊपर के रूप में कोड जोड़ें।

  • फ़ाइल को इस रूप में सहेजें: MyFirstJavaProgram.java।

  • एक कमांड प्रॉम्प्ट विंडो खोलें और उस निर्देशिका पर जाएं जहां आपने कक्षा को बचाया था। मान लें कि यह C: \ है।

  • 'Javac MyFirstJavaProgram.java' टाइप करें और अपना कोड संकलित करने के लिए एंटर दबाएँ। यदि आपके कोड में कोई त्रुटि नहीं है, तो कमांड प्रॉम्प्ट आपको अगली पंक्ति में ले जाएगा (मान लें: पथ चर सेट है)।

  • अब, अपना प्रोग्राम चलाने के लिए 'java MyFirstJavaProgram' टाइप करें।

  • आप 'हैलो वर्ल्ड' को विंडो पर प्रिंट करके देख पाएंगे।

उत्पादन

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

बेसिक सिंटेक्स

जावा कार्यक्रमों के बारे में, निम्नलिखित बातों को ध्यान में रखना बहुत महत्वपूर्ण है।

  • Case Sensitivity - जावा केस सेंसिटिव है, जिसका अर्थ है पहचानकर्ता Hello तथा hello जावा में अलग अर्थ होगा।

  • Class Names- सभी वर्ग नामों के लिए पहला पत्र ऊपरी मामले में होना चाहिए। यदि कक्षा के नाम को बनाने के लिए कई शब्दों का उपयोग किया जाता है, तो प्रत्येक आंतरिक शब्द का पहला अक्षर ऊपरी मामले में होना चाहिए।

    Example: वर्ग MyFirstJavaClass

  • Method Names- सभी विधि नाम लोअर केस अक्षर से शुरू होने चाहिए। यदि विधि के नाम को बनाने के लिए कई शब्दों का उपयोग किया जाता है, तो प्रत्येक आंतरिक शब्द का पहला अक्षर ऊपरी मामले में होना चाहिए।

    Example: सार्वजनिक शून्य myMethodName ()

  • Program File Name - प्रोग्राम फ़ाइल का नाम कक्षा के नाम से बिल्कुल मेल खाना चाहिए।

    फ़ाइल को सहेजते समय, आपको इसे वर्ग नाम (याद रखें जावा संवेदनशील है) का उपयोग करके इसे सहेजना चाहिए और नाम के अंत में '। जावा' जोड़ें (यदि फ़ाइल का नाम और वर्ग का नाम मेल नहीं खाते हैं, तो आपका कार्यक्रम संकलित नहीं होगा। )।

    Example:मान लें कि 'MyFirstJavaProgram' वर्ग का नाम है। तब फ़ाइल को 'MyFirstJavaProgram.java' के रूप में सहेजा जाना चाहिए

  • public static void main(String args[]) - जावा प्रोग्राम प्रोसेसिंग मुख्य () विधि से शुरू होती है जो हर जावा प्रोग्राम का अनिवार्य हिस्सा है।

जावा पहचानकर्ता

सभी जावा घटकों के नाम की आवश्यकता है। कक्षाओं, चर और विधियों के लिए उपयोग किए जाने वाले नामों को कहा जाता हैidentifiers

जावा में, पहचानकर्ताओं के बारे में याद रखने के लिए कई बिंदु हैं। वे इस प्रकार हैं -

  • सभी पहचानकर्ताओं को एक अक्षर (ए से जेड या ए टू जेड), मुद्रा चरित्र ($) या एक अंडरस्कोर (_) से शुरू होना चाहिए।

  • पहले चरित्र के बाद, पहचानकर्ताओं के पास पात्रों का कोई संयोजन हो सकता है।

  • एक प्रमुख शब्द का उपयोग पहचानकर्ता के रूप में नहीं किया जा सकता है।

  • सबसे महत्वपूर्ण बात यह है कि पहचानकर्ता संवेदनशील होते हैं।

  • कानूनी पहचानकर्ताओं के उदाहरण: आयु, $ वेतन, _value, __1_value।

  • अवैध पहचानकर्ताओं के उदाहरण: 123abc, -salary।

जावा संशोधक

अन्य भाषाओं की तरह, संशोधक का उपयोग करके कक्षाओं, विधियों आदि को संशोधित करना संभव है। संशोधक की दो श्रेणियां हैं -

  • Access Modifiers - डिफ़ॉल्ट, सार्वजनिक, संरक्षित, निजी

  • Non-access Modifiers - अंतिम, सार, सख्त

हम अगले खंड में संशोधक के बारे में अधिक जानकारी देख रहे हैं।

जावा चर

जावा में चर के प्रकार निम्नलिखित हैं -

  • स्थानीय चर
  • वर्ग चर (स्थैतिक चर)
  • उदाहरण चर (गैर-स्थिर चर)

जावा एरेस

Arrays ऐसी वस्तुएँ हैं जो एक ही प्रकार के कई चर संग्रहित करती हैं। हालाँकि, एक सरणी ही ढेर पर एक वस्तु है। हम आगामी अध्यायों में घोषणा करने, निर्माण और आरंभ करने के तरीकों पर गौर करेंगे।

जावा एनम

Enums जावा 5.0 में पेश किए गए थे। Enums केवल कुछ पूर्वनिर्धारित मूल्यों में से एक होने के लिए एक चर को प्रतिबंधित करते हैं। इस प्रगणित सूची के मूल्यों को एनम कहा जाता है।

Enums के उपयोग से आपके कोड में बगों की संख्या को कम करना संभव है।

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

उदाहरण

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

उपरोक्त उदाहरण निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Size: MEDIUM

Note- एनमों को अपने स्वयं के या एक वर्ग के अंदर घोषित किया जा सकता है। तरीकों, चर, कंस्ट्रक्टरों को एनम के अंदर भी परिभाषित किया जा सकता है।

जावा कीवर्ड

निम्नलिखित सूची जावा में आरक्षित शब्दों को दर्शाती है। ये आरक्षित शब्द निरंतर या परिवर्तनशील या किसी अन्य पहचानकर्ता नाम के रूप में उपयोग नहीं किए जा सकते हैं।

सार ज़ोर बूलियन टूटना
बाइट मामला पकड़ चार
कक्षा स्थिरांक जारी रखें चूक
कर दोहरा अन्य enum
फैली अंतिम आखिरकार नाव
के लिये के लिए जाओ अगर औजार
आयात का उदाहरण पूर्णांक इंटरफेस
लंबा देशी नया पैकेज
निजी संरक्षित जनता वापसी
कम स्थिर strictfp उत्तम
स्विच सिंक्रनाइज़ यह फेंकना
फेंकता क्षणिक प्रयत्न शून्य
परिवर्तनशील जबकि

जावा में टिप्पणियाँ

जावा सी और सी ++ के समान सिंगल-लाइन और मल्टी-लाइन टिप्पणियों का समर्थन करता है। किसी भी टिप्पणी के अंदर उपलब्ध सभी पात्रों को जावा संकलक द्वारा अनदेखा किया जाता है।

उदाहरण

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

उत्पादन

Hello World

खाली लाइनों का उपयोग करना

एक लाइन जिसमें केवल सफेद स्थान होता है, संभवतः एक टिप्पणी के साथ, एक रिक्त रेखा के रूप में जाना जाता है, और जावा इसे पूरी तरह से अनदेखा करता है।

विरासत

जावा में, कक्षाएं कक्षाओं से प्राप्त की जा सकती हैं। मूल रूप से, यदि आपको एक नया वर्ग बनाने की आवश्यकता है और यहां पहले से ही एक वर्ग है जिसमें आपके पास कुछ कोड हैं, तो आपके नए वर्ग को पहले से मौजूद कोड से प्राप्त करना संभव है।

यह अवधारणा आपको एक नए वर्ग में कोड को फिर से लिखने के बिना मौजूदा वर्ग के क्षेत्रों और विधियों का पुन: उपयोग करने की अनुमति देती है। इस परिदृश्य में, मौजूदा वर्ग को कहा जाता हैsuperclass और व्युत्पन्न वर्ग को कहा जाता है subclass

इंटरफेस

जावा भाषा में, एक इंटरफ़ेस को एक दूसरे के साथ संवाद करने के तरीके पर वस्तुओं के बीच एक अनुबंध के रूप में परिभाषित किया जा सकता है। जब वंशानुक्रम की अवधारणा की बात आती है तो इंटरफेस एक महत्वपूर्ण भूमिका निभाता है।

एक इंटरफ़ेस विधियों को परिभाषित करता है, एक व्युत्पन्न वर्ग (उपवर्ग) का उपयोग करना चाहिए। लेकिन विधियों का कार्यान्वयन पूरी तरह से उपवर्ग तक है।

आगे क्या है?

अगला खंड जावा प्रोग्रामिंग में ऑब्जेक्ट्स और कक्षाओं के बारे में बताता है। सत्र के अंत में, आप स्पष्ट चित्र प्राप्त कर सकेंगे कि जावा में कौन सी वस्तुएं और क्या वर्ग हैं।

जावा एक ऑब्जेक्ट-ओरिएंटेड भाषा है। ऑब्जेक्ट-ओरिएंटेड सुविधा वाली भाषा के रूप में, जावा निम्नलिखित मूलभूत अवधारणाओं का समर्थन करता है -

  • Polymorphism
  • Inheritance
  • Encapsulation
  • Abstraction
  • Classes
  • Objects
  • Instance
  • Method
  • संदेश देना

इस अध्याय में, हम अवधारणाओं - कक्षाओं और वस्तुओं पर ध्यान देंगे।

  • Object- वस्तुओं में राज्य और व्यवहार होते हैं। उदाहरण: एक कुत्ते में राज्य होते हैं - रंग, नाम, नस्ल के साथ-साथ व्यवहार - पूंछ को छेड़ना, भौंकना, खाना। एक वस्तु एक वर्ग का एक उदाहरण है।

  • Class - एक वर्ग को एक टेम्पलेट / खाका के रूप में परिभाषित किया जा सकता है जो उस व्यवहार / स्थिति का वर्णन करता है जो उसके प्रकार के समर्थन का उद्देश्य है।

जावा में वस्तुएँ

आइए अब हम गहराई से देखते हैं कि वस्तुएं क्या हैं। यदि हम वास्तविक दुनिया पर विचार करते हैं, तो हम अपने आस-पास कई वस्तुओं, कारों, कुत्तों, मनुष्यों आदि को पा सकते हैं। इन सभी वस्तुओं का एक राज्य और एक व्यवहार होता है।

यदि हम एक कुत्ते पर विचार करते हैं, तो उसकी स्थिति है - नाम, नस्ल, रंग, और व्यवहार है - भौंकना, पूंछ को छेड़ना, दौड़ना।

यदि आप सॉफ़्टवेयर ऑब्जेक्ट की वास्तविक दुनिया ऑब्जेक्ट के साथ तुलना करते हैं, तो उनके पास बहुत समान विशेषताएं हैं।

सॉफ्टवेयर ऑब्जेक्ट में एक स्थिति और एक व्यवहार भी होता है। सॉफ़्टवेयर ऑब्जेक्ट की स्थिति को फ़ील्ड में संग्रहीत किया जाता है और व्यवहार विधियों के माध्यम से दिखाया जाता है।

इसलिए सॉफ्टवेयर डेवलपमेंट में, किसी ऑब्जेक्ट की आंतरिक स्थिति पर तरीके संचालित होते हैं और ऑब्जेक्ट-टू-ऑब्जेक्ट संचार विधियों के माध्यम से किया जाता है।

जावा में कक्षाएं

एक वर्ग एक खाका है जिसमें से व्यक्तिगत वस्तुएं बनाई जाती हैं।

निम्नलिखित एक वर्ग का एक नमूना है।

उदाहरण

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

किसी वर्ग में निम्न चर प्रकार हो सकते हैं।

  • Local variables- तरीकों, कंस्ट्रक्टरों या ब्लॉकों के अंदर परिभाषित चर को स्थानीय चर कहा जाता है। चर घोषित किया जाएगा और विधि के भीतर शुरू किया जाएगा और चर पूरा हो जाएगा जब विधि पूरी हो गई है।

  • Instance variables- इंस्टेंस चर एक वर्ग के भीतर लेकिन किसी भी विधि के बाहर चर रहे हैं। इन चर को तब आरम्भ किया जाता है, जब कक्षा को त्वरित किया जाता है। इंस्टेंस वेरिएबल को उस विशेष वर्ग के किसी भी तरीके, कंस्ट्रक्टर या ब्लॉक के अंदर से एक्सेस किया जा सकता है।

  • Class variables - क्लास चर किसी भी विधि के बाहर, स्थिर कीवर्ड के साथ, वर्ग के भीतर घोषित चर हैं।

एक वर्ग के पास विभिन्न प्रकार के तरीकों के मूल्य तक पहुंचने के लिए किसी भी तरीके की संख्या हो सकती है। उपरोक्त उदाहरण में, भौंकना (), भूख () और नींद () विधियां हैं।

जावा भाषा की कक्षाओं को देखते समय कुछ महत्वपूर्ण विषयों पर चर्चा की जानी आवश्यक है।

कंस्ट्रक्टर्स

कक्षाओं के बारे में चर्चा करते समय, सबसे महत्वपूर्ण उप विषय में से एक निर्माता होगा। हर वर्ग का एक रचनाकार होता है। यदि हम स्पष्ट रूप से एक क्लास के लिए कंस्ट्रक्टर नहीं लिखते हैं, तो जावा कंपाइलर उस क्लास के लिए डिफॉल्ट कंस्ट्रक्टर बनाता है।

हर बार एक नई वस्तु बनाई जाती है, कम से कम एक निर्माणकर्ता को आमंत्रित किया जाएगा। कंस्ट्रक्टरों का मुख्य नियम यह है कि उनका वर्ग के समान नाम होना चाहिए। एक वर्ग में एक से अधिक कंस्ट्रक्टर हो सकते हैं।

निम्नलिखित निर्माणकर्ता का एक उदाहरण है -

उदाहरण

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

जावा सिंग्लटन क्लासेस को भी सपोर्ट करता है जहाँ आप एक क्लास का केवल एक ही उदाहरण बना पाएंगे।

Note- हमारे पास दो अलग-अलग प्रकार के कंस्ट्रक्टर हैं। हम बाद के अध्यायों में विस्तार से चर्चा करने जा रहे हैं।

एक वस्तु का निर्माण

जैसा कि पहले उल्लेख किया गया है, एक वर्ग वस्तुओं के लिए ब्लूप्रिंट प्रदान करता है। तो मूल रूप से, एक वर्ग से एक वस्तु बनाई जाती है। जावा में, नए कीवर्ड का उपयोग नई वस्तुओं को बनाने के लिए किया जाता है।

कक्षा से वस्तु बनाते समय तीन चरण होते हैं -

  • Declaration - एक चर प्रकार के साथ एक चर नाम के साथ एक चर घोषणा।

  • Instantiation - ऑब्जेक्ट बनाने के लिए 'नए' कीवर्ड का उपयोग किया जाता है।

  • Initialization- कंस्ट्रक्टर को कॉल करने के बाद 'नया' कीवर्ड आता है। यह कॉल नई ऑब्जेक्ट को इनिशियलाइज़ करता है।

निम्नलिखित एक वस्तु बनाने का एक उदाहरण है -

उदाहरण

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

यदि हम उपरोक्त कार्यक्रम को संकलित और चलाते हैं, तो यह निम्नलिखित परिणाम देगा -

उत्पादन

Passed Name is :tommy

एक्सेसिंग चर और तरीके

इंस्टेंस वैरिएबल और तरीके निर्मित वस्तुओं के माध्यम से एक्सेस किए जाते हैं। एक उदाहरण चर का उपयोग करने के लिए, निम्नलिखित पूरी तरह से योग्य पथ है -

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

उदाहरण

यह उदाहरण बताता है कि किसी वर्ग के उदाहरण चर और तरीकों का उपयोग कैसे करें।

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

यदि हम उपरोक्त कार्यक्रम को संकलित और चलाते हैं, तो यह निम्नलिखित परिणाम देगा -

उत्पादन

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

स्रोत फ़ाइल घोषणा नियम

इस अनुभाग के अंतिम भाग के रूप में, आइए अब स्रोत फ़ाइल घोषणा नियमों पर ध्यान दें। स्रोत फ़ाइल में कक्षाएं, आयात विवरण और पैकेज स्टेटमेंट घोषित करते समय ये नियम आवश्यक हैं ।

  • प्रति स्रोत फ़ाइल में केवल एक सार्वजनिक वर्ग हो सकता है।

  • एक स्रोत फ़ाइल में कई गैर-सार्वजनिक वर्ग हो सकते हैं।

  • सार्वजनिक श्रेणी का नाम स्रोत फ़ाइल का नाम होना चाहिए और साथ ही इसे जोड़ा जाना चाहिए .javaअतं मै। उदाहरण के लिए: वर्ग का नाम सार्वजनिक वर्ग कर्मचारी {} है तो स्रोत फ़ाइल Employee.java के रूप में होनी चाहिए।

  • यदि क्लास को पैकेज के अंदर परिभाषित किया गया है, तो पैकेज स्टेटमेंट स्रोत फ़ाइल में पहला स्टेटमेंट होना चाहिए।

  • यदि आयात स्टेटमेंट मौजूद हैं, तो उन्हें पैकेज स्टेटमेंट और क्लास डिक्लेरेशन के बीच लिखा जाना चाहिए। यदि कोई पैकेज स्टेटमेंट नहीं हैं, तो आयात विवरण स्रोत फ़ाइल में पहली पंक्ति होनी चाहिए।

  • आयात और पैकेज स्टेटमेंट स्रोत फ़ाइल में मौजूद सभी वर्गों के लिए लागू होंगे। स्रोत फ़ाइल में विभिन्न वर्गों के लिए अलग-अलग आयात और / या पैकेज विवरणों को घोषित करना संभव नहीं है।

कक्षाओं में कई पहुंच स्तर होते हैं और विभिन्न प्रकार की कक्षाएं होती हैं; अमूर्त कक्षाएं, अंतिम कक्षाएं, आदि हम एक्सेस मॉडिफायर अध्याय में इन सभी के बारे में बताएंगे।

उपर्युक्त प्रकार की कक्षाओं के अलावा, जावा में कुछ विशेष कक्षाएं भी हैं जिन्हें इनर क्लासेस और एनोनिमस क्लासेस कहा जाता है।

जावा पैकेज

सरल शब्दों में, यह वर्गों और इंटरफेस को वर्गीकृत करने का एक तरीका है। जावा में एप्लिकेशन विकसित करते समय, सैकड़ों कक्षाएं और इंटरफेस लिखे जाएंगे, इसलिए इन कक्षाओं को वर्गीकृत करना बहुत जरूरी है और साथ ही जीवन को बहुत आसान बनाता है।

आयात विवरण

जावा में अगर एक पूरी तरह से योग्य नाम, जिसमें पैकेज शामिल है और वर्ग का नाम दिया गया है, तो संकलक आसानी से स्रोत कोड या कक्षाएं ढूँढ सकता है। आयात विवरण संकलक को उस विशेष वर्ग को खोजने के लिए उचित स्थान देने का एक तरीका है।

उदाहरण के लिए, निम्नलिखित पंक्ति कंपाइलर को डायरेक्टरी java_installation / java / io में उपलब्ध सभी वर्गों को लोड करने के लिए कहेगी -

import java.io.*;

एक साधारण केस स्टडी

हमारे मामले के अध्ययन के लिए, हम दो कक्षाएं बनाएंगे। वे कर्मचारी और कर्मचारी हैं।

पहले नोटपैड खोलें और निम्नलिखित कोड जोड़ें। याद रखें यह कर्मचारी वर्ग है और वर्ग एक सार्वजनिक वर्ग है। अब, इस स्रोत फ़ाइल को Employee.java नाम से सहेजें।

कर्मचारी वर्ग के चार उदाहरण चर हैं - नाम, आयु, पदनाम और वेतन। कक्षा में एक स्पष्ट रूप से परिभाषित कंस्ट्रक्टर है, जो एक पैरामीटर लेता है।

उदाहरण

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

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

निम्नलिखित कर्मचारी वर्ग है, जो वर्ग कर्मचारी के दो उदाहरण बनाता है और प्रत्येक चर के लिए मान नियत करने के लिए प्रत्येक वस्तु के तरीकों का आह्वान करता है।

निम्न कोड को EmployeeTest.java फ़ाइल में सहेजें।

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

अब, दोनों वर्गों को संकलित करें और फिर परिणाम देखने के लिए EmployeeTest चलाएं -

उत्पादन

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

आगे क्या है?

अगले सत्र में, हम जावा में बुनियादी डेटा प्रकारों पर चर्चा करेंगे और जावा अनुप्रयोगों को विकसित करते समय उनका उपयोग कैसे किया जा सकता है।

एक निर्माणकर्ता एक ऑब्जेक्ट को तब बनाता है जब इसे बनाया जाता है। इसका वर्ग के समान नाम है और यह एक विधि के समान ही है। हालांकि, कंस्ट्रक्टरों के पास कोई स्पष्ट रिटर्न प्रकार नहीं है।

आमतौर पर, आप क्लास द्वारा परिभाषित उदाहरण चर के लिए प्रारंभिक मान देने के लिए या पूरी तरह से बनाई गई ऑब्जेक्ट बनाने के लिए आवश्यक किसी भी अन्य स्टार्ट-अप प्रक्रियाओं को करने के लिए एक कंस्ट्रक्टर का उपयोग करेंगे।

सभी वर्गों में कंस्ट्रक्टर होते हैं, चाहे आप एक को परिभाषित करें या न करें, क्योंकि जावा स्वचालित रूप से एक डिफ़ॉल्ट कंस्ट्रक्टर प्रदान करता है जो सभी सदस्य चर को शून्य पर आरंभीकृत करता है। हालांकि, एक बार जब आप अपने स्वयं के कंस्ट्रक्टर को परिभाषित करते हैं, तो डिफ़ॉल्ट कंस्ट्रक्टर का उपयोग नहीं किया जाता है।

वाक्य - विन्यास

निर्माणकर्ता का वाक्य विन्यास निम्नलिखित है -

class ClassName {
   ClassName() {
   }
}

जावा दो प्रकार के निर्माणकर्ताओं को अनुमति देता है -

  • कोई तर्क नहीं
  • पैरामीटरी कंस्ट्रक्टर्स

कोई तर्क नहीं

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

उदाहरण

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

आप कंस्ट्रक्टर को ऑब्जेक्ट्स को इनिशियलाइज़ करने के लिए निम्नानुसार कहेंगे

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

यह निम्नलिखित परिणाम उत्पन्न करेगा

100 100

पैरामीटरी कंस्ट्रक्टर्स

सबसे अधिक बार, आपको एक निर्माता की आवश्यकता होगी जो एक या अधिक मापदंडों को स्वीकार करता है। पैरामीटर को एक कंस्ट्रक्टर में उसी तरह से जोड़ा जाता है जिस तरह से उन्हें एक विधि में जोड़ा जाता है, बस कंस्ट्रक्टर के नाम के बाद उन्हें कोष्ठक के अंदर घोषित करें।

उदाहरण

यहाँ एक सरल उदाहरण है जो एक निर्माता का उपयोग करता है -

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

आप कंस्ट्रक्टर को ऑब्जेक्ट्स को इनिशियलाइज़ करने के लिए इस प्रकार कहेंगे -

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

10 20

वेरिएबल्स मूल्यों को संग्रहीत करने के लिए आरक्षित मेमोरी स्थानों के अलावा कुछ भी नहीं हैं। इसका मतलब यह है कि जब आप एक चर बनाते हैं तो आप मेमोरी में कुछ स्थान आरक्षित करते हैं।

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

जावा में दो डेटा प्रकार उपलब्ध हैं -

  • आदिम डेटा प्रकार
  • संदर्भ / वस्तु डेटा प्रकार

आदिम डेटा प्रकार

जावा द्वारा समर्थित आठ आदिम डेटाैटिप्स हैं। आदिम डेटाैटिप्स भाषा द्वारा पूर्वनिर्धारित होते हैं और एक कीवर्ड द्वारा नामित किए जाते हैं। आइए अब विस्तार से आठ आदिम डेटा प्रकारों पर गौर करें।

बाइट

  • बाइट डेटा प्रकार एक 8-बिट हस्ताक्षरित दो के पूरक पूर्णांक है

  • न्यूनतम मूल्य -128 है (-2 ^ 7)

  • अधिकतम मूल्य 127 (समावेशी) (2 ^ 7 -1)

  • डिफ़ॉल्ट मान 0 है

  • बाइट डेटा प्रकार का उपयोग बड़े सरणियों में अंतरिक्ष को बचाने के लिए किया जाता है, मुख्य रूप से पूर्णांक के स्थान पर, चूंकि एक बाइट एक पूर्णांक से चार गुना छोटा होता है।

  • उदाहरण: बाइट ए = 100, बाइट बी = -50

कम

  • लघु डेटा प्रकार एक 16-बिट हस्ताक्षरित दो के पूरक पूर्णांक है

  • न्यूनतम मूल्य -32,768 (-2 ^ 15) है

  • अधिकतम मूल्य 32,767 (समावेशी) (2 ^ 15 -1) है

  • शॉर्ट डेटा प्रकार का उपयोग बाइट डेटा प्रकार के रूप में मेमोरी को बचाने के लिए भी किया जा सकता है। एक पूर्णांक की तुलना में एक छोटा 2 गुना छोटा होता है

  • डिफ़ॉल्ट मान 0 है।

  • उदाहरण: लघु s = 10000, लघु r = -20000

पूर्णांक

  • इंट डेटा प्रकार एक 32-बिट हस्ताक्षरित दो के पूरक पूर्णांक है।

  • न्यूनतम मूल्य है - 2,147,483,648 (-2 ^ 31)

  • अधिकतम मूल्य 2,147,483,647 (समावेशी) (2 ^ 31 -1) है

  • जब तक मेमोरी के बारे में चिंता नहीं होती है, तब इंटीगर को आम तौर पर अभिन्न मूल्यों के लिए डिफ़ॉल्ट डेटा प्रकार के रूप में उपयोग किया जाता है।

  • डिफॉल्यू मूल्य शून्य है

  • उदाहरण: int a = 100000, int b = -200000

लंबा

  • लंबा डेटा प्रकार एक 64-बिट हस्ताक्षरित दो का पूर्णांक है
  • न्यूनतम मूल्य -9,223,372,036,854,775,808 (-2 ^ 63) है
  • अधिकतम मूल्य 9,223,372,036,854,775,807 (समावेशी) (2 ^ 63 -1) है
  • इस प्रकार का उपयोग तब किया जाता है जब इंट की तुलना में व्यापक रेंज की आवश्यकता होती है
  • डिफ़ॉल्ट मान 0L है
  • उदाहरण: लंबी ए = 100000 एल, लंबी बी = -200000 एल

नाव

  • फ्लोट डेटा प्रकार एक एकल-सटीक 32-बिट IEEE 754 फ़्लोटिंग पॉइंट है

  • फ्लोट का उपयोग मुख्य रूप से फ्लोटिंग पॉइंट नंबरों की बड़ी सरणियों में मेमोरी को बचाने के लिए किया जाता है

  • डिफ़ॉल्ट मान 0.0f है

  • फ्लोट डेटा प्रकार का उपयोग मुद्रा जैसे सटीक मूल्यों के लिए कभी नहीं किया जाता है

  • उदाहरण: फ्लोट f1 = 234.5f

दोहरा

  • डबल डेटा प्रकार एक डबल-सटीक 64-बिट IEEE 754 फ़्लोटिंग पॉइंट है

  • यह डेटा प्रकार आम तौर पर दशमलव मूल्यों के लिए डिफ़ॉल्ट डेटा प्रकार के रूप में उपयोग किया जाता है, आमतौर पर डिफ़ॉल्ट विकल्प

  • मुद्रा जैसे सटीक मूल्यों के लिए डबल डेटा प्रकार का उपयोग कभी नहीं किया जाना चाहिए

  • डिफ़ॉल्ट मान 0.0d है

  • उदाहरण: डबल डी 1 = 123.4

बूलियन

  • बूलियन डेटा प्रकार एक बिट जानकारी का प्रतिनिधित्व करता है
  • केवल दो संभावित मान हैं: सत्य और असत्य
  • यह डेटा प्रकार सरल झंडे के लिए उपयोग किया जाता है जो सही / गलत स्थितियों को ट्रैक करता है
  • डिफ़ॉल्ट मान गलत है
  • उदाहरण: बूलियन एक = सत्य

चार

  • char डेटा प्रकार एक एकल 16-बिट यूनिकोड वर्ण है
  • न्यूनतम मूल्य '\ u0000' (या 0) है
  • अधिकतम मूल्य '\ uffff' (या 65,535 समावेशी) है
  • किसी भी वर्ण को संग्रहीत करने के लिए चार डेटा प्रकार का उपयोग किया जाता है
  • उदाहरण: चार अक्षर = 'ए'

संदर्भ डेटाटिप्स

  • कक्षाओं के परिभाषित कंस्ट्रक्टरों का उपयोग करके संदर्भ चर बनाए जाते हैं। उनका उपयोग वस्तुओं तक पहुंचने के लिए किया जाता है। इन चरों को एक विशिष्ट प्रकार का घोषित किया जाता है जिन्हें बदला नहीं जा सकता। उदाहरण के लिए, कर्मचारी, पिल्ला, आदि।

  • क्लास ऑब्जेक्ट और विभिन्न प्रकार के सरणी चर संदर्भ डेटाटाइप के अंतर्गत आते हैं।

  • किसी भी संदर्भ चर का डिफ़ॉल्ट मान शून्य है।

  • एक संदर्भ चर का उपयोग घोषित प्रकार की किसी भी वस्तु या किसी भी संगत प्रकार को संदर्भित करने के लिए किया जा सकता है।

  • उदाहरण: पशु पशु = नया पशु ("जिराफ़");

जावा साहित्य

एक शाब्दिक एक निश्चित मूल्य का एक स्रोत कोड प्रतिनिधित्व है। उन्हें बिना किसी गणना के सीधे कोड में दर्शाया जाता है।

साहित्य को किसी भी आदिम प्रकार के चर में सौंपा जा सकता है। उदाहरण के लिए -

byte a = 68;
char a = 'A';

बाइट, इंट, लॉन्ग और शॉर्ट को दशमलव (बेस 10), हेक्साडेसिमल (बेस 16) या ऑक्टल (बेस 8) नंबर सिस्टम में भी व्यक्त किया जा सकता है।

प्रीफिक्स 0 का उपयोग ऑक्टल को इंगित करने के लिए किया जाता है, और उपसर्ग 0x हेक्साडेसिमल को इंगित करता है जब इन नंबर सिस्टम का उपयोग शाब्दिक के लिए होता है। उदाहरण के लिए -

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

जावा में स्ट्रिंग शाब्दिकों को निर्दिष्ट किया जाता है जैसे कि वे दोहरे उद्धरण चिह्नों के बीच वर्णों के अनुक्रम को संलग्न करके अधिकांश अन्य भाषाओं में हैं। स्ट्रिंग शाब्दिक के उदाहरण हैं -

उदाहरण

"Hello World"
"two\nlines"
"\"This is in quotes\""

स्ट्रिंग और चार प्रकार के शाब्दिक में किसी भी यूनिकोड वर्ण शामिल हो सकते हैं। उदाहरण के लिए -

char a = '\u0001';
String a = "\u0001";

जावा भाषा स्ट्रिंग और चार लीटर के लिए कुछ विशेष एस्केप दृश्यों का भी समर्थन करती है। वे हैं -

नोटेशन चरित्र का प्रतिनिधित्व किया
\ n न्यूलाइन (0x0a)
\r Carriage return (0x0d)
\f Formfeed (0x0c)
\b Backspace (0x08)
\s Space (0x20)
\t tab
\" Double quote
\' Single quote
\\ backslash
\ddd Octal character (ddd)
\uxxxx Hexadecimal UNICODE character (xxxx)

What is Next?

This chapter explained the various data types. The next topic explains different variable types and their usage. This will give you a good understanding on how they can be used in the Java classes, interfaces, etc.

A variable provides us with named storage that our programs can manipulate. Each variable in Java has a specific type, which determines the size and layout of the variable's memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

You must declare all variables before they can be used. Following is the basic form of a variable declaration −

data type variable [ = value][, variable [ = value] ...] ;

Here data type is one of Java's datatypes and variable is the name of the variable. To declare more than one variable of the specified type, you can use a comma-separated list.

Following are valid examples of variable declaration and initialization in Java −

Example

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A';        // the char variable a iis initialized with value 'a'

This chapter will explain various variable types available in Java Language. There are three kinds of variables in Java −

  • Local variables
  • Instance variables
  • Class/Static variables

Local Variables

  • Local variables are declared in methods, constructors, or blocks.

  • Local variables are created when the method, constructor or block is entered and the variable will be destroyed once it exits the method, constructor, or block.

  • Access modifiers cannot be used for local variables.

  • Local variables are visible only within the declared method, constructor, or block.

  • Local variables are implemented at stack level internally.

  • There is no default value for local variables, so local variables should be declared and an initial value should be assigned before the first use.

Example

Here, age is a local variable. This is defined inside pupAge() method and its scope is limited to only this method.

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

This will produce the following result −

Output

Puppy age is: 7

Example

Following example uses age without initializing it, so it would give an error at the time of compilation.

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

This will produce the following error while compiling it −

Output

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Instance Variables

  • Instance variables are declared in a class, but outside a method, constructor or any block.

  • When a space is allocated for an object in the heap, a slot for each instance variable value is created.

  • Instance variables are created when an object is created with the use of the keyword 'new' and destroyed when the object is destroyed.

  • Instance variables hold values that must be referenced by more than one method, constructor or block, or essential parts of an object's state that must be present throughout the class.

  • Instance variables can be declared in class level before or after use.

  • Access modifiers can be given for instance variables.

  • The instance variables are visible for all methods, constructors and block in the class. Normally, it is recommended to make these variables private (access level). However, visibility for subclasses can be given for these variables with the use of access modifiers.

  • Instance variables have default values. For numbers, the default value is 0, for Booleans it is false, and for object references it is null. Values can be assigned during the declaration or within the constructor.

  • Instance variables can be accessed directly by calling the variable name inside the class. However, within static methods (when instance variables are given accessibility), they should be called using the fully qualified name. ObjectReference.VariableName.

Example

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

This will produce the following result −

Output

name  : Ransika
salary :1000.0

Class/Static Variables

  • Class variables also known as static variables are declared with the static keyword in a class, but outside a method, constructor or a block.

  • There would only be one copy of each class variable per class, regardless of how many objects are created from it.

  • Static variables are rarely used other than being declared as constants. Constants are variables that are declared as public/private, final, and static. Constant variables never change from their initial value.

  • Static variables are stored in the static memory. It is rare to use static variables other than declared final and used as either public or private constants.

  • Static variables are created when the program starts and destroyed when the program stops.

  • Visibility is similar to instance variables. However, most static variables are declared public since they must be available for users of the class.

  • Default values are same as instance variables. For numbers, the default value is 0; for Booleans, it is false; and for object references, it is null. Values can be assigned during the declaration or within the constructor. Additionally, values can be assigned in special static initializer blocks.

  • Static variables can be accessed by calling with the class name ClassName.VariableName.

  • When declaring class variables as public static final, then variable names (constants) are all in upper case. If the static variables are not public and final, the naming syntax is the same as instance and local variables.

Example

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

This will produce the following result −

Output

Development average salary:1000

Note − If the variables are accessed from an outside class, the constant should be accessed as Employee.DEPARTMENT

What is Next?

You already have used access modifiers (public & private) in this chapter. The next chapter will explain Access Modifiers and Non-Access Modifiers in detail.

Modifiers are keywords that you add to those definitions to change their meanings. Java language has a wide variety of modifiers, including the following −

  • Java Access Modifiers

  • Non Access Modifiers

एक संशोधक का उपयोग करने के लिए, आप एक वर्ग, विधि या चर की परिभाषा में इसके कीवर्ड को शामिल करते हैं। संशोधक शेष कथन को पसंद करता है, जैसा कि निम्नलिखित उदाहरण में है।

उदाहरण

public class className {
   // ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
   // body of method
}

अभिगम नियंत्रण संशोधक

जावा कक्षाओं, चर, विधियों और निर्माणकर्ताओं के लिए पहुँच स्तर निर्धारित करने के लिए कई पहुँच संशोधक प्रदान करता है। चार पहुँच स्तर हैं -

  • पैकेज के लिए दृश्यमान, डिफ़ॉल्ट। किसी भी संशोधक की जरूरत नहीं है।
  • केवल कक्षा के लिए दृश्यमान (निजी)।
  • विश्व के लिए दृश्यमान (सार्वजनिक)।
  • पैकेज और सभी उपवर्ग (संरक्षित) के लिए दृश्यमान।

गैर-पहुंच संशोधक

जावा कई अन्य कार्यक्षमता को प्राप्त करने के लिए गैर-पहुंच संशोधक प्रदान करता है।

  • स्थिर वर्ग के तरीकों और चर बनाने के लिए संशोधक।

  • अंतिम कक्षाएं, विधियों, और चर के कार्यान्वयन को अंतिम रूप देने के लिए संशोधक।

  • सार सार वर्गों और तरीकों बनाने के लिए संशोधक।

  • सिंक्रनाइज़ और अस्थिर संशोधक, जो धागे के लिए उपयोग किया जाता है।

आगे क्या है?

अगले भाग में, हम जावा भाषा में प्रयुक्त बेसिक ऑपरेटर्स के बारे में चर्चा करेंगे। अध्याय आपको एक अवलोकन देगा कि इन ऑपरेटरों को आवेदन विकास के दौरान कैसे उपयोग किया जा सकता है।

जावा वैरिएबल में हेरफेर करने के लिए ऑपरेटरों का एक समृद्ध सेट प्रदान करता है। हम सभी जावा ऑपरेटरों को निम्नलिखित समूहों में विभाजित कर सकते हैं -

  • अंकगणितीय आपरेटर
  • संबंधपरक संकारक
  • बिटवाइज ऑपरेटर्स
  • लॉजिकल ऑपरेटर्स
  • असाइनमेंट ऑपरेटर्स
  • विविध संचालक

अरिथमेटिक ऑपरेटर्स

अंकगणितीय संचालकों का उपयोग गणितीय अभिव्यक्तियों में उसी तरह किया जाता है जैसे कि वे बीजगणित में उपयोग किए जाते हैं। निम्न तालिका अंकगणितीय संचालकों को सूचीबद्ध करती है -

पूर्णांक चर मान लें 10 और चर बी 20 धारण करता है, तो -

उदाहरण दिखाएं

ऑपरेटर विवरण उदाहरण
+ (जोड़) ऑपरेटर के दोनों ओर मान जोड़ता है। A + B 30 देगा
- (घटाव) बाएं हाथ के ऑपरेंड से दाएं हाथ के ऑपरेंड को घटाएं। A - B देगा -10
* (गुणा) ऑपरेटर के दोनों ओर मान बढ़ता है। A * B 200 देगा
/ (विभाजन) दाएं हाथ के ऑपरेंड द्वारा बाएं हाथ के ऑपरेंड को विभाजित करता है। B / A 2 देगा
% (मापांक) दाएं हाथ के ऑपरेंड द्वारा बाएं हाथ के ऑपरेंड को विभाजित करता है और शेष रिटर्न करता है। ब% ए द 0 दे खेंगे
++ (वृद्धि) 1 से ऑपरेंड के मूल्य को बढ़ाता है। B ++ 21 देता है
- (कमी) 1 से ऑपरेंड के मूल्य को घटाता है। B-- 19 देता है

रिलेशनल ऑपरेटर्स

जावा भाषा द्वारा समर्थित रिलेशनल ऑपरेटर्स निम्नलिखित हैं।

चर ए मान लें 10 और चर बी 20 रखती है, तो -

उदाहरण दिखाएं

ऑपरेटर विवरण उदाहरण
== (बराबर) जाँच करता है कि दो ऑपरेंड के मान समान हैं या नहीं, यदि हाँ तो स्थिति सच हो जाती है। (ए == बी) सच नहीं है।
! = (बराबर नहीं) जाँच करता है कि दो ऑपरेंड के मान समान हैं या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है। (ए! = बी) सच है।
> (इससे अधिक) यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से अधिक है, यदि हाँ, तो स्थिति सत्य है। (ए> बी) सच नहीं है।
<(से कम) यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम है, यदि हाँ, तो स्थिति सही है। (ए <बी) सच है।
> = (से अधिक या बराबर) जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या उसके बराबर है, यदि हाँ तो स्थिति सच हो जाती है। (ए> = बी) सच नहीं है।
<= (इससे कम या बराबर) जाँच करता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम या उसके बराबर है, यदि हाँ तो स्थिति सत्य हो जाती है। (ए <= बी) सच है।

बिटवाइज ऑपरेटर्स

जावा कई बिटकॉइन ऑपरेटरों को परिभाषित करता है, जो पूर्णांक प्रकारों पर लागू किया जा सकता है, लंबे, इंट, लघु, चार और बाइट।

बिटवाइज़ ऑपरेटर बिट पर काम करता है और बिट-बाय-बिट ऑपरेशन करता है। मान लें कि एक = 60 और बी = 13; अब द्विआधारी प्रारूप में वे निम्नानुसार होंगे -

a = 0011 1100

b = ०००० ११०१

-----------------

a & b = 0000 1100

a | b = 0011 1101

ए ^ बी = 0011 0001

~ a = 1100 0011

निम्न तालिका बिटवाइज़ ऑपरेटरों को सूचीबद्ध करती है -

पूर्णांक चर मानें एक धारण 60 और चर बी 13 रखती है -

उदाहरण दिखाएं

ऑपरेटर विवरण उदाहरण
और (बिटवाइज़ और) बाइनरी और ऑपरेटर परिणाम के लिए थोड़ा सा कॉपी करता है यदि यह दोनों ऑपरेंड में मौजूद है। (A & B) 12 देगा जो 0000 1100 है
| (बिटवाइज़ या) बाइनरी या ऑपरेटर थोड़ा सा कॉपी करता है अगर यह किसी भी ऑपरेंड में मौजूद है। (ए | बी) 61 देगा जो 0011 1101 है
^ (बिट वाइज XOR) बाइनरी एक्सओआर ऑपरेटर बिट को कॉपी करता है यदि यह एक ऑपरेंड में सेट होता है लेकिन दोनों नहीं। (ए ^ बी) 49 देगा जो 0011 0001 है
~ (बिटवाइस तारीफ) बाइनरी ओन्स कंप्लीट ऑपरेटर, एकात्मक है और इसमें 'फ्लिपिंग' बिट्स का प्रभाव होता है। (~ ए) -61 देगा जो हस्ताक्षरित बाइनरी नंबर के कारण 2 के पूरक रूप में 1100 0011 है।
<< (बाईं पारी) बाइनरी लेफ्ट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से छोड़ दिया जाता है। A << 2 240 देगा जो 1111 0000 है
>> (सही पारी) बाइनरी राइट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाएं स्थानांतरित किया जाता है। A >> 2 15 देगा जो 1111 है
>>> (शून्य भरण दाईं पारी) दाएं शून्य भरण ऑपरेटर को शिफ्ट करें बाएं ऑपरेंड वैल्यू को सही ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाएं स्थानांतरित किया जाता है और शिफ्ट किए गए मान शून्य से भरे जाते हैं। A >>> 2 15 देगा जो 0000 1111 है

लॉजिकल ऑपरेटर्स

निम्न तालिका तार्किक ऑपरेटरों को सूचीबद्ध करती है -

बूलियन चर मान लें कि A सत्य है और परिवर्तनशील B गलत धारण करता है, तो -

उदाहरण दिखाएं

ऑपरेटर विवरण उदाहरण
&& (तार्किक और) जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। यदि दोनों ऑपरेशंस गैर-शून्य हैं, तो स्थिति सच हो जाती है। (A && B) गलत है
|| (तार्किक या) जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दोनों संचालकों में से कोई भी गैर-शून्य है, तो स्थिति सच हो जाती है। (ए || बी) सच है
! (तार्किक नहीं) जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है। उपयोग अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सही है तो लॉजिकल नॉट ऑपरेटर गलत साबित करेगा। ! (A && B) सत्य है

असाइनमेंट ऑपरेटर्स

जावा भाषा द्वारा समर्थित असाइनमेंट ऑपरेटर निम्नलिखित हैं -

उदाहरण दिखाएं

ऑपरेटर विवरण उदाहरण
= सरल असाइनमेंट ऑपरेटर। राइट साइड ऑपरेंड से लेफ्ट साइड ऑपरेंड तक वैल्यू असाइन करता है। C = A + B A + B का C में मान प्रदान करेगा
+ = जोड़ें और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड में दाईं ओर ऑपरेंड जोड़ता है और परिणाम को बाएं ऑपरेंड में असाइन करता है। C + = A C = C + A के बराबर है
- = घटाना और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड से दाएं ऑपरेंड को घटाता है और लेफ्ट ऑपरेंड को रिजल्ट सौंपता है। C - = A C = C - A के बराबर है
* = गुणा और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड के साथ दाएं ऑपरेंड को गुणा करता है और परिणाम को बाएं ऑपरेंड में असाइन करता है। C * = A C = C * A के बराबर है
/ = डिवाइड और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड को दाएं ऑपरेंड के साथ विभाजित करता है और परिणाम को बाएं ऑपरेंड को सौंपता है। C / = A C = C / A के बराबर है
% = मापांक और असाइनमेंट ऑपरेटर। यह दो ऑपरेंड का उपयोग करके मापांक लेता है और परिणाम को बाएं ऑपरेंड में असाइन करता है। C% = A C = C% A के बराबर है
<< = लेफ्ट शिफ्ट और असाइनमेंट ऑपरेटर। C << = 2 C = C << 2 के समान है
>> = राइट शिफ्ट और असाइनमेंट ऑपरेटर। C >> = 2 C = C >> 2 के समान है
और = बिटवाइज और असाइनमेंट ऑपरेटर। C & = 2 C = C & 2 के समान है
^ = बिटवाइज एक्सक्लूसिव OR एंड असाइनमेंट ऑपरेटर। C ^ = 2 C = C ^ 2 के समान है
| = बिटवाइज समावेशी या असाइनमेंट ऑपरेटर। C | = 2 C = C के समान है 2

विविध संचालक

जावा भाषा द्वारा समर्थित कुछ अन्य ऑपरेटर हैं।

सशर्त संचालक (:)

सशर्त संचालक के रूप में भी जाना जाता है ternary operator। इस ऑपरेटर में तीन ऑपरेंड होते हैं और इसका उपयोग बूलियन अभिव्यक्तियों के मूल्यांकन के लिए किया जाता है। ऑपरेटर का लक्ष्य यह तय करना है कि किस मूल्य को चर को सौंपा जाना चाहिए। ऑपरेटर के रूप में लिखा है -

variable x = (expression) ? value if true : value if false

निम्नलिखित एक उदाहरण है -

Example

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Output

Value of b is : 30
Value of b is : 20

instof ऑपरेटर

इस ऑपरेटर का उपयोग केवल ऑब्जेक्ट संदर्भ चर के लिए किया जाता है। ऑपरेटर जाँचता है कि क्या वस्तु एक विशेष प्रकार (वर्ग प्रकार या इंटरफ़ेस प्रकार) की है। Instof ऑपरेटर के रूप में लिखा जाता है -

( Object reference variable ) instanceof  (class/interface type)

यदि ऑपरेटर के बाईं ओर चर द्वारा संदर्भित ऑब्जेक्ट IS / A चेक को दाईं ओर वर्ग / इंटरफ़ेस प्रकार के लिए पास करता है, तो परिणाम सही होगा। निम्नलिखित एक उदाहरण है -

Example

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Output

true

यह ऑपरेटर अभी भी सही लौटेगा, यदि ऑब्जेक्ट की तुलना सही पर टाइप के साथ काम करने के लिए की गई है। निम्नलिखित एक और उदाहरण है -

Example

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Output

true

जावा ऑपरेटर्स की प्राथमिकता

ऑपरेटर पूर्वता एक अभिव्यक्ति में शब्दों के समूहीकरण को निर्धारित करता है। यह प्रभावित करता है कि अभिव्यक्ति का मूल्यांकन कैसे किया जाता है। कुछ ऑपरेटरों में अन्य लोगों की तुलना में अधिक पूर्वता है; उदाहरण के लिए, गुणा ऑपरेटर में अतिरिक्त ऑपरेटर की तुलना में अधिक पूर्वता है -

उदाहरण के लिए, x = 7 + 3 * 2; यहाँ x को 13 नहीं, 20 को सौंपा गया है क्योंकि ऑपरेटर * में + से अधिक पूर्वता है, इसलिए यह पहले 3 * 2 के साथ गुणा हो जाता है और फिर 7 में जुड़ जाता है।

यहां, सबसे अधिक पूर्वता वाले ऑपरेटर तालिका के शीर्ष पर दिखाई देते हैं, जो सबसे निचले तल पर दिखाई देते हैं। एक अभिव्यक्ति के भीतर, उच्च पूर्वता ऑपरेटरों का मूल्यांकन पहले किया जाएगा।

वर्ग ऑपरेटर संबद्धता
पोस्टफ़िक्स अभिव्यक्ति ++ अभिव्यक्ति-- बाएं से दाएं
एकल ++ अभिव्यक्ति-- अभिव्यक्ति + अभिव्यक्ति-अभिव्यक्ति ~! दाएं से बाएं
गुणक * *% बाएं से दाएं
additive + - बाएं से दाएं
खिसक जाना << >>> बाएं से दाएं
रिलेशनल <> <=> = उदाहरण बाएं से दाएं
समानता ==! = बाएं से दाएं
बिटवाइज़ और और बाएं से दाएं
बिटवाइज़ XOR ^ बाएं से दाएं
बिटवार या | बाएं से दाएं
तार्किक और && बाएं से दाएं
तार्किक या || बाएं से दाएं
सशर्त ?: दाएं से बाएं
असाइनमेंट = + = - = * = / =% = ^ = | = << = >> = >>>> = | दाएं से बाएं

आगे क्या है?

अगला अध्याय जावा प्रोग्रामिंग में लूप नियंत्रण के बारे में बताएगा। अध्याय विभिन्न प्रकार के छोरों का वर्णन करेगा और जावा प्रोग्राम के विकास में इन छोरों का उपयोग कैसे किया जा सकता है और उनका उपयोग किन उद्देश्यों के लिए किया जा रहा है।

ऐसी स्थिति हो सकती है जब आपको कई बार कोड के ब्लॉक को निष्पादित करने की आवश्यकता होती है। सामान्य तौर पर, बयानों को क्रमिक रूप से निष्पादित किया जाता है: किसी फ़ंक्शन में पहला कथन पहले निष्पादित किया जाता है, उसके बाद दूसरा, और इसी तरह।

प्रोग्रामिंग भाषाएँ विभिन्न नियंत्रण संरचनाएं प्रदान करती हैं जो अधिक जटिल निष्पादन पथों के लिए अनुमति देती हैं।

loop कथन हमें कई बार एक बयान या बयान के समूह को निष्पादित करने की अनुमति देता है और निम्नलिखित प्रोग्रामिंग भाषाओं में से एक लूप स्टेटमेंट का सामान्य रूप है -

जावा प्रोग्रामिंग भाषा लूपिंग आवश्यकताओं को संभालने के लिए निम्न प्रकार के लूप प्रदान करती है। उनके विवरण की जाँच करने के लिए निम्न लिंक पर क्लिक करें।

अनु क्रमांक। लूप और विवरण
1 घुमाव के दौरान

एक बयान या बयानों के समूह को दोहराता है जबकि किसी दिए गए शर्त सही है। यह लूप बॉडी को निष्पादित करने से पहले स्थिति का परीक्षण करता है।

2 पाश के लिए

कई बार बयानों का एक क्रम निष्पादित करें और उस कोड को संक्षिप्त करें जो लूप चर का प्रबंधन करता है।

3 करते हैं ... जबकि पाश

थोड़ी देर के बयान की तरह, सिवाय इसके कि यह लूप बॉडी के अंत में स्थिति का परीक्षण करता है।

लूप नियंत्रण विवरण

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

जावा निम्नलिखित नियंत्रण कथनों का समर्थन करता है। उनके विवरण की जाँच करने के लिए निम्न लिंक पर क्लिक करें।

अनु क्रमांक। नियंत्रण विवरण और विवरण
1 तोड़ बयान

टर्मिनेट करता है loop या switch बयान और लूप या स्विच के तुरंत बाद निष्पादन को बयान में स्थानांतरित करता है।

2 जारी रखें बयान

लूप को उसके शरीर के शेष हिस्से को छोड़ने के लिए कहता है और पुनरावृत्ति करने से पहले तुरंत उसकी स्थिति को फिर से बना देता है।

जावा में लूप के लिए बढ़ाया

जावा 5 के रूप में, लूप के लिए बढ़ाया गया था। यह मुख्य रूप से सरणियों सहित तत्वों के संग्रह को पार करने के लिए उपयोग किया जाता है।

वाक्य - विन्यास

निम्नलिखित लूप के लिए संवर्धित का सिंटैक्स है -

for(declaration : expression) {
   // Statements
}
  • Declaration- नया घोषित ब्लॉक वैरिएबल, आपके द्वारा एक्सेस किए जा रहे एरे के तत्वों के साथ संगत प्रकार का है। चर ब्लॉक के लिए उपलब्ध होगा और इसका मान वर्तमान सरणी तत्व के समान होगा।

  • Expression- यह उस सरणी का मूल्यांकन करता है जिसके माध्यम से आपको लूप करने की आवश्यकता होती है। अभिव्यक्ति एक सरणी चर या विधि कॉल हो सकती है जो एक सरणी लौटाती है।

उदाहरण

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names = {"James", "Larry", "Tom", "Lacy"};

      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

आगे क्या है?

निम्नलिखित अध्याय में, हम जावा प्रोग्रामिंग में निर्णय लेने के बारे में सीखेंगे।

निर्णय लेने की संरचनाओं में एक या एक से अधिक परिस्थितियों का मूल्यांकन या कार्यक्रम के साथ परीक्षण किया जाता है, एक बयान या बयान के साथ जो निष्पादित किया जाना है यदि स्थिति सच है, और वैकल्पिक रूप से, अन्य बयानों को निष्पादित किया जाना है यदि स्थिति निर्धारित की जाती है झूठा होना।

अधिकांश प्रोग्रामिंग भाषाओं में पाया जाने वाला एक विशिष्ट निर्णय लेने की संरचना का सामान्य रूप निम्नलिखित है -

जावा प्रोग्रामिंग लैंग्वेज निम्नलिखित निर्णय लेने के प्रकार प्रदान करती है। उनके विवरण की जाँच करने के लिए निम्न लिंक पर क्लिक करें।

अनु क्रमांक। विवरण और विवरण
1 अगर बयान

एक if statement एक या अधिक बयानों के बाद एक बूलियन अभिव्यक्ति के होते हैं।

2 अगर ... और बयान

एक if statement एक वैकल्पिक द्वारा पीछा किया जा सकता है else statement, जो निष्पादित करता है जब बूलियन अभिव्यक्ति झूठी होती है।

3 बयान अगर नेस्टेड

आप एक का उपयोग कर सकते हैं if या else if दूसरे के अंदर बयान if या else if कथन (नों)।

4 स्विच स्टेटमेंट

switch कथन मानों की सूची के विरुद्ध समानता के लिए एक चर का परीक्षण करने की अनुमति देता है।

? : ऑपरेटर

हमने कवर किया है conditional operator ? : पिछले अध्याय में जिसका उपयोग प्रतिस्थापित करने के लिए किया जा सकता है if...elseबयान। इसके निम्नलिखित सामान्य रूप हैं -

Exp1 ? Exp2 : Exp3;

जहां Exp1, Exp2 और Exp3 एक्सप्रेशन हैं। बृहदान्त्र के उपयोग और प्लेसमेंट को नोटिस करें।

To determine the value of the whole expression, initially exp1 is evaluated.

  • If the value of exp1 is true, then the value of Exp2 will be the value of the whole expression.

  • If the value of exp1 is false, then Exp3 is evaluated and its value becomes the value of the entire expression.

What is Next?

In the next chapter, we will discuss about Number class (in the java.lang package) and its subclasses in Java Language.

We will be looking into some of the situations where you will use instantiations of these classes rather than the primitive data types, as well as classes such as formatting, mathematical functions that you need to know about when working with Numbers.

Normally, when we work with Numbers, we use primitive data types such as byte, int, long, double, etc.

Example

int i = 5000;
float gpa = 13.65f;
double mask = 125;

However, in development, we come across situations where we need to use objects instead of primitive data types. In order to achieve this, Java provides wrapper classes.

All the wrapper classes (Integer, Long, Byte, Double, Float, Short) are subclasses of the abstract class Number.

The object of the wrapper class contains or wraps its respective primitive data type. Converting primitive data types into object is called boxing, and this is taken care by the compiler. Therefore, while using a wrapper class you just need to pass the value of the primitive data type to the constructor of the Wrapper class.

And the Wrapper object will be converted back to a primitive data type, and this process is called unboxing. The Number class is part of the java.lang package.

Following is an example of boxing and unboxing −

Example

public class Test {

   public static void main(String args[]) {
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

This will produce the following result −

Output

15

When x is assigned an integer value, the compiler boxes the integer because x is integer object. Later, x is unboxed so that they can be added as an integer.

Number Methods

Following is the list of the instance methods that all the subclasses of the Number class implements −

Sr.No. Method & Description
1 xxxValue()

Converts the value of this Number object to the xxx data type and returns it.

2 compareTo()

Compares this Number object to the argument.

3 equals()

Determines whether this number object is equal to the argument.

4 valueOf()

Returns an Integer object holding the value of the specified primitive.

5 toString()

Returns a String object representing the value of a specified int or Integer.

6 parseInt()

This method is used to get the primitive data type of a certain String.

7 abs()

Returns the absolute value of the argument.

8 ceil()

Returns the smallest integer that is greater than or equal to the argument. Returned as a double.

9 floor()

Returns the largest integer that is less than or equal to the argument. Returned as a double.

10 rint()

Returns the integer that is closest in value to the argument. Returned as a double.

11 round()

Returns the closest long or int, as indicated by the method's return type to the argument.

12 min()

Returns the smaller of the two arguments.

13 max()

Returns the larger of the two arguments.

14 exp()

Returns the base of the natural logarithms, e, to the power of the argument.

15 log()

Returns the natural logarithm of the argument.

16 pow()

Returns the value of the first argument raised to the power of the second argument.

17 sqrt()

Returns the square root of the argument.

18 sin()

Returns the sine of the specified double value.

19 cos()

Returns the cosine of the specified double value.

20 tan()

Returns the tangent of the specified double value.

21 asin()

Returns the arcsine of the specified double value.

22 acos()

Returns the arccosine of the specified double value.

23 atan()

Returns the arctangent of the specified double value.

24 atan2()

Converts rectangular coordinates (x, y) to polar coordinate (r, theta) and returns theta.

25 toDegrees()

Converts the argument to degrees.

26 toRadians()

Converts the argument to radians.

27 random()

Returns a random number.

What is Next?

In the next section, we will be going through the Character class in Java. You will be learning how to use object Characters and primitive data type char in Java.

Normally, when we work with characters, we use primitive data types char.

Example

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

However in development, we come across situations where we need to use objects instead of primitive data types. In order to achieve this, Java provides wrapper class Character for primitive data type char.

The Character class offers a number of useful class (i.e., static) methods for manipulating characters. You can create a Character object with the Character constructor −

Character ch = new Character('a');

The Java compiler will also create a Character object for you under some circumstances. For example, if you pass a primitive char into a method that expects an object, the compiler automatically converts the char to a Character for you. This feature is called autoboxing or unboxing, if the conversion goes the other way.

Example

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

Escape Sequences

A character preceded by a backslash (\) is an escape sequence and has a special meaning to the compiler.

The newline character (\n) has been used frequently in this tutorial in System.out.println() statements to advance to the next line after the string is printed.

Following table shows the Java escape sequences −

Escape Sequence Description
\t Inserts a tab in the text at this point.
\b Inserts a backspace in the text at this point.
\n Inserts a newline in the text at this point.
\r Inserts a carriage return in the text at this point.
\f Inserts a form feed in the text at this point.
\' Inserts a single quote character in the text at this point.
\" Inserts a double quote character in the text at this point.
\\ Inserts a backslash character in the text at this point.

When an escape sequence is encountered in a print statement, the compiler interprets it accordingly.

Example

If you want to put quotes within quotes, you must use the escape sequence, \", on the interior quotes −

public class Test {

   public static void main(String args[]) {
      System.out.println("She said \"Hello!\" to me.");
   }
}

This will produce the following result −

Output

She said "Hello!" to me.

Character Methods

Following is the list of the important instance methods that all the subclasses of the Character class implement −

Sr.No. Method & Description
1 isLetter()

Determines whether the specified char value is a letter.

2 isDigit()

Determines whether the specified char value is a digit.

3 isWhitespace()

Determines whether the specified char value is white space.

4 isUpperCase()

Determines whether the specified char value is uppercase.

5 isLowerCase()

Determines whether the specified char value is lowercase.

6 toUpperCase()

Returns the uppercase form of the specified char value.

7 toLowerCase()

Returns the lowercase form of the specified char value.

8 toString()

Returns a String object representing the specified character value that is, a one-character string.

For a complete list of methods, please refer to the java.lang.Character API specification.

What is Next?

In the next section, we will be going through the String class in Java. You will be learning how to declare and use Strings efficiently as well as some of the important methods in the String class.

Strings, which are widely used in Java programming, are a sequence of characters. In Java programming language, strings are treated as objects.

The Java platform provides the String class to create and manipulate strings.

Creating Strings

The most direct way to create a string is to write −

String greeting = "Hello world!";

Whenever it encounters a string literal in your code, the compiler creates a String object with its value in this case, "Hello world!'.

As with any other object, you can create String objects by using the new keyword and a constructor. The String class has 11 constructors that allow you to provide the initial value of the string using different sources, such as an array of characters.

Example

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

This will produce the following result −

Output

hello.

Note − The String class is immutable, so that once it is created a String object cannot be changed. If there is a necessity to make a lot of modifications to Strings of characters, then you should use String Buffer & String Builder Classes.

String Length

Methods used to obtain information about an object are known as accessor methods. One accessor method that you can use with strings is the length() method, which returns the number of characters contained in the string object.

The following program is an example of length(), method String class.

Example

public class StringDemo {

   public static void main(String args[]) {
      String palindrome = "Dot saw I was Tod";
      int len = palindrome.length();
      System.out.println( "String Length is : " + len );
   }
}

This will produce the following result −

Output

String Length is : 17

Concatenating Strings

The String class includes a method for concatenating two strings −

string1.concat(string2);

This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in −

"My name is ".concat("Zara");

Strings are more commonly concatenated with the + operator, as in −

"Hello," + " world" + "!"

which results in −

"Hello, world!"

Let us look at the following example −

Example

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

This will produce the following result −

Output

Dot saw I was Tod

Creating Format Strings

You have printf() and format() methods to print output with formatted numbers. The String class has an equivalent class method, format(), that returns a String object rather than a PrintStream object.

Using String's static format() method allows you to create a formatted string that you can reuse, as opposed to a one-time print statement. For example, instead of −

Example

System.out.printf("The value of the float variable is " +
                  "%f, while the value of the integer " +
                  "variable is %d, and the string " +
                  "is %s", floatVar, intVar, stringVar);

You can write −

String fs;
fs = String.format("The value of the float variable is " +
                   "%f, while the value of the integer " +
                   "variable is %d, and the string " +
                   "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

String Methods

Here is the list of methods supported by String class −

Sr.No. Method & Description
1 char charAt(int index)

Returns the character at the specified index.

2 int compareTo(Object o)

Compares this String to another Object.

3 int compareTo(String anotherString)

Compares two strings lexicographically.

4 int compareToIgnoreCase(String str)

Compares two strings lexicographically, ignoring case differences.

5 String concat(String str)

Concatenates the specified string to the end of this string.

6 boolean contentEquals(StringBuffer sb)

Returns true if and only if this String represents the same sequence of characters as the specified StringBuffer.

7 static String copyValueOf(char[] data)

Returns a String that represents the character sequence in the array specified.

8 static String copyValueOf(char[] data, int offset, int count)

Returns a String that represents the character sequence in the array specified.

9 boolean endsWith(String suffix)

Tests if this string ends with the specified suffix.

10 boolean equals(Object anObject)

Compares this string to the specified object.

11 boolean equalsIgnoreCase(String anotherString)

Compares this String to another String, ignoring case considerations.

12 byte getBytes()

Encodes this String into a sequence of bytes using the platform's default charset, storing the result into a new byte array.

13 byte[] getBytes(String charsetName)

Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array.

14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Copies characters from this string into the destination character array.

15 int hashCode()

Returns a hash code for this string.

16 int indexOf(int ch)

Returns the index within this string of the first occurrence of the specified character.

17 int indexOf(int ch, int fromIndex)

Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.

18 int indexOf(String str)

Returns the index within this string of the first occurrence of the specified substring.

19 int indexOf(String str, int fromIndex)

Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.

20 String intern()

Returns a canonical representation for the string object.

21 int lastIndexOf(int ch)

Returns the index within this string of the last occurrence of the specified character.

22 int lastIndexOf(int ch, int fromIndex)

Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.

23 int lastIndexOf(String str)

Returns the index within this string of the rightmost occurrence of the specified substring.

24 int lastIndexOf(String str, int fromIndex)

Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.

25 int length()

Returns the length of this string.

26 boolean matches(String regex)

Tells whether or not this string matches the given regular expression.

27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

Tests if two string regions are equal.

28 boolean regionMatches(int toffset, String other, int ooffset, int len)

Tests if two string regions are equal.

29 String replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

30 String replaceAll(String regex, String replacement

Replaces each substring of this string that matches the given regular expression with the given replacement.

31 String replaceFirst(String regex, String replacement)

Replaces the first substring of this string that matches the given regular expression with the given replacement.

32 String[] split(String regex)

Splits this string around matches of the given regular expression.

33 String[] split(String regex, int limit)

Splits this string around matches of the given regular expression.

34 boolean startsWith(String prefix)

Tests if this string starts with the specified prefix.

35 boolean startsWith(String prefix, int toffset)

Tests if this string starts with the specified prefix beginning a specified index.

36 CharSequence subSequence(int beginIndex, int endIndex)

Returns a new character sequence that is a subsequence of this sequence.

37 String substring(int beginIndex)

Returns a new string that is a substring of this string.

38 String substring(int beginIndex, int endIndex)

Returns a new string that is a substring of this string.

39 char[] toCharArray()

Converts this string to a new character array.

40 String toLowerCase()

Converts all of the characters in this String to lower case using the rules of the default locale.

41 String toLowerCase(Locale locale)

Converts all of the characters in this String to lower case using the rules of the given Locale.

42 String toString()

This object (which is already a string!) is itself returned.

43 String toUpperCase()

Converts all of the characters in this String to upper case using the rules of the default locale.

44 String toUpperCase(Locale locale)

Converts all of the characters in this String to upper case using the rules of the given Locale.

45 String trim()

Returns a copy of the string, with leading and trailing whitespace omitted.

46 static String valueOf(primitive data type x)

Returns the string representation of the passed data type argument.

Java provides a data structure, the array, which stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables.

This tutorial introduces how to declare array variables, create arrays, and process arrays using indexed variables.

Declaring Array Variables

To use an array in a program, you must declare a variable to reference the array, and you must specify the type of array the variable can reference. Here is the syntax for declaring an array variable −

Syntax

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

Note − The style dataType[] arrayRefVar is preferred. The style dataType arrayRefVar[] comes from the C/C++ language and was adopted in Java to accommodate C/C++ programmers.

Example

The following code snippets are examples of this syntax −

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

Creating Arrays

You can create an array by using the new operator with the following syntax −

Syntax

arrayRefVar = new dataType[arraySize];

The above statement does two things −

  • It creates an array using new dataType[arraySize].

  • It assigns the reference of the newly created array to the variable arrayRefVar.

Declaring an array variable, creating an array, and assigning the reference of the array to the variable can be combined in one statement, as shown below −

dataType[] arrayRefVar = new dataType[arraySize];

Alternatively you can create arrays as follows −

dataType[] arrayRefVar = {value0, value1, ..., valuek};

The array elements are accessed through the index. Array indices are 0-based; that is, they start from 0 to arrayRefVar.length-1.

Example

Following statement declares an array variable, myList, creates an array of 10 elements of double type and assigns its reference to myList −

double[] myList = new double[10];

Following picture represents array myList. Here, myList holds ten double values and the indices are from 0 to 9.

Processing Arrays

When processing array elements, we often use either for loop or foreach loop because all of the elements in an array are of the same type and the size of the array is known.

Example

Here is a complete example showing how to create, initialize, and process arrays −

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

This will produce the following result −

Output

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

The foreach Loops

JDK 1.5 introduced a new for loop known as foreach loop or enhanced for loop, which enables you to traverse the complete array sequentially without using an index variable.

Example

The following code displays all the elements in the array myList −

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

This will produce the following result −

Output

1.9
2.9
3.4
3.5

Passing Arrays to Methods

Just as you can pass primitive type values to methods, you can also pass arrays to methods. For example, the following method displays the elements in an int array −

Example

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

You can invoke it by passing an array. For example, the following statement invokes the printArray method to display 3, 1, 2, 6, 4, and 2 −

Example

printArray(new int[]{3, 1, 2, 6, 4, 2});

Returning an Array from a Method

A method may also return an array. For example, the following method returns an array that is the reversal of another array −

Example

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

The Arrays Class

The java.util.Arrays class contains various static methods for sorting and searching arrays, comparing arrays, and filling array elements. These methods are overloaded for all primitive types.

Sr.No. Method & Description
1

public static int binarySearch(Object[] a, Object key)

Searches the specified array of Object ( Byte, Int , double, etc.) for the specified value using the binary search algorithm. The array must be sorted prior to making this call. This returns index of the search key, if it is contained in the list; otherwise, it returns ( – (insertion point + 1)).

2

public static boolean equals(long[] a, long[] a2)

Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. This returns true if the two arrays are equal. Same method could be used by all other primitive data types (Byte, short, Int, etc.)

3

public static void fill(int[] a, int val)

Assigns the specified int value to each element of the specified array of ints. The same method could be used by all other primitive data types (Byte, short, Int, etc.)

4

public static void sort(Object[] a)

Sorts the specified array of objects into an ascending order, according to the natural ordering of its elements. The same method could be used by all other primitive data types ( Byte, short, Int, etc.)

Java provides the Date class available in java.util package, this class encapsulates the current date and time.

The Date class supports two constructors as shown in the following table.

Sr.No. Constructor & Description
1

Date( )

This constructor initializes the object with the current date and time.

2

Date(long millisec)

This constructor accepts an argument that equals the number of milliseconds that have elapsed since midnight, January 1, 1970.

Following are the methods of the date class.

Sr.No. Method & Description
1

boolean after(Date date)

Returns true if the invoking Date object contains a date that is later than the one specified by date, otherwise, it returns false.

2

boolean before(Date date)

Returns true if the invoking Date object contains a date that is earlier than the one specified by date, otherwise, it returns false.

3

Object clone( )

Duplicates the invoking Date object.

4

int compareTo(Date date)

Compares the value of the invoking object with that of date. Returns 0 if the values are equal. Returns a negative value if the invoking object is earlier than date. Returns a positive value if the invoking object is later than date.

5

int compareTo(Object obj)

Operates identically to compareTo(Date) if obj is of class Date. Otherwise, it throws a ClassCastException.

6

boolean equals(Object date)

Returns true if the invoking Date object contains the same time and date as the one specified by date, otherwise, it returns false.

7

long getTime( )

Returns the number of milliseconds that have elapsed since January 1, 1970.

8

int hashCode( )

Returns a hash code for the invoking object.

9

void setTime(long time)

Sets the time and date as specified by time, which represents an elapsed time in milliseconds from midnight, January 1, 1970.

10

String toString( )

Converts the invoking Date object into a string and returns the result.

वर्तमान तिथि और समय प्राप्त करना

जावा में वर्तमान तिथि और समय प्राप्त करने के लिए यह एक बहुत ही आसान तरीका है। आप वर्तमान तिथि और समय को निम्न प्रकार से मुद्रित करने के लिए () विधि के साथ एक साधारण दिनांक वस्तु का उपयोग कर सकते हैं -

उदाहरण

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

on May 04 09:51:52 CDT 2009

तारीख तुलना

दो तिथियों की तुलना करने के तीन तरीके निम्नलिखित हैं -

  • आप दोनों वस्तुओं के लिए आधी रात, 1 जनवरी, 1970 से बीती हुई मिलीसेकंड की संख्या प्राप्त करने के लिए गेटटाइम () का उपयोग कर सकते हैं और फिर इन दोनों मूल्यों की तुलना कर सकते हैं।

  • आप पहले (), बाद (), और बराबर () तरीकों का उपयोग कर सकते हैं। क्योंकि महीने की 12 वीं 18 वीं से पहले आती है, उदाहरण के लिए, नई तिथि (99, 2, 12) .before (नई तिथि (99, 2, 18)) सही है।

  • आप तुलना () विधि का उपयोग कर सकते हैं, जिसे तुलनात्मक इंटरफ़ेस द्वारा परिभाषित किया गया है और तिथि द्वारा कार्यान्वित किया गया है।

दिनांक स्वरूपण SimpleDateFormat का उपयोग करना

SimpleDateFormat स्थानीय-संवेदनशील तरीके से तिथियों को प्रारूपित करने और पार्स करने के लिए एक ठोस वर्ग है। SimpleDateFormat आपको दिनांक-समय स्वरूपण के लिए किसी भी उपयोगकर्ता-परिभाषित पैटर्न को चुनकर शुरू करने की अनुमति देता है।

उदाहरण

import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Current Date: Sun 2004.07.18 at 04:14:09 PM PDT

सरल DateFormat प्रारूप कोड

समय प्रारूप निर्दिष्ट करने के लिए, एक समय पैटर्न स्ट्रिंग का उपयोग करें। इस पैटर्न में, सभी ASCII अक्षर पैटर्न अक्षरों के रूप में आरक्षित हैं, जिन्हें निम्नलिखित के रूप में परिभाषित किया गया है -

चरित्र विवरण उदाहरण
जी युग का सूत्रधार विज्ञापन
y चार अंकों में वर्ष 2001
साल में महीना जुलाई या ० July
महीने में दिन 10
एच AM / PM में घंटे (1 ~ 12) 12
एच दिन में घंटे (0 ~ 23) 22
घंटे में मिनट 30
रों दूसरा मिनट में 55
रों मिलीसेकंड 234
सप्ताह में दिन मंगलवार
वर्ष में दिन 360
एफ महीने में सप्ताह का दिन 2 (जुलाई में दूसरा बुध)
w साल में सप्ताह 40
डब्ल्यू महीने में सप्ताह 1
AM / PM मार्कर बजे
दिन में घंटा (1 ~ 24) 24
AM / PM में घंटे (0 ~ 11) 10
जेड समय क्षेत्र पूर्व मानक समय
' पाठ के लिए बच सीमान्तक
" एकल बोली `

मुद्रण का उपयोग करते हुए दिनांक स्वरूपण

दिनांक और समय प्रारूपण का उपयोग बहुत आसानी से किया जा सकता है printfतरीका। आप दो-अक्षर के प्रारूप का उपयोग करते हैं, जिसके साथ शुरू होता हैt और तालिका के अक्षरों में से एक में समाप्त होता है जैसा कि निम्नलिखित कोड में दिखाया गया है।

उदाहरण

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String str = String.format("Current Date/Time : %tc", date );

      System.out.printf(str);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Current Date/Time : Sat Dec 15 16:37:57 MST 2012

यह थोड़ा मूर्खतापूर्ण होगा यदि आपको प्रत्येक भाग को प्रारूपित करने के लिए कई बार तारीख की आपूर्ति करनी पड़े। उस कारण से, एक प्रारूप स्ट्रिंग स्वरूपित किए जाने वाले तर्क के सूचकांक को इंगित कर सकता है।

सूचकांक को तुरंत% का पालन करना चाहिए और इसे $ द्वारा समाप्त किया जाना चाहिए।

उदाहरण

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Due date: February 09, 2004

वैकल्पिक रूप से, आप <ध्वज का उपयोग कर सकते हैं। यह इंगित करता है कि पूर्ववर्ती प्रारूप विनिर्देश के समान तर्क को फिर से उपयोग किया जाना चाहिए।

उदाहरण

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Due date: February 09, 2004

दिनांक और समय रूपांतरण वर्ण

चरित्र विवरण उदाहरण
सी पूरी तारीख और समय सोम मई 04 09:51:52 सीडीटी 2009
एफ आईएसओ 8601 दिनांक 2004/02/09
यूएस प्रारूपित तिथि (माह / दिन / वर्ष) 2004/02/09
टी 24 घंटे का समय 18:05:19
आर 12 घंटे का समय 06:05:19 बजे
आर 24-घंटे का समय, कोई सेकंड नहीं 18:05
Y चार अंकों वाला वर्ष (अग्रणी शून्य के साथ) 2004
y वर्ष के अंतिम दो अंक (अग्रणी शून्य के साथ) 04
सी वर्ष के पहले दो अंक (अग्रणी शून्य के साथ) 20
पूरे महीने का नाम फ़रवरी
संक्षिप्त माह का नाम फ़रवरी
दो अंकों वाला महीना (अग्रणी शून्य के साथ) 02
दो-अंकीय दिन (अग्रणी शून्य के साथ) 03
दो अंकों का दिन (अग्रणी शून्य के बिना) 9
पूरे सप्ताह का नाम सोमवार
संक्षिप्त सप्ताह का नाम सोमवार
जे वर्ष का तीन अंकों वाला दिन (अग्रणी शून्य के साथ) 069
एच दो अंकों का घंटा (अग्रणी शून्य के साथ), 00 से 23 के बीच 18
दो अंकों का घंटा (अग्रणी शून्य के बिना), 0 से 23 के बीच 18
मैं दो अंकों का घंटा (अग्रणी शून्य के साथ), 01 से 12 के बीच 06
एल दो अंकों का घंटा (अग्रणी शून्य के बिना), 1 से 12 के बीच 6
दो-अंकीय मिनट (अग्रणी शून्य के साथ) 05
रों दो-अंकीय सेकंड (अग्रणी शून्य के साथ) 19
एल तीन-अंकीय मिलीसेकंड (अग्रणी शून्य के साथ) 047
एन नौ अंकों के नैनोसेकंड (अग्रणी शून्य के साथ) 047000000
पी अपरकेस सुबह या दोपहर मार्कर बजे
पी लोअरकेस सुबह या दोपहर मार्कर बजे
जेड जीएमटी से आरएफसी 822 संख्यात्मक ऑफसेट -0800
जेड समय क्षेत्र PST
रों 1970-01-01 से 00:00:00 GMT के बाद के सेकंड 1078884319
क्यू 1970-01-01 से 00:00:00 जीएमटी के बाद के मिलिसेकंड 1078884319047

दिनांक और समय से संबंधित अन्य उपयोगी कक्षाएं हैं। अधिक जानकारी के लिए, आप जावा मानक प्रलेखन का उल्लेख कर सकते हैं।

डेट्स में पार्सिंग स्ट्रिंग्स

SimpleDateFormat वर्ग में कुछ अतिरिक्त विधियां हैं, विशेष रूप से पार्स (), जो दिए गए SimpleDateFormat ऑब्जेक्ट में संग्रहीत प्रारूप के अनुसार स्ट्रिंग को पार्स करने की कोशिश करता है।

उदाहरण

import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

उपरोक्त कार्यक्रम का नमूना रन निम्नलिखित परिणाम उत्पन्न करेगा -

उत्पादन

1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818

थोड़ी देर सोता रहा

आप अपने कंप्यूटर के जीवनकाल तक एक मिलीसेकंड तक किसी भी समय तक सो सकते हैं। उदाहरण के लिए, निम्नलिखित कार्यक्रम 3 सेकंड के लिए सो जाएगा -

उदाहरण

import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009

मापने का समय समाप्त हो गया

कभी-कभी, आपको मिलीसेकंड में समय को मापने की आवश्यकता हो सकती है। तो चलिए उपरोक्त उदाहरण को एक बार फिर से लिखते हैं -

उदाहरण

import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993

ग्रेगोरियन कैलेन्डर क्लास

ग्रेगोरियन कैलेन्डर एक कैलेंडर क्लास का एक ठोस कार्यान्वयन है जो सामान्य ग्रेगोरियन कैलेंडर को लागू करता है जिसके साथ आप परिचित हैं। हमने इस ट्यूटोरियल में कैलेंडर क्लास पर चर्चा नहीं की है, आप इसके लिए मानक जावा प्रलेखन देख सकते हैं।

getInstance( )कैलेंडर की विधि एक ग्रेगोरियन कैलंडर को डिफ़ॉल्ट लोकेल और टाइम ज़ोन में वर्तमान दिनांक और समय के साथ आरम्भ करती है। ग्रेगोरियन कैलेन्डर दो क्षेत्रों को परिभाषित करता है: AD और BC। ये ग्रेगोरियन कैलेंडर द्वारा परिभाषित दो युगों का प्रतिनिधित्व करते हैं।

ग्रेगोरियन कैलेन्डर वस्तुओं के लिए कई निर्माणकर्ता भी हैं -

अनु क्रमांक। कंस्ट्रक्टर और विवरण
1

GregorianCalendar()

डिफ़ॉल्ट लोकेल के साथ डिफ़ॉल्ट समय क्षेत्र में वर्तमान समय का उपयोग करके एक डिफ़ॉल्ट ग्रेगोरियन कैलेन्डर का निर्माण करता है।

2

GregorianCalendar(int year, int month, int date)

डिफ़ॉल्ट स्थान के साथ डिफ़ॉल्ट समय क्षेत्र में सेट की गई तारीख के साथ एक ग्रेगोरियनकैलर का निर्माण करता है।

3

GregorianCalendar(int year, int month, int date, int hour, int minute)

डिफ़ॉल्ट स्थान के साथ डिफ़ॉल्ट समय क्षेत्र के लिए दिए गए दिनांक और समय सेट के साथ एक ग्रेगोरियनकैलर का निर्माण करता है।

4

GregorianCalendar(int year, int month, int date, int hour, int minute, int second)

डिफ़ॉल्ट स्थान के साथ डिफ़ॉल्ट समय क्षेत्र के लिए दिए गए दिनांक और समय सेट के साथ एक ग्रेगोरियनकैलर का निर्माण करता है।

5

GregorianCalendar(Locale aLocale)

दिए गए स्थान के साथ डिफ़ॉल्ट समय क्षेत्र में वर्तमान समय के आधार पर एक ग्रेगोरियनकैलर का निर्माण करता है।

6

GregorianCalendar(TimeZone zone)

डिफ़ॉल्ट स्थान के साथ दिए गए टाइम ज़ोन में वर्तमान समय के आधार पर एक ग्रेगोरियनकैल्डर का निर्माण करता है।

7

GregorianCalendar(TimeZone zone, Locale aLocale)

दिए गए स्थान के साथ दिए गए समय क्षेत्र में वर्तमान समय के आधार पर एक ग्रेगोरियन कैलेन्डर का निर्माण करता है।

यहाँ ग्रेगोरियन कैलेन्डर वर्ग द्वारा प्रदान की जाने वाली कुछ उपयोगी सहायक विधियों की सूची दी गई है -

अनु क्रमांक। विधि और विवरण
1

void add(int field, int amount)

कैलेंडर के नियमों के आधार पर, दिए गए समय क्षेत्र में समय की निर्दिष्ट (हस्ताक्षरित) राशि जोड़ता है।

2

protected void computeFields()

यूटीसी को समय क्षेत्र मूल्यों के लिए मिलीसेकंड के रूप में परिवर्तित करता है।

3

protected void computeTime()

कैलेंडर को ओवरराइड करता है समय फ़ील्ड मानों को यूटीसी को मिलीसेकंड के रूप में बदलता है।

4

boolean equals(Object obj)

एक वस्तु संदर्भ के लिए इस ग्रेगोरियन कैलंडर की तुलना करता है।

5

int get(int field)

दिए गए समय क्षेत्र के लिए मान प्राप्त करता है।

6

int getActualMaximum(int field)

वर्तमान दिनांक को देखते हुए इस फ़ील्ड का अधिकतम मान लौटा सकता है।

7

int getActualMinimum(int field)

यह फ़ील्ड वर्तमान दिनांक को देखते हुए न्यूनतम मान देता है।

8

int getGreatestMinimum(int field)

यदि दिए गए क्षेत्र के लिए उच्चतम न्यूनतम मान लौटाता है तो भिन्न होता है।

9

Date getGregorianChange()

ग्रेगोरियन कैलेंडर परिवर्तन तिथि प्राप्त होती है।

10

int getLeastMaximum(int field)

दिए गए क्षेत्र के लिए सबसे कम अधिकतम मान लौटाता है।

1 1

int getMaximum(int field)

दिए गए क्षेत्र के लिए अधिकतम मूल्य देता है।

12

Date getTime()

इस कैलेंडर का वर्तमान समय हो जाता है।

13

long getTimeInMillis()

इस कैलेंडर का वर्तमान समय एक लंबा हो जाता है।

14

TimeZone getTimeZone()

समय क्षेत्र हो जाता है।

15

int getMinimum(int field)

दिए गए क्षेत्र के लिए न्यूनतम मूल्य देता है।

16

int hashCode()

ओवरशाइड हैशकोड।

17

boolean isLeapYear(int year)

निर्धारित करता है कि दिया गया वर्ष लीप वर्ष है।

18

void roll(int field, boolean up)

बड़े क्षेत्रों को बदलने के बिना दिए गए समय क्षेत्र पर समय की एक इकाई को जोड़ता या घटाता (ऊपर / नीचे) करता है।

19

void set(int field, int value)

दिए गए मान के साथ समय क्षेत्र सेट करता है।

20

void set(int year, int month, int date)

वर्ष, माह, और दिनांक फ़ील्ड के लिए मान सेट करता है।

21

void set(int year, int month, int date, int hour, int minute)

वर्ष, माह, तिथि, घंटा और मिनट के लिए मान सेट करता है।

22

void set(int year, int month, int date, int hour, int minute, int second)

वर्ष, माह, तिथि, घंटा, मिनट और दूसरे के लिए मान सेट करता है।

23

void setGregorianChange(Date date)

ग्रेगोरियन कैलंडर परिवर्तन तिथि निर्धारित करता है।

24

void setTime(Date date)

दिए गए दिनांक के साथ इस कैलेंडर का वर्तमान समय सेट करता है।

25

void setTimeInMillis(long millis)

इस कैलेंडर के वर्तमान समय को दिए गए लंबे मान से सेट करता है।

26

void setTimeZone(TimeZone value)

दिए गए समय क्षेत्र मान के साथ समय क्षेत्र सेट करता है।

27

String toString()

इस कैलेंडर का एक स्ट्रिंग प्रतिनिधित्व लौटाता है।

उदाहरण

import java.util.*;
public class GregorianCalendarDemo {

   public static void main(String args[]) {
      String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", 
         "Oct", "Nov", "Dec"};
      
      int year;
      // Create a Gregorian calendar initialized
      // with the current date and time in the
      // default locale and timezone.
      
      GregorianCalendar gcalendar = new GregorianCalendar();
      
      // Display current time and date information.
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));

      // Test if the current year is a leap year
      if(gcalendar.isLeapYear(year)) {
         System.out.println("The current year is a leap year");
      }else {
         System.out.println("The current year is not a leap year");
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year

कैलेंडर वर्ग में उपलब्ध निरंतर की पूरी सूची के लिए, आप मानक जावा प्रलेखन का उल्लेख कर सकते हैं।

जावा नियमित अभिव्यक्ति के साथ मेल खाते पैटर्न के लिए java.util.regex पैकेज प्रदान करता है। जावा नियमित अभिव्यक्ति पर्ल प्रोग्रामिंग भाषा के समान हैं और सीखने में बहुत आसान हैं।

एक नियमित अभिव्यक्ति वर्णों का एक विशेष अनुक्रम है जो आपको एक पैटर्न में आयोजित एक विशेष वाक्यविन्यास का उपयोग करके, अन्य तारों या तारों के सेट को खोजने या खोजने में मदद करता है। उनका उपयोग टेक्स्ट और डेटा को खोजने, संपादित करने या हेरफेर करने के लिए किया जा सकता है।

Java.util.regex पैकेज में मुख्य रूप से निम्नलिखित तीन वर्ग शामिल हैं -

  • Pattern Class- एक पैटर्न ऑब्जेक्ट एक नियमित अभिव्यक्ति का संकलित प्रतिनिधित्व है। पैटर्न वर्ग कोई सार्वजनिक निर्माण प्रदान नहीं करता है। एक पैटर्न बनाने के लिए, आपको सबसे पहले इसके किसी सार्वजनिक स्टेटिक का आह्वान करना होगाcompile()विधियाँ, जो फिर एक पैटर्न ऑब्जेक्ट लौटाएंगी। ये विधियाँ पहले तर्क के रूप में एक नियमित अभिव्यक्ति को स्वीकार करती हैं।

  • Matcher Class- एक मिलान ऑब्जेक्ट वह इंजन है जो पैटर्न की व्याख्या करता है और एक इनपुट स्ट्रिंग के खिलाफ मैच संचालन करता है। पैटर्न वर्ग की तरह, माचिस कोई सार्वजनिक कंस्ट्रक्टर को परिभाषित नहीं करता है। आप एक निवेशक ऑब्जेक्ट प्राप्त करके प्राप्त करते हैंmatcher() एक पैटर्न ऑब्जेक्ट पर विधि।

  • PatternSyntaxException - एक PatternSyntaxException ऑब्जेक्ट एक अनियंत्रित अपवाद है जो नियमित अभिव्यक्ति पैटर्न में एक वाक्यविन्यास त्रुटि को इंगित करता है।

समूह पर कब्जा करना

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

कैप्चरिंग समूहों को उनके शुरुआती कोष्ठकों को बाईं ओर से दाईं ओर गिना जाता है। उदाहरण में ((ए) (बी (सी)), चार ऐसे समूह हैं -

  • ((A)(B(C)))
  • (A)
  • (B(C))
  • (C)

यह पता लगाने के लिए कि अभिव्यक्ति में कितने समूह मौजूद हैं, एक मिलान ऑब्जेक्ट पर GroupCount विधि को कॉल करें। GroupCount पद्धति एक लौटाती हैint मिलानकर्ता के पैटर्न में मौजूद कैप्चरिंग समूहों की संख्या दिखा रहा है।

एक विशेष समूह, समूह 0 भी है, जो हमेशा संपूर्ण अभिव्यक्ति का प्रतिनिधित्व करता है। यह समूह GroupCount द्वारा रिपोर्ट किए गए कुल में शामिल नहीं है।

Example

निम्न उदाहरण दिखाता है कि दिए गए अल्फ़ान्यूमेरिक स्ट्रिंग से एक अंक स्ट्रिंग कैसे प्राप्त करें -

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

नियमित अभिव्यक्ति सिंटैक्स

यहाँ जावा में उपलब्ध सभी नियमित अभिव्यक्ति मेटाचैकर सिंटैक्स की सूची नीचे दी गई है -

उपसूचक माचिस
^ रेखा की शुरुआत से मेल खाता है।
$ रेखा के अंत से मेल खाता है।
न्यूलाइन को छोड़कर किसी भी एकल वर्ण से मेल खाता है। का उपयोग करते हुएm विकल्प के रूप में अच्छी तरह से newline मैच के लिए अनुमति देता है।
[...] कोष्ठक में किसी एक वर्ण से मेल खाता है।
[^ ...] किसी भी एकल वर्ण को कोष्ठक में नहीं मिलाता है।
\ए पूरे स्ट्रिंग की शुरुआत।
\ z पूरी स्ट्रिंग का अंत।
\ जेड स्वीकार्य अंतिम पंक्ति टर्मिनेटर को छोड़कर पूरे स्ट्रिंग का अंत।
फिर * पूर्ववर्ती अभिव्यक्ति के 0 या अधिक घटनाओं से मेल खाता है।
फिर + पिछली चीज़ के 1 या अधिक से मेल खाता है।
फिर? पूर्ववर्ती अभिव्यक्ति की 0 या 1 घटना से मेल खाती है।
पुनः {n} पूर्ववर्ती अभिव्यक्ति की घटनाओं की बिल्कुल n संख्या से मेल खाता है।
पुनः {n,} पूर्ववर्ती अभिव्यक्ति की n या अधिक घटनाओं से मेल खाता है।
पुनः {n, m} कम से कम n और पूर्ववर्ती अभिव्यक्ति के अधिकांश m घटनाओं पर मेल खाता है।
एक | ख माचिस या तो एक या बी।
(फिर से) समूह नियमित अभिव्यक्ति और मिलान किए गए पाठ को याद करता है।
(?: re) मिलान किए गए पाठ को याद किए बिना समूह नियमित अभिव्यक्ति करता है।
(?> re) बैकट्रैकिंग के बिना स्वतंत्र पैटर्न से मेल खाता है।
\ w शब्द वर्णों से मेल खाता है।
\ डब्ल्यू नॉनवर्ड अक्षरों से मेल खाता है।
\ रों व्हॉट्सएप से मेल खाता है। [\ T \ n \ r \ f] के बराबर है।
\ एस Nonwhitespace से मेल खाता है।
\ घ अंकों से मेल खाता है। [0-9] के बराबर है।
\ डी Nondigits से मेल खाता है।
\ए स्ट्रिंग की शुरुआत से मेल खाता है।
\Z Matches the end of the string. If a newline exists, it matches just before newline.
\z Matches the end of the string.
\G Matches the point where the last match finished.
\n Back-reference to capture group number "n".
\b Matches the word boundaries when outside the brackets. Matches the backspace (0x08) when inside the brackets.
\B Matches the nonword boundaries.
\n, \t, etc. Matches newlines, carriage returns, tabs, etc.
\Q Escape (quote) all characters up to \E.
\E Ends quoting begun with \Q.

Methods of the Matcher Class

Here is a list of useful instance methods −

Index Methods

Index methods provide useful index values that show precisely where the match was found in the input string −

Sr.No. Method & Description
1

public int start()

Returns the start index of the previous match.

2

public int start(int group)

Returns the start index of the subsequence captured by the given group during the previous match operation.

3

public int end()

Returns the offset after the last character matched.

4

public int end(int group)

Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.

Study Methods

Study methods review the input string and return a Boolean indicating whether or not the pattern is found −

Sr.No. Method & Description
1

public boolean lookingAt()

Attempts to match the input sequence, starting at the beginning of the region, against the pattern.

2

public boolean find()

Attempts to find the next subsequence of the input sequence that matches the pattern.

3

public boolean find(int start)

Resets this matcher and then attempts to find the next subsequence of the input sequence that matches the pattern, starting at the specified index.

4

public boolean matches()

Attempts to match the entire region against the pattern.

Replacement Methods

Replacement methods are useful methods for replacing text in an input string −

Sr.No. Method & Description
1

public Matcher appendReplacement(StringBuffer sb, String replacement)

Implements a non-terminal append-and-replace step.

2

public StringBuffer appendTail(StringBuffer sb)

Implements a terminal append-and-replace step.

3

public String replaceAll(String replacement)

Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.

4

public String replaceFirst(String replacement)

Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string.

5

public static String quoteReplacement(String s)

Returns a literal replacement String for the specified String. This method produces a String that will work as a literal replacement s in the appendReplacement method of the Matcher class.

The start and end Methods

Following is the example that counts the number of times the word "cat" appears in the input string −

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;

      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

This will produce the following result −

Output

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

You can see that this example uses word boundaries to ensure that the letters "c" "a" "t" are not merely a substring in a longer word. It also gives some useful information about where in the input string the match has occurred.

The start method returns the start index of the subsequence captured by the given group during the previous match operation, and the end returns the index of the last character matched, plus one.

The matches and lookingAt Methods

The matches and lookingAt methods both attempt to match an input sequence against a pattern. The difference, however, is that matches requires the entire input sequence to be matched, while lookingAt does not.

Both methods always start at the beginning of the input string. Here is the example explaining the functionality −

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

This will produce the following result −

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

The replaceFirst and replaceAll Methods

The replaceFirst and replaceAll methods replace the text that matches a given regular expression. As their names indicate, replaceFirst replaces the first occurrence, and replaceAll replaces all occurrences.

Here is the example explaining the functionality −

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

This will produce the following result −

Output

The cat says meow. All cats say meow.

The appendReplacement and appendTail Methods

The Matcher class also provides appendReplacement and appendTail methods for text replacement.

Here is the example explaining the functionality −

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

This will produce the following result −

Output

-foo-foo-foo-

PatternSyntaxException Class Methods

A PatternSyntaxException is an unchecked exception that indicates a syntax error in a regular expression pattern. The PatternSyntaxException class provides the following methods to help you determine what went wrong −

Sr.No. Method & Description
1

public String getDescription()

Retrieves the description of the error.

2

public int getIndex()

Retrieves the error index.

3

public String getPattern()

Retrieves the erroneous regular expression pattern.

4

public String getMessage()

Returns a multi-line string containing the description of the syntax error and its index, the erroneous regular expression pattern, and a visual indication of the error index within the pattern.

A Java method is a collection of statements that are grouped together to perform an operation. When you call the System.out.println() method, for example, the system actually executes several statements in order to display a message on the console.

Now you will learn how to create your own methods with or without return values, invoke a method with or without parameters, and apply method abstraction in the program design.

Creating Method

Considering the following example to explain the syntax of a method −

Syntax

public static int methodName(int a, int b) {
   // body
}

Here,

  • public static − modifier

  • int − return type

  • methodName − name of the method

  • a, b − formal parameters

  • int a, int b − list of parameters

Method definition consists of a method header and a method body. The same is shown in the following syntax −

Syntax

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

The syntax shown above includes −

  • modifier − It defines the access type of the method and it is optional to use.

  • returnType − Method may return a value.

  • nameOfMethod − This is the method name. The method signature consists of the method name and the parameter list.

  • Parameter List − The list of parameters, it is the type, order, and number of parameters of a method. These are optional, method may contain zero parameters.

  • method body − The method body defines what the method does with the statements.

Example

Here is the source code of the above defined method called min(). This method takes two parameters num1 and num2 and returns the maximum between the two −

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Method Calling

For using a method, it should be called. There are two ways in which a method is called i.e., method returns a value or returning nothing (no return value).

The process of method calling is simple. When a program invokes a method, the program control gets transferred to the called method. This called method then returns control to the caller in two conditions, when −

  • the return statement is executed.
  • it reaches the method ending closing brace.

The methods returning void is considered as call to a statement. Lets consider an example −

System.out.println("This is tutorialspoint.com!");

The method returning value can be understood by the following example −

int result = sum(6, 9);

Following is the example to demonstrate how to define a method and how to call it −

Example

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

This will produce the following result −

Output

Minimum value = 6

The void Keyword

The void keyword allows us to create methods which do not return a value. Here, in the following example we're considering a void method methodRankPoints. This method is a void method, which does not return any value. Call to a void method must be a statement i.e. methodRankPoints(255.7);. It is a Java statement which ends with a semicolon as shown in the following example.

Example

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

This will produce the following result −

Output

Rank:A1

Passing Parameters by Value

While working under calling process, arguments is to be passed. These should be in the same order as their respective parameters in the method specification. Parameters can be passed by value or by reference.

Passing Parameters by Value means calling a method with a parameter. Through this, the argument value is passed to the parameter.

Example

The following program shows an example of passing parameter by value. The values of the arguments remains the same even after the method invocation.

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

This will produce the following result −

Output

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Method Overloading

When a class has two or more methods by the same name but different parameters, it is known as method overloading. It is different from overriding. In overriding, a method has the same method name, type, number of parameters, etc.

Let’s consider the example discussed earlier for finding minimum numbers of integer type. If, let’s say we want to find the minimum number of double type. Then the concept of overloading will be introduced to create two or more methods with the same name but different parameters.

The following example explains the same −

Example

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

This will produce the following result −

Output

Minimum Value = 6
Minimum Value = 7.3

Overloading methods makes program readable. Here, two methods are given by the same name but with different parameters. The minimum number from integer and double types is the result.

Using Command-Line Arguments

Sometimes you will want to pass some information into a program when you run it. This is accomplished by passing command-line arguments to main( ).

A command-line argument is the information that directly follows the program's name on the command line when it is executed. To access the command-line arguments inside a Java program is quite easy. They are stored as strings in the String array passed to main( ).

Example

The following program displays all of the command-line arguments that it is called with −

public class CommandLine {

   public static void main(String args[]) { 
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

Try executing this program as shown here −

$java CommandLine this is a command line 200 -100

This will produce the following result −

Output

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

The this keyword

this is a keyword in Java which is used as a reference to the object of the current class, with in an instance method or a constructor. Using this you can refer the members of a class such as constructors, variables and methods.

Note − The keyword this is used only within instance methods or constructors

In general, the keyword this is used to −

  • Differentiate the instance variables from local variables if they have same names, within a constructor or a method.

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}
  • Call one type of constructor (Parameterized constructor or default) from other in a class. It is known as explicit constructor invocation.

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Example

Here is an example that uses this keyword to access the members of a class. Copy and paste the following program in a file with the name, This_Example.java.

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through Parameterized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

This will produce the following result −

Output

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Variable Arguments(var-args)

JDK 1.5 enables you to pass a variable number of arguments of the same type to a method. The parameter in the method is declared as follows −

typeName... parameterName

In the method declaration, you specify the type followed by an ellipsis (...). Only one variable-length parameter may be specified in a method, and this parameter must be the last parameter. Any regular parameters must precede it.

Example

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

This will produce the following result −

Output

The max value is 56.5
The max value is 3.0

The finalize( ) Method

It is possible to define a method that will be called just before an object's final destruction by the garbage collector. This method is called finalize( ), and it can be used to ensure that an object terminates cleanly.

For example, you might use finalize( ) to make sure that an open file owned by that object is closed.

To add a finalizer to a class, you simply define the finalize( ) method. The Java runtime calls that method whenever it is about to recycle an object of that class.

Inside the finalize( ) method, you will specify those actions that must be performed before an object is destroyed.

The finalize( ) method has this general form −

protected void finalize( ) {
   // finalization code here
}

Here, the keyword protected is a specifier that prevents access to finalize( ) by code defined outside its class.

This means that you cannot know when or even if finalize( ) will be executed. For example, if your program ends before garbage collection occurs, finalize( ) will not execute.

The java.io package contains nearly every class you might ever need to perform input and output (I/O) in Java. All these streams represent an input source and an output destination. The stream in the java.io package supports many data such as primitives, object, localized characters, etc.

Stream

A stream can be defined as a sequence of data. There are two kinds of Streams −

  • InPutStream − The InputStream is used to read data from a source.

  • OutPutStream − The OutputStream is used for writing data to a destination.

Java provides strong but flexible support for I/O related to files and networks but this tutorial covers very basic functionality related to streams and I/O. We will see the most commonly used examples one by one −

Byte Streams

Java byte streams are used to perform input and output of 8-bit bytes. Though there are many classes related to byte streams but the most frequently used classes are, FileInputStream and FileOutputStream. Following is an example which makes use of these two classes to copy an input file into an output file −

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

अब चलो एक फ़ाइल है input.txt निम्नलिखित सामग्री के साथ -

This is test for copy file.

अगले चरण के रूप में, उपरोक्त प्रोग्राम को संकलित करें और इसे निष्पादित करें, जिसके परिणामस्वरूप output.txt फ़ाइल उसी सामग्री के साथ बनाई जाएगी जैसा कि हमारे पास input.txt में है। तो चलिए CopyFile.java फ़ाइल में उपरोक्त कोड डालते हैं और निम्न कार्य करते हैं -

$javac CopyFile.java $java CopyFile

चरित्र धाराओं

जावा Byte धाराओं का उपयोग 8-बिट बाइट्स के इनपुट और आउटपुट को निष्पादित करने के लिए किया जाता है, जबकि जावा Characterधाराएँ 16-बिट यूनिकोड के लिए इनपुट और आउटपुट प्रदर्शन करने के लिए उपयोग की जाती हैं। यद्यपि वर्ण धाराओं से संबंधित कई वर्ग हैं लेकिन सबसे अधिक उपयोग की जाने वाली कक्षाएं हैं,FileReader तथा FileWriter। हालांकि आंतरिक रूप से FileReader FileInputStream का उपयोग करता है और FileWriter FileOutputStream का उपयोग करता है, लेकिन यहाँ प्रमुख अंतर यह है कि FileReader एक समय में दो बाइट्स पढ़ता है और FileWriter एक बार में दो बाइट्स लिखता है।

हम उपरोक्त उदाहरण को फिर से लिख सकते हैं, जो इनपुट फाइल (यूनिकोड वर्ण वाले) को एक आउटपुट फाइल में कॉपी करने के लिए इन दो वर्गों का उपयोग करता है -

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

अब चलो एक फ़ाइल है input.txt निम्नलिखित सामग्री के साथ -

This is test for copy file.

अगले चरण के रूप में, उपरोक्त प्रोग्राम को संकलित करें और इसे निष्पादित करें, जिसके परिणामस्वरूप output.txt फ़ाइल उसी सामग्री के साथ बनाई जाएगी जैसा कि हमारे पास input.txt में है। तो चलिए CopyFile.java फ़ाइल में उपरोक्त कोड डालते हैं और निम्न कार्य करते हैं -

$javac CopyFile.java $java CopyFile

मानक धाराएँ

सभी प्रोग्रामिंग भाषाएं मानक I / O के लिए समर्थन प्रदान करती हैं जहां उपयोगकर्ता का कार्यक्रम एक कीबोर्ड से इनपुट ले सकता है और फिर कंप्यूटर स्क्रीन पर आउटपुट का उत्पादन कर सकता है। यदि आप C या C ++ प्रोग्रामिंग भाषाओं से अवगत हैं, तो आपको तीन मानक उपकरणों STDIN, STDOUT और STDRR के बारे में पता होना चाहिए। इसी तरह, जावा निम्नलिखित तीन मानक धाराएँ प्रदान करता है -

  • Standard Input - इसका उपयोग उपयोगकर्ता के प्रोग्राम को डेटा खिलाने के लिए किया जाता है और आमतौर पर एक कीबोर्ड का उपयोग मानक इनपुट स्ट्रीम के रूप में किया जाता है और इसका प्रतिनिधित्व किया जाता है System.in

  • Standard Output - इसका उपयोग उपयोगकर्ता के कार्यक्रम द्वारा उत्पादित डेटा को आउटपुट करने के लिए किया जाता है और आमतौर पर एक कंप्यूटर स्क्रीन का उपयोग मानक आउटपुट स्ट्रीम के लिए किया जाता है और इसका प्रतिनिधित्व किया जाता है System.out

  • Standard Error - इसका उपयोग उपयोगकर्ता के प्रोग्राम द्वारा उत्पादित त्रुटि डेटा को आउटपुट करने के लिए किया जाता है और आमतौर पर एक कंप्यूटर स्क्रीन का उपयोग मानक त्रुटि स्ट्रीम के लिए किया जाता है और इसका प्रतिनिधित्व किया जाता है System.err

निम्नलिखित एक सरल कार्यक्रम है, जो बनाता है InputStreamReader जब तक उपयोगकर्ता "q" प्रकार का मानक इनपुट स्ट्रीम नहीं पढ़ सकता -

Example

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

उपरोक्त कोड को ReadConsole.java फ़ाइल में रखें और निम्न प्रोग्राम में दिखाए अनुसार इसे संकलित और निष्पादित करने का प्रयास करें। जब तक हम 'q' दबाते हैं, तब तक यह प्रोग्राम उसी वर्ण को पढ़ता और आउटपुट करता रहता है -

$javac ReadConsole.java $java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

फाइल पढ़ना और लिखना

जैसा कि पहले वर्णित है, एक धारा को डेटा के अनुक्रम के रूप में परिभाषित किया जा सकता है। InputStream एक स्रोत और डेटा को पढ़ने के लिए उपयोग किया जाता है OutputStream एक गंतव्य के लिए डेटा लिखने के लिए प्रयोग किया जाता है।

इनपुट और आउटपुट स्ट्रीम से निपटने के लिए यहां कक्षाओं का एक पदानुक्रम है।

दो महत्वपूर्ण धाराएँ हैं FileInputStream तथा FileOutputStream, जो इस ट्यूटोरियल में चर्चा की जाएगी।

FileInputStream

इस स्ट्रीम का उपयोग फाइलों से डेटा पढ़ने के लिए किया जाता है। कीवर्ड का उपयोग करके ऑब्जेक्ट बनाए जा सकते हैंnew और कई प्रकार के निर्माणकर्ता उपलब्ध हैं।

निम्नलिखित कंस्ट्रक्टर फ़ाइल को पढ़ने के लिए एक इनपुट स्ट्रीम ऑब्जेक्ट बनाने के लिए एक स्ट्रिंग के रूप में एक फ़ाइल का नाम लेता है -

InputStream f = new FileInputStream("C:/java/hello");

निम्नलिखित कंस्ट्रक्टर फ़ाइल को पढ़ने के लिए एक इनपुट स्ट्रीम ऑब्जेक्ट बनाने के लिए एक फ़ाइल ऑब्जेक्ट लेता है। पहले हम फ़ाइल () विधि का उपयोग करके एक फ़ाइल ऑब्जेक्ट बनाते हैं -

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

एक बार जब आपके पास इनपुटस्ट्रीम ऑब्जेक्ट हाथ में होता है, तो सहायक विधियों की एक सूची होती है, जिसका उपयोग स्ट्रीम को पढ़ने या स्ट्रीम पर अन्य संचालन करने के लिए किया जा सकता है।

अनु क्रमांक। विधि और विवरण
1

public void close() throws IOException{}

यह विधि फ़ाइल आउटपुट स्ट्रीम बंद कर देती है। फ़ाइल से जुड़े किसी भी सिस्टम संसाधन को रिलीज़ करता है। एक IOException फेंकता है।

2

protected void finalize()throws IOException {}

यह विधि फ़ाइल से कनेक्शन को साफ़ करती है। यह सुनिश्चित करता है कि इस फाइल आउटपुट स्ट्रीम की करीबी विधि को कहा जाता है जब इस स्ट्रीम के लिए अधिक संदर्भ नहीं होते हैं। एक IOException फेंकता है।

3

public int read(int r)throws IOException{}

यह विधि InputStream से डेटा की निर्दिष्ट बाइट को पढ़ती है। एक इंट लौटाता है। डेटा के अगले बाइट को लौटाता है और -1 फाइल के अंत में वापस आ जाएगा।

4

public int read(byte[] r) throws IOException{}

यह विधि इनपुट स्ट्रीम से r.length बाइट्स को एक सरणी में पढ़ती है। पढ़े गए बाइट्स की कुल संख्या लौटाता है। यदि यह फ़ाइल का अंत है, तो -1 वापस कर दिया जाएगा।

5

public int available() throws IOException{}

इस फाइल इनपुट स्ट्रीम से पढ़े जाने वाले बाइट्स की संख्या देता है। एक इंट लौटाता है।

अन्य महत्वपूर्ण इनपुट स्ट्रीम उपलब्ध हैं, और अधिक विवरण के लिए आप निम्न लिंक देख सकते हैं -

  • ByteArrayInputStream

  • DataInputStream

FileOutputStream

FileOutputStream का उपयोग फाइल बनाने और उसमें डेटा लिखने के लिए किया जाता है। स्ट्रीम एक फाइल बनाएगी, अगर यह आउटपुट के लिए खोलने से पहले ही मौजूद नहीं है।

यहाँ दो कंस्ट्रक्टर हैं जिनका उपयोग FileOutputStream ऑब्जेक्ट बनाने के लिए किया जा सकता है।

निम्नलिखित कंस्ट्रक्टर फ़ाइल को लिखने के लिए एक इनपुट स्ट्रीम ऑब्जेक्ट बनाने के लिए एक स्ट्रिंग के रूप में एक फ़ाइल का नाम लेता है -

OutputStream f = new FileOutputStream("C:/java/hello")

निम्नलिखित कंस्ट्रक्टर फ़ाइल को लिखने के लिए आउटपुट स्ट्रीम ऑब्जेक्ट बनाने के लिए एक फ़ाइल ऑब्जेक्ट लेता है। सबसे पहले, हम फ़ाइल () विधि का उपयोग करके एक फ़ाइल ऑब्जेक्ट बनाते हैं -

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

एक बार जब आपके हाथ में OutputStream ऑब्जेक्ट होता है, तो सहायक विधियों की एक सूची होती है, जिसका उपयोग स्ट्रीम पर लिखने या स्ट्रीम पर अन्य संचालन करने के लिए किया जा सकता है।

अनु क्रमांक। विधि और विवरण
1

public void close() throws IOException{}

यह विधि फ़ाइल आउटपुट स्ट्रीम बंद कर देती है। फ़ाइल से जुड़े किसी भी सिस्टम संसाधन को रिलीज़ करता है। एक IOException फेंकता है।

2

protected void finalize()throws IOException {}

यह विधि फ़ाइल से कनेक्शन को साफ़ करती है। यह सुनिश्चित करता है कि इस फाइल आउटपुट स्ट्रीम की करीबी विधि को कहा जाता है जब इस स्ट्रीम के लिए अधिक संदर्भ नहीं होते हैं। एक IOException फेंकता है।

3

public void write(int w)throws IOException{}

यह विधियाँ निर्दिष्ट बाइट को आउटपुट स्ट्रीम में लिखती है।

4

public void write(byte[] w)

W.length बाइट्स का उल्लेख बाइट सरणी से आउटपुटस्ट्रीम में करता है।

अन्य महत्वपूर्ण आउटपुट स्ट्रीम उपलब्ध हैं, और अधिक विवरण के लिए आप निम्न लिंक देख सकते हैं -

  • ByteArrayOutputStream

  • DataOutputStream

Example

निम्नलिखित इनपुटस्ट्रीम और आउटपुटस्ट्रीम को प्रदर्शित करने के लिए उदाहरण है -

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

उपरोक्त कोड फ़ाइल test.txt बनाएगा और बाइनरी प्रारूप में दिए गए नंबर लिखेगा। वही stdout स्क्रीन पर आउटपुट होगा।

फ़ाइल नेविगेशन और I / O

कई अन्य वर्ग हैं जो हम फाइल नेविगेशन और I / O की मूल बातें जानने के लिए गुजर रहे हैं।

  • फ़ाइल वर्ग

  • FileReader वर्ग

  • FileWriter क्लास

जावा में निर्देशिकाएँ

एक निर्देशिका एक फ़ाइल है जिसमें अन्य फ़ाइलों और निर्देशिकाओं की सूची हो सकती है। तुम इस्तेमालFileनिर्देशिका बनाने के लिए ऑब्जेक्ट, एक निर्देशिका में उपलब्ध फ़ाइलों को सूचीबद्ध करने के लिए। पूर्ण विवरण के लिए, उन सभी विधियों की सूची देखें, जिन्हें आप फ़ाइल ऑब्जेक्ट पर कॉल कर सकते हैं और जो निर्देशिकाओं से संबंधित हैं।

निर्देशिका बनाना

दो उपयोगी हैं File उपयोगिता विधियाँ, जिनका उपयोग निर्देशिका बनाने के लिए किया जा सकता है -

  • mkdir( )विधि एक निर्देशिका बनाती है, सफलता पर सही और असफलता पर झूठ। विफलता इंगित करती है कि फ़ाइल ऑब्जेक्ट में निर्दिष्ट पथ पहले से मौजूद है, या कि निर्देशिका बनाई नहीं जा सकती क्योंकि संपूर्ण पथ अभी तक मौजूद नहीं है।

  • mkdirs() विधि एक निर्देशिका और निर्देशिका के सभी माता-पिता दोनों बनाती है।

निम्नलिखित उदाहरण "/ tmp / user / java / bin" निर्देशिका बनाता है -

Example

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

"/ Tmp / user / java / bin" बनाने के लिए उपरोक्त कोड को संकलित और निष्पादित करें।

Note- जावा स्वचालित रूप से सम्मेलनों के अनुसार यूनिक्स और विंडोज पर पथ विभाजकों का ख्याल रखता है। यदि आप जावा के विंडोज संस्करण पर फॉरवर्ड स्लैश (/) का उपयोग करते हैं, तो पथ अभी भी सही तरीके से हल होगा।

लिस्टिंग निर्देशिका

आप उपयोग कर सकते हैं list( ) द्वारा प्रदान की गई विधि File एक निर्देशिका में उपलब्ध सभी फाइलों और निर्देशिकाओं को सूचीबद्ध करने के लिए वस्तु निम्नानुसार है -

Example

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

यह आपके में उपलब्ध निर्देशिका और फ़ाइलों के आधार पर निम्नलिखित परिणाम का उत्पादन करेगा /tmp निर्देशिका -

Output

test1.txt
test2.txt
ReadDir.java
ReadDir.class

एक अपवाद (या असाधारण घटना) एक समस्या है जो एक कार्यक्रम के निष्पादन के दौरान उत्पन्न होती है। जब एException तब होता है जब प्रोग्राम का सामान्य प्रवाह बाधित हो जाता है और प्रोग्राम / एप्लिकेशन असामान्य रूप से समाप्त हो जाता है, जिसकी अनुशंसा नहीं की जाती है, इसलिए, इन अपवादों को नियंत्रित किया जाना है।

एक अपवाद कई अलग-अलग कारणों से हो सकता है। कुछ परिदृश्य निम्नलिखित हैं जहां अपवाद होता है।

  • उपयोगकर्ता ने एक अमान्य डेटा दर्ज किया है।

  • एक फ़ाइल जिसे खोलने की आवश्यकता है वह नहीं मिल सकती है।

  • संचार के बीच में एक नेटवर्क कनेक्शन खो गया है या जेवीएम मेमोरी से बाहर चला गया है।

इनमें से कुछ अपवाद उपयोगकर्ता त्रुटि के कारण होते हैं, अन्य प्रोग्रामर त्रुटि के द्वारा, और अन्य भौतिक संसाधनों द्वारा जो किसी तरह से विफल हो गए हैं।

इनके आधार पर, हमारे पास अपवादों की तीन श्रेणियां हैं। आपको यह समझने की ज़रूरत है कि जावा में अपवाद हैंडलिंग कैसे काम करता है।

  • Checked exceptions- एक जाँच अपवाद एक अपवाद है जिसे संकलन-समय पर संकलक द्वारा जांचा (अधिसूचित) किया जाता है, इन्हें अपवाद के रूप में संकलित भी कहा जाता है। इन अपवादों को अनदेखा नहीं किया जा सकता है, प्रोग्रामर को इन अपवादों का ध्यान रखना चाहिए।

उदाहरण के लिए, यदि आप उपयोग करते हैं FileReaderकिसी फ़ाइल से डेटा पढ़ने के लिए आपके प्रोग्राम में क्लास, यदि इसके निर्माता में निर्दिष्ट फ़ाइल मौजूद नहीं है, तो एक FileNotFoundException होती है, और कंपाइलर प्रोग्रामर को अपवाद को संभालने के लिए संकेत देता है।

उदाहरण

import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

   public static void main(String args[]) {		
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file); 
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित करने का प्रयास करते हैं, तो आपको निम्नलिखित अपवाद मिलेंगे।

उत्पादन

C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(file);
                      ^
1 error

Note - विधियों के बाद से read() तथा close() FileReader वर्ग के IOException को फेंकता है, आप देख सकते हैं कि कंपाइलर IOException को संभालने के लिए Notify के साथ-साथ FileNotFoundException को भी सूचित करता है।

  • Unchecked exceptions- अनियंत्रित अपवाद एक अपवाद है जो निष्पादन के समय होता है। इन्हें भी कहा जाता हैRuntime Exceptions। इनमें प्रोग्रामिंग बग शामिल हैं, जैसे तर्क त्रुटियां या एपीआई का अनुचित उपयोग। संकलन के समय रनटाइम अपवादों को अनदेखा किया जाता है।

उदाहरण के लिए, यदि आपने अपने कार्यक्रम में आकार 5 की एक सरणी घोषित की है, और सरणी के 6 वें तत्व को कॉल करने का प्रयास कर रहे हैं तो एक ArrayIndexOutOfBoundsExceptionexception होती है।

उदाहरण

public class Unchecked_Demo {
   
   public static void main(String args[]) {
      int num[] = {1, 2, 3, 4};
      System.out.println(num[5]);
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो आपको निम्नलिखित अपवाद मिलेगा।

उत्पादन

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)
  • Errors- ये अपवाद नहीं हैं, लेकिन उपयोगकर्ता या प्रोग्रामर के नियंत्रण से परे उत्पन्न होने वाली समस्याएं। आपके कोड में त्रुटियों को आमतौर पर नजरअंदाज कर दिया जाता है क्योंकि आप किसी त्रुटि के बारे में शायद ही कुछ कर सकते हैं। उदाहरण के लिए, यदि स्टैक ओवरफ्लो होता है, तो एक त्रुटि उत्पन्न होगी। संकलन के समय उन्हें भी नजरअंदाज किया जाता है।

अपवाद पदानुक्रम

सभी अपवाद वर्ग java.lang.Exception वर्ग के उपप्रकार हैं। अपवाद वर्ग थ्रेडेबल वर्ग का एक उपवर्ग है। अपवाद वर्ग के अलावा एक और उपवर्ग है, जिसे एरर कहा जाता है, जो थ्रोबेबल क्लास से लिया गया है।

त्रुटियां असामान्य स्थिति हैं जो गंभीर विफलताओं के मामले में होती हैं, ये जावा कार्यक्रमों द्वारा नियंत्रित नहीं की जाती हैं। त्रुटियां रनटाइम वातावरण द्वारा उत्पन्न त्रुटियों को इंगित करने के लिए उत्पन्न होती हैं। उदाहरण: JVM मेमोरी से बाहर है। आम तौर पर, प्रोग्राम त्रुटियों से उबर नहीं सकते हैं।

अपवाद कक्षा के दो मुख्य उपवर्ग हैं: IOException class और RuntimeException Class।

निम्नलिखित जावा के बिल्ट-इन अपवादों में सबसे आम जाँच और अनियंत्रित सूची है ।

अपवाद तरीके

थ्रोबल श्रेणी में उपलब्ध महत्वपूर्ण विधियों की सूची निम्नलिखित है।

अनु क्रमांक। विधि और विवरण
1

public String getMessage()

अपवाद के बारे में एक विस्तृत संदेश देता है। यह संदेश थ्रेडेबल कंस्ट्रक्टर में आरंभिक है।

2

public Throwable getCause()

अपवाद का कारण देता है जैसा कि एक थ्रोबेबल ऑब्जेक्ट द्वारा दर्शाया गया है।

3

public String toString()

GetMessage () के परिणाम के साथ सम्‍मिलित वर्ग का नाम लौटाता है।

4

public void printStackTrace()

System.err, त्रुटि आउटपुट स्ट्रीम में स्टैक ट्रेस के साथ () स्ट्रिंग के परिणाम को प्रिंट करता है।

5

public StackTraceElement [] getStackTrace()

स्टैक ट्रेस पर प्रत्येक तत्व युक्त एक सरणी देता है। इंडेक्स 0 का तत्व कॉल स्टैक के शीर्ष का प्रतिनिधित्व करता है, और सरणी में अंतिम तत्व कॉल स्टैक के निचले भाग में विधि का प्रतिनिधित्व करता है।

6

public Throwable fillInStackTrace()

स्टैक ट्रेस में किसी भी पिछली जानकारी को जोड़ने के साथ, वर्तमान स्टैक ट्रेस के साथ इस थ्रेडेबल ऑब्जेक्ट के स्टैक ट्रेस को भरता है।

पकड़ने के अपवाद

एक विधि एक संयोजन का उपयोग करके एक अपवाद को पकड़ती है try तथा catchकीवर्ड। कोड के आसपास एक कोशिश / कैच ब्लॉक रखा गया है जो एक अपवाद उत्पन्न कर सकता है। एक कोशिश / कैच ब्लॉक के भीतर कोड को संरक्षित कोड के रूप में जाना जाता है, और ट्राइ / कैच का उपयोग करने के लिए सिंटैक्स निम्न की तरह दिखता है -

वाक्य - विन्यास

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

जो कोड अपवादों के लिए प्रवण होता है, उसे कोशिश ब्लॉक में रखा जाता है। जब कोई अपवाद होता है, तो जो अपवाद होता है, उसे इससे जुड़े ब्लॉक द्वारा नियंत्रित किया जाता है। हर कोशिश ब्लॉक को तुरंत या तो कैच ब्लॉक या अंत में ब्लॉक होना चाहिए।

एक कैच स्टेटमेंट में अपवाद के प्रकार को घोषित करना शामिल है जिसे आप पकड़ने की कोशिश कर रहे हैं। यदि कोई संरक्षित कोड में अपवाद होता है, तो कोशिश करने वाले चेक ब्लॉक (या ब्लॉक) की जाँच की जाती है। यदि अपवाद के प्रकार को कैच ब्लॉक में सूचीबद्ध किया गया है, तो अपवाद को ब्लॉक ब्लॉक में पास किया जाता है क्योंकि एक तर्क को एक पैरामीटर पैरामीटर में पारित किया जाता है।

उदाहरण

निम्नलिखित 2 तत्वों के साथ घोषित एक सरणी है। फिर कोड सरणी के 3 आरडी तत्व तक पहुंचने का प्रयास करता है जो एक अपवाद को फेंकता है।

// File Name : ExcepTest.java
import java.io.*;

public class ExcepTest {

   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

एकाधिक पकड़ ब्लॉक

एक कोशिश ब्लॉक कई कैच ब्लॉक द्वारा पीछा किया जा सकता है। कई कैच ब्लॉक के लिए सिंटैक्स निम्न की तरह दिखता है -

वाक्य - विन्यास

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}

पिछले बयानों में तीन कैच ब्लॉक प्रदर्शित होते हैं, लेकिन आपके पास किसी भी प्रयास के बाद उनकी संख्या हो सकती है। यदि संरक्षित कोड में कोई अपवाद होता है, तो अपवाद को सूची में पहले कैच ब्लॉक में फेंक दिया जाता है। यदि अपवाद का डेटा प्रकार ExceptionType1 से मेल खाता है, तो वह वहां पकड़ा जाता है। यदि नहीं, तो अपवाद दूसरे कैच स्टेटमेंट के लिए नीचे जाता है। यह तब तक जारी रहता है जब तक कि अपवाद या तो पकड़ा नहीं जाता है या सभी कैच के माध्यम से गिर जाता है, जिस स्थिति में वर्तमान विधि निष्पादन बंद कर देती है और कॉल स्टैक पर पिछले विधि पर अपवाद को फेंक दिया जाता है।

उदाहरण

यहाँ कोड सेगमेंट में दिखाया गया है कि कैसे कई कोशिशों / कैच स्टेटमेंट्स का उपयोग किया जाता है।

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
} catch (IOException i) {
   i.printStackTrace();
   return -1;
} catch (FileNotFoundException f) // Not valid! {
   f.printStackTrace();
   return -1;
}

कई प्रकार के अपवादों को पकड़ना

जावा 7 के बाद से, आप सिंगल कैच ब्लॉक का उपयोग करके एक से अधिक अपवादों को संभाल सकते हैं, यह सुविधा कोड को सरल बनाती है। यहाँ है कि आप इसे कैसे करेंगे -

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

थ्रो / थ्रो कीवर्ड

यदि कोई विधि जाँच अपवाद को नहीं संभालती है, तो विधि को इसका उपयोग करके घोषित करना चाहिए throwsकीवर्ड। थ्रो कीवर्ड एक विधि के हस्ताक्षर के अंत में दिखाई देता है।

आप एक अपवाद फेंक सकते हैं, या तो एक नव तात्कालिक एक या एक अपवाद जिसे आपने अभी पकड़ा है, का उपयोग करके throw कीवर्ड।

थ्रो और थ्रो कीवर्ड के बीच के अंतर को समझने की कोशिश करें, थ्रो का उपयोग चेक किए गए अपवाद से निपटने के लिए किया जाता है और थ्रो का उपयोग स्पष्ट रूप से एक अपवाद को लागू करने के लिए किया जाता है।

निम्नलिखित विधि घोषित करती है कि यह एक दूरस्थ अपवाद फेंकता है -

उदाहरण

import java.io.*;
public class className {

   public void deposit(double amount) throws RemoteException {
      // Method implementation
      throw new RemoteException();
   }
   // Remainder of class definition
}

एक विधि यह घोषित कर सकती है कि यह एक से अधिक अपवादों को फेंकता है, इस स्थिति में अपवादों को अल्पविराम द्वारा अलग की गई सूची में घोषित किया जाता है। उदाहरण के लिए, निम्न विधि यह घोषित करती है कि यह एक RemoteException और InsufficientFundsException को फेंकता है -

उदाहरण

import java.io.*;
public class className {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Method implementation
   }
   // Remainder of class definition
}

अंत में ब्लॉक

अंत में ब्लॉक एक कोशिश ब्लॉक या कैच ब्लॉक होता है। कोड का एक अंतिम ब्लॉक हमेशा निष्पादित होता है, चाहे एक अपवाद की घटना हो।

अंततः ब्लॉक का उपयोग करने से आप किसी भी क्लीन-टाइप स्टेटमेंट को चला सकते हैं, जिसे आप निष्पादित करना चाहते हैं, भले ही संरक्षित कोड में कुछ भी न हो।

अंत में ब्लॉक कैच ब्लॉक के अंत में दिखाई देता है और इसमें निम्नलिखित सिंटैक्स होता है -

वाक्य - विन्यास

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}finally {
   // The finally block always executes.
}

उदाहरण

public class ExcepTest {

   public static void main(String args[]) {
      int a[] = new int[2];
      try {
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }finally {
         a[0] = 6;
         System.out.println("First element value: " + a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

निम्नलिखित नोट करें -

  • एक कोशिश बयान के बिना एक पकड़ खंड मौजूद नहीं हो सकता।

  • जब भी कोई ट्रायल / कैच ब्लॉक मौजूद होता है, तो क्लॉस का होना अनिवार्य नहीं है।

  • ट्रायल ब्लॉक या तो क्लॉज या अंत में क्लॉज को पकड़े बिना मौजूद नहीं हो सकता।

  • कोई भी कोड कोशिश, पकड़, अंत में ब्लॉक के बीच मौजूद नहीं हो सकता है।

कोशिश-साथ-संसाधन

आम तौर पर, जब हम धाराओं, कनेक्शनों आदि जैसे किसी भी संसाधन का उपयोग करते हैं, तो हमें अंत में ब्लॉक का उपयोग करके उन्हें स्पष्ट रूप से बंद करना होगा। निम्नलिखित कार्यक्रम में, हम एक फ़ाइल का उपयोग करके डेटा पढ़ रहे हैंFileReader और हम अंत में ब्लॉक का उपयोग करके इसे बंद कर रहे हैं।

उदाहरण

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File file = new File("file.txt");
         fr = new FileReader(file); char [] a = new char[50];
         fr.read(a);   // reads the content to the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         try {
            fr.close();
         } catch (IOException ex) {		
            ex.printStackTrace();
         }
      }
   }
}

try-with-resources, के रूप में भी जाना जाता है automatic resource management, एक नया अपवाद हैंडलिंग तंत्र है जो जावा 7 में पेश किया गया था, जो कि स्वचालित रूप से ट्राई कैच ब्लॉक में उपयोग किए गए संसाधनों को बंद कर देता है।

इस कथन का उपयोग करने के लिए, आपको केवल कोष्ठक के भीतर आवश्यक संसाधनों को घोषित करने की आवश्यकता है, और बनाए गए संसाधन ब्लॉक के अंत में स्वचालित रूप से बंद हो जाएंगे। निम्नलिखित संसाधनों के साथ कथन का वाक्य विन्यास है।

वाक्य - विन्यास

try(FileReader fr = new FileReader("file path")) {
   // use the resource
   } catch () {
      // body of catch 
   }
}

निम्नलिखित प्रोग्राम है जो कोशिश-संसाधनों संसाधनों के बयान का उपयोग करके फ़ाइल में डेटा पढ़ता है।

उदाहरण

import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://file.txt")) {
         char [] a = new char[50];
         fr.read(a);   // reads the contentto the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

कोशिश के साथ संसाधनों के बयान के साथ काम करते समय निम्नलिखित बिंदुओं को ध्यान में रखा जाना चाहिए।

  • कोशिश-संसाधनों के बयान के साथ एक वर्ग का उपयोग करने के लिए इसे लागू करना चाहिए AutoCloseable इंटरफ़ेस और close() इसका तरीका रनटाइम पर स्वचालित रूप से लागू हो जाता है।

  • आप कोशिश के साथ संसाधनों के बयान में एक से अधिक वर्ग की घोषणा कर सकते हैं।

  • जब आप कोशिश-के-संसाधन संसाधनों की कोशिश ब्लॉक में कई वर्गों की घोषणा करते हैं तो ये कक्षाएं रिवर्स ऑर्डर में बंद हो जाती हैं।

  • कोष्ठक के भीतर संसाधनों की घोषणा को छोड़कर सब कुछ एक कोशिश ब्लॉक के सामान्य प्रयास / पकड़ने ब्लॉक के समान है।

  • प्रयास में घोषित संसाधन, कोशिश-ब्लॉक की शुरुआत से ठीक पहले हो जाता है।

  • ट्रायल ब्लॉक में घोषित संसाधन को अंतिम रूप से घोषित किया जाता है।

उपयोगकर्ता-परिभाषित अपवाद

आप अपने स्वयं के अपवाद जावा में बना सकते हैं। अपने स्वयं के अपवाद वर्गों को लिखते समय निम्नलिखित बिंदुओं को ध्यान में रखें -

  • सभी अपवादों को थ्रोबेबल का बच्चा होना चाहिए।

  • यदि आप एक जाँच अपवाद लिखना चाहते हैं जो स्वचालित रूप से हैंडल या डिक्लेयर नियम द्वारा लागू किया जाता है, तो आपको अपवाद वर्ग को विस्तारित करने की आवश्यकता है।

  • यदि आप एक रनटाइम अपवाद लिखना चाहते हैं, तो आपको RuntimeException वर्ग का विस्तार करने की आवश्यकता है।

हम अपने स्वयं के अपवाद वर्ग को नीचे के रूप में परिभाषित कर सकते हैं -

class MyException extends Exception {
}

आपको बस पूर्वनिर्धारित का विस्तार करने की आवश्यकता है Exceptionअपनी खुद की अपवाद बनाने के लिए कक्षा। इन्हें अपवाद माना जाता है। निम्नलिखितInsufficientFundsExceptionवर्ग एक उपयोगकर्ता-परिभाषित अपवाद है जो अपवाद वर्ग का विस्तार करता है, यह एक जाँच अपवाद है। एक अपवाद वर्ग किसी भी अन्य वर्ग की तरह है, जिसमें उपयोगी क्षेत्र और विधियां हैं।

उदाहरण

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

हमारे उपयोगकर्ता-परिभाषित अपवाद का उपयोग करके प्रदर्शित करने के लिए, निम्नलिखित CheckingAccount वर्ग में एक InsufficFundsException फेंकता है, जिसमें एक वापसी () विधि होती है।

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount {
   private double balance;
   private int number;
   
   public CheckingAccount(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

निम्नलिखित BankDemo कार्यक्रम जमा () और आहरण () CheckingAccount के तरीकों को प्रदर्शित करता है।

// File Name BankDemo.java
public class BankDemo {

   public static void main(String [] args) {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); } catch (InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

उपरोक्त सभी तीन फ़ाइलों को संकलित करें और BankDemo चलाएं। यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Depositing $500... Withdrawing $100...

Withdrawing $600... Sorry, but you are short $200.0
InsufficientFundsException
         at CheckingAccount.withdraw(CheckingAccount.java:25)
         at BankDemo.main(BankDemo.java:13)

आम अपवाद

जावा में, अपवादों और त्रुटियों के दो कैटरगरीज को परिभाषित करना संभव है।

  • JVM Exceptions- ये अपवाद / त्रुटियां हैं जो विशेष रूप से या तार्किक रूप से JVM द्वारा फेंकी जाती हैं। उदाहरण: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException।

  • Programmatic Exceptions- इन अपवादों को एप्लिकेशन या एपीआई प्रोग्रामर द्वारा स्पष्ट रूप से फेंक दिया जाता है। उदाहरण: IllegalArgumentException, IllegalStateException।

इस अध्याय में, हम जावा के आंतरिक वर्गों पर चर्चा करेंगे।

नेस्टेड क्लासेस

जावा में, तरीकों की तरह, एक वर्ग के चर भी इसके सदस्य के रूप में एक और वर्ग हो सकते हैं। जावा में किसी अन्य के लिए एक वर्ग लिखने की अनुमति है। भीतर लिखी कक्षा को कहा जाता हैnested class, और आंतरिक वर्ग को धारण करने वाले वर्ग को कहा जाता है outer class

Syntax

नेस्टेड क्लास लिखने के लिए सिंटैक्स निम्नलिखित है। इधर, क्लासOuter_Demo बाहरी वर्ग और वर्ग है Inner_Demo नेस्टेड क्लास है।

class Outer_Demo {
   class Inner_Demo {
   }
}

नेस्टेड वर्गों को दो प्रकारों में विभाजित किया जाता है -

  • Non-static nested classes - ये एक वर्ग के गैर-स्थैतिक सदस्य हैं।

  • Static nested classes - ये एक वर्ग के स्थिर सदस्य हैं।

इनर क्लासेस (नॉन-स्टेटिक नेस्टेड क्लासेस)

आंतरिक कक्षाएं जावा में एक सुरक्षा तंत्र हैं। हम जानते हैं कि एक वर्ग पहुँच संशोधक से जुड़ा नहीं हो सकता हैprivate, लेकिन अगर हमारे पास अन्य वर्ग के सदस्य के रूप में वर्ग है, तो आंतरिक वर्ग को निजी बनाया जा सकता है। और इसका उपयोग किसी वर्ग के निजी सदस्यों तक पहुंचने के लिए भी किया जाता है।

आंतरिक वर्ग तीन प्रकार के होते हैं जो इस बात पर निर्भर करते हैं कि आप उन्हें कैसे और कहां परिभाषित करते हैं। वे हैं -

  • भीतरी वर्ग
  • विधि-स्थानीय इनर क्लास
  • अनाम भीतरी वर्ग

भीतरी वर्ग

एक आंतरिक वर्ग बनाना काफी सरल है। आपको बस एक वर्ग के भीतर एक वर्ग लिखने की आवश्यकता है। एक वर्ग के विपरीत, एक आंतरिक वर्ग निजी हो सकता है और एक बार जब आप एक आंतरिक वर्ग को निजी घोषित करते हैं, तो इसे कक्षा के बाहर किसी ऑब्जेक्ट से एक्सेस नहीं किया जा सकता है।

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

Example

class Outer_Demo {
   int num;
   
   // inner class
   private class Inner_Demo {
      public void print() {
         System.out.println("This is an inner class");
      }
   }
   
   // Accessing he inner class from the method within
   void display_Inner() {
      Inner_Demo inner = new Inner_Demo();
      inner.print();
   }
}
   
public class My_class {

   public static void main(String args[]) {
      // Instantiating the outer class 
      Outer_Demo outer = new Outer_Demo();
      
      // Accessing the display_Inner() method.
      outer.display_Inner();
   }
}

यहां आप उसका अवलोकन कर सकते हैं Outer_Demo बाहरी वर्ग है, Inner_Demo भीतरी वर्ग है, display_Inner() वह विधि है जिसके भीतर हम भीतर के वर्ग को तात्कालिक कर रहे हैं, और यह विधि भीतर से आक्रांत है main तरीका।

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो आपको निम्न परिणाम प्राप्त होंगे -

Output

This is an inner class.

निजी सदस्यों तक पहुँचना

जैसा कि पहले उल्लेख किया गया है, आंतरिक कक्षाओं का उपयोग किसी वर्ग के निजी सदस्यों तक पहुंचने के लिए भी किया जाता है। मान लीजिए, एक वर्ग के पास निजी सदस्य हैं जो उन्हें एक्सेस कर सकते हैं। इसमें एक आंतरिक वर्ग लिखें, निजी सदस्यों को आंतरिक वर्ग के भीतर एक विधि से लौटें, कहें,getValue(), और अंत में एक अन्य वर्ग (जिसमें से आप निजी सदस्यों तक पहुंच चाहते हैं) को इनवर्ट क्लास का गेटवैल्यू () विधि कहते हैं।

आंतरिक कक्षा को तुरंत शुरू करने के लिए, शुरुआत में आपको बाहरी वर्ग को त्वरित करना होगा। तत्पश्चात, बाहरी वर्ग की वस्तु का उपयोग करते हुए, निम्नलिखित तरीका है जिससे आप आंतरिक वर्ग को त्वरित कर सकते हैं।

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

निम्न कार्यक्रम दिखाता है कि आंतरिक वर्ग का उपयोग करके किसी वर्ग के निजी सदस्यों तक कैसे पहुंचा जाए।

Example

class Outer_Demo {
   // private variable of the outer class
   private int num = 175;  
   
   // inner class
   public class Inner_Demo {
      public int getNum() {
         System.out.println("This is the getnum method of the inner class");
         return num;
      }
   }
}

public class My_class2 {

   public static void main(String args[]) {
      // Instantiating the outer class
      Outer_Demo outer = new Outer_Demo();
      
      // Instantiating the inner class
      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
      System.out.println(inner.getNum());
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो आपको निम्न परिणाम प्राप्त होंगे -

Output

This is the getnum method of the inner class: 175

विधि-स्थानीय इनर क्लास

जावा में, हम एक विधि के भीतर एक वर्ग लिख सकते हैं और यह एक स्थानीय प्रकार होगा। स्थानीय चर की तरह, विधि के भीतर आंतरिक वर्ग का दायरा प्रतिबंधित है।

एक विधि-स्थानीय आंतरिक वर्ग केवल उस पद्धति के भीतर त्वरित किया जा सकता है जहां आंतरिक वर्ग को परिभाषित किया गया है। निम्न प्रोग्राम दिखाता है कि विधि-स्थानीय आंतरिक वर्ग का उपयोग कैसे करें।

Example

public class Outerclass {
   // instance method of the outer class 
   void my_Method() {
      int num = 23;

      // method-local inner class
      class MethodInner_Demo {
         public void print() {
            System.out.println("This is method inner class "+num);	   
         }   
      } // end of inner class
	   
      // Accessing the inner class
      MethodInner_Demo inner = new MethodInner_Demo();
      inner.print();
   }
   
   public static void main(String args[]) {
      Outerclass outer = new Outerclass();
      outer.my_Method();	   	   
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो आपको निम्न परिणाम प्राप्त होंगे -

Output

This is method inner class 23

अनाम भीतरी वर्ग

वर्ग नाम के बिना घोषित एक आंतरिक वर्ग को एक के रूप में जाना जाता है anonymous inner class। अनाम आंतरिक वर्गों के मामले में, हम उन्हें एक ही समय में घोषित और त्वरित करते हैं। जब भी आपको क्लास या इंटरफ़ेस की विधि को ओवरराइड करने की आवश्यकता होती है, तो आमतौर पर उनका उपयोग किया जाता है। अनाम आंतरिक वर्ग का वाक्य विन्यास इस प्रकार है -

Syntax

AnonymousInner an_inner = new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

निम्न प्रोग्राम दिखाता है कि अनाम आंतरिक वर्ग का उपयोग करके किसी वर्ग की पद्धति को कैसे ओवरराइड किया जाए।

Example

abstract class AnonymousInner {
   public abstract void mymethod();
}

public class Outer_class {

   public static void main(String args[]) {
      AnonymousInner inner = new AnonymousInner() {
         public void mymethod() {
            System.out.println("This is an example of anonymous inner class");
         }
      };
      inner.mymethod();	
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो आपको निम्न परिणाम प्राप्त होंगे -

Output

This is an example of anonymous inner class

उसी तरह, आप कंक्रीट वर्ग के तरीकों के साथ-साथ एक अनाम आंतरिक वर्ग का उपयोग करके इंटरफ़ेस को ओवरराइड कर सकते हैं।

अनाम आंतरिक कक्षा तर्क के रूप में

आम तौर पर, यदि कोई विधि किसी इंटरफ़ेस, एब्स्ट्रैक्ट क्लास या कंक्रीट क्लास के ऑब्जेक्ट को स्वीकार करती है, तो हम इंटरफ़ेस को लागू कर सकते हैं, एब्सट्रैक्ट क्लास का विस्तार कर सकते हैं और ऑब्जेक्ट को विधि में पास कर सकते हैं। यदि यह एक वर्ग है, तो हम इसे सीधे विधि में पारित कर सकते हैं।

लेकिन तीनों मामलों में, आप एक अनाम आंतरिक वर्ग को विधि में पास कर सकते हैं। एक अनाम आंतरिक वर्ग को एक विधि तर्क के रूप में पारित करने का सिंटैक्स यहां दिया गया है -

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

निम्नलिखित कार्यक्रम दिखाता है कि एक अनाम आंतरिक वर्ग को विधि तर्क के रूप में कैसे पास किया जाए।

Example

// interface
interface Message {
   String greet();
}

public class My_class {
   // method which accepts the object of interface Message
   public void displayMessage(Message m) {
      System.out.println(m.greet() +
         ", This is an example of anonymous inner class as an argument");  
   }

   public static void main(String args[]) {
      // Instantiating the class
      My_class obj = new My_class();

      // Passing an anonymous inner class as an argument
      obj.displayMessage(new Message() {
         public String greet() {
            return "Hello";
         }
      });
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो यह आपको निम्नलिखित परिणाम देता है -

Output

Hello, This is an example of anonymous inner class as an argument

स्टेटिक नेस्टेड क्लास

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

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

स्टैटिक नेस्टेड क्लास को इंस्टेंट करना, आंतरिक क्लास को इंस्टेंट करने से थोड़ा अलग है। निम्न प्रोग्राम दिखाता है कि एक स्थिर नेस्टेड क्लास का उपयोग कैसे करें।

Example

public class Outer {
   static class Nested_Demo {
      public void my_method() {
         System.out.println("This is my nested class");
      }
   }
   
   public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();	 
      nested.my_method();
   }
}

यदि आप उपरोक्त कार्यक्रम को संकलित और निष्पादित करते हैं, तो आपको निम्न परिणाम प्राप्त होंगे -

Output

This is my nested class

वंशानुक्रम को उस प्रक्रिया के रूप में परिभाषित किया जा सकता है जहां एक वर्ग दूसरे के गुणों (तरीकों और क्षेत्रों) का अधिग्रहण करता है। विरासत के उपयोग के साथ सूचना को एक पदानुक्रमित क्रम में प्रबंधनीय बनाया जाता है।

जो वर्ग अन्य के गुणों को विरासत में देता है, उसे उपवर्ग (व्युत्पन्न वर्ग, बाल वर्ग) के रूप में जाना जाता है और जिस वर्ग के गुण विरासत में मिलते हैं उसे सुपरक्लास (आधार वर्ग, मूल वर्ग) के रूप में जाना जाता है।

कीवर्ड बढ़ाता है

extendsवह कीवर्ड है जिसका उपयोग किसी वर्ग के गुणों को प्राप्त करने के लिए किया जाता है। निम्नलिखित कीवर्ड का विस्तार है।

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

नमूना कोड

निम्नलिखित जावा विरासत का प्रदर्शन करने वाला एक उदाहरण है। इस उदाहरण में, आप गणना और My_Calacle दो वर्गों का निरीक्षण कर सकते हैं।

कीवर्ड का उपयोग करते हुए, My_Calacle गणना वर्ग के अतिरिक्त () और घटाव () तरीकों को विरासत में मिला है।

निम्न प्रोग्राम को My_Calacle.java नाम की फ़ाइल में कॉपी और पेस्ट करें

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

उपरोक्त कोड को संकलित और निष्पादित करें जैसा कि नीचे दिखाया गया है।

javac My_Calculation.java
java My_Calculation

कार्यक्रम को निष्पादित करने के बाद, यह निम्नलिखित परिणाम देगा -

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

दिए गए कार्यक्रम में, जब कोई वस्तु My_Calculationवर्ग बनाया जाता है, उसके भीतर सुपरक्लास की सामग्री की एक प्रति बनाई जाती है। इसीलिए, उपवर्ग के ऑब्जेक्ट का उपयोग करके आप सुपरक्लास के सदस्यों तक पहुँच सकते हैं।

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

यदि आप उपरोक्त कार्यक्रम पर विचार करते हैं, तो आप नीचे दिए गए अनुसार कक्षा को तुरंत लिख सकते हैं। लेकिन सुपरक्लास संदर्भ चर का उपयोग करना (cal इस मामले में) आप विधि नहीं कह सकते multiplication(), जो उपवर्ग My_Calacle से संबंधित है।

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

Note- एक उपवर्ग अपने सुपरक्लास से सभी सदस्यों (क्षेत्रों, विधियों, और नेस्टेड वर्गों) को विरासत में मिला है। कंस्ट्रक्टर सदस्य नहीं हैं, इसलिए उन्हें उप-वर्ग द्वारा विरासत में नहीं मिला है, लेकिन सुपरक्लास के निर्माता को उपवर्ग से आमंत्रित किया जा सकता है।

सुपर कीवर्ड

super कीवर्ड के समान है thisकीवर्ड। निम्नलिखित परिदृश्य हैं जहां सुपर कीवर्ड का उपयोग किया जाता है।

  • इसका उपयोग किया जाता है differentiate the members सुपरक्लास के सदस्यों के उपवर्गों से, यदि उनके नाम समान हैं।

  • इसका उपयोग किया जाता है invoke the superclass उपवर्ग से निर्माणकर्ता।

सदस्यों को विभेदित करना

यदि एक वर्ग दूसरे वर्ग के गुणों को विरासत में प्राप्त कर रहा है। और अगर सुपरक्लास के सदस्यों के उप वर्ग के समान नाम हैं, तो इन चरों को अलग करने के लिए हम नीचे दिखाए गए अनुसार सुपर कीवर्ड का उपयोग करते हैं।

super.variable
super.method();

नमूना कोड

यह खंड आपको एक प्रोग्राम प्रदान करता है जो के उपयोग को दर्शाता है super कीवर्ड।

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

Sub_class.java नाम की फ़ाइल में प्रोग्राम को कॉपी और पेस्ट करें।

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

निम्नलिखित सिंटैक्स का उपयोग करके उपरोक्त कोड को संकलित और निष्पादित करें।

javac Super_Demo
java Super

कार्यक्रम को निष्पादित करने पर, आपको निम्नलिखित परिणाम मिलेगा -

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

सुपरक्लास कंस्ट्रक्टर को आमंत्रित करना

यदि एक वर्ग किसी अन्य वर्ग के गुणों को विरासत में प्राप्त कर रहा है, तो उपवर्ग स्वचालित रूप से सुपरक्लास के डिफ़ॉल्ट निर्माणकर्ता को प्राप्त कर लेता है। लेकिन अगर आप सुपरक्लास के एक पैरामीटर निर्मित निर्माता को कॉल करना चाहते हैं, तो आपको नीचे दिखाए गए अनुसार सुपर कीवर्ड का उपयोग करने की आवश्यकता है।

super(values);

नमूना कोड

इस खंड में दिए गए कार्यक्रम से पता चलता है कि सुपरक्लास के Parameterized कंस्ट्रक्टर को आमंत्रित करने के लिए सुपर कीवर्ड का उपयोग कैसे करें। इस कार्यक्रम में एक सुपरक्लास और एक उपवर्ग शामिल हैं, जहां सुपरक्लास में एक पैरामीटर निर्मित निर्माता होता है जो पूर्णांक मान को स्वीकार करता है, और हमने सुपर-क्लास के पैरामीटर वाले निर्माता को आमंत्रित करने के लिए सुपर कीवर्ड का उपयोग किया।

Subclass.java नाम के साथ एक फ़ाइल में निम्न प्रोग्राम को कॉपी और पेस्ट करें

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

निम्नलिखित सिंटैक्स का उपयोग करके उपरोक्त कोड को संकलित और निष्पादित करें।

javac Subclass
java Subclass

कार्यक्रम को निष्पादित करने पर, आपको निम्नलिखित परिणाम मिलेगा -

Output

The value of the variable named age in super class is: 24

आईएस-ए रिलेशनशिप

IS-A कहने का एक तरीका है: यह वस्तु उस वस्तु का एक प्रकार है। आइए देखते हैं कि कैसेextends वंशानुक्रम प्राप्त करने के लिए खोजशब्द का उपयोग किया जाता है।

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

अब, उपरोक्त उदाहरण के आधार पर, ऑब्जेक्ट-ओरिएंटेड शब्दों में, निम्नलिखित सत्य हैं -

  • पशु स्तनपायी वर्ग का सुपरक्लास है।
  • पशु सरीसृप वर्ग का सुपरक्लास है।
  • स्तनपायी और सरीसृप पशु वर्ग के उपवर्ग हैं।
  • डॉग स्तनपायी और पशु दोनों वर्गों का उपवर्ग है।

अब, यदि हम IS-A संबंध पर विचार करते हैं, तो हम कह सकते हैं -

  • स्तनपायी आईएस-ए एनिमल
  • सरीसृप IS-A पशु है
  • डॉग IS-A स्तनपायी
  • इसलिए: डॉग आईएस-ए एनिमल भी है

फैली हुई कीवर्ड के उपयोग के साथ, उपवर्ग सुपरक्लास के निजी गुणों को छोड़कर सुपरक्लास के सभी गुणों को प्राप्त करने में सक्षम होंगे।

हम आश्वस्त कर सकते हैं कि स्तनपायी वास्तव में एक जानवर है जिसका उपयोग उदाहरण के लिए किया जाता है।

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Output

true
true
true

चूंकि हमें इसकी अच्छी समझ है extends कीवर्ड, आइए देखें कि कैसे implements कीवर्ड का उपयोग IS-A संबंध प्राप्त करने के लिए किया जाता है।

आम तौर पर, implementsएक इंटरफेस के गुणों को प्राप्त करने के लिए कक्षाओं के साथ कीवर्ड का उपयोग किया जाता है। Interfaces को एक class के द्वारा कभी नहीं बढ़ाया जा सकता है।

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

Instof Keyword

हमें उपयोग करते हैं instanceof यह जाँचने के लिए कि क्या स्तनपायी वास्तव में एक पशु है, और कुत्ता वास्तव में एक पशु है।

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Output

true
true
true

एच ए-ए संबंध

ये रिश्ते मुख्य रूप से उपयोग पर आधारित हैं। यह निर्धारित करता है कि क्या एक निश्चित वर्गHAS-Aनिश्चित बात। यह रिश्ता कोड के दोहराव को कम करने के साथ-साथ बग्स को भी मदद करता है।

एक उदाहरण में देखें -

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

इससे पता चलता है कि क्लास वैन एचएएस-ए स्पीड। स्पीड के लिए एक अलग वर्ग होने से, हमें पूरे कोड को वैन क्लास के अंदर स्पीड से संबंधित नहीं करना पड़ता है, जिससे कई अनुप्रयोगों में स्पीड क्लास का पुन: उपयोग करना संभव हो जाता है।

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

वंशानुक्रम के प्रकार

नीचे दिखाए गए अनुसार विभिन्न प्रकार के वंशानुक्रम हैं।

याद रखने के लिए एक बहुत महत्वपूर्ण तथ्य यह है कि जावा कई उत्तराधिकार का समर्थन नहीं करता है। इसका मतलब है कि एक वर्ग एक से अधिक वर्ग का विस्तार नहीं कर सकता है। इसलिए निम्नलिखित अवैध है -

Example

public class extends Animal, Mammal{}

हालांकि, एक वर्ग एक या एक से अधिक इंटरफेस को लागू कर सकता है, जिसने जावा को कई विरासत की असंभवता से छुटकारा पाने में मदद की है।

पिछले अध्याय में, हमने सुपरक्लास और उपवर्गों के बारे में बात की थी। यदि कोई वर्ग अपने सुपरक्लास से एक विधि प्राप्त करता है, तो उस विधि को ओवरराइड करने का एक मौका होता है बशर्ते कि वह अंतिम रूप से चिह्नित न हो।

ओवरराइडिंग का लाभ है: एक व्यवहार को परिभाषित करने की क्षमता जो उपवर्ग प्रकार के लिए विशिष्ट है, जिसका अर्थ है कि एक उपवर्ग अपनी आवश्यकता के आधार पर एक मूल वर्ग विधि को लागू कर सकता है।

ऑब्जेक्ट-ओरिएंटेड शब्दों में, ओवरराइडिंग का मतलब मौजूदा विधि की कार्यक्षमता को ओवरराइड करना है।

उदाहरण

आइए एक उदाहरण देखें।

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Animals can move
Dogs can walk and run

उपरोक्त उदाहरण में, आप देख सकते हैं कि भले ही bएक प्रकार का एनिमल है जो डॉग क्लास में मूव मेथड चलाता है। इसका कारण यह है: संकलन समय में, चेक को संदर्भ प्रकार पर बनाया जाता है। हालाँकि, रनटाइम में, JVM ऑब्जेक्ट प्रकार का पता लगाता है और उस पद्धति को चलाएगा जो उस विशेष ऑब्जेक्ट से संबंधित है।

इसलिए, उपरोक्त उदाहरण में, कार्यक्रम ठीक से संकलन करेगा क्योंकि पशु वर्ग के पास विधि चाल है। फिर, रनटाइम पर, यह उस ऑब्जेक्ट के लिए विशिष्ट विधि चलाता है।

निम्नलिखित उदाहरण पर विचार करें -

उदाहरण

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
   public void bark() {
      System.out.println("Dogs can bark");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
      b.bark();
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

यह प्रोग्राम b के संदर्भ प्रकार के बाद से संकलित समय त्रुटि को फेंक देगा। पशु के पास छाल के नाम से एक विधि नहीं है।

विधि अधिभाव के लिए नियम

  • तर्क सूची बिल्कुल वैसी ही होनी चाहिए जैसी कि ओवरराइड विधि।

  • सुपरक्लास में मूल ओवरराइड विधि में घोषित रिटर्न प्रकार एक ही होना चाहिए या रिटर्न प्रकार का एक उपप्रकार होना चाहिए।

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

  • उदाहरण के तरीके केवल तभी ओवरराइड किए जा सकते हैं जब वे उपवर्ग द्वारा विरासत में मिले हों।

  • अंतिम घोषित की गई विधि को ओवरराइड नहीं किया जा सकता है।

  • स्थिर घोषित की गई विधि को ओवरराइड नहीं किया जा सकता है, लेकिन फिर से घोषित किया जा सकता है।

  • यदि कोई विधि विरासत में नहीं ली जा सकती है, तो उसे ओवरराइड नहीं किया जा सकता है।

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

  • एक अलग पैकेज में एक उपवर्ग केवल सार्वजनिक या संरक्षित घोषित किए गए गैर-अंतिम तरीकों को ओवरराइड कर सकता है।

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

  • कन्स्ट्रक्टर्स को ओवरराइड नहीं किया जा सकता है।

सुपर कीवर्ड का उपयोग करना

जब एक अधिरोहित विधि के सुपरक्लास संस्करण का आह्वान किया जाता है super कीवर्ड का उपयोग किया जाता है।

उदाहरण

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Animals can move
Dogs can walk and run

बहुरूपता एक वस्तु की कई रूपों को लेने की क्षमता है। ओओपी में बहुरूपता का सबसे आम उपयोग तब होता है जब एक अभिभावक वर्ग के संदर्भ का उपयोग बाल वर्ग वस्तु को संदर्भित करने के लिए किया जाता है।

कोई भी जावा ऑब्जेक्ट जो एक से अधिक आईएस-ए परीक्षण पास कर सकता है, उसे बहुरूपक माना जाता है। जावा में, सभी जावा ऑब्जेक्ट पॉलीमॉर्फिक हैं क्योंकि कोई भी वस्तु अपने स्वयं के प्रकार और वर्ग वस्तु के लिए आईएस-ए परीक्षण पास करेगी।

यह जानना महत्वपूर्ण है कि किसी वस्तु तक पहुंचने का एकमात्र संभव तरीका एक संदर्भ चर है। एक संदर्भ चर केवल एक प्रकार का हो सकता है। एक बार घोषित होने के बाद, संदर्भ चर का प्रकार बदला नहीं जा सकता।

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

एक संदर्भ चर इसके घोषित प्रकार के किसी भी ऑब्जेक्ट या इसके घोषित प्रकार के किसी भी उपप्रकार का उल्लेख कर सकता है। एक संदर्भ चर को एक वर्ग या इंटरफ़ेस प्रकार के रूप में घोषित किया जा सकता है।

उदाहरण

आइए एक उदाहरण देखें।

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

अब, हिरण वर्ग को बहुपत्नी माना जाता है क्योंकि इसमें कई वंशानुक्रम होते हैं। उपरोक्त उदाहरणों के लिए निम्नलिखित सत्य हैं -

  • एक हिरण IS-A पशु है
  • एक हिरण IS-A शाकाहारी
  • एक हिरण IS-A हिरण
  • एक हिरण IS-A ऑब्जेक्ट

जब हम संदर्भ चर तथ्यों को एक हिरण ऑब्जेक्ट संदर्भ पर लागू करते हैं, तो निम्नलिखित घोषणाएं कानूनी हैं -

उदाहरण

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

सभी संदर्भ चर d, a, v, o ढेर में समान हिरण ऑब्जेक्ट को संदर्भित करते हैं।

आभासी तरीके

इस खंड में, मैं आपको दिखाऊंगा कि कैसे जावा में ओवरराइड तरीकों का व्यवहार आपको इन वर्गों को डिजाइन करते समय बहुरूपता का लाभ उठाने की अनुमति देता है।

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

उदाहरण

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

अब मान लीजिए कि हम कर्मचारी वर्ग का विस्तार करते हैं -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

अब, आप निम्नलिखित कार्यक्रम का ध्यानपूर्वक अध्ययन करें और इसके आउटपुट को निर्धारित करने का प्रयास करें -

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

यहाँ, हम दो वेतन वस्तुओं को तुरंत रोकते हैं। एक वेतन संदर्भ का उपयोग करs, और एक कर्मचारी संदर्भ का उपयोग कर अन्य e

S.mailCheck () को लागू करते समय, संकलनकर्ता संकलन समय में वेतन वर्ग में mailCheck () देखता है, और JVM रन समय में वेतन श्रेणी में mailCheck () को आमंत्रित करता है।

mailCheck () पर e काफी अलग है क्योंकि eएक कर्मचारी संदर्भ है। जब कंपाइलर e.mailCheck () देखता है , तो कंपाइलर कर्मचारी वर्ग में mailCheck () विधि देखता है।

यहाँ, संकलन के समय, संकलक ने इस कथन को मान्य करने के लिए कर्मचारी में mailCheck () का उपयोग किया। हालांकि, रन टाइम में, JVM सैलरी क्लास में mailCheck () को आमंत्रित करता है।

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

शब्दकोश के अनुसार, abstractionघटनाओं के बजाय विचारों से निपटने का गुण है। उदाहरण के लिए, जब आप ई-मेल के मामले पर विचार करते हैं, तो जटिल विवरण जैसे कि ई-मेल भेजते ही क्या होता है, आपके ई-मेल सर्वर का उपयोग करने वाला प्रोटोकॉल उपयोगकर्ता से छिपा होता है। इसलिए, एक ई-मेल भेजने के लिए आपको केवल सामग्री टाइप करने की आवश्यकता है, रिसीवर के पते का उल्लेख करें, और भेजें पर क्लिक करें।

इसी तरह ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, अमूर्तता उपयोगकर्ता से कार्यान्वयन विवरण छिपाने की एक प्रक्रिया है, केवल उपयोगकर्ता को कार्यक्षमता प्रदान की जाएगी। दूसरे शब्दों में, उपयोगकर्ता के पास इस बात की जानकारी होगी कि वस्तु इसके बजाय यह कैसे करती है।

जावा में, अमूर्त वर्गों और इंटरफेस का उपयोग करके अमूर्तता प्राप्त की जाती है।

सार वर्ग

एक वर्ग जिसमें शामिल है abstract इसकी घोषणा में कीवर्ड को अमूर्त वर्ग के रूप में जाना जाता है।

  • अमूर्त वर्ग में अमूर्त विधियाँ हो सकती हैं या नहीं , अर्थात बिना शरीर के विधियाँ (सार्वजनिक शून्य प्राप्त) (;)

  • लेकिन, यदि किसी वर्ग में कम से कम एक सार पद्धति है, तो वह कक्षा है must सार घोषित किया जाए।

  • यदि किसी वर्ग को सार घोषित किया जाता है, तो उसे तत्काल नहीं किया जा सकता है।

  • एक अमूर्त वर्ग का उपयोग करने के लिए, आपको इसे दूसरे वर्ग से विरासत में प्राप्त करना होगा, इसमें अमूर्त विधियों को कार्यान्वयन प्रदान करना होगा।

  • यदि आपको एक सार वर्ग विरासत में मिला है, तो आपको इसमें सभी सार विधियों को क्रियान्वयन प्रदान करना होगा।

उदाहरण

यह खंड आपको अमूर्त वर्ग का एक उदाहरण प्रदान करता है। अमूर्त वर्ग बनाने के लिए, बस का उपयोग करेंabstract कक्षा घोषणा से पहले खोजशब्द।

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

आप देख सकते हैं कि सार विधियों को छोड़कर कर्मचारी वर्ग जावा में सामान्य वर्ग के समान है। वर्ग अब सार है, लेकिन इसमें अभी भी तीन क्षेत्र, सात विधियां, और एक निर्माणकर्ता है।

अब आप निम्न तरीके से कर्मचारी वर्ग को तत्काल करने की कोशिश कर सकते हैं -

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

जब आप उपरोक्त वर्ग को संकलित करते हैं, तो यह आपको निम्न त्रुटि देता है -

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

सार वर्ग का पालन

हम निम्न प्रकार से कंक्रीट वर्ग की तरह कर्मचारी वर्ग के गुणों को विरासत में दे सकते हैं -

उदाहरण

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

यहां, आप कर्मचारी वर्ग को तुरंत नहीं भेज सकते हैं, लेकिन आप वेतन वर्ग को त्वरित कर सकते हैं, और इस उदाहरण का उपयोग करके आप कर्मचारी वर्ग के सभी तीन क्षेत्रों और सात तरीकों का उपयोग कर सकते हैं जैसा कि नीचे दिखाया गया है।

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

यह निम्न परिणाम उत्पन्न करता है -

उत्पादन

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

सार विधियां

यदि आप एक वर्ग को किसी विशेष विधि में शामिल करना चाहते हैं, लेकिन आप चाहते हैं कि उस पद्धति का वास्तविक कार्यान्वयन बाल वर्गों द्वारा निर्धारित किया जाए, तो आप मूल कक्षा में इस पद्धति को एक सार के रूप में घोषित कर सकते हैं।

  • abstract कीवर्ड का उपयोग विधि को सार घोषित करने के लिए किया जाता है।

  • आपको जगह देनी होगी abstract विधि घोषणा में विधि के नाम से पहले कीवर्ड।

  • एक अमूर्त विधि में एक विधि हस्ताक्षर है, लेकिन कोई विधि निकाय नहीं है।

  • घुंघराले ब्रेसिज़ के बजाय, एक अमूर्त विधि के अंत में एक अर्ध-बृहदान्त्र (;) होगा।

निम्नलिखित सार विधि का एक उदाहरण है।

उदाहरण

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

एक विधि को सार के रूप में घोषित करने के दो परिणाम हैं -

  • इस वर्ग को सार के रूप में घोषित किया जाना चाहिए।

  • वर्तमान वर्ग को विरासत में प्राप्त किसी भी वर्ग को या तो अमूर्त विधि को ओवरराइड करना चाहिए या खुद को अमूर्त घोषित करना चाहिए।

Note- अंत में, एक वंशज वर्ग को अमूर्त पद्धति को लागू करना होगा; अन्यथा, आपके पास अमूर्त वर्गों का एक पदानुक्रम होगा जिसे तत्काल नहीं किया जा सकता है।

मान लें कि वेतन वर्ग कर्मचारी वर्ग को विरासत में मिला है, तो इसे लागू करना चाहिए computePay() नीचे दिखाए अनुसार विधि -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Encapsulationचार मौलिक ओओपी अवधारणाओं में से एक है। अन्य तीन विरासत, बहुरूपता और अमूर्त हैं।

जावा में एनकैप्सुलेशन एक इकाई के रूप में डेटा (चर) और डेटा (विधियों) पर कोड अभिनय को लपेटने का एक तंत्र है। एनकैप्सुलेशन में, एक वर्ग के चर को अन्य वर्गों से छिपाया जाएगा, और केवल उनकी वर्तमान कक्षा के तरीकों के माध्यम से पहुँचा जा सकता है। इसलिए, इसे के रूप में भी जाना जाता हैdata hiding

जावा में इनकैप्सुलेशन प्राप्त करने के लिए -

  • एक वर्ग के चरों को निजी घोषित करें।

  • चर मानों को संशोधित करने और देखने के लिए सार्वजनिक सेटर और गेट्टर विधियाँ प्रदान करें।

उदाहरण

निम्नलिखित एक उदाहरण है जो दर्शाता है कि जावा में एनकैप्सुलेशन कैसे प्राप्त किया जाए -

/* File name : EncapTest.java */
public class EncapTest {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

सार्वजनिक सेटएक्सएक्सएक्सएक्स () और गेटएक्सएक्सएक्सएक्स () तरीके एनकैपेस्ट क्लास के उदाहरण चर के पहुंच बिंदु हैं। आम तौर पर, इन विधियों को गेटर्स और सेटर के रूप में संदर्भित किया जाता है। इसलिए, कोई भी वर्ग जो चर को एक्सेस करना चाहता है, उन्हें इन गेटर्स और सेटर के माध्यम से एक्सेस करना चाहिए।

EncapTest वर्ग के चर निम्नलिखित कार्यक्रम का उपयोग करके पहुँचा जा सकता है -

/* File name : RunEncap.java */
public class RunEncap {

   public static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Name : James Age : 20

एनकैप्सुलेशन के लाभ

  • एक वर्ग के क्षेत्रों को केवल-पढ़ने या केवल लिखने के लिए बनाया जा सकता है।

  • एक वर्ग के पास अपने क्षेत्रों में संग्रहीत किए गए कुल नियंत्रण हो सकते हैं।

एक इंटरफ़ेस जावा में एक संदर्भ प्रकार है। यह कक्षा के समान है। यह अमूर्त विधियों का एक संग्रह है। एक वर्ग एक इंटरफ़ेस को लागू करता है, जिससे इंटरफ़ेस के सार तरीके विरासत में मिलते हैं।

अमूर्त विधियों के साथ, एक इंटरफ़ेस में स्थिरांक, डिफ़ॉल्ट विधियाँ, स्थैतिक विधियाँ और नेस्टेड प्रकार भी हो सकते हैं। विधि निकाय केवल डिफ़ॉल्ट विधियों और स्थिर विधियों के लिए मौजूद हैं।

इंटरफ़ेस लिखना क्लास लिखने के समान है। लेकिन एक वर्ग किसी वस्तु की विशेषताओं और व्यवहारों का वर्णन करता है। और एक इंटरफ़ेस में एक वर्ग लागू होने वाले व्यवहार शामिल हैं।

जब तक इंटरफ़ेस को लागू करने वाले वर्ग का सार नहीं होता है, तब तक इंटरफ़ेस के सभी तरीकों को कक्षा में परिभाषित करने की आवश्यकता होती है।

एक इंटरफ़ेस निम्न तरीकों में एक वर्ग के समान है -

  • एक इंटरफ़ेस में किसी भी संख्या में विधियाँ हो सकती हैं।

  • एक इंटरफ़ेस में फ़ाइल के साथ लिखा है a .java फ़ाइल के नाम से मेल खाते इंटरफ़ेस के नाम के साथ विस्तार।

  • इंटरफ़ेस का बाइट कोड एक में दिखाई देता है .class फ़ाइल।

  • पैकेज में इंटरफेस दिखाई देते हैं, और उनकी संबंधित बाइटकोड फ़ाइल एक निर्देशिका संरचना में होनी चाहिए जो पैकेज नाम से मेल खाती है।

हालाँकि, एक इंटरफ़ेस एक वर्ग से कई मायनों में अलग है, जिसमें शामिल हैं -

  • आप एक इंटरफ़ेस को तुरंत नहीं कर सकते।

  • एक इंटरफ़ेस में कोई निर्माता नहीं है।

  • एक इंटरफेस में सभी तरीके अमूर्त हैं।

  • एक इंटरफ़ेस में उदाहरण फ़ील्ड नहीं हो सकते। एकमात्र फ़ील्ड जो एक इंटरफ़ेस में दिखाई दे सकती है उसे स्थैतिक और अंतिम दोनों घोषित किया जाना चाहिए।

  • एक इंटरफ़ेस एक वर्ग द्वारा विस्तारित नहीं है; यह एक वर्ग द्वारा लागू किया जाता है।

  • एक इंटरफ़ेस कई इंटरफेस का विस्तार कर सकता है।

घोषणाओं को समाप्त करना

interfaceकीवर्ड का उपयोग इंटरफ़ेस घोषित करने के लिए किया जाता है। यहाँ एक इंटरफ़ेस घोषित करने के लिए एक सरल उदाहरण है -

उदाहरण

निम्नलिखित एक इंटरफ़ेस का एक उदाहरण है -

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

public interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations\
}

इंटरफेस में निम्नलिखित गुण हैं -

  • एक इंटरफ़ेस संक्षेप में सार है। आपको उपयोग करने की आवश्यकता नहीं हैabstract इंटरफ़ेस घोषित करते समय कीवर्ड।

  • एक इंटरफ़ेस में प्रत्येक विधि भी संक्षेप में सार है, इसलिए सार कीवर्ड की आवश्यकता नहीं है।

  • एक इंटरफेस में तरीके स्पष्ट रूप से सार्वजनिक हैं।

उदाहरण

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

अंतर लागू करना

जब कोई वर्ग इंटरफ़ेस लागू करता है, तो आप इंटरफ़ेस के विशिष्ट व्यवहारों को करने के लिए सहमत होते हुए, अनुबंध पर हस्ताक्षर करने के रूप में वर्ग के बारे में सोच सकते हैं। यदि कोई वर्ग इंटरफ़ेस के सभी व्यवहारों को निष्पादित नहीं करता है, तो कक्षा को खुद को सार घोषित करना चाहिए।

एक वर्ग उपयोग करता है implementsइंटरफ़ेस लागू करने के लिए कीवर्ड। घोषणा के विस्तार के भाग के बाद कक्षा की घोषणा में लागू होने वाला कीवर्ड दिखाई देता है।

उदाहरण

/* File name : MammalInt.java */
public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Mammal eats
Mammal travels

जब इंटरफेस में परिभाषित तरीकों को ओवरराइड करना है, तो कई नियमों का पालन किया जाना है -

  • चेक किए गए अपवादों को इंटरफ़ेस पद्धति द्वारा घोषित किए गए इंटरफ़ेस विधियों द्वारा घोषित किए गए लोगों के अलावा कार्यान्वयन विधियों पर घोषित नहीं किया जाना चाहिए।

  • इंटरफ़ेस विधि का हस्ताक्षर और उसी रिटर्न प्रकार या उपप्रकार को तरीकों को ओवरराइड करते समय बनाए रखा जाना चाहिए।

  • एक कार्यान्वयन वर्ग ही सार हो सकता है और यदि हां, तो इंटरफ़ेस विधियों को लागू करने की आवश्यकता नहीं है।

जब कार्यान्वयन इंटरफेस, कई नियम हैं -

  • एक वर्ग एक समय में एक से अधिक इंटरफ़ेस लागू कर सकता है।

  • एक वर्ग केवल एक वर्ग का विस्तार कर सकता है, लेकिन कई इंटरफेस लागू कर सकता है।

  • एक इंटरफ़ेस दूसरे इंटरफ़ेस का विस्तार कर सकता है, उसी तरह जैसे एक वर्ग दूसरे वर्ग का विस्तार कर सकता है।

फैली हुई जगह

एक इंटरफ़ेस उसी तरह एक और इंटरफ़ेस का विस्तार कर सकता है, जिसमें एक वर्ग दूसरे वर्ग का विस्तार कर सकता है। extends कीवर्ड का उपयोग एक इंटरफ़ेस का विस्तार करने के लिए किया जाता है, और चाइल्ड इंटरफ़ेस पैरेंट इंटरफ़ेस के तरीकों को विरासत में देता है।

निम्नलिखित स्पोर्ट्स इंटरफ़ेस हॉकी और फुटबॉल इंटरफेस द्वारा विस्तारित है।

उदाहरण

// Filename: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

हॉकी इंटरफ़ेस में चार विधियाँ हैं, लेकिन यह दो खेल से विरासत में मिली है; इस प्रकार, एक वर्ग जो हॉकी को लागू करता है, उसे सभी छह विधियों को लागू करने की आवश्यकता है। इसी तरह, एक वर्ग जो फुटबॉल को लागू करता है उसे फुटबॉल से तीन तरीकों और स्पोर्ट्स से दो तरीकों को परिभाषित करने की आवश्यकता होती है।

कई इंटरफेस का विस्तार

एक जावा वर्ग केवल एक मूल वर्ग का विस्तार कर सकता है। एकाधिक वंशानुक्रम की अनुमति नहीं है। इंटरफेस, कक्षाएं नहीं हैं, हालांकि, और एक इंटरफ़ेस एक से अधिक मूल इंटरफ़ेस का विस्तार कर सकता है।

फैली हुई कीवर्ड का उपयोग एक बार किया जाता है, और पेरेंट इंटरफेस अल्पविराम से अलग की गई सूची में घोषित किए जाते हैं।

उदाहरण के लिए, यदि हॉकी इंटरफ़ेस ने स्पोर्ट्स और इवेंट दोनों को बढ़ाया, तो इसे इस प्रकार घोषित किया जाएगा -

उदाहरण

public interface Hockey extends Sports, Event

टैगिंग इंटरफेस

विस्तृत इंटरफ़ेस का सबसे आम उपयोग तब होता है जब मूल इंटरफ़ेस में कोई विधियाँ नहीं होती हैं। उदाहरण के लिए, java.awt.event पैकेज विस्तारित java.util.EventListener में माउस लिस्टनर इंटरफ़ेस, जिसे निम्न के रूप में परिभाषित किया गया है -

उदाहरण

package java.util;
public interface EventListener
{}

इसमें बिना किसी तरीके के एक इंटरफेस को एक के रूप में संदर्भित किया जाता है taggingइंटरफेस। टैगिंग इंटरफेस के दो मूल डिज़ाइन उद्देश्य हैं -

Creates a common parent- EventListener इंटरफ़ेस के साथ, जो कि जावा एपीआई में दर्जनों अन्य इंटरफेस द्वारा बढ़ाया जाता है, आप इंटरफेस के समूह के बीच एक आम अभिभावक बनाने के लिए टैगिंग इंटरफ़ेस का उपयोग कर सकते हैं। उदाहरण के लिए, जब कोई इंटरफ़ेस EventListener का विस्तार करता है, तो JVM जानता है कि इस विशेष इंटरफ़ेस का उपयोग इवेंट प्रतिनिधि परिदृश्य में होने जा रहा है।

Adds a data type to a class- यह स्थिति वह है जहां शब्द, टैगिंग आती है। एक वर्ग जो एक टैगिंग इंटरफ़ेस को लागू करता है, उसे किसी भी तरीके को परिभाषित करने की आवश्यकता नहीं है (क्योंकि इंटरफ़ेस में कोई भी नहीं है), लेकिन वर्ग बहुरूपता के माध्यम से एक इंटरफ़ेस प्रकार बन जाता है।

जावा में संकुलन का उपयोग नामकरण संघर्ष को रोकने, अभिगम को नियंत्रित करने, खोज / पता लगाने और कक्षाओं, इंटरफेस, गणना और एनोटेशन के उपयोग को आसान बनाने आदि के लिए किया जाता है।

Package संबंधित प्रकारों (वर्गों, इंटरफेस, गणना और एनोटेशन) के एक समूह के रूप में परिभाषित किया जा सकता है जो पहुंच संरक्षण और नाम प्रबंधन प्रदान करता है।

जावा में कुछ मौजूदा पैकेज हैं -

  • java.lang - मौलिक कक्षाओं को बंडल करता है

  • java.io - इनपुट, आउटपुट फ़ंक्शन के लिए कक्षाएं इस पैकेज में बंडल की जाती हैं

प्रोग्रामर अपने स्वयं के पैकेज को कक्षाओं / इंटरफेस के समूह को बंडल करने के लिए परिभाषित कर सकते हैं, आदि यह आपके द्वारा कार्यान्वित समूह से संबंधित कक्षाओं के लिए एक अच्छा अभ्यास है ताकि एक प्रोग्रामर आसानी से निर्धारित कर सके कि कक्षाएं, इंटरफेस, गणना और एनोटेशन संबंधित हैं।

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

पैकेज बनाना

पैकेज बनाते समय, आपको पैकेज के लिए एक नाम चुनना चाहिए और इसमें शामिल होना चाहिए package प्रत्येक स्रोत फ़ाइल के शीर्ष पर उस नाम के साथ बयान जिसमें वर्ग, इंटरफ़ेस, गणना, और एनोटेशन प्रकार शामिल हैं जिन्हें आप पैकेज में शामिल करना चाहते हैं।

पैकेज स्टेटमेंट स्रोत फ़ाइल में पहली पंक्ति होनी चाहिए। प्रत्येक स्रोत फ़ाइल में केवल एक पैकेज स्टेटमेंट हो सकता है, और यह फ़ाइल के सभी प्रकारों पर लागू होता है।

यदि एक पैकेज स्टेटमेंट का उपयोग नहीं किया जाता है, तो क्लास, इंटरफेस, एनुमरेशन और एनोटेशन प्रकार को वर्तमान डिफ़ॉल्ट पैकेज में रखा जाएगा।

जावा प्रोग्राम को पैकेज स्टेटमेंट के साथ संकलित करने के लिए, आपको नीचे दिखाए अनुसार -d विकल्प का उपयोग करना होगा।

javac -d Destination_folder file_name.java

फिर दिए गए पैकेज नाम के साथ एक फ़ोल्डर निर्दिष्ट गंतव्य में बनाया गया है, और संकलित वर्ग फ़ाइलों को उस फ़ोल्डर में रखा जाएगा।

उदाहरण

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

निम्नलिखित पैकेज उदाहरण में इंटरफ़ेस नाम के जानवर हैं -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

अब, हम उपरोक्त इंटरफ़ेस को उसी पैकेज के जानवरों में लागू करते हैं -

package animals;
/* File name : MammalInt.java */

public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

अब नीचे दिखाए अनुसार जावा फाइलों को संकलित करें -

$ javac -d . Animal.java $ javac -d . MammalInt.java

अब नाम के साथ एक पैकेज / फ़ोल्डर animals वर्तमान निर्देशिका में बनाया जाएगा और इन वर्ग फ़ाइलों को नीचे दिखाए गए अनुसार रखा जाएगा।

आप पैकेज के भीतर वर्ग फ़ाइल निष्पादित कर सकते हैं और नीचे दिखाए अनुसार परिणाम प्राप्त कर सकते हैं।

Mammal eats
Mammal travels

आयात कीवर्ड

यदि एक वर्ग उसी पैकेज में दूसरी कक्षा का उपयोग करना चाहता है, तो पैकेज नाम का उपयोग नहीं किया जाना चाहिए। एक ही पैकेज में कक्षाएं बिना किसी विशेष वाक्यविन्यास के एक-दूसरे को ढूंढती हैं।

उदाहरण

यहां, पेरोल पैकेज में बॉस नामक एक वर्ग जोड़ा जाता है जिसमें पहले से ही कर्मचारी शामिल हैं। बॉस तब पेरोल उपसर्ग का उपयोग किए बिना कर्मचारी वर्ग को संदर्भित कर सकता है, जैसा कि निम्नलिखित बॉस वर्ग द्वारा दिखाया गया है।

package payroll;
public class Boss {
   public void payEmployee(Employee e) {
      e.mailCheck();
   }
}

यदि कर्मचारी वर्ग पेरोल पैकेज में नहीं है तो क्या होगा? बॉस वर्ग को तब एक अलग पैकेज में एक कक्षा का संदर्भ देने के लिए निम्नलिखित तकनीकों में से एक का उपयोग करना चाहिए।

  • वर्ग के पूरी तरह से योग्य नाम का उपयोग किया जा सकता है। उदाहरण के लिए -
payroll.Employee
  • पैकेज को आयात कीवर्ड और वाइल्ड कार्ड (*) का उपयोग करके आयात किया जा सकता है। उदाहरण के लिए -

import payroll.*;
  • आयात कीवर्ड का उपयोग करके कक्षा को ही आयात किया जा सकता है। उदाहरण के लिए -
import payroll.Employee;

Note- एक वर्ग फ़ाइल में किसी भी संख्या में आयात विवरण हो सकते हैं। इम्पोर्ट स्टेटमेंट पैकेज स्टेटमेंट के बाद और क्लास डिक्लेरेशन से पहले प्रदर्शित होना चाहिए।

संकुल की निर्देशिका संरचना

दो बड़े परिणाम तब होते हैं जब एक वर्ग को एक पैकेज में रखा जाता है -

  • पैकेज का नाम वर्ग के नाम का एक हिस्सा बन जाता है, जैसा कि हमने पिछले अनुभाग में चर्चा की थी।

  • पैकेज का नाम निर्देशिका संरचना से मेल खाना चाहिए, जहां संबंधित बाइटकोड रहता है।

यहाँ जावा में अपनी फ़ाइलों को प्रबंधित करने का सरल तरीका है -

किसी पाठ फ़ाइल में एक वर्ग, इंटरफ़ेस, गणना, या एनोटेशन प्रकार के लिए स्रोत कोड रखो जिसका नाम टाइप का सरल नाम है और जिसका विस्तार है .java

उदाहरण के लिए -

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

अब, स्रोत फ़ाइल को एक निर्देशिका में रखें, जिसका नाम उस पैकेज के नाम को दर्शाता है जिसका वर्ग है -

....\vehicle\Car.java

अब, योग्य वर्ग का नाम और पथनाम निम्नानुसार होगा -

  • वर्ग का नाम → वाहन ।कार
  • पथ का नाम → वाहन \ Car.java (विंडोज़ में)

सामान्य तौर पर, एक कंपनी अपने पैकेज नामों के लिए अपने उल्टे इंटरनेट डोमेन नाम का उपयोग करती है।

Example- किसी कंपनी के इंटरनेट डोमेन का नाम apple.com है, तो उसके सभी पैकेज के नाम com.apple से शुरू होंगे। पैकेज नाम का प्रत्येक घटक एक उपनिर्देशिका से मेल खाता है।

Example - कंपनी के पास एक com.apple.comक्यूपर्स पैकेज था, जिसमें एक डेल.जावा सोर्स फाइल थी, यह इस तरह की उपनिर्देशिकाओं की एक श्रृंखला में शामिल होगी -

....\com\apple\computers\Dell.java

संकलन के समय, संकलक इसमें परिभाषित प्रत्येक वर्ग, इंटरफ़ेस और गणना के लिए एक अलग आउटपुट फ़ाइल बनाता है। आउटपुट फ़ाइल का आधार नाम प्रकार का नाम है, और इसका विस्तार है.class

उदाहरण के लिए -

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

अब, इस फ़ाइल को -d विकल्प का उपयोग करते हुए संकलित करें -

$javac -d . Dell.java

फाइलों को इस प्रकार संकलित किया जाएगा -

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

आप सभी वर्गों या इंटरफेस में परिभाषित आयात कर सकते हैं \ \ कॉम \ सेब \ कंप्यूटर के रूप में निम्नानुसार -

import com.apple.computers.*;

.Java स्रोत फ़ाइलों की तरह, संकलित .class फाइलें निर्देशिकाओं की एक श्रृंखला में होनी चाहिए जो पैकेज नाम को दर्शाती हैं। हालाँकि, .class फ़ाइलों का पथ .java स्रोत फ़ाइलों के लिए पथ के समान नहीं है। आप अपने स्रोत और वर्ग निर्देशिकाओं को अलग से व्यवस्थित कर सकते हैं, जैसे -

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

ऐसा करने से, अपने स्रोतों को प्रकट किए बिना अन्य प्रोग्रामर को कक्षाएं निर्देशिका तक पहुंच देना संभव है। आपको इस तरीके से स्रोत और वर्ग फ़ाइलों को प्रबंधित करने की भी आवश्यकता है ताकि कंपाइलर और जावा वर्चुअल मशीन (JVM) आपके प्रोग्राम के सभी प्रकारों का उपयोग कर पा सकें।

कक्षाओं निर्देशिका के लिए पूर्ण पथ, <path-two> \ Classes, वर्ग पथ कहा जाता है, और CLASSPATH सिस्टम चर के साथ सेट किया गया है। कंपाइलर और JVM दोनों ही आपके .class फ़ाइलों के लिए पथ का नाम वर्ग पथ में जोड़कर पथ का निर्माण करते हैं।

<Path-two> \ Classes कहें क्लास क्लास है, और पैकेज का नाम com.apple.compoint है, फिर कंपाइलर और JVM <path-दो> \ classes \ com \ apple \ कंप्यूटर्स में .class फ़ाइलों की तलाश करेंगे।

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

CLASSPATH सिस्टम चर सेट करें

वर्तमान CLASSPATH वैरिएबल को प्रदर्शित करने के लिए, Windows और UNIX (बॉर्न शेल) में निम्न कमांड्स का उपयोग करें -

  • विंडोज में → C: \> सेट क्लास
  • UNIX में →% इको $ CLASSPATH

CLASSPATH चर की वर्तमान सामग्री को हटाने के लिए, का उपयोग करें -

  • विंडोज में → C: \> सेट क्लास =
  • UNIX में →% unset CLASSPATH; निर्यात कक्षा

CLASSPATH चर सेट करने के लिए -

  • Windows में → CLASSPATH = C: \ users \ jack \ java \ classes को सेट करें
  • UNIX में →% CLASSPATH = / home / jack / java / classes; निर्यात कक्षा

जावा उपयोगिता पैकेज द्वारा प्रदान की गई डेटा संरचना बहुत शक्तिशाली है और कई प्रकार के कार्य करती है। इन डेटा संरचनाओं में निम्नलिखित इंटरफ़ेस और कक्षाएं शामिल हैं -

  • Enumeration
  • BitSet
  • Vector
  • Stack
  • Dictionary
  • Hashtable
  • Properties

ये सभी कक्षाएं अब विरासत हैं और जावा -2 ने कलेक्शंस फ्रेमवर्क नामक एक नई रूपरेखा पेश की है, जिसकी चर्चा अगले अध्याय में की गई है। -

गणना

एन्यूमरेशन इंटरफ़ेस स्वयं एक डेटा संरचना नहीं है, लेकिन यह अन्य डेटा संरचनाओं के संदर्भ में बहुत महत्वपूर्ण है। गणन इंटरफ़ेस डेटा संरचना से क्रमिक तत्वों को पुनः प्राप्त करने के लिए एक साधन को परिभाषित करता है।

उदाहरण के लिए, एन्यूमरेशन ने नेक्स्टइलमेंट नामक एक विधि को परिभाषित किया है जिसका उपयोग डेटा संरचना में अगले तत्व को प्राप्त करने के लिए किया जाता है जिसमें कई तत्व होते हैं।

इस इंटरफ़ेस के बारे में अधिक विवरण के लिए, गणना की जाँच करें ।

बिटसेट

बिटसेट वर्ग बिट्स या झंडे के एक समूह को लागू करता है जिसे व्यक्तिगत रूप से सेट और क्लियर किया जा सकता है।

यह वर्ग उन मामलों में बहुत उपयोगी है जहां आपको बूलियन मूल्यों के एक सेट के साथ रखने की आवश्यकता होती है; आप बस प्रत्येक मान के लिए थोड़ा सा असाइन करते हैं और इसे उपयुक्त के रूप में सेट या साफ़ करते हैं।

इस वर्ग के बारे में अधिक जानकारी के लिए, द बिटसेट की जाँच करें ।

वेक्टर

वेक्टर क्लास पारंपरिक जावा सरणी के समान है, सिवाय इसके कि नए तत्वों को समायोजित करने के लिए आवश्यक रूप से बढ़ सकता है।

एक सरणी की तरह, वेक्टर ऑब्जेक्ट के तत्वों को वेक्टर में एक इंडेक्स के माध्यम से एक्सेस किया जा सकता है।

वेक्टर वर्ग का उपयोग करने के बारे में अच्छी बात यह है कि आपको इसे एक विशिष्ट आकार के निर्माण पर स्थापित करने के बारे में चिंता करने की आवश्यकता नहीं है; यह सिकुड़ता है और आवश्यक होने पर स्वतः बढ़ता है।

इस वर्ग के बारे में अधिक जानकारी के लिए, वेक्टर की जाँच करें ।

ढेर

स्टैक वर्ग तत्वों के अंतिम-इन-पहले (एलआईएफओ) ढेर को लागू करता है।

आप एक स्टैक का शाब्दिक रूप से वस्तुओं के एक ऊर्ध्वाधर स्टैक के रूप में सोच सकते हैं; जब आप एक नया तत्व जोड़ते हैं, तो यह दूसरों के ऊपर ढेर हो जाता है।

जब आप स्टैक से किसी तत्व को खींचते हैं, तो यह शीर्ष पर आता है। दूसरे शब्दों में, आपने जिस अंतिम तत्व को स्टैक में जोड़ा है, वह पहला है जो वापस आ गया है।

इस वर्ग के बारे में अधिक जानकारी के लिए, स्टैक की जाँच करें ।

शब्दकोष

डिक्शनरी क्लास एक अमूर्त वर्ग है जो मानों के लिए कीपिंग मैपिंग के लिए डेटा संरचना को परिभाषित करता है।

यह उन मामलों में उपयोगी है, जहां आप पूर्णांक सूचकांक के बजाय किसी विशेष कुंजी के माध्यम से डेटा तक पहुंचने में सक्षम होना चाहते हैं।

चूंकि डिक्शनरी क्लास सार है, इसलिए यह एक विशिष्ट कार्यान्वयन के बजाय एक कुंजी-मैप्ड डेटा संरचना के लिए केवल रूपरेखा प्रदान करता है।

इस वर्ग के बारे में अधिक जानकारी के लिए, शब्दकोश की जाँच करें ।

द हैशटेबल

हैशटेबल वर्ग कुछ उपयोगकर्ता-परिभाषित कुंजी संरचना के आधार पर डेटा को व्यवस्थित करने का एक साधन प्रदान करता है।

उदाहरण के लिए, एक पता सूची हैश तालिका में आप किसी व्यक्ति के नाम के बजाय ज़िप जैसे कुंजी के आधार पर डेटा संग्रहीत और सॉर्ट कर सकते हैं।

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

इस वर्ग के बारे में अधिक विस्तार से, द हैशटेबल की जाँच करें ।

गुण

गुण हैशटेबल का एक उपवर्ग है। इसका उपयोग उन मूल्यों की सूचियों को बनाए रखने के लिए किया जाता है जिनमें कुंजी एक स्ट्रिंग है और मूल्य भी एक स्ट्रिंग है।

गुण वर्ग का उपयोग कई अन्य जावा वर्गों द्वारा किया जाता है। उदाहरण के लिए, यह पर्यावरण मान प्राप्त करते समय System.getProperties () द्वारा लौटाए गए ऑब्जेक्ट का प्रकार है।

इस वर्ग के बारे में अधिक विस्तार के लिए, गुणों की जाँच करें ।

जावा 2 से पहले, जावा ने तदर्थ कक्षाएं प्रदान की हैं Dictionary, Vector, Stack, तथा Propertiesवस्तुओं के समूहों को संग्रहीत और हेरफेर करना। हालांकि ये कक्षाएं काफी उपयोगी थीं, लेकिन उनके पास एक केंद्रीय, एकीकृत विषय का अभाव था। इस प्रकार, आपने वेक्टर का उपयोग करने के तरीके को गुणों के उपयोग के तरीके से अलग किया था।

संग्रह की रूपरेखा कई लक्ष्यों को पूरा करने के लिए डिज़ाइन की गई थी, जैसे कि -

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

  • फ्रेमवर्क को विभिन्न प्रकार के संग्रह को एक समान तरीके से और उच्च स्तर की इंटरऑपरेबिलिटी के साथ काम करने की अनुमति देनी थी।

  • ढांचे को एक संग्रह को आसानी से विस्तारित और / या अनुकूलित करना था।

इस छोर की ओर, पूरे संग्रह ढांचे को मानक इंटरफेस के एक सेट के आसपास डिज़ाइन किया गया है। कई मानक कार्यान्वयन जैसे किLinkedList, HashSet, तथा TreeSetइनमें से इंटरफेस दिए गए हैं जिनका आप उपयोग कर सकते हैं-और यदि आप चुनते हैं तो आप अपने स्वयं के संग्रह को भी लागू कर सकते हैं।

संग्रह का प्रतिनिधित्व करने और हेरफेर करने के लिए एक संग्रह रूपरेखा एक एकीकृत वास्तुकला है। सभी संग्रह ढांचे में निम्नलिखित शामिल हैं -

  • Interfaces- ये सार डेटा प्रकार हैं जो संग्रह का प्रतिनिधित्व करते हैं। इंटरफेस संग्रह को उनके प्रतिनिधित्व के विवरण से स्वतंत्र रूप से हेरफेर करने की अनुमति देते हैं। वस्तु-उन्मुख भाषाओं में, इंटरफेस आमतौर पर एक पदानुक्रम बनाते हैं।

  • Implementations, i.e., Classes- ये संग्रह इंटरफेस के ठोस कार्यान्वयन हैं। संक्षेप में, वे पुन: प्रयोज्य डेटा संरचनाएं हैं।

  • Algorithms- ये वे विधियाँ हैं जो उपयोगी संगणनाएँ प्रस्तुत करती हैं, जैसे कि संग्रह इंटरफेस को लागू करने वाली वस्तुओं पर खोज करना और छाँटना। एल्गोरिदम को बहुरूपता कहा जाता है: अर्थात्, एक ही विधि का उपयोग उचित संग्रह इंटरफ़ेस के कई अलग-अलग कार्यान्वयनों पर किया जा सकता है।

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

संग्रह इंटरफेस

संग्रह की रूपरेखा कई इंटरफेस को परिभाषित करती है। यह खंड प्रत्येक इंटरफ़ेस का अवलोकन प्रदान करता है -

अनु क्रमांक। इंटरफ़ेस और विवरण
1 संग्रह इंटरफ़ेस

यह आपको वस्तुओं के समूहों के साथ काम करने में सक्षम बनाता है; यह संग्रह पदानुक्रम के शीर्ष पर है।

2 सूची इंटरफ़ेस

इसका विस्तार होता है Collection और सूची का एक उदाहरण तत्वों का एक संग्रह संग्रहीत करता है।

3 सेट

यह सेट को संभालने के लिए संग्रह का विस्तार करता है, जिसमें अद्वितीय तत्व होने चाहिए।

4 क्रमबद्ध करें

यह सॉर्ट किए गए सेट को संभालने के लिए सेट का विस्तार करता है।

5 नक्शा

यह मूल्यों के लिए अद्वितीय कुंजियों को मैप करता है।

6 Map.Entry

यह नक्शे में एक तत्व (एक कुंजी / मूल्य जोड़ी) का वर्णन करता है। यह मानचित्र का एक आंतरिक वर्ग है।

7 क्रमबद्ध करें

यह मानचित्र का विस्तार करता है ताकि कुंजियाँ एक बढ़ते क्रम में बनी रहें।

8 गणना

यह विरासत इंटरफ़ेस उन विधियों को परिभाषित करता है जिनके द्वारा आप वस्तुओं के संग्रह में तत्वों को गणना (एक समय में एक) प्राप्त कर सकते हैं। इस विरासत इंटरफ़ेस को Iterator द्वारा सुपररेड किया गया है।

संग्रह कक्षाएं

जावा मानक संग्रह कक्षाओं का एक सेट प्रदान करता है जो संग्रह इंटरफेस को लागू करता है। कुछ वर्ग पूर्ण कार्यान्वयन प्रदान करते हैं जिन्हें-के रूप में उपयोग किया जा सकता है और अन्य अमूर्त वर्ग हैं, कंकालीय कार्यान्वयन प्रदान करते हैं जो कंक्रीट संग्रह बनाने के लिए शुरुआती बिंदुओं के रूप में उपयोग किए जाते हैं।

मानक संग्रह कक्षाओं को निम्नलिखित तालिका में संक्षेपित किया गया है -

अनु क्रमांक। कक्षा और विवरण
1

AbstractCollection

संग्रह इंटरफ़ेस का अधिकांश भाग लागू करता है।

2

AbstractList

AbstractCollection बढ़ाता है और सूची इंटरफ़ेस के अधिकांश लागू करता है।

3

AbstractSequentialList

एक संग्रह द्वारा उपयोग के लिए AbstractList को विस्तारित करता है जो इसके तत्वों के यादृच्छिक उपयोग के बजाय अनुक्रमिक का उपयोग करता है।

4 लिंक्ड सूची

AbstractSequentialList का विस्तार करके एक लिंक्ड सूची को लागू करता है।

5 सारणी सूची

AbstractList का विस्तार करके एक गतिशील सरणी लागू करता है।

6

AbstractSet

सेट इंटरफ़ेस में से अधिकांश का सार और कार्यान्वयन लागू होता है।

7 HashSet

एक हैश तालिका के साथ उपयोग के लिए AbstractSet बढ़ाता है।

8 LinkedHashSet

सम्मिलन-क्रम पुनरावृत्तियों की अनुमति देने के लिए हैशसेट का विस्तार करता है।

9 TreeSet

एक पेड़ में संग्रहीत एक सेट लागू करता है। AbstractSet का विस्तार करता है।

10

AbstractMap

अधिकांश मैप इंटरफ़ेस को लागू करता है।

1 1 हैश मैप

हैश तालिका का उपयोग करने के लिए AbstractMap का विस्तार करता है।

12 ट्री-मैप

ट्री का उपयोग करने के लिए AbstractMap का विस्तार करता है।

13 WeakHashMap

कमजोर कुंजियों के साथ हैश तालिका का उपयोग करने के लिए AbstractMap का विस्तार करता है।

14 LinkedHashMap

सम्मिलन-क्रम पुनरावृत्तियों की अनुमति देने के लिए HashMap का विस्तार करता है।

15 IdentityHashMap

AbstractMap का विस्तार करता है और दस्तावेजों की तुलना करते समय संदर्भ समानता का उपयोग करता है।

AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList और AbstractMap कक्षाएं, कोर संग्रह इंटरफेस के कंकाल कार्यान्वयन प्रदान प्रयास कम करने के लिए उन्हें लागू करने की आवश्यकता है।

Java.util द्वारा परिभाषित निम्नलिखित विरासत कक्षाएं पिछले अध्याय में चर्चा की गई हैं -

अनु क्रमांक। कक्षा और विवरण
1 वेक्टर

यह एक गतिशील सरणी को लागू करता है। यह ArrayList के समान है, लेकिन कुछ अंतरों के साथ।

2 ढेर

स्टैक वेक्टर का एक उपवर्ग है जो एक मानक अंतिम-इन, पहले-आउट स्टैक को लागू करता है।

3 शब्दकोश

डिक्शनरी एक अमूर्त वर्ग है जो एक कुंजी / मान भंडारण भंडार का प्रतिनिधित्व करता है और बहुत कुछ मैप की तरह काम करता है।

4 हैश टेबल

हैशटेबल मूल java.util का हिस्सा था और एक शब्दकोश का एक ठोस कार्यान्वयन है।

5 गुण

गुण हैशटेबल का एक उपवर्ग है। इसका उपयोग उन मूल्यों की सूचियों को बनाए रखने के लिए किया जाता है जिनमें कुंजी एक स्ट्रिंग है और मूल्य भी एक स्ट्रिंग है।

6 BitSet

एक बिटसेट वर्ग एक विशेष प्रकार का सरणी बनाता है जो बिट वैल्यूज़ को धारण करता है। आवश्यकतानुसार यह सरणी आकार में बढ़ सकती है।

संग्रह एल्गोरिदम

संग्रह की रूपरेखा कई एल्गोरिदम को परिभाषित करती है जिन्हें संग्रह और मानचित्र पर लागू किया जा सकता है। इन एल्गोरिदम को सामूहिक वर्ग के भीतर स्थिर तरीकों के रूप में परिभाषित किया गया है।

तरीकों में से कई एक फेंक सकते हैं ClassCastException, जो तब होता है जब असंगत प्रकार, या ए की तुलना करने का प्रयास किया जाता है UnsupportedOperationException, जो तब होता है जब एक संग्रहणीय संग्रह को संशोधित करने का प्रयास किया जाता है।

संग्रह तीन स्थिर चर को परिभाषित करते हैं: EMPTY_SET, EMPTY_LIST और EMPTY_MAP। सभी अपरिवर्तनीय हैं।

अनु क्रमांक। एल्गोरिथम और विवरण
1 संग्रह एल्गोरिदम

यहां सभी एल्गोरिदम कार्यान्वयन की एक सूची दी गई है।

Iterator का उपयोग कैसे करें?

अक्सर, आप एक संग्रह में तत्वों के माध्यम से चक्र करना चाहेंगे। उदाहरण के लिए, आप प्रत्येक तत्व प्रदर्शित करना चाह सकते हैं।

ऐसा करने का सबसे आसान तरीका एक इटरेटर को नियोजित करना है, जो एक ऐसी वस्तु है जो Iterator या ListIfator इंटरफ़ेस को लागू करता है।

Iterator आपको एक संग्रह, तत्वों को प्राप्त करने या निकालने के माध्यम से चक्र करने में सक्षम बनाता है। ListIterator Iterator का विस्तार करता है एक सूची के द्विदिश traversal और तत्वों के संशोधन की अनुमति देने के लिए।

अनु क्रमांक। Iterator विधि और विवरण
1 जावा इटरेटर का उपयोग करना

यहां Iterator और ListIterator इंटरफेस द्वारा प्रदान किए गए उदाहरणों के साथ सभी विधियों की एक सूची दी गई है।

एक तुलनित्र का उपयोग कैसे करें?

ट्रीसेट और ट्रीपाइप दोनों एक क्रमबद्ध क्रम में तत्वों को संग्रहीत करते हैं। हालांकि, यह तुलनित्र है जो ठीक-ठीक परिभाषित करता है कि क्रमबद्ध क्रम का क्या अर्थ है।

यह इंटरफ़ेस हमें दिए गए संग्रह को विभिन्न तरीकों से किसी भी संख्या में सॉर्ट करने देता है। साथ ही इस इंटरफ़ेस का उपयोग किसी भी वर्ग के किसी भी उदाहरण को सॉर्ट करने के लिए किया जा सकता है (यहां तक ​​कि जिन कक्षाओं को हम संशोधित नहीं कर सकते हैं)।

अनु क्रमांक। Iterator विधि और विवरण
1 जावा तुलनित्र का उपयोग करना

यहाँ सभी तरीकों की एक सूची है, उदाहरण के लिए तुलनित्र इंटरफ़ेस द्वारा प्रदान की गई।

सारांश

जावा संग्रह की रूपरेखा प्रोग्रामर को पहले से तैयार डेटा संरचनाओं के साथ-साथ एल्गोरिदम तक पहुंच प्रदान करती है।

एक संग्रह एक ऑब्जेक्ट है जो अन्य वस्तुओं के संदर्भों को पकड़ सकता है। संग्रह इंटरफेस उन ऑपरेशनों की घोषणा करता है जो प्रत्येक प्रकार के संग्रह पर किए जा सकते हैं।

संग्रह ढांचे के वर्ग और इंटरफेस पैकेज java.util में हैं।

यह अच्छा होगा यदि हम एक एकल प्रकार की विधि लिख सकते हैं जो एक पूर्णांक सरणी, एक स्ट्रिंग सरणी या तत्वों के किसी भी प्रकार को क्रमबद्ध करने में सहायक हो सकती है।

जावा Generic विधियाँ और सामान्य कक्षाएं प्रोग्रामर को निर्दिष्ट करने के लिए सक्षम करती हैं, एक एकल विधि घोषणा, संबंधित विधियों का एक समूह, या एकल वर्ग घोषणा के साथ, संबंधित प्रकारों का एक सेट, क्रमशः।

जेनरिक संकलन-समय प्रकार की सुरक्षा भी प्रदान करते हैं जो प्रोग्रामर को संकलन के समय अवैध प्रकारों को पकड़ने की अनुमति देता है।

जावा जेनेरिक अवधारणा का उपयोग करते हुए, हम वस्तुओं की एक सरणी को सॉर्ट करने के लिए एक सामान्य विधि लिख सकते हैं, फिर सरणी तत्वों को सॉर्ट करने के लिए इंटेगर सरणियों, डबल सरणियों, स्ट्रिंग सरणियों और इसी तरह से सामान्य विधि को लागू करें।

सामान्य तरीके

आप एक एकल सामान्य विधि घोषणा लिख ​​सकते हैं जिसे विभिन्न प्रकार के तर्कों के साथ कहा जा सकता है। जेनेरिक विधि को पारित किए गए तर्कों के प्रकारों के आधार पर, कंपाइलर प्रत्येक विधि कॉल को उचित रूप से संभालता है। जेनेरिक विधियों को परिभाषित करने के नियम निम्नलिखित हैं -

  • सभी जेनेरिक विधि घोषणाओं में कोण कोष्ठक (<और>) द्वारा टाइप किया गया एक पैरामीटर पैरामीटर सेक्शन होता है, जो विधि के रिटर्न प्रकार (<E> अगले उदाहरण में) से पहले होता है।

  • प्रत्येक प्रकार के पैरामीटर सेक्शन में कॉमा द्वारा अलग किए गए एक या अधिक प्रकार के पैरामीटर होते हैं। एक प्रकार का पैरामीटर, जिसे एक प्रकार चर के रूप में भी जाना जाता है, एक पहचानकर्ता है जो एक सामान्य प्रकार का नाम निर्दिष्ट करता है।

  • प्रकार के मापदंडों का उपयोग रिटर्न प्रकार की घोषणा करने के लिए किया जा सकता है और जेनेरिक विधि को पारित किए गए तर्कों के प्रकार के लिए प्लेसहोल्डर के रूप में कार्य करते हैं, जिन्हें वास्तविक प्रकार के तर्क के रूप में जाना जाता है।

  • जेनेरिक विधि का शरीर किसी अन्य विधि की तरह घोषित किया जाता है। ध्यान दें कि टाइप पैरामीटर केवल संदर्भ प्रकारों का प्रतिनिधित्व कर सकते हैं, न कि आदिम प्रकार (जैसे इंट, डबल और चार)।

उदाहरण

निम्नलिखित उदाहरण से पता चलता है कि हम एकल जेनेरिक पद्धति का उपयोग करके विभिन्न प्रकार की एक सरणी कैसे प्रिंट कर सकते हैं -

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

बंधे हुए टाइप पैरामीटर्स

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

एक बंधे हुए प्रकार के पैरामीटर को घोषित करने के लिए, टाइप करने वाले पैरामर के नाम को सूचीबद्ध करें, उसके बाद उसके ऊपरी सीमा के बाद कीवर्ड को बढ़ाएं।

उदाहरण

निम्नलिखित उदाहरण से पता चलता है कि सामान्य अर्थों में "एक्सटेंड्स" (जैसा कि कक्षाओं में) या "इम्प्लीमेंट्स" (इंटरफेस में) का उपयोग कैसे किया जाता है। यह उदाहरण तीन तुलनात्मक वस्तुओं में से सबसे बड़ी राशि को लौटाने का सामान्य तरीका है -

public class MaximumTest {
   // determines the largest of three Comparable objects
   
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

सामान्य वर्ग

एक सामान्य श्रेणी की घोषणा गैर-जेनेरिक श्रेणी की घोषणा की तरह दिखती है, सिवाय इसके कि कक्षा का नाम एक प्रकार के पैरामीटर अनुभाग के बाद है।

जेनेरिक विधियों के साथ, जेनेरिक क्लास के प्रकार पैरामीटर सेक्शन में कॉमा द्वारा अलग किए गए एक या अधिक प्रकार के पैरामीटर हो सकते हैं। इन वर्गों को मानकीकृत कक्षाओं या पैरामीटर प्रकारों के रूप में जाना जाता है क्योंकि वे एक या अधिक मापदंडों को स्वीकार करते हैं।

उदाहरण

निम्नलिखित उदाहरण दिखाता है कि हम एक सामान्य वर्ग को कैसे परिभाषित कर सकते हैं -

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Integer Value :10
String Value :Hello World

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

किसी सीरियल किए गए ऑब्जेक्ट को किसी फ़ाइल में लिखे जाने के बाद, इसे फ़ाइल से पढ़ा जा सकता है और deserialized अर्थात्, प्रकार की जानकारी और बाइट्स जो ऑब्जेक्ट का प्रतिनिधित्व करते हैं और इसके डेटा का उपयोग मेमोरी में ऑब्जेक्ट को फिर से बनाने के लिए किया जा सकता है।

सबसे प्रभावशाली यह है कि पूरी प्रक्रिया JVM स्वतंत्र है, जिसका अर्थ है कि एक वस्तु को एक मंच पर क्रमांकित किया जा सकता है और एक पूरी तरह से अलग मंच पर deserialized किया जा सकता है।

कक्षाओं ObjectInputStream तथा ObjectOutputStream उच्च-स्तरीय धाराएँ हैं जो किसी वस्तु को क्रमबद्ध और निष्क्रिय करने की विधियाँ शामिल करती हैं।

ObjectOutputStream वर्ग में विभिन्न डेटा प्रकार लिखने के लिए कई लिखने के तरीके शामिल हैं, लेकिन विशेष रूप से एक विधि बाहर खड़ी है -

public final void writeObject(Object x) throws IOException

उपरोक्त विधि किसी ऑब्जेक्ट को क्रमबद्ध करती है और इसे आउटपुट स्ट्रीम में भेजती है। इसी प्रकार, ObjectInputStream वर्ग में ऑब्जेक्ट को डीरेल करने के लिए निम्न विधि है -

public final Object readObject() throws IOException, ClassNotFoundException

यह विधि अगली ऑब्जेक्ट को स्ट्रीम से बाहर निकालती है और इसे डिसेर्बलाइज़ करती है। रिटर्न वैल्यू ऑब्जेक्ट है, इसलिए आपको इसे इसके उपयुक्त डेटा प्रकार में डालना होगा।

यह प्रदर्शित करने के लिए कि जावा में क्रमांकन कैसे काम करता है, मैं उस कर्मचारी वर्ग का उपयोग करने जा रहा हूं, जिसकी हमने पुस्तक में शुरुआती चर्चा की थी। मान लीजिए कि हमारे पास निम्न कर्मचारी वर्ग है, जो सीरियल इंटरफ़ेस को लागू करता है -

उदाहरण

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + name + " " + address);
   }
}

ध्यान दें कि किसी वर्ग के लिए सफलतापूर्वक अनुक्रमित होने के लिए, दो शर्तों को पूरा करना होगा -

  • वर्ग को java.io.Serializable इंटरफ़ेस लागू करना होगा।

  • कक्षा के सभी क्षेत्र क्रमबद्ध होने चाहिए। यदि कोई क्षेत्र क्रमिक नहीं है, तो उसे चिह्नित किया जाना चाहिएtransient

यदि आप यह जानने के लिए उत्सुक हैं कि क्या जावा स्टैंडर्ड क्लास सीरियल करने योग्य है या नहीं, तो क्लास के लिए डॉक्यूमेंटेशन देखें। परीक्षण सरल है: यदि वर्ग java.io.Serializable लागू करता है, तो यह धारावाहिक है; अन्यथा, यह नहीं है।

किसी वस्तु का सीरियल करना

ObjectOutputStream वर्ग का उपयोग किसी ऑब्जेक्ट को क्रमबद्ध करने के लिए किया जाता है। निम्न SerializeDemo प्रोग्राम एक कर्मचारी ऑब्जेक्ट को तुरंत बनाता है और इसे एक फ़ाइल में क्रमांकित करता है।

जब प्रोग्राम निष्पादित किया जाता है, तो कर्मचारी नामक एक फ़ाइल बनाई जाती है। प्रोग्राम कोई आउटपुट उत्पन्न नहीं करता है, लेकिन कोड का अध्ययन करें और यह निर्धारित करने का प्रयास करें कि प्रोग्राम क्या कर रहा है।

Note - जब किसी ऑब्जेक्ट को किसी फाइल में सीरीज़ किया जाता है, तो जावा में मानक कन्वेंशन फ़ाइल को देने के लिए होता है .ser विस्तार।

उदाहरण

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

किसी वस्तु का वर्णन करना

निम्न DeserializeDemo प्रोग्राम SerializeDemo प्रोग्राम में बनाए गए कर्मचारी ऑब्जेक्ट को deserializes। कार्यक्रम का अध्ययन करें और इसके उत्पादन को निर्धारित करने का प्रयास करें -

उदाहरण

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

यहां महत्वपूर्ण बिंदुओं का उल्लेख किया जा रहा है -

  • ट्राई / कैच ब्लॉक एक ClassNotFoundException को पकड़ने की कोशिश करता है, जिसे readObject () विधि द्वारा घोषित किया जाता है। एक JVM के लिए एक वस्तु deserialize करने में सक्षम होने के लिए, यह वर्ग के लिए बायटेकोड को खोजने में सक्षम होना चाहिए। यदि JVM किसी ऑब्जेक्ट के डीरिएरलाइज़ेशन के दौरान एक क्लास नहीं ढूँढ सकता है, तो वह ClassNotFoundException को फेंकता है।

  • ध्यान दें कि readObject () का रिटर्न मान कर्मचारी के संदर्भ में दिया गया है।

  • SSN फ़ील्ड का मान 11122333 था जब ऑब्जेक्ट सीरियल किया गया था, लेकिन क्योंकि फ़ील्ड क्षणिक है, यह मान आउटपुट स्ट्रीम में नहीं भेजा गया था। Deserialized कर्मचारी ऑब्जेक्ट का SSN फ़ील्ड 0 है।

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

J2SE API के java.net पैकेज में उन कक्षाओं और इंटरफेस का संग्रह है जो निम्न-स्तरीय संचार विवरण प्रदान करते हैं, जिससे आप ऐसे प्रोग्राम लिख सकते हैं जो हाथ में समस्या को हल करने पर ध्यान केंद्रित करते हैं।

Java.net पैकेज दो सामान्य नेटवर्क प्रोटोकॉल के लिए समर्थन प्रदान करता है -

  • TCP- टीसीपी ट्रांसमिशन ट्रांसमिशन प्रोटोकॉल के लिए है, जो दो अनुप्रयोगों के बीच विश्वसनीय संचार की अनुमति देता है। टीसीपी का उपयोग आमतौर पर इंटरनेट प्रोटोकॉल पर किया जाता है, जिसे टीसीपी / आईपी कहा जाता है।

  • UDP - यूडीपी उपयोगकर्ता डेटाग्राम प्रोटोकॉल के लिए खड़ा है, एक कनेक्शन-कम प्रोटोकॉल जो अनुप्रयोगों के बीच डेटा के पैकेट को प्रसारित करने की अनुमति देता है।

यह अध्याय निम्नलिखित दो विषयों पर एक अच्छी समझ देता है -

  • Socket Programming - यह नेटवर्किंग में सबसे व्यापक रूप से इस्तेमाल की जाने वाली अवधारणा है और इसे बहुत विस्तार से समझाया गया है।

  • URL Processing- यह अलग से कवर किया जाएगा। जावा भाषा में URL प्रोसेसिंग के बारे में जानने के लिए यहाँ क्लिक करें ।

सॉकेट प्रोग्रामिंग

सॉकेट टीसीपी का उपयोग करके दो कंप्यूटरों के बीच संचार तंत्र प्रदान करता है। एक क्लाइंट प्रोग्राम संचार के अंत में एक सॉकेट बनाता है और उस सॉकेट को सर्वर से जोड़ने का प्रयास करता है।

जब कनेक्शन किया जाता है, तो सर्वर संचार के अंत में एक सॉकेट ऑब्जेक्ट बनाता है। क्लाइंट और सर्वर अब सॉकेट से लिखने और पढ़ने के लिए संवाद कर सकते हैं।

Java.net.Socket वर्ग एक सॉकेट का प्रतिनिधित्व करता है, और java.net.ServerSocket क्लास क्लाइंट प्रोग्राम को क्लाइंट्स को सुनने और उनके साथ कनेक्शन स्थापित करने के लिए एक तंत्र प्रदान करता है।

सॉकेट्स का उपयोग करते हुए दो कंप्यूटरों के बीच एक टीसीपी कनेक्शन स्थापित करते समय निम्न चरण होते हैं -

  • सर्वर एक सर्वर सॉकेट को तुरंत चालू करता है, यह दर्शाता है कि पोर्ट नंबर संचार किस पर होना है।

  • सर्वर सर्वर सॉकेट क्लास के स्वीकार () विधि को आमंत्रित करता है। यह विधि तब तक प्रतीक्षा करती है जब तक कि कोई क्लाइंट दिए गए पोर्ट पर सर्वर से कनेक्ट नहीं होता है।

  • सर्वर के इंतजार के बाद, एक क्लाइंट सॉकेट ऑब्जेक्ट को इंस्टेंट करता है, जिससे सर्वर का नाम और पोर्ट नंबर को जोड़ने के लिए निर्दिष्ट किया जाता है।

  • सॉकेट क्लास का निर्माण क्लाइंट को निर्दिष्ट सर्वर और पोर्ट नंबर से जोड़ने का प्रयास करता है। यदि संचार स्थापित किया जाता है, तो क्लाइंट के पास अब सॉकेट ऑब्जेक्ट है जो सर्वर के साथ संचार करने में सक्षम है।

  • सर्वर साइड पर, स्वीकार () विधि क्लाइंट के सॉकेट से जुड़े सर्वर पर एक नए सॉकेट का संदर्भ देती है।

कनेक्शन स्थापित होने के बाद, I / O स्ट्रीम का उपयोग करके संचार हो सकता है। प्रत्येक सॉकेट में एक आउटपुटस्ट्रीम और एक इनपुटस्ट्रीम दोनों होते हैं। क्लाइंट का आउटपुटस्ट्रीम सर्वर के इनपुटस्ट्रीम से जुड़ा होता है, और क्लाइंट का इनपुटस्ट्रीम सर्वर के आउटपुटस्ट्रीम से जुड़ा होता है।

टीसीपी एक दो-तरफ़ा संचार प्रोटोकॉल है, इसलिए एक ही समय में दोनों धाराओं में डेटा भेजा जा सकता है। सॉकेट्स को लागू करने के तरीकों का पूरा सेट प्रदान करने वाली उपयोगी कक्षाएं निम्नलिखित हैं।

ServerSocket क्लास मेथड्स

java.net.ServerSocket पोर्ट प्राप्त करने और क्लाइंट अनुरोधों को सुनने के लिए सर्वर एप्लिकेशन द्वारा क्लास का उपयोग किया जाता है।

ServerSocket क्लास में चार कंस्ट्रक्टर हैं -

अनु क्रमांक। विधि और विवरण
1

public ServerSocket(int port) throws IOException

निर्दिष्ट पोर्ट से बंधे सर्वर सॉकेट बनाने का प्रयास। अपवाद तब होता है जब पोर्ट पहले से ही किसी अन्य अनुप्रयोग द्वारा बाध्य है।

2

public ServerSocket(int port, int backlog) throws IOException

पिछले निर्माता के समान, बैकलॉग पैरामीटर निर्दिष्ट करता है कि कितने आवक ग्राहकों को प्रतीक्षा कतार में संग्रहीत करना है।

3

public ServerSocket(int port, int backlog, InetAddress address) throws IOException

पिछले निर्माता के समान, InetAddress पैरामीटर स्थानीय IP पते को बाइंड करने के लिए निर्दिष्ट करता है। InetAddress का उपयोग उन सर्वरों के लिए किया जाता है, जिनके पास कई IP पते हो सकते हैं, जिससे सर्वर को यह निर्दिष्ट करने की अनुमति मिलती है कि ग्राहक अनुरोधों को स्वीकार करने के लिए अपने IP पते में से कौन-सा IP पता है।

4

public ServerSocket() throws IOException

एक अनबाउंड सर्वर सॉकेट बनाता है। इस कंस्ट्रक्टर का उपयोग करते समय, जब आप सर्वर सॉकेट को बांधने के लिए तैयार होते हैं तो बाइंड () विधि का उपयोग करें।

यदि ServerSocket कंस्ट्रक्टर अपवाद को नहीं फेंकता है, तो इसका मतलब है कि आपका एप्लिकेशन सफलतापूर्वक निर्दिष्ट पोर्ट से बंध गया है और क्लाइंट अनुरोधों के लिए तैयार है।

ServerSocket क्लास के कुछ सामान्य तरीके निम्नलिखित हैं -

अनु क्रमांक। विधि और विवरण
1

public int getLocalPort()

उस पोर्ट को लौटाता है जो सर्वर सॉकेट पर सुन रहा है। यह विधि उपयोगी है यदि आप एक निर्माता में पोर्ट नंबर के रूप में 0 में पारित हुए हैं और सर्वर को आपके लिए एक पोर्ट ढूंढने दें।

2

public Socket accept() throws IOException

आने वाले ग्राहक की प्रतीक्षा करता है। यह विधि तब तक अवरुद्ध होती है जब तक कि कोई क्लाइंट निर्दिष्ट पोर्ट या सॉकेट समय पर सर्वर से कनेक्ट नहीं होता है, यह मानते हुए कि सेट-टाइमटाइम () विधि का उपयोग करके टाइम-आउट मान सेट किया गया है। अन्यथा, यह विधि अनिश्चित काल के लिए ब्लॉक हो जाती है।

3

public void setSoTimeout(int timeout)

स्वीकार के दौरान क्लाइंट के लिए सर्वर सॉकेट का इंतजार करने के लिए समय-आउट मान सेट करता है।

4

public void bind(SocketAddress host, int backlog)

सॉकेट को निर्दिष्ट सर्वर पर सेट करता है और सॉकेटअंड्रेस ऑब्जेक्ट में पोर्ट। इस विधि का उपयोग करें यदि आपने सर्वर-सॉकेट को नो-लॉजिक कंस्ट्रक्टर का उपयोग करके तत्काल बनाया है।

जब ServerSocket आमंत्रण स्वीकार करता है (), क्लाइंट के कनेक्ट होने तक विधि वापस नहीं आती है। क्लाइंट के कनेक्ट होने के बाद, सर्वर सॉकेट एक अनिर्दिष्ट पोर्ट पर एक नया सॉकेट बनाता है और इस नए सॉकेट का संदर्भ देता है। एक टीसीपी कनेक्शन अब क्लाइंट और सर्वर के बीच मौजूद है, और संचार शुरू हो सकता है।

सॉकेट क्लास के तरीके

java.net.Socketवर्ग सॉकेट का प्रतिनिधित्व करता है जो क्लाइंट और सर्वर दोनों एक दूसरे के साथ संवाद करने के लिए उपयोग करते हैं। क्लाइंट किसी को इंस्टेंट करके एक सॉकेट ऑब्जेक्ट प्राप्त करता है, जबकि सर्वर स्वीकार () विधि के रिटर्न वैल्यू से सॉकेट ऑब्जेक्ट प्राप्त करता है।

सॉकेट क्लास में पांच कंस्ट्रक्टर होते हैं जो क्लाइंट सर्वर से कनेक्ट करने के लिए उपयोग करता है -

अनु क्रमांक। विधि और विवरण
1

public Socket(String host, int port) throws UnknownHostException, IOException.

यह विधि निर्दिष्ट पोर्ट पर निर्दिष्ट सर्वर से कनेक्ट करने का प्रयास करती है। यदि यह निर्माता अपवाद को नहीं फेंकता है, तो कनेक्शन सफल होता है और क्लाइंट सर्वर से जुड़ा होता है।

2

public Socket(InetAddress host, int port) throws IOException

यह विधि पिछले निर्माता के समान है, सिवाय इसके कि मेजबान को एक InetAddress ऑब्जेक्ट द्वारा दर्शाया गया है।

3

public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException.

निर्दिष्ट होस्ट और पोर्ट से जुड़ता है, निर्दिष्ट पते और पोर्ट पर स्थानीय होस्ट पर एक सॉकेट बनाता है।

4

public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.

यह विधि पिछले कंस्ट्रक्टर के समान है, सिवाय इसके कि होस्ट को स्ट्रिंग के बजाय एक InetAddress ऑब्जेक्ट द्वारा दर्शाया गया है।

5

public Socket()

एक असंबद्ध सॉकेट बनाता है। इस सॉकेट को सर्वर से जोड़ने के लिए कनेक्ट () विधि का उपयोग करें।

सॉकेट कंस्ट्रक्टर जब वापस आता है, तो यह केवल सॉकेट ऑब्जेक्ट को इंस्टेंट नहीं करता है, लेकिन यह वास्तव में निर्दिष्ट सर्वर और पोर्ट से कनेक्ट करने का प्रयास करता है।

सॉकेट क्लास में रुचि के कुछ तरीके यहां सूचीबद्ध हैं। ध्यान दें कि क्लाइंट और सर्वर दोनों में सॉकेट ऑब्जेक्ट है, इसलिए इन तरीकों को क्लाइंट और सर्वर दोनों द्वारा लागू किया जा सकता है।

अनु क्रमांक। विधि और विवरण
1

public void connect(SocketAddress host, int timeout) throws IOException

यह विधि सॉकेट को निर्दिष्ट होस्ट से जोड़ती है। इस पद्धति की आवश्यकता तभी होती है जब आप सॉकेट को नो-लॉजिक कंस्ट्रक्टर का उपयोग करके इंस्टेंट करते हैं।

2

public InetAddress getInetAddress()

यह विधि दूसरे कंप्यूटर के पते को लौटाती है जिससे यह सॉकेट जुड़ा होता है।

3

public int getPort()

पोर्ट को लौटाता है रिमोट मशीन पर सॉकेट बंध जाता है।

4

public int getLocalPort()

उस पोर्ट को लौटाता है जो सॉकेट लोकल मशीन पर होता है।

5

public SocketAddress getRemoteSocketAddress()

रिमोट सॉकेट का पता देता है।

6

public InputStream getInputStream() throws IOException

सॉकेट की इनपुट स्ट्रीम लौटाता है। इनपुट स्ट्रीम रिमोट सॉकेट के आउटपुट स्ट्रीम से जुड़ा है।

7

public OutputStream getOutputStream() throws IOException

सॉकेट का आउटपुट स्ट्रीम लौटाता है। आउटपुट स्ट्रीम रिमोट सॉकेट के इनपुट स्ट्रीम से जुड़ा है।

8

public void close() throws IOException

सॉकेट को बंद करता है, जो इस सॉकेट ऑब्जेक्ट को अब किसी भी सर्वर से दोबारा कनेक्ट करने में सक्षम नहीं बनाता है।

InetAddress कक्षा के तरीके

यह वर्ग एक इंटरनेट प्रोटोकॉल (IP) पते का प्रतिनिधित्व करता है। यहाँ उपयोगी तरीके दिए जा रहे हैं जो आपको सॉकेट प्रोग्रामिंग करते समय चाहिए होंगे -

अनु क्रमांक। विधि और विवरण
1

static InetAddress getByAddress(byte[] addr)

रिटर्न एक InetAddress कच्चे IP पता दिया वस्तु।

2

static InetAddress getByAddress(String host, byte[] addr)

प्रदान किए गए होस्ट नाम और आईपी पते के आधार पर एक InetAddress बनाता है।

3

static InetAddress getByName(String host)

होस्ट के नाम को देखते हुए, होस्ट का IP पता निर्धारित करता है।

4

String getHostAddress()

पाठ प्रस्तुति में IP पता स्ट्रिंग लौटाता है।

5

String getHostName()

इस IP पते के लिए होस्ट नाम मिलता है।

6

static InetAddress InetAddress getLocalHost()

स्थानीय होस्ट लौटाता है।

7

String toString()

इस IP पते को एक स्ट्रिंग में परिवर्तित करता है।

सॉकेट क्लाइंट उदाहरण

निम्नलिखित ग्रीटिंगक्लाइंट एक क्लाइंट प्रोग्राम है जो सॉकेट का उपयोग करके सर्वर से जुड़ता है और ग्रीटिंग भेजता है, और फिर प्रतिक्रिया का इंतजार करता है।

उदाहरण

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

सॉकेट सर्वर उदाहरण

निम्नलिखित ग्रीटिंगसर्वर कार्यक्रम एक सर्वर एप्लिकेशन का एक उदाहरण है जो कमांड-लाइन तर्क द्वारा निर्दिष्ट पोर्ट नंबर पर क्लाइंट के लिए सुनने के लिए सॉकेट क्लास का उपयोग करता है -

उदाहरण

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

क्लाइंट और सर्वर को संकलित करें और फिर सर्वर को निम्नानुसार शुरू करें -

$ java GreetingServer 6066
Waiting for client on port 6066...

ग्राहक कार्यक्रम की जाँच इस प्रकार है -

उत्पादन

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

अपने जावा एप्लिकेशन का उपयोग करके एक ई-मेल भेजने के लिए पर्याप्त सरल है लेकिन आपके पास शुरू होना चाहिए JavaMail API तथा Java Activation Framework (JAF) आपकी मशीन पर स्थापित है।

  • आप जावा के मानक वेबसाइट से जावामैल (संस्करण 1.2) का नवीनतम संस्करण डाउनलोड कर सकते हैं ।

  • आप जावा की मानक वेबसाइट से जेएएफ (संस्करण 1.1.1) का नवीनतम संस्करण डाउनलोड कर सकते हैं ।

इन फ़ाइलों को डाउनलोड करें और अनज़िप करें, नए बनाए गए शीर्ष स्तर निर्देशिकाओं में आपको दोनों अनुप्रयोगों के लिए कई जार फाइलें मिलेंगी। आपको जोड़ने की आवश्यकता हैmail.jar तथा activation.jar आपके CLASSPATH में फ़ाइलें।

एक साधारण ई-मेल भेजें

अपनी मशीन से एक सरल ई-मेल भेजने के लिए यहां एक उदाहरण है। यह माना जाता है कि आपकेlocalhost इंटरनेट से जुड़ा है और एक ई-मेल भेजने के लिए पर्याप्त सक्षम है।

उदाहरण

// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

   public static void main(String [] args) {    
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Now set the actual message
         message.setText("This is actual message");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

एक सरल ई-मेल भेजने के लिए इस कार्यक्रम को संकलित करें और चलाएं -

उत्पादन

$ java SendEmail
Sent message successfully....

यदि आप कई प्राप्तकर्ताओं को ई-मेल भेजना चाहते हैं तो निम्नलिखित तरीकों का उपयोग कई ई-मेल आईडी को निर्दिष्ट करने के लिए किया जाएगा -

void addRecipients(Message.RecipientType type, Address[] addresses)
   throws MessagingException

यहाँ मापदंडों का वर्णन है -

  • type- यह TO, CC या BCC पर सेट किया जाएगा। यहाँ CC कार्बन कॉपी का प्रतिनिधित्व करता है और BCC ब्लैक कार्बन कॉपी का प्रतिनिधित्व करता है। उदाहरण: Message.RecipientType.TO

  • addresses- यह ई-मेल आईडी की एक सरणी है। आपको ईमेल आईडी निर्दिष्ट करते समय InternetAddress () विधि का उपयोग करने की आवश्यकता होगी।

एक HTML ई-मेल भेजें

अपनी मशीन से HTML ई-मेल भेजने के लिए यहां एक उदाहरण दिया गया है। यहाँ यह माना जाता है कि आपकेlocalhost इंटरनेट से जुड़ा है और एक ई-मेल भेजने के लिए पर्याप्त सक्षम है।

यह उदाहरण पिछले एक के समान है, सिवाय इसके कि हम सेटकंटेंट () विधि का उपयोग सामग्री सेट करने के लिए कर रहे हैं जिसका दूसरा तर्क "पाठ / एचटीएमएल" है यह निर्दिष्ट करने के लिए कि HTML सामग्री संदेश में शामिल है।

इस उदाहरण का उपयोग करके, आप अपनी पसंद के अनुसार HTML सामग्री भेज सकते हैं।

उदाहरण

// File Name SendHTMLEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendHTMLEmail {

   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

HTML ई-मेल भेजने के लिए इस प्रोग्राम को संकलित करें और चलाएं -

उत्पादन

$ java SendHTMLEmail
Sent message successfully....

ई-मेल में अटैचमेंट भेजें

अपनी मशीन से अनुलग्नक के साथ ई-मेल भेजने के लिए यहां एक उदाहरण है। यहाँ यह माना जाता है कि आपकेlocalhost इंटरनेट से जुड़ा है और एक ई-मेल भेजने के लिए पर्याप्त सक्षम है।

उदाहरण

// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendFileEmail {

   public static void main(String [] args) {     
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Create the message part 
         BodyPart messageBodyPart = new MimeBodyPart();

         // Fill the message
         messageBodyPart.setText("This is message body");
         
         // Create a multipar message
         Multipart multipart = new MimeMultipart();

         // Set text message part
         multipart.addBodyPart(messageBodyPart);

         // Part two is attachment
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);

         // Send the complete message parts
         message.setContent(multipart );

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

HTML ई-मेल भेजने के लिए इस प्रोग्राम को संकलित करें और चलाएं -

उत्पादन

$ java SendFileEmail
Sent message successfully....

उपयोगकर्ता प्रमाणीकरण भाग

यदि प्रमाणीकरण उद्देश्य के लिए ई-मेल सर्वर को उपयोगकर्ता आईडी और पासवर्ड प्रदान करना आवश्यक है, तो आप इन गुणों को निम्नानुसार सेट कर सकते हैं -

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

शेष ई-मेल भेजने की व्यवस्था ऊपर बताई गई है।

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

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

मल्टी-थ्रेडिंग आपको एक तरह से लिखने में सक्षम बनाता है जहां एक ही कार्यक्रम में कई गतिविधियाँ समवर्ती रूप से आगे बढ़ सकती हैं।

थ्रेड का जीवन चक्र

एक धागा अपने जीवन चक्र में विभिन्न चरणों से गुजरता है। उदाहरण के लिए, एक धागा पैदा होता है, शुरू होता है, चलाता है, और फिर मर जाता है। निम्नलिखित चित्र एक धागे के पूर्ण जीवन चक्र को दर्शाता है।

निम्नलिखित जीवन चक्र के चरण हैं -

  • New- एक नया सूत्र नए राज्य में अपना जीवन चक्र शुरू करता है। यह इस स्थिति में रहता है जब तक कि कार्यक्रम थ्रेड शुरू नहीं करता है। यह भी एक के रूप में जाना जाता हैborn thread

  • Runnable- एक नवजात धागा शुरू होने के बाद, धागा चल योग्य हो जाता है। इस स्थिति में एक धागा को अपने कार्य को निष्पादित करने के लिए माना जाता है।

  • Waiting- कभी-कभी, एक थ्रेड प्रतीक्षा स्थिति में संक्रमण करता है जबकि थ्रेड किसी कार्य को करने के लिए दूसरे थ्रेड का इंतजार करता है। एक थ्रेड रननीय अवस्था में तभी वापस आता है जब कोई अन्य थ्रेड निष्पादन को जारी रखने के लिए प्रतीक्षा थ्रेड को इंगित करता है।

  • Timed Waiting- एक रनवेबल थ्रेड समय के निर्दिष्ट अंतराल के लिए समयबद्ध प्रतीक्षा स्थिति में प्रवेश कर सकता है। इस स्थिति में एक थ्रेड रननीय अवस्था में वापस आ जाता है जब उस समय का अंतराल समाप्त हो जाता है या जब वह घटना घटती है, तब होती है।

  • Terminated (Dead) - जब कोई कार्य पूरा हो जाता है या अन्यथा समाप्त हो जाता है, तो एक रननीय थ्रेड समाप्त अवस्था में प्रवेश करता है।

सूत्र प्राथमिकताएँ

प्रत्येक जावा थ्रेड में एक प्राथमिकता होती है जो ऑपरेटिंग सिस्टम को उस क्रम को निर्धारित करने में मदद करती है जिसमें थ्रेड अनुसूचित हैं।

जावा थ्रेड प्राथमिकताएँ MIN_PRIORITY (1 का एक स्थिर) और MAX_PRIORITY (10 का एक निरंतर) के बीच सीमा में हैं। डिफ़ॉल्ट रूप से, प्रत्येक थ्रेड को प्राथमिकता NORM_PRIORITY (लगातार 5) दी जाती है।

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

एक Runnable इंटरफ़ेस को लागू करके एक धागा बनाएँ

यदि आपकी कक्षा को एक धागे के रूप में निष्पादित करने का इरादा है, तो आप इसे लागू करके इसे प्राप्त कर सकते हैं Runnableइंटरफेस। आपको तीन बुनियादी चरणों का पालन करना होगा -

चरण 1

पहले कदम के रूप में, आपको एक रन () विधि द्वारा प्रदान करने की आवश्यकता है Runnableइंटरफेस। यह विधि थ्रेड के लिए एक प्रवेश बिंदु प्रदान करती है और आप इस पद्धति के अंदर अपना पूरा व्यावसायिक तर्क रखेंगे। निम्नलिखित रन का सरल सिंटैक्स है () विधि -

public void run( )

चरण 2

दूसरे चरण के रूप में, आप एक पल में करेंगे Thread निम्नलिखित कंस्ट्रक्टर का उपयोग करने वाली वस्तु -

Thread(Runnable threadObj, String threadName);

जहां, थ्रेडबॉज एक ऐसे वर्ग का उदाहरण है जो लागू करता हैRunnable इंटरफ़ेस और threadName नए धागे को दिया गया नाम है।

चरण 3

एक बार थ्रेड ऑब्जेक्ट बन जाने पर, आप इसे कॉल करके शुरू कर सकते हैं start()विधि, जो चलाने के लिए कॉल निष्पादित करती है () विधि। निम्नलिखित आरंभ का सरल सिंटैक्स है () विधि -

void start();

उदाहरण

यहां एक उदाहरण दिया गया है जो एक नया धागा बनाता है और इसे चलाना शुरू करता है -

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

थ्रेड क्लास बढ़ाकर एक थ्रेड बनाएं

एक धागा बनाने का दूसरा तरीका एक नया वर्ग बनाना है जो फैली हुई है Threadनिम्न दो सरल चरणों का उपयोग करके कक्षा। यह दृष्टिकोण थ्रेड क्लास में उपलब्ध तरीकों का उपयोग करके बनाए गए कई थ्रेड्स को संभालने में अधिक लचीलापन प्रदान करता है।

चरण 1

आपको ओवरराइड करने की आवश्यकता होगी run( )थ्रेड क्लास में उपलब्ध विधि। यह विधि थ्रेड के लिए एक प्रवेश बिंदु प्रदान करती है और आप इस पद्धति के अंदर अपना पूरा व्यावसायिक तर्क रखेंगे। निम्नलिखित रन () विधि का एक सरल वाक्यविन्यास है -

public void run( )

चरण 2

एक बार थ्रेड ऑब्जेक्ट बन जाने पर, आप इसे कॉल करके शुरू कर सकते हैं start()विधि, जो चलाने के लिए कॉल निष्पादित करती है () विधि। निम्नलिखित आरंभ का सरल सिंटैक्स है () विधि -

void start( );

उदाहरण

यहाँ थ्रेड का विस्तार करने के लिए पूर्व लिखित कार्यक्रम है -

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

धागे के तरीके

थ्रेड क्लास में उपलब्ध महत्वपूर्ण विधियों की सूची निम्नलिखित है।

अनु क्रमांक। विधि और विवरण
1

public void start()

थ्रेड को निष्पादन के एक अलग पथ में शुरू करता है, फिर इस थ्रेड ऑब्जेक्ट पर रन () विधि को आमंत्रित करता है।

2

public void run()

यदि इस थ्रेड ऑब्जेक्ट को एक अलग Runnable लक्ष्य का उपयोग करके त्वरित किया गया था, तो रन () विधि को उस Runnable ऑब्जेक्ट पर लागू किया जाता है।

3

public final void setName(String name)

थ्रेड ऑब्जेक्ट का नाम बदलता है। नाम पुनर्प्राप्त करने के लिए एक गेटनेम () विधि भी है।

4

public final void setPriority(int priority)

इस थ्रेड ऑब्जेक्ट की प्राथमिकता सेट करता है। संभावित मान 1 और 10 के बीच हैं।

5

public final void setDaemon(boolean on)

सच का एक पैरामीटर इस धागे को डेमॉन थ्रेड के रूप में दर्शाता है।

6

public final void join(long millisec)

वर्तमान धागा दूसरे धागे पर इस विधि को लागू करता है, जिससे वर्तमान धागा तब तक अवरुद्ध हो जाता है जब तक कि दूसरा धागा समाप्त नहीं होता है या मिलीसेकंड की निर्दिष्ट संख्या गुजरती है।

7

public void interrupt()

इस थ्रेड को बाधित करता है, जिससे किसी भी कारण से अवरुद्ध होने पर निष्पादन जारी रखना पड़ता है।

8

public final boolean isAlive()

अगर थ्रेड जीवित है, जो कि थ्रेड शुरू होने के बाद किसी भी समय है, लेकिन पूरा होने से पहले चलता है, तो यह सही है।

पिछले तरीके किसी विशेष थ्रेड ऑब्जेक्ट पर लागू होते हैं। थ्रेड वर्ग में निम्न विधियाँ स्थिर हैं। स्थिर तरीकों में से एक को लागू करना वर्तमान में चल रहे धागे पर ऑपरेशन करता है।

अनु क्रमांक। विधि और विवरण
1

public static void yield()

वर्तमान में चल रहे धागे को उसी प्राथमिकता के किसी भी अन्य धागे के लिए उपज देता है जो अनुसूचित होने की प्रतीक्षा कर रहे हैं।

2

public static void sleep(long millisec)

कम से कम निर्दिष्ट मिलीसेकंड के लिए ब्लॉक करने के लिए वर्तमान में चल रहे धागे का कारण बनता है।

3

public static boolean holdsLock(Object x)

यदि वर्तमान थ्रेड दिए गए ऑब्जेक्ट पर लॉक रखता है, तो सही है।

4

public static Thread currentThread()

वर्तमान में चल रहे धागे का संदर्भ देता है, जो कि इस विधि को लागू करने वाला धागा है।

5

public static void dumpStack()

स्टैक ट्रेस को वर्तमान में चल रहे थ्रेड के लिए प्रिंट करता है, जो एक मल्टीथ्रेड एप्लिकेशन को डीबग करते समय उपयोगी होता है।

उदाहरण

निम्न थ्रेडक्लासडेमो प्रोग्राम थ्रेड क्लास के इन तरीकों में से कुछ को प्रदर्शित करता है। एक वर्ग पर विचार करेंDisplayMessage जो लागू होता है Runnable -

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

निम्नलिखित एक अन्य वर्ग है जो थ्रेड वर्ग का विस्तार करता है -

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

निम्नलिखित मुख्य कार्यक्रम है, जो उपरोक्त परिभाषित वर्गों का उपयोग करता है -

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा। आप इस उदाहरण को बार-बार आज़मा सकते हैं और आपको हर बार एक अलग परिणाम मिलेगा।

उत्पादन

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

मेजर जावा मल्टीथ्रेडिंग कॉन्सेप्ट्स

जावा में मल्टीथ्रेडिंग प्रोग्रामिंग करते समय, आपको निम्नलिखित अवधारणाओं को बहुत काम करना होगा -

  • थ्रेड सिंक्रोनाइज़ेशन क्या है?

  • इंटरथ्रेड कम्युनिकेशन को हैंडल करना

  • थ्रेड गतिरोध से निपटने

  • मेजर थ्रेड ऑपरेशन

एक appletएक जावा प्रोग्राम है जो वेब ब्राउज़र में चलता है। एक एप्लेट पूरी तरह कार्यात्मक जावा एप्लिकेशन हो सकता है क्योंकि इसके निपटान में संपूर्ण जावा एपीआई है।

एक एप्लेट और एक स्वसंपूर्ण जावा अनुप्रयोग के बीच कुछ महत्वपूर्ण अंतर हैं, जिनमें निम्न शामिल हैं -

  • एक एप्लेट एक जावा क्लास है जो java.applet.Applet क्लास का विस्तार करता है।

  • एक एपलेट पर एक मुख्य () विधि को लागू नहीं किया जाता है, और एक एपलेट क्लास मुख्य () को परिभाषित नहीं करेगा।

  • Apple को HTML पृष्ठ के भीतर एम्बेड करने के लिए डिज़ाइन किया गया है।

  • जब कोई उपयोगकर्ता एक HTML पृष्ठ देखता है जिसमें एक एप्लेट होता है, तो एप्लेट के लिए कोड को उपयोगकर्ता की मशीन में डाउनलोड किया जाता है।

  • एप्लेट देखने के लिए एक JVM की आवश्यकता होती है। JVM वेब ब्राउज़र का प्लग-इन या अलग रनटाइम वातावरण हो सकता है।

  • उपयोगकर्ता की मशीन पर JVM एप्लेट वर्ग का एक उदाहरण बनाता है और एप्लेट के जीवनकाल के दौरान विभिन्न तरीकों को आमंत्रित करता है।

  • ऐप्पल के सख्त सुरक्षा नियम हैं जो वेब ब्राउज़र द्वारा लागू किए जाते हैं। एक एप्लेट की सुरक्षा को अक्सर सैंडबॉक्स सुरक्षा के रूप में संदर्भित किया जाता है, ऐपलेट की तुलना सैंडबॉक्स में खेलने वाले बच्चे की तुलना में विभिन्न नियमों के साथ की जानी चाहिए।

  • अन्य कक्षाएं जिन्हें एप्लेट की जरूरत है, उन्हें एकल जावा आर्काइव (JAR) फ़ाइल में डाउनलोड किया जा सकता है।

एक एपलेट का जीवन चक्र

एप्लेट क्लास में चार विधियाँ आपको वह ढांचा प्रदान करती हैं जिस पर आप किसी भी गंभीर एप्लेट का निर्माण करते हैं -

  • init- यह विधि आपके एप्लेट के लिए जो भी आरंभीकरण की आवश्यकता है, उसके लिए है। एपलेट टैग के अंदर पैराम टैग को संसाधित करने के बाद इसे कॉल किया जाता है।

  • start- ब्राउज़र द्वारा इनिट विधि को कॉल करने के बाद यह विधि स्वचालित रूप से कहलाती है। यह तब भी कहा जाता है जब उपयोगकर्ता पृष्ठ पर वापस आ जाता है, जिसमें अन्य पृष्ठों से हटने के बाद एप्लेट होता है।

  • stop- यह विधि स्वचालित रूप से कहा जाता है जब उपयोगकर्ता उस पृष्ठ से हट जाता है जिस पर एप्लेट बैठता है। इसलिए, एक ही एप्लेट में बार-बार कॉल किया जा सकता है।

  • destroy- इस विधि को केवल तब कहा जाता है जब ब्राउज़र सामान्य रूप से बंद हो जाता है। क्योंकि एप्लेट्स एक HTML पेज पर रहने के लिए होते हैं, इसलिए उपयोगकर्ता को एप्लेट वाले पेज को छोड़ने के बाद आमतौर पर संसाधनों को पीछे नहीं छोड़ना चाहिए।

  • paint- प्रारंभ () विधि के तुरंत बाद, और किसी भी समय एप्लेट को ब्राउज़र में स्वयं को फिर से लिखने की आवश्यकता होती है। पेंट () विधि वास्तव में java.awt से विरासत में मिली है।

एक "हैलो, वर्ल्ड" एप्लेट

निम्नलिखित एक सरल एप्लेट है जिसका नाम HelloWorldApplet.java है -

import java.applet.*;
import java.awt.*;

public class HelloWorldApplet extends Applet {
   public void paint (Graphics g) {
      g.drawString ("Hello World", 25, 50);
   }
}

इन आयात कथनों ने कक्षाओं को हमारे एप्लेट वर्ग के दायरे में ला दिया -

  • java.applet.Applet
  • java.awt.Graphics

उन आयात कथनों के बिना, जावा कंपाइलर कक्षाओं एप्लेट और ग्राफिक्स को नहीं पहचानता, जिसे एप्लेट क्लास संदर्भित करता है।

एप्लेट क्लास

हर एपलेट java.applet.Applet क्लास का एक्सटेंशन है । आधार एप्लेट क्लास उन तरीकों को प्रदान करता है जो एक व्युत्पन्न एप्लेट क्लास ब्राउजर संदर्भ से जानकारी और सेवाएं प्राप्त करने के लिए कह सकता है।

इन विधियों में निम्नलिखित शामिल हैं -

  • एप्लेट पैरामीटर प्राप्त करें
  • HTML फ़ाइल का नेटवर्क स्थान प्राप्त करें जिसमें एप्लेट है
  • एप्लेट श्रेणी निर्देशिका का नेटवर्क स्थान प्राप्त करें
  • ब्राउज़र में एक स्थिति संदेश प्रिंट करें
  • एक छवि प्राप्त करें
  • एक ऑडियो क्लिप लाएं
  • एक ऑडियो क्लिप चलाएं
  • एप्लेट का आकार बदलें

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

  • एप्लेट के लेखक, संस्करण और कॉपीराइट के बारे में जानकारी का अनुरोध करें
  • एप्लेट को पहचानने वाले मापदंडों के विवरण का अनुरोध करें
  • एप्लेट शुरू करें
  • एप्लेट को नष्ट करें
  • एप्लेट का निष्पादन शुरू करें
  • एप्लेट के निष्पादन को रोकें

एप्लेट वर्ग इनमें से प्रत्येक विधि का डिफ़ॉल्ट कार्यान्वयन प्रदान करता है। आवश्यकतानुसार इन कार्यान्वयनों को ओवरराइड किया जा सकता है।

"हैलो, वर्ल्ड" एप्लेट जैसे ही खड़ा होता है पूरा हो जाता है। ओवरराइड की एकमात्र विधि पेंट विधि है।

एक एप्लेट प्राप्त करना

HTML फ़ाइल में निर्देशों को एम्बेड करके और ऐपलेट दर्शक या जावा-सक्षम ब्राउज़र के माध्यम से फ़ाइल को देखने के द्वारा एक एप्लेट मंगवाया जा सकता है।

<एप्लेट> टैग एक HTML फाइल में एप्लेट को एम्बेड करने का आधार है। निम्नलिखित एक उदाहरण है जो "हैलो, वर्ल्ड" एप्लेट को आमंत्रित करता है -

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Note- आप HTML से एप्लेट कॉल करने के बारे में अधिक समझने के लिए HTML एप्लेट टैग का उल्लेख कर सकते हैं ।

<एप्लेट> टैग की कोड विशेषता आवश्यक है। यह चलाने के लिए एप्लेट क्लास निर्दिष्ट करता है। पैनल के प्रारंभिक आकार को निर्दिष्ट करने के लिए चौड़ाई और ऊंचाई भी आवश्यक है जिसमें एक एप्लेट चलता है। एप्लेट निर्देश </ एप्लेट> टैग के साथ बंद होना चाहिए।

यदि कोई एपलेट पैरामीटर लेता है, तो मानों के लिए मान <param> टैग के बीच <applet> और </ applet> जोड़कर पारित किया जा सकता है। ब्राउज़र एप्लेट टैग के बीच पाठ और अन्य टैग को अनदेखा करता है।

गैर-जावा-सक्षम ब्राउज़र <एप्लेट> और </ एप्लेट> को संसाधित नहीं करता है। इसलिए, टैग के बीच दिखाई देने वाली कुछ भी, एप्लेट से संबंधित नहीं, गैर-जावा-सक्षम ब्राउज़र में दिखाई देती है।

दर्शक या ब्राउज़र दस्तावेज़ के स्थान पर संकलित जावा कोड की तलाश करता है। अन्यथा निर्दिष्ट करने के लिए, दिखाए गए अनुसार <applet> टैग के कोडबेस विशेषता का उपयोग करें -

<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
   width = "320" height = "120">

यदि कोई एप्लेट डिफ़ॉल्ट के अलावा किसी पैकेज में रहता है, तो होल्डिंग पैकेज को पीरियड कैरेक्टर (।) का उपयोग कर अलग-अलग पैकेज / क्लास कंपोनेंट्स का उपयोग करके कोड विशेषता में निर्दिष्ट किया जाना चाहिए। उदाहरण के लिए -

<applet  = "mypackage.subpackage.TestApplet.class" 
   width = "320" height = "120">

एप्लेट पैरामीटर प्राप्त करना

निम्न उदाहरण दर्शाता है कि दस्तावेज़ में निर्दिष्ट सेटअप मापदंडों के लिए एक एप्लेट कैसे बनाया जाए। यह एप्लेट काले रंग की एक बिसात का पैटर्न और दूसरा रंग दिखाता है।

प्रत्येक वर्ग का दूसरा रंग और आकार दस्तावेज़ के भीतर एप्लेट के मापदंडों के रूप में निर्दिष्ट किया जा सकता है।

CheckerApplet init () विधि में अपने मापदंडों को प्राप्त करता है। यह पेंट () विधि में इसके पैरामीटर भी प्राप्त कर सकता है। हालांकि, मूल्यों को प्राप्त करना और एप्लेट की शुरुआत में एक बार सेटिंग्स को सहेजना, हर ताज़ा करने के बजाय, सुविधाजनक और कुशल है।

एप्लेट व्यूअर या ब्राउजर प्रत्येक एपलेट के इनिट () विधि को चलाता है। एपलेट लोड करने के तुरंत बाद दर्शक एक बार init () कहता है। (Applet.init () कुछ भी करने के लिए लागू किया गया है।) कस्टम इनिशियलाइज़ेशन कोड डालने के लिए डिफ़ॉल्ट कार्यान्वयन को ओवरराइड करें।

Applet.getParameter () विधि पैरामीटर के नाम (पैरामीटर का मान हमेशा एक स्ट्रिंग है) दिए गए पैरामीटर को प्राप्त करता है। यदि मान संख्यात्मक या अन्य गैर-वर्ण डेटा है, तो स्ट्रिंग को पार्स किया जाना चाहिए।

निम्नलिखित CheckerApplet.java का एक कंकाल है -

import java.applet.*;
import java.awt.*;

public class CheckerApplet extends Applet {
   int squareSize = 50;   // initialized to default size
   public void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   public void paint (Graphics g) {}
}

यहाँ CheckerApplet के init () और निजी parseSquareSize () विधियाँ हैं -

public void init () {
   String squareSizeParam = getParameter ("squareSize");
   parseSquareSize (squareSizeParam);
   
   String colorParam = getParameter ("color");
   Color fg = parseColor (colorParam);
   
   setBackground (Color.black);
   setForeground (fg);
}

private void parseSquareSize (String param) {
   if (param == null) return;
   try {
      squareSize = Integer.parseInt (param);
   } catch (Exception e) {
      // Let default value remain
   }
}

एप्लेट स्क्वेयरसाइज़ पैरामीटर को पार्स करने के लिए parseSquareSize () कहता है। parseSquareSize () लाइब्रेरी विधि Integer.parseInt () को कॉल करता है, जो एक स्ट्रिंग को पार्स करता है और एक पूर्णांक देता है। जब भी इसका तर्क अमान्य है, Integer.parseInt () एक अपवाद फेंकता है।

इसलिए, खराब इनपुट पर एप्लेट को अनुमति देने के बजाय, पार्सेक्वेरीसाइज़ () अपवादों को पकड़ता है।

एप्लेट रंग पैरामीटर को रंग मान में पार्स करने के लिए पार्सकोलर () कहता है। parseColor () एक पूर्वनिर्धारित रंग के नाम के पैरामीटर मान से मेल खाने के लिए स्ट्रिंग तुलनाओं की एक श्रृंखला करता है। इस एप्लेट को काम करने के लिए आपको इन तरीकों को लागू करने की आवश्यकता है।

एप्लेट पैरामीटर निर्दिष्ट करना

निम्न HTML फ़ाइल का एक उदाहरण है जिसमें एक चेकर एपलेट सन्निहित है। HTML फ़ाइल <पैरामीटर> टैग के माध्यम से एप्लेट के दोनों मापदंडों को निर्दिष्ट करती है।

<html>
   <title>Checkerboard Applet</title>
   <hr>
   <applet code = "CheckerApplet.class" width = "480" height = "320">
      <param name = "color" value = "blue">
      <param name = "squaresize" value = "30">
   </applet>
   <hr>
</html>

Note - पैरामीटर नाम केस संवेदी नहीं हैं।

Applets के लिए आवेदन रूपांतरण

एक ग्राफिकल जावा एप्लिकेशन (जो कि AWT का उपयोग करने वाला एप्लिकेशन है और जिसे आप जावा प्रोग्राम लॉन्चर से शुरू कर सकते हैं) को एक एप्लेट में बदलना आसान है जिसे आप वेब पेज में एम्बेड कर सकते हैं।

एप्लिकेशन को एप्लेट में परिवर्तित करने के लिए विशिष्ट चरण निम्नलिखित हैं।

  • एप्लेट कोड लोड करने के लिए उपयुक्त टैग के साथ एक HTML पेज बनाएं।

  • JApplet वर्ग के एक उपवर्ग की आपूर्ति करें। इस वर्ग को सार्वजनिक करें। अन्यथा, एप्लेट को लोड नहीं किया जा सकता है।

  • आवेदन में मुख्य विधि को हटा दें। एप्लिकेशन के लिए फ़्रेम विंडो का निर्माण न करें। आपका एप्लिकेशन ब्राउज़र के अंदर प्रदर्शित होगा।

  • एप्लेट की इनिट विधि से फ्रेम विंडो कंस्ट्रक्टर से किसी भी इनिशियलाइज़ेशन कोड को स्थानांतरित करें। आपको एप्लेट ऑब्जेक्ट को स्पष्ट रूप से बनाने की आवश्यकता नहीं है। ब्राउज़र आपके लिए इसे इंस्टेंट करता है और इनिट विधि को कॉल करता है।

  • सेट करने के लिए कॉल निकालें; एप्लेट्स के लिए, HTML फ़ाइल में चौड़ाई और ऊंचाई के मापदंडों के साथ साइज़िंग की जाती है।

  • कॉल को SetDefaultCloseOperation पर निकालें। एक एप्लेट बंद नहीं किया जा सकता है; ब्राउज़र से बाहर निकलने पर यह समाप्त हो जाता है।

  • यदि एप्लिकेशन सेटटाइटल कॉल करता है, तो कॉल को विधि में समाप्त करें। Applets में शीर्षक पट्टियाँ नहीं हो सकतीं। (आप निश्चित रूप से, HTML शीर्षक टैग का उपयोग करके वेब पेज को शीर्षक दे सकते हैं।)

  • सेटविजनेबल (सत्य) न कहें। एप्लेट स्वचालित रूप से प्रदर्शित होता है।

घटना से निपटना

ऐप्पल ने कंटेनर क्लास से इवेंट-हैंडलिंग विधियों का एक समूह प्राप्त किया है। कंटेनर वर्ग कई प्रकार की प्रक्रियाओं को परिभाषित करता है, जैसे कि विशेष प्रकार की घटनाओं से निपटने के लिए प्रक्रियाकिशन और प्रोसेसमूसेवन, और फिर एक कैच-ऑल विधि जिसे प्रोसेसईवेंट कहा जाता है।

किसी घटना पर प्रतिक्रिया करने के लिए, एप्लेट को उपयुक्त ईवेंट-विशिष्ट विधि को ओवरराइड करना चाहिए।

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;

public class ExampleEventHandling extends Applet implements MouseListener {
   StringBuffer strBuffer;

   public void init() {
      addMouseListener(this);
      strBuffer = new StringBuffer();
      addItem("initializing the apple ");
   }

   public void start() {
      addItem("starting the applet ");
   }

   public void stop() {
      addItem("stopping the applet ");
   }

   public void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   public void paint(Graphics g) {
      // Draw a Rectangle around the applet's display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      g.drawString(strBuffer.toString(), 10, 20);
   }

   
   public void mouseEntered(MouseEvent event) {
   }
   public void mouseExited(MouseEvent event) {
   }
   public void mousePressed(MouseEvent event) {
   }
   public void mouseReleased(MouseEvent event) {
   }
   public void mouseClicked(MouseEvent event) {
      addItem("mouse clicked! ");
   }
}

अब, हम इस एप्लेट को इस प्रकार कहते हैं -

<html>
   <title>Event Handling</title>
   <hr>
   <applet code = "ExampleEventHandling.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

प्रारंभ में, एप्लेट "एप्लेट को इनिशियलाइज़ करना" शुरू करेगा। फिर एक बार जब आप आयत के अंदर क्लिक करते हैं, तो "माउस क्लिक" भी प्रदर्शित किया जाएगा।

छवियाँ प्रदर्शित करना

एक एपलेट प्रारूप GIF, JPEG, BMP, और अन्य की छवियों को प्रदर्शित कर सकता है। एप्लेट के भीतर एक छवि प्रदर्शित करने के लिए, आप java.awt.Graphics क्लास में पाई गई drawImage () विधि का उपयोग करें।

निम्नलिखित चित्र दिखाने के लिए सभी चरणों को दर्शाने वाला एक उदाहरण है -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class ImageDemo extends Applet {
   private Image image;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String imageURL = this.getParameter("image");
      if(imageURL == null) {
         imageURL = "java.jpg";
      }
      try {
         URL url = new URL(this.getDocumentBase(), imageURL);
         image = context.getImage(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   public void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javalicense.com", 35, 100);
   }  
}

अब, हम इस एप्लेट को इस प्रकार कहते हैं -

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "300" height = "200">
      <param name = "image" value = "java.jpg">
   </applet>
   <hr>
</html>

ऑडियो बजाना

एक ऐपलेट java.applet पैकेज में AudioClip इंटरफ़ेस द्वारा प्रस्तुत एक ऑडियो फ़ाइल चला सकता है। ऑडियोक्लिप इंटरफ़ेस में तीन विधियाँ हैं, जिनमें शामिल हैं -

  • public void play() - शुरू से ही एक बार ऑडियो क्लिप चलाती है।

  • public void loop() - ऑडियो क्लिप को लगातार रीप्ले करने का कारण बनता है।

  • public void stop() - ऑडियो क्लिप चला रहा है।

एक ऑडियोक्लिप ऑब्जेक्ट प्राप्त करने के लिए, आपको अपलेट क्लास की getAudioClip () विधि को लागू करना होगा। GetAudioClip () विधि तुरंत वापस आ जाती है, भले ही URL वास्तविक ऑडियो फ़ाइल में हल हो या न हो। ऑडियो फ़ाइल को तब तक डाउनलोड नहीं किया जाता है जब तक ऑडियो क्लिप को चलाने का प्रयास नहीं किया जाता है।

एक ऑडियो चलाने के लिए सभी चरणों को दर्शाने वाला एक उदाहरण निम्नलिखित है -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class AudioDemo extends Applet {
   private AudioClip clip;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String audioURL = this.getParameter("audio");
      if(audioURL == null) {
         audioURL = "default.au";
      }
      try {
         URL url = new URL(this.getDocumentBase(), audioURL);
         clip = context.getAudioClip(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         context.showStatus("Could not load audio file!");
      }
   }
   
   public void start() {
      if(clip != null) {
         clip.loop();
      }
   }
   
   public void stop() {
      if(clip != null) {
         clip.stop();
      }
   }
}

अब, हम इस एप्लेट को इस प्रकार कहते हैं -

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "0" height = "0">
      <param name = "audio" value = "test.wav">
   </applet>
   <hr>
</html>

आप उपरोक्त उदाहरण का परीक्षण करने के लिए अपने पीसी पर test.wav का उपयोग कर सकते हैं।

जावा भाषा तीन प्रकार की टिप्पणियों का समर्थन करती है -

अनु क्रमांक। टिप्पणी और विवरण
1

/* text */

संकलक / * से * / तक सब कुछ अनदेखा करता है।

2

//text

संकलक // से पंक्ति के अंत तक सब कुछ अनदेखा करता है।

3

/** documentation */

यह एक दस्तावेजी टिप्पणी है और सामान्य तौर पर इसे कहा जाता है doc commentJDK javadocउपकरण स्वचालित रूप से उत्पन्न प्रलेखन तैयार करते समय डॉक्टर टिप्पणियों का उपयोग करता है ।

यह अध्याय जावदोक को समझाने के बारे में है। हम देखेंगे कि जावा कोड के लिए उपयोगी प्रलेखन उत्पन्न करने के लिए हम Javadoc का उपयोग कैसे कर सकते हैं।

जावदोक क्या है?

Javadoc एक टूल है जो JDK के साथ आता है और इसका उपयोग जावा सोर्स कोड से HTML फॉर्मेट में Java कोड डॉक्यूमेंट जनरेट करने के लिए किया जाता है, जिसके लिए पूर्वनिर्धारित फॉर्मेट में डॉक्यूमेंटेशन की आवश्यकता होती है।

निम्नलिखित एक सरल उदाहरण है, जहां /*………… के अंदर की लाइनें जावा मल्टी-लाइन टिप्पणियां हैं। इसी तरह, जो लाइन // आगे बढ़ती है वह जावा सिंगल-लाइन टिप्पणी है।

उदाहरण

/**
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

आप विवरण भाग के अंदर आवश्यक HTML टैग शामिल कर सकते हैं। उदाहरण के लिए, निम्न उदाहरण हेडिंग के लिए <h1> .... </ h1> का उपयोग करता है और <p> का उपयोग पैराग्राफ के लिए किया जाता है -

उदाहरण

/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
* 
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

जावाडॉक टैग

Javadoc टूल निम्नलिखित टैग को पहचानता है -

टैग विवरण वाक्य - विन्यास
@लेखक एक वर्ग के लेखक को जोड़ता है। @ आधार नाम-पाठ
{} @Code HTML मार्कअप या नेस्टेड जावाडॉक टैग के रूप में पाठ की व्याख्या किए बिना कोड फ़ॉन्ट में पाठ प्रदर्शित करता है। {@ पाठ पाठ}
{} @DocRoot किसी भी उत्पन्न पृष्ठ से उत्पन्न दस्तावेज़ के रूट निर्देशिका के सापेक्ष पथ का प्रतिनिधित्व करता है। {} @DocRoot
@deprecated एक टिप्पणी जोड़ता है कि यह दर्शाता है कि इस एपीआई का उपयोग नहीं किया जाना चाहिए। @deprecated deprecatedtext
@exception जोड़ता है a Throws क्लासनाम और विवरण पाठ के साथ, जनरेट किए गए दस्तावेज़ के लिए सबहेडिंग। @ अपवाद वर्ग-नाम विवरण
{} @InheritDoc से एक टिप्पणी की पुष्टि करता है nearest अंतर्निहित वर्ग या कार्यान्वयन योग्य इंटरफ़ेस। तत्काल surperclass से एक टिप्पणी की पुष्टि करता है।
{@संपर्क} दृश्य पाठ लेबल के साथ एक इन-लाइन लिंक सम्मिलित करता है जो निर्दिष्ट पैकेज, वर्ग, या एक संदर्भित वर्ग के सदस्य नाम के दस्तावेज़ीकरण को इंगित करता है। {@link package.class # सदस्य लेबल}
{} @Linkplain {@Link} की पहचान, लिंक के लेबल को छोड़कर कोड फ़ॉन्ट की तुलना में सादे पाठ में प्रदर्शित किया जाता है। {@linkplain package.class # सदस्य लेबल}
@param निर्दिष्ट पैरामीटर-नाम के साथ एक पैरामीटर जोड़ता है जिसके बाद "पैरामीटर" अनुभाग में निर्दिष्ट विवरण होता है। @ अपरम पैरामीटर नाम-विवरण
@वापसी वर्णन पाठ के साथ एक "रिटर्न" खंड जोड़ता है। @ विवरण का वर्णन करें
@देख एक लिंक या पाठ प्रविष्टि के साथ "देखें भी" शीर्षक जोड़ता है जो संदर्भ को इंगित करता है। @ संदर्भ
@धारावाहिक डिफ़ॉल्ट धारावाहिक क्षेत्र के लिए डॉक्टर टिप्पणी में प्रयुक्त। @ क्षेत्र-वर्णन | शामिल हैं | निकालना
@serialData डेटा को राइटऑब्जेक्ट () या राइट एक्सटर्नल () तरीकों से लिखा गया है। @serialData डेटा-विवरण
@serialField एक ObjectStreamField घटक दस्तावेज़। @serialField फ़ील्ड-नाम फ़ील्ड-प्रकार फ़ील्ड-वर्णन
@जबसे एक "से" उत्पन्न निर्दिष्ट प्रलेखन के बाद से पाठ के साथ शीर्षक जोड़ता है। @ सिंस रिलीज
@throws @Throws और @exception टैग पर्यायवाची हैं। @ वर्ग-नाम विवरण
{} @Value जब {@value} का उपयोग किसी स्थिर क्षेत्र की डॉक टिप्पणी में किया जाता है, तो यह उस स्थिरांक का मान प्रदर्शित करता है। {@value package.class # फ़ील्ड}
@version जब -version विकल्प का उपयोग किया जाता है, तो निर्दिष्ट संस्करण-पाठ के साथ एक "संस्करण" को उत्पन्न डॉक्स में जोड़ता है। @ संस्करण-पाठ

उदाहरण

निम्नलिखित कार्यक्रम प्रलेखन टिप्पणियों के लिए उपलब्ध कुछ महत्वपूर्ण टैग का उपयोग करता है। आप अपनी आवश्यकताओं के आधार पर अन्य टैग का उपयोग कर सकते हैं।

AddNum वर्ग के बारे में दस्तावेज़ीकरण HTML फ़ाइल AddNum.html में निर्मित किया जाएगा, लेकिन एक ही समय में एक नाम index.html के साथ एक मास्टर फ़ाइल भी बनाई जाएगी।

import java.io.*;

/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an application that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31
*/
public class AddNum {
   /**
   * This method is used to add two integers. This is
   * a the simplest form of a class method, just to
   * show the usage of various javadoc Tags.
   * @param numA This is the first paramter to addNum method
   * @param numB  This is the second parameter to addNum method
   * @return int This returns sum of numA and numB.
   */
   public int addNum(int numA, int numB) {
      return numA + numB;
   }

   /**
   * This is the main method which makes use of addNum method.
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */

   public static void main(String args[]) throws IOException {
      AddNum obj = new AddNum();
      int sum = obj.addNum(10, 20);

      System.out.println("Sum of 10 and 20 is :" + sum);
   }
}

अब, उपरोक्त AddNum.java फ़ाइल को निम्नानुसार javadoc उपयोगिता की प्रक्रिया करें -

$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating /package-frame.html...
Generating /package-summary.html...
Generating /package-tree.html...
Generating /constant-values.html...
Building index for all the packages and classes...
Generating /overview-tree.html...
Generating /index-all.html...
Generating /deprecated-list.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$

आप देख सकते हैं सब उत्पन्न प्रलेखन यहाँ - AddNum । यदि आप JDK 1.7 का उपयोग कर रहे हैं तो javadoc एक महान उत्पन्न नहीं करता हैstylesheet.css, इसलिए हम मानक स्टाइलशीट को डाउनलोड और उपयोग करने का सुझाव देते हैं https://docs.oracle.com/javase/7/docs/api/stylesheet.css