ग्रूवी - त्वरित गाइड

ग्रूवी एक ऑब्जेक्ट ओरिएंटेड भाषा है जो जावा प्लेटफॉर्म पर आधारित है। ग्रूवी 1.0 को 2 जनवरी, 2007 में ग्रूवी 2.4 के साथ वर्तमान प्रमुख रिलीज़ के रूप में रिलीज़ किया गया था। ग्रूवी को अपाचे लाइसेंस वी 2.0 के माध्यम से वितरित किया जाता है।

ग्रूवी की विशेषताएं

ग्रूवी में निम्नलिखित विशेषताएं हैं -

स्थिर और गतिशील दोनों प्रकार के लिए समर्थन।
ऑपरेटर ओवरलोडिंग के लिए समर्थन।
सूचियों और साहचर्य सरणियों के लिए मूल वाक्यविन्यास।
नियमित अभिव्यक्तियों के लिए मूल समर्थन।
विभिन्न मार्कअप भाषाओं जैसे XML और HTML के लिए मूल समर्थन।
ग्रूवी जावा डेवलपर्स के लिए सरल है क्योंकि जावा और ग्रूवी के लिए वाक्य रचना बहुत समान है।
आप मौजूदा जावा पुस्तकालयों का उपयोग कर सकते हैं।
ग्रूवी ने java.lang.Object का विस्तार किया।

ग्रूवी के लिए आधिकारिक वेबसाइट है http://www.groovy-lang.org/

ग्रूवी पर्यावरण सेटअप प्राप्त करने के कई तरीके हैं।

Binary download and installation- विंडोज इंस्टालर सेक्शन पाने के लिए लिंक www.groovy-lang.org/download.html पर जाएं । ग्रूवी इंस्टॉलर का डाउनलोड शुरू करने के लिए इस विकल्प पर क्लिक करें।

इंस्टॉलर को लॉन्च करने के बाद, इंस्टॉलेशन को पूरा करने के लिए नीचे दिए गए चरणों का पालन करें।

Step 1 - भाषा इंस्टॉलर का चयन करें।

Step 2 - अगली स्क्रीन में नेक्स्ट बटन पर क्लिक करें।

Step 3 - 'I Agree' बटन पर क्लिक करें।

Step 4 - डिफ़ॉल्ट घटकों को स्वीकार करें और अगला बटन पर क्लिक करें।

Step 5 - उपयुक्त गंतव्य फ़ोल्डर चुनें और फिर अगला बटन पर क्लिक करें।

Step 6 - इंस्टॉलेशन शुरू करने के लिए इंस्टॉल बटन पर क्लिक करें।

Step 7 - इंस्टॉलेशन पूरा होने के बाद, कॉन्फ़िगरेशन शुरू करने के लिए नेक्स्ट बटन पर क्लिक करें।

Step 8 - डिफ़ॉल्ट विकल्प चुनें और नेक्स्ट बटन पर क्लिक करें।

Step 9 - डिफ़ॉल्ट फ़ाइल संघों को स्वीकार करें और अगला बटन पर क्लिक करें।

Step 10 - इंस्टॉलेशन पूरा करने के लिए फिनिश बटन पर क्लिक करें।

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

यदि आप ग्रोवी बायनेरिज़ को मावेन या ग्रेडल बिल्ड के हिस्से के रूप में शामिल करना चाहते हैं, तो आप निम्नलिखित पंक्तियों को जोड़ सकते हैं

Gradle

'org.codehaus.groovy:groovy:2.4.5'

Maven

<groupId>org.codehaus.groovy</groupId> 
<artifactId>groovy</artifactId>  
<version>2.4.5</version>

ग्रूवी के मूल सिंटैक्स को समझने के लिए, आइए पहले एक साधारण हैलो वर्ल्ड प्रोग्राम देखें।

आपका पहला हैलो वर्ल्ड प्रोग्राम बनाना

अपना पहला हैलो वर्ल्ड प्रोग्राम बनाना उतना ही सरल है जितना कि निम्नलिखित कोड लाइन में प्रवेश करना -

class Example {
   static void main(String[] args) {
      // Using a simple println statement to print output to the console
      println('Hello World');
   }
}

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

Hello World

ग्रूवी में आयात विवरण

आयात विवरण का उपयोग अन्य पुस्तकालयों की कार्यक्षमता को आयात करने के लिए किया जा सकता है जो आपके कोड में उपयोग किए जा सकते हैं। यह का उपयोग करके किया जाता हैimport कीवर्ड।

निम्न उदाहरण से पता चलता है कि मार्कअपबर्स्ट क्लास के एक साधारण आयात का उपयोग कैसे करें जो संभवतः HTML या XML मार्कअप बनाने के लिए सबसे अधिक उपयोग की जाने वाली कक्षाओं में से एक है।

import groovy.xml.MarkupBuilder 
def xml = new MarkupBuilder()

डिफ़ॉल्ट रूप से, ग्रूवी में आपके कोड में निम्नलिखित पुस्तकालय शामिल हैं, इसलिए आपको उन्हें स्पष्ट रूप से आयात करने की आवश्यकता नहीं है।

import java.lang.* 
import java.util.* 
import java.io.* 
import java.net.* 

import groovy.lang.* 
import groovy.util.* 

import java.math.BigInteger 
import java.math.BigDecimal

ग्रूवी में टोकन

एक टोकन या तो एक कीवर्ड, एक पहचानकर्ता, एक स्थिर, एक स्ट्रिंग शाब्दिक, या एक प्रतीक है।

println(“Hello World”);

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

Groovy में टिप्पणियां

आपके कोड को दस्तावेज करने के लिए टिप्पणियों का उपयोग किया जाता है। ग्रूवी में टिप्पणियाँ सिंगल लाइन या मल्टीलाइन हो सकती हैं।

लाइन में किसी भी स्थिति में // का उपयोग करके एकल लाइन टिप्पणियों की पहचान की जाती है। एक उदाहरण नीचे दिखाया गया है -

class Example {
   static void main(String[] args) {
      // Using a simple println statement to print output to the console
      println('Hello World');
   }
}

बहुस्तरीय टिप्पणियों की शुरुआत में / * के साथ और * बहुभाषी टिप्पणी के अंत की पहचान करने के लिए की जाती है।

class Example {
   static void main(String[] args) {
      /* This program is the first program
      This program shows how to display hello world */
      println('Hello World');
   }
}

अर्धविराम

जावा प्रोग्रामिंग भाषा के विपरीत, प्रत्येक कथन के अंत के बाद अर्धविराम होना अनिवार्य नहीं है, यह वैकल्पिक है।

class Example {
   static void main(String[] args) {
      def x = 5
      println('Hello World');  
   }
}

यदि आप उपरोक्त प्रोग्राम को निष्पादित करते हैं, तो मुख्य विधि में दोनों कथन कोई त्रुटि उत्पन्न नहीं करते हैं।

पहचानकर्ता

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

def employeename 
def student1 
def student_name

कहाँ पे def एक पहचानकर्ता को परिभाषित करने के लिए Groovy में उपयोग किया जाने वाला एक कीवर्ड है।

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

class Example {
   static void main(String[] args) {
      // One can see the use of a semi-colon after each statement
      def x = 5;
      println('Hello World'); 
   }
}

उपरोक्त उदाहरण में, चर x एक पहचानकर्ता के रूप में प्रयोग किया जाता है।

कीवर्ड

नाम के रूप में कीवर्ड सुझाव विशेष शब्द हैं जो ग्रूवी प्रोग्रामिंग भाषा में आरक्षित हैं। निम्न तालिका ग्रूवी में परिभाषित किए गए कीवर्ड को सूचीबद्ध करती है।

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

व्हाइटस्पेस

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

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

def x = 5;

शाब्दिक

एक शाब्दिक ग्रूवी में एक निश्चित मूल्य का प्रतिनिधित्व करने के लिए एक संकेतन है। ग्रूवी भाषा में पूर्णांक, फ्लोटिंग-पॉइंट संख्या, वर्ण और स्ट्रिंग्स के लिए सूचनाएं हैं। यहाँ ग्रूवी प्रोग्रामिंग भाषा में शाब्दिक उदाहरण दिए गए हैं -

12 
1.45 
‘a’ 
“aa”

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

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

अंतर्निहित डेटा प्रकार

ग्रूवी निर्मित डेटा प्रकारों की एक विस्तृत विविधता प्रदान करता है। निम्नलिखित डेटा प्रकारों की एक सूची है जिसे ग्रूवी में परिभाषित किया गया है -

byte- यह एक बाइट मान का प्रतिनिधित्व करने के लिए प्रयोग किया जाता है। एक उदाहरण 2 है।
short- यह एक छोटी संख्या का प्रतिनिधित्व करने के लिए प्रयोग किया जाता है। एक उदाहरण 10 है।
int- इसका उपयोग संपूर्ण संख्याओं को दर्शाने के लिए किया जाता है। एक उदाहरण 1234 है।
long- इसका उपयोग लंबी संख्या का प्रतिनिधित्व करने के लिए किया जाता है। एक उदाहरण 10000090 है।
float- इसका उपयोग 32-बिट फ्लोटिंग पॉइंट नंबरों को दर्शाने के लिए किया जाता है। एक उदाहरण 12.34 है।
double- इसका उपयोग 64-बिट फ्लोटिंग पॉइंट नंबरों को दर्शाने के लिए किया जाता है जो लंबे समय तक दशमलव संख्या में होते हैं जो कई बार आवश्यक हो सकते हैं। एक उदाहरण 12.3456565 है।
char- यह एक एकल चरित्र शाब्दिक परिभाषित करता है। एक उदाहरण 'क' है।
Boolean - यह एक बूलियन मूल्य का प्रतिनिधित्व करता है जो या तो सच या गलत हो सकता है।
String - ये पाठ शाब्दिक हैं जिनका प्रतिनिधित्व किया जाता है the formपात्रों की श्रृंखला। उदाहरण के लिए "हैलो वर्ल्ड"।

बंधे हुए मूल्य

निम्न तालिका संख्यात्मक और दशमलव शाब्दिक के लिए अधिकतम अनुमत मान दिखाती है।

बाइट	-128 से 127
कम	-32,768 से 32,767
पूर्णांक	-2,147,483,648 से 2,147,483,647
लंबा	-9,223,372,036,854,775,808 से +9,223,372,036,854,775,807
नाव	1.40129846432481707e-45 से 3.40282346638528860e + 38
दोहरा	4.94065645841246544e-324d से 1.79769313486231570e + 308d

क्लास न्यूमेरिक

प्रकार आदिम प्रकारों के अलावा, निम्न वस्तु प्रकार (कभी-कभी आवरण प्रकार के रूप में संदर्भित) की अनुमति है -

java.lang.Byte
java.lang.Short
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double

इसके अलावा, निम्नलिखित वर्गों का उपयोग मनमाने ढंग से सटीक अंकगणित का समर्थन करने के लिए किया जा सकता है -

नाम	विवरण	उदाहरण
java.math.BigInteger	अपरिवर्तनीय मनमानी-सटीक हस्ताक्षरित अभिन्न संख्या	30g
java.math.BigDecimal	अपरिवर्तनीय मनमानी-सटीक हस्ताक्षरित दशमलव संख्या	3.5g

निम्न कोड उदाहरण दिखाता है कि विभिन्न अंतर्निहित डेटा प्रकारों का उपयोग कैसे किया जा सकता है -

class Example { 
   static void main(String[] args) { 
      //Example of a int datatype 
      int x = 5; 
		
      //Example of a long datatype 
      long y = 100L; 
		
      //Example of a floating point datatype 
      float a = 10.56f; 
		
      //Example of a double datatype 
      double b = 10.5e40; 
		
      //Example of a BigInteger datatype 
      BigInteger bi = 30g; 
		
      //Example of a BigDecimal datatype 
      BigDecimal bd = 3.5g; 
		
      println(x); 
      println(y); 
      println(a); 
      println(b); 
      println(bi); 
      println(bd); 
   } 
}

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

ग्रूवी में चर को दो तरीकों से परिभाषित किया जा सकता है - का उपयोग करते हुए native syntax डेटा प्रकार या अगले के लिए है by using the def keyword। चर परिभाषाओं के लिए या तो स्पष्ट रूप से एक प्रकार का नाम प्रदान करना या प्रतिस्थापन में "डीफ़" का उपयोग करना अनिवार्य है। यह ग्रूवी पार्सर द्वारा आवश्यक है।

पिछले अध्याय में बताए गए ग्रूवी में बुनियादी प्रकार के चर निम्नलिखित हैं -

byte- यह एक बाइट मान का प्रतिनिधित्व करने के लिए प्रयोग किया जाता है। एक उदाहरण 2 है।
short- यह एक छोटी संख्या का प्रतिनिधित्व करने के लिए प्रयोग किया जाता है। एक उदाहरण 10 है।
int- इसका उपयोग संपूर्ण संख्याओं को दर्शाने के लिए किया जाता है। एक उदाहरण 1234 है।
long- इसका उपयोग लंबी संख्या का प्रतिनिधित्व करने के लिए किया जाता है। एक उदाहरण 10000090 है।
float- इसका उपयोग 32-बिट फ्लोटिंग पॉइंट नंबरों को दर्शाने के लिए किया जाता है। एक उदाहरण 12.34 है।
double- इसका उपयोग 64-बिट फ्लोटिंग पॉइंट नंबरों को दर्शाने के लिए किया जाता है जो लंबे समय तक दशमलव संख्या में होते हैं जो कई बार आवश्यक हो सकते हैं। एक उदाहरण 12.3456565 है।
char- यह एक एकल चरित्र शाब्दिक परिभाषित करता है। एक उदाहरण 'क' है।
Boolean - यह एक बूलियन मूल्य का प्रतिनिधित्व करता है जो या तो सच या गलत हो सकता है।
String - ये पाठ शाब्दिक हैं जिनका प्रतिनिधित्व किया जाता है the formपात्रों की श्रृंखला। उदाहरण के लिए "हैलो वर्ल्ड"।

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

परिवर्तनीय घोषणाएँ

एक चर घोषणा संकलक को बताती है कि चर के लिए भंडारण कहां और कितना बनाना है।

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

class Example { 
   static void main(String[] args) { 
      // x is defined as a variable 
      String x = "Hello";
		
      // The value of the variable is printed to the console 
      println(x);
   }
}

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

Hello

नामकरण चर

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

class Example { 
   static void main(String[] args) { 
      // Defining a variable in lowercase  
      int x = 5;
	  
      // Defining a variable in uppercase  
      int X = 6; 
	  
      // Defining a variable with the underscore in it's name 
      def _Name = "Joe"; 
		
      println(x); 
      println(X); 
      println(_Name); 
   } 
}

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

5 
6 
Joe

हम देख सकते हैं कि x तथा X केस सेंसिटिविटी के कारण दो अलग-अलग चर हैं और तीसरे मामले में, हम देख सकते हैं कि _Name एक अंडरस्कोर से शुरू होता है।

मुद्रण योग्य चर

आप प्रिंटलाइन फ़ंक्शन के साथ एक चर के वर्तमान मूल्य को प्रिंट कर सकते हैं। निम्नलिखित उदाहरण से पता चलता है कि यह कैसे प्राप्त किया जा सकता है।

class Example { 
   static void main(String[] args) { 
      //Initializing 2 variables 
      int x = 5; 
      int X = 6; 
	  
      //Printing the value of the variables to the console 
      println("The value of x is " + x + "The value of X is " + X);  
   }
}

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

The value of x is 5 The value of X is 6

एक ऑपरेटर एक प्रतीक है जो संकलक को विशिष्ट गणितीय या तार्किक जोड़तोड़ करने के लिए कहता है।

ग्रूवी के पास निम्न प्रकार के ऑपरेटर हैं -

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

अंकगणितीय आपरेटर

Groovy भाषा किसी भी भाषा के रूप में सामान्य अंकगणितीय ऑपरेटरों का समर्थन करती है। ग्रोवी में उपलब्ध अंकगणितीय ऑपरेटर निम्नलिखित हैं -

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

ऑपरेटर	विवरण	उदाहरण
+	दो ऑपरेंड का जोड़	1 + 2 3 देगा
-	पहले से दूसरे ऑपरेंड को घटाता है	2 - 1 1 देगा
*	दोनों ऑपरेंड का गुणन	२ * २ देंगे ४
/	भाजक द्वारा अंश का विभाजन	3/2 1.5 देंगे
%	मापांक ऑपरेटर और एक पूर्णांक / फ्लोट डिवीजन के बाद शेष	3% 2 1 देगा
++	वृद्धिशील संचालक 1 से एक संचालक के मूल्य में वृद्धि करते थे	int x = 5; एक्स ++; x 6 देगा
-	वृद्धिशील संचालक एक संचालक के मान को 1 से घटाते थे	int x = 5; एक्स--; x 4 देगा

संबंधपरक संकारक

रिलेशनल ऑपरेटर वस्तुओं की तुलना की अनुमति देते हैं। ग्रोवी में उपलब्ध रिलेशनल ऑपरेटर निम्नलिखित हैं -

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

ऑपरेटर	विवरण	उदाहरण
==	दो वस्तुओं के बीच समानता का परीक्षण करता है	2 == 2 सत्य देगा
! =	दो वस्तुओं के बीच के अंतर को परखता है	३! = २ सत्य देगा
<	यह देखने के लिए जाँच करता है कि क्या बाईं ऑब्जेक्ट सही ऑपरेंड से कम है या नहीं।	2 <3 सच दे देंगे
<=	यह देखने के लिए जाँच करता है कि क्या बाएँ ऑब्जेक्ट सही ऑपरेंड से कम या बराबर हैं।	2 <= 3 सत्य देगा
>	यह देखने के लिए जाँच करता है कि क्या बाईं ऑब्जेक्ट सही ऑपरेंड से अधिक है या नहीं।	3> 2 सच देंगे
> =	यह देखने के लिए जाँच करता है कि क्या बाएं ऑब्जेक्ट सही ऑपरेंड से अधिक या बराबर है।	3> = 2 सत्य देगा

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

बूलियन एक्सप्रेशन का मूल्यांकन करने के लिए लॉजिकल ऑपरेटर्स का उपयोग किया जाता है। ग्रूवी में उपलब्ध तार्किक ऑपरेटर निम्नलिखित हैं -

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

ऑपरेटर	विवरण	उदाहरण
&&	यह तार्किक "और" ऑपरेटर है	true && सच सच देगा
\|\|	यह तार्किक "या" ऑपरेटर है	सच \|\| सच ही सच देगा
!	यह तार्किक "नहीं" ऑपरेटर है	असत्य सत्य देगा

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

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

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

अनु क्रमांक	ऑपरेटर और विवरण
1	& यह बिटवाइज़ “और” ऑपरेटर है
2	\| यह बिटवाइज़ “या” ऑपरेटर है
3	^ यह बिटवाइज़ “xor” या एक्सक्लूसिव या ऑपरेटर है
4	~ यह बिटवाइज़ नेगेटिव ऑपरेटर है

इन संचालकों को दिखाने के लिए यहाँ सत्य सारणी है।

पी	क्यू	पी क्यू	पी \| क्यू	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

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

ग्रूवी भाषा असाइनमेंट ऑपरेटर भी प्रदान करती है। ग्रोवी में उपलब्ध असाइनमेंट ऑपरेटर निम्नलिखित हैं -

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

ऑपरेटर	विवरण	उदाहरण
+ =	यह बाएं ऑपरेंड में दायां ऑपरेंड जोड़ता है और परिणाम को बाएं ऑपरेंड में असाइन करता है।	डी ए = 5 A + = 3 आउटपुट 8 होगा
- =	यह बाएं ऑपरेंड से दाएं ऑपरेंड को घटाता है और लेफ्ट ऑपरेंड को रिजल्ट सौंपता है	डी ए = 5 ए = 3 आउटपुट 2 होगा
* =	यह बाएं ऑपरेंड के साथ दाएं ऑपरेंड को गुणा करता है और बाएं ऑपरेंड को परिणाम प्रदान करता है	डी ए = 5 ए * = 3 आउटपुट 15 होगा
/ =	यह बाएं ऑपरेंड को दाएं ऑपरेंड के साथ विभाजित करता है और परिणाम को बाएं ऑपरेंड को सौंपता है	डी ए = 6 ए / = 3 आउटपुट 2 होगा
% =	यह दो ऑपरेंड का उपयोग करके मापांक लेता है और परिणाम को बाएं ऑपरेंड में असाइन करता है	डी ए = 5 एक% = 3 आउटपुट 2 होगा

रेंज ऑपरेटर्स

ग्रूवी पर्वतमाला की अवधारणा का समर्थन करता है और रेंज संचालकों को .. संकेतन की सहायता से एक संकेतन प्रदान करता है। रेंज ऑपरेटर का एक सरल उदाहरण नीचे दिया गया है।

def range = 0..5

यह सिर्फ एक साधारण श्रेणी के पूर्णांक को परिभाषित करता है, जिसे स्थानीय चर में श्रेणी में रखा जाता है जिसे 0 के निचले हिस्से और 5 के ऊपरी हिस्से के साथ रखा जाता है।

निम्नलिखित कोड स्निपेट दिखाता है कि विभिन्न ऑपरेटरों का उपयोग कैसे किया जा सकता है।

class Example { 
   static void main(String[] args) { 
      def range = 5..10; 
      println(range); 
      println(range.get(2)); 
   } 
}

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

वहाँ से println बयान, आप देख सकते हैं कि रेंज स्टेटमेंट में परिभाषित संख्याओं की पूरी श्रृंखला प्रदर्शित होती है।

प्राप्त कथन का उपयोग उस श्रेणी से एक वस्तु प्राप्त करने के लिए किया जाता है, जो एक इंडेक्स मान में पैरामीटर के रूप में लेता है।

[5, 6, 7, 8, 9, 10] 
7

संचालक वरीयता

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

अनु क्रमांक	संचालक और नाम
1	++ -- + - प्री इंक्रीमेंट / डिक्रीमेंट, यूनीरी प्लस, यूनरी माइनस
2	* / % गुणा, दिवि, मोदुलो
3	+ - इसके अलावा, घटाव
4	== != <=> बराबरी, बराबरी नहीं, तुलना
5	& बाइनरी / बिटवाइज़ और
6	^ बाइनरी / बिटवाइज़ एक्सर
7	\| बाइनरी / बिटवाइज़ या
8	&& तार्किक और
9	\|\| तार्किक या
10	= = = /= %= += -= <<= >>= >>>= &= ^= \|=* विभिन्न असाइनमेंट ऑपरेटर

अब तक, हमने ऐसे बयान देखे हैं जिन्हें क्रमबद्ध तरीके से एक के बाद एक निष्पादित किया गया है। इसके अतिरिक्त, एक कार्यक्रम के तर्क में नियंत्रण के प्रवाह को बदलने के लिए ग्रूवी में बयान दिए जाते हैं। फिर उन्हें नियंत्रण बयानों के प्रवाह में वर्गीकृत किया जाता है जिसे हम विस्तार से देखेंगे।

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

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

क्र.सं.	कथन और विवरण
1	ब्रेक स्टेटमेंट ब्रेक स्टेटमेंट का उपयोग लूप और स्विच स्टेटमेंट के अंदर नियंत्रण के प्रवाह को बदलने के लिए किया जाता है।
2	जारी बयान जारी बयान ब्रेक स्टेटमेंट को पूरक करता है। इसका उपयोग लूप के लिए और उसके बाद तक सीमित है।

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

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

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

एक विधि का सबसे सरल प्रकार कोई पैरामीटर नहीं है जैसा कि नीचे दिखाया गया है -

def methodName() { 
   //Method code 
}

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

class Example {
   static def DisplayName() {
      println("This is how methods work in groovy");
      println("This is an example of a simple method");
   } 
	
   static void main(String[] args) {
      DisplayName();
   } 
}

उपरोक्त उदाहरण में, DisplayName एक सरल विधि है जिसमें दो प्रिंटनल स्टेटमेंट होते हैं जो कंसोल में कुछ टेक्स्ट को आउटपुट करने के लिए उपयोग किए जाते हैं। हमारी स्थैतिक मुख्य विधि में, हम सिर्फ DisplayName विधि को बुला रहे हैं। उपरोक्त विधि का उत्पादन होगा -

This is how methods work in groovy 
This is an example of a simple method

विधि पैरामीटर्स

एक विधि अधिक सामान्यतः उपयोगी होती है यदि इसका व्यवहार एक या अधिक मापदंडों के मूल्य से निर्धारित होता है। हम मानों को विधि मापदंडों का उपयोग करके विधि में स्थानांतरित कर सकते हैं। ध्यान दें कि पैरामीटर नाम एक दूसरे से भिन्न होना चाहिए।

मापदंडों के साथ एक विधि का सबसे सरल प्रकार जैसा कि नीचे दिखाया गया है -

def methodName(parameter1, parameter2, parameter3) { 
   // Method code goes here 
}

निम्नलिखित मापदंडों के साथ सरल विधि का एक उदाहरण है

class Example {
   static void sum(int a,int b) {
      int c = a+b;
      println(c);
   }  
	
   static void main(String[] args) {
      sum(10,5);
   } 
}

इस उदाहरण में, हम 2 मापदंडों के साथ एक योग विधि बना रहे हैं, a तथा b। दोनों पैरामीटर प्रकार के हैंint। फिर हम अपने मुख्य विधि से योग विधि को बुला रहे हैं और मानों को चर तक पहुंचा रहे हैंa तथा b।

उपरोक्त विधि का उत्पादन मूल्य 15 होगा।

डिफ़ॉल्ट पैरामीटर

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

निम्नलिखित मापदंडों के साथ सरल विधि का एक उदाहरण है -

def someMethod(parameter1, parameter2 = 0, parameter3 = 0) { 
   // Method code goes here 
}

आइए उसी उदाहरण को देखें जिसे हमने पहले दो संख्याओं को जोड़ने के लिए देखा था और एक विधि बनाई जिसमें एक डिफ़ॉल्ट और दूसरा गैर-डिफ़ॉल्ट पैरामीटर है -

class Example { 
   static void sum(int a,int b = 5) { 
      int c = a+b; 
      println(c); 
   } 
	
   static void main(String[] args) {
      sum(6); 
   } 
}

इस उदाहरण में, हम दो मापदंडों के साथ एक योग विधि बना रहे हैं, a तथा b। दोनों पैरामीटर टाइप इंट के हैं। इस उदाहरण और पिछले उदाहरण के बीच अंतर यह है कि इस मामले में हम एक डिफ़ॉल्ट मान निर्दिष्ट कर रहे हैंb जैसा कि 5. इसलिए जब हम अपने मुख्य विधि से योग विधि कहते हैं, तो हमारे पास केवल एक मान पास करने का विकल्प होता है जो 6 है और इसे पैरामीटर को सौंपा जाएगा a के अंदर sum तरीका।

उपरोक्त विधि का आउटपुट मान 11 होगा।

class Example {
   static void sum(int a,int b = 5) {
      int c = a+b;
      println(c);
   } 
	
   static void main(String[] args) {
      sum(6,6);
   } 
}

हम 2 मानों को पास करके योग विधि भी कह सकते हैं, ऊपर हमारे उदाहरण में हम 6 के 2 मान दे रहे हैं। 6 का दूसरा मान वास्तव में डिफ़ॉल्ट मान को प्रतिस्थापित करेगा जो पैरामीटर को सौंपा गया है b।

उपरोक्त विधि का आउटपुट मान 12 होगा।

विधि वापसी मान

तरीके कॉलिंग प्रोग्राम पर वापस मान भी लौटा सकते हैं। आधुनिक समय की प्रोग्रामिंग भाषा में इसकी आवश्यकता होती है जिसमें कोई विधि किसी प्रकार की संगणना करती है और फिर कॉलिंग विधि के लिए वांछित मान लौटाती है।

निम्नलिखित वापसी मूल्य के साथ सरल विधि का एक उदाहरण है।

class Example {
   static int sum(int a,int b = 5) {
      int c = a+b;
      return c;
   } 
	
   static void main(String[] args) {
      println(sum(6));
   } 
}

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

उपरोक्त विधि का आउटपुट मान 11 होगा।

उदाहरण के तरीके

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

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

निम्नलिखित इस बात का उदाहरण है कि कैसे तरीकों को लागू किया जा सकता है।

class Example { 
   int x; 
	
   public int getX() { 
      return x; 
   } 
	
   public void setX(int pX) { 
      x = pX; 
   } 
	
   static void main(String[] args) { 
      Example ex = new Example(); 
      ex.setX(100); 
      println(ex.getX()); 
   } 
}

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

उपरोक्त विधि का आउटपुट मान 100 होगा।

स्थानीय और बाहरी पैरामीटर नाम

ग्रोवी स्थानीय और वैश्विक मापदंडों के लिए जावा की तरह ही सुविधा प्रदान करता है। निम्नलिखित उदाहरण में,lx एक स्थानीय पैरामीटर है जिसमें केवल कार्य के दायरे में एक गुंजाइश है getX() तथा xएक वैश्विक संपत्ति है जिसे पूरे उदाहरण वर्ग के अंदर पहुँचा जा सकता है। अगर हम वैरिएबल को एक्सेस करने की कोशिश करते हैंlx के बाहर getX() फ़ंक्शन, हमें एक त्रुटि मिलेगी।

class Example { 
   static int x = 100; 
	
   public static int getX() { 
      int lx = 200; 
      println(lx); 
      return x; 
   } 
	
   static void main(String[] args) { 
      println(getX()); 
   }  
}

जब हम उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलेंगे।

200 
100

गुण के लिए यह विधि

जावा की तरह, ग्रूवी अपने उदाहरण के सदस्यों तक पहुँच का उपयोग कर सकता है thisकीवर्ड। निम्नलिखित उदाहरण से पता चलता है कि जब हम बयान का उपयोग करते हैंthis.x, यह अपने उदाहरण को संदर्भित करता है और के मूल्य को निर्धारित करता है x तदनुसार।

class Example { 
   int x = 100; 
	
   public int getX() { 
      this.x = 200; 
      return x; 
   } 
	
   static void main(String[] args) {
      Example ex = new Example(); 
      println(ex.getX());
   }
}

जब हम उपरोक्त कार्यक्रम चलाते हैं, तो हमें कंसोल पर मुद्रित 200 का परिणाम मिलेगा।

ग्रूवी आई / ओ के साथ काम करते समय कई सहायक तरीके प्रदान करता है। ग्रूवी फाइलों के लिए निम्नलिखित कार्य करने के लिए आसान कक्षाएं प्रदान करता है।

फाइलें पढ़ना
फाइलों में लिखना
फ़ाइल पेड़ों की कटाई
फ़ाइलों को डेटा ऑब्जेक्ट पढ़ना और लिखना

इसके अतिरिक्त, आप हमेशा फ़ाइल I / O संचालन के लिए नीचे सूचीबद्ध सामान्य जावा कक्षाओं का उपयोग कर सकते हैं।

java.io.File
java.io.InputStream
java.io.OutputStream
java.io.Reader
java.io.Writer

फाइलें पढ़ना

निम्न उदाहरण ग्रूवी में एक पाठ फ़ाइल की सभी पंक्तियों को आउटपुट करेगा। प्रक्रियाeachLine पाठ फ़ाइल की प्रत्येक पंक्ति को पढ़ने के लिए सुनिश्चित करने के उद्देश्य से ग्रूवी में फ़ाइल वर्ग में बनाया गया है।

import java.io.File 
class Example { 
   static void main(String[] args) { 
      new File("E:/Example.txt").eachLine {  
         line -> println "line : $line"; 
      } 
   } 
}

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

यदि फ़ाइल में निम्न पंक्तियाँ हैं, तो उन्हें मुद्रित किया जाएगा।

line : Example1
line : Example2

एक फ़ाइल की सामग्री को एक स्ट्रिंग स्ट्रिंग के रूप में पढ़ना

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

class Example { 
   static void main(String[] args) { 
      File file = new File("E:/Example.txt") 
      println file.text 
   } 
}

यदि फ़ाइल में निम्न पंक्तियाँ हैं, तो उन्हें मुद्रित किया जाएगा।

line : Example1 
line : Example2

फ़ाइलों को लेखन

यदि आप फ़ाइलों को लिखना चाहते हैं, तो आपको एक फ़ाइल में पाठ को आउटपुट करने के लिए लेखक वर्ग का उपयोग करने की आवश्यकता है। निम्न उदाहरण दिखाता है कि यह कैसे किया जा सकता है।

import java.io.File 
class Example { 
   static void main(String[] args) { 
      new File('E:/','Example.txt').withWriter('utf-8') { 
         writer -> writer.writeLine 'Hello World' 
      }  
   } 
}

यदि आप फ़ाइल का उदाहरण खोलते हैं। उदाहरण के लिए, आप फ़ाइल में मुद्रित शब्द "हैलो वर्ल्ड" देखेंगे।

किसी फ़ाइल का आकार प्राप्त करना

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

class Example {
   static void main(String[] args) {
      File file = new File("E:/Example.txt")
      println "The file ${file.absolutePath} has ${file.length()} bytes"
   } 
}

उपरोक्त कोड बाइट्स में फ़ाइल का आकार दिखाएगा।

एक फ़ाइल एक निर्देशिका है अगर परीक्षण

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

class Example { 
   static void main(String[] args) { 
      def file = new File('E:/') 
      println "File? ${file.isFile()}" 
      println "Directory? ${file.isDirectory()}" 
   } 
}

उपरोक्त कोड निम्न आउटपुट दिखाएगा -

File? false 
Directory? True

एक निर्देशिका बनाना

यदि आप एक नई निर्देशिका बनाना चाहते हैं, तो आप इसका उपयोग कर सकते हैं mkdirफ़ाइल वर्ग का कार्य। निम्न उदाहरण दिखाता है कि यह कैसे किया जा सकता है।

class Example {
   static void main(String[] args) {
      def file = new File('E:/Directory')
      file.mkdir()
   } 
}

यदि यह मौजूद नहीं है, तो निर्देशिका E: \ Directory बनाई जाएगी।

फ़ाइल हटाना

यदि आप किसी फ़ाइल को हटाना चाहते हैं तो आप फ़ाइल वर्ग के डिलीट फ़ंक्शन का उपयोग कर सकते हैं। निम्न उदाहरण दिखाता है कि यह कैसे किया जा सकता है।

class Example {
   static void main(String[] args) {
      def file = new File('E:/Example.txt')
      file.delete()
   } 
}

मौजूद होने पर फ़ाइल को हटा दिया जाएगा।

फ़ाइलों की प्रतिलिपि बनाना

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

class Example {
   static void main(String[] args) {
      def src = new File("E:/Example.txt")
      def dst = new File("E:/Example1.txt")
      dst << src.text
   } 
}

File1.txt फ़ाइल बनाई जाएगी और File.txt की सभी सामग्री इस फ़ाइल में कॉपी की जाएगी।

निर्देशिका सामग्री हो रही है

ग्रूवी ड्राइव में ड्राइव और फाइलों को सूचीबद्ध करने के लिए कार्यक्षमता प्रदान करता है।

निम्न उदाहरण दिखाता है कि किसी मशीन पर ड्राइव का उपयोग करके कैसे प्रदर्शित किया जा सकता है listRoots फ़ाइल वर्ग का कार्य।

class Example { 
   static void main(String[] args) { 
      def rootFiles = new File("test").listRoots() 
      rootFiles.each { 
         file -> println file.absolutePath 
      }
   }
}

आपकी मशीन पर उपलब्ध ड्राइव के आधार पर, आउटपुट अलग-अलग हो सकता है। एक मानक मशीन पर आउटपुट निम्नलिखित के समान होगा -

C:\ 
D:\

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

class Example {
   static void main(String[] args) {
      new File("E:/Temp").eachFile() {  
         file->println file.getAbsolutePath()
      }
   } 
}

आउटपुट निर्देशिका E: \ Temp में सभी फ़ाइलों को प्रदर्शित करेगा

यदि आप किसी निर्देशिका और उसकी उपनिर्देशिका में सभी फ़ाइलों को पुन: प्रदर्शित करना चाहते हैं, तो आप इसका उपयोग करेंगे eachFileRecurseफ़ाइल वर्ग का कार्य। निम्न उदाहरण दिखाता है कि यह कैसे किया जा सकता है।

class Example { 
   static void main(String[] args) {
      new File("E:/temp").eachFileRecurse() {
         file -> println file.getAbsolutePath()
      }
   }
}

आउटपुट निर्देशिका E: \ Temp और इसके उपनिर्देशिकाओं में मौजूद होने पर सभी फाइलों को प्रदर्शित करेगा।

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

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

ग्रूवी में, 'डीफ़' कीवर्ड के माध्यम से वैकल्पिक टाइपिंग की जाती है। निम्नलिखित के उपयोग का एक उदाहरण हैdef विधि -

class Example { 
   static void main(String[] args) { 
      // Example of an Integer using def 
      def a = 100; 
      println(a); 
		
      // Example of an float using def 
      def b = 100.10; 
      println(b); 
		
      // Example of an Double using def 
      def c = 100.101; 
      println(c);
		
      // Example of an String using def 
      def d = "HelloWorld"; 
      println(d); 
   } 
}

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

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

100 
100.10 
100.101
HelloWorld

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

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

यदि हम डक टाइपिंग का उपयोग करके उपरोक्त कोड को फिर से लिखते हैं, तो यह नीचे दिए गए एक जैसा दिखेगा। चर नामों को ऐसे नाम दिए गए हैं जो अधिक बार मिलते-जुलते हैं न कि वे जिस प्रकार का प्रतिनिधित्व करते हैं जो कोड को अधिक समझने योग्य बनाता है।

class Example { 
   static void main(String[] args) { 
      // Example of an Integer using def 
      def aint = 100; 
      println(aint); 
		
      // Example of an float using def 
      def bfloat = 100.10; 
      println(bfloat); 
		
      // Example of an Double using def 
      def cDouble = 100.101; 
      println(cDouble);
		
      // Example of an String using def 
      def dString = "HelloWorld"; 
      println(dString); 
   } 
}

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

ग्रूवी पूर्णांक और फ्लोटिंग पॉइंट नंबरों का समर्थन करता है।

पूर्णांक एक मान है जिसमें एक अंश शामिल नहीं है।
फ़्लोटिंग-पॉइंट संख्या एक दशमलव मान है जिसमें दशमलव अंश शामिल होता है।

Groovy में संख्याओं का एक उदाहरण नीचे दिखाया गया है -

Integer x = 5; 
Float y = 1.25;

कहाँ पे x इंटेगर का प्रकार है और y फ्लोट है।

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

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

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

उदाहरण

निम्नलिखित बॉक्सिंग और अनबॉक्सिंग का एक उदाहरण है -

class Example { 
   static void main(String[] args) {
      Integer x = 5,y = 10,z = 0; 
		
      // The the values of 5,10 and 0 are boxed into Integer types 
      // The values of x and y are unboxed and the addition is performed 
      z = x+y; 
      println(z);
   }
}

उपरोक्त कार्यक्रम का आउटपुट 15. होगा। उपरोक्त उदाहरण में, 5, 10 और 0 के मानों को पहले इंटेगर चर x, y और z के अनुसार बॉक्स किया गया है। और फिर जब x और y के जोड़ को प्रदर्शित किया जाता है तो मान उनके पूर्णांक प्रकारों से अनबॉक्स किए जाते हैं।

संख्या विधियाँ

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

क्र.सं.	तरीके और विवरण
1	xxxValue () यह विधि पैरामीटर के रूप में संख्या पर ले जाती है और जिस विधि को लागू किया जाता है, उसके आधार पर एक आदिम प्रकार देता है।
2	से तुलना() तुलना विधि दूसरे के विरुद्ध एक संख्या का उपयोग करने के लिए है। यदि आप संख्याओं के मूल्य की तुलना करना चाहते हैं तो यह उपयोगी है।
3	के बराबर होती है () विधि यह निर्धारित करती है कि संख्या ऑब्जेक्ट जो विधि को लागू करती है वह उस ऑब्जेक्ट के बराबर है जिसे तर्क के रूप में पारित किया गया है।
4	का मूल्य() मान मान विधि पास किए गए तर्क का मान रखते हुए प्रासंगिक संख्या ऑब्जेक्ट लौटाता है।
5	तार() नंबर ऑब्जेक्ट के मान का प्रतिनिधित्व करने वाली स्ट्रिंग ऑब्जेक्ट को प्राप्त करने के लिए विधि का उपयोग किया जाता है।
6	parseInt () इस पद्धति का उपयोग एक निश्चित स्ट्रिंग के आदिम डेटा प्रकार को प्राप्त करने के लिए किया जाता है। parseXxx () एक स्थिर विधि है और इसमें एक या दो तर्क हो सकते हैं।
7	पेट () विधि तर्क का पूर्ण मूल्य देती है। तर्क इंट, फ्लोट, लॉन्ग, डबल, शॉर्ट, बाइट हो सकता है।
8	प्लस्तर लगाना () विधि छत छोटे पूर्णांक देता है जो तर्क से अधिक या बराबर होता है।
9	मंज़िल() विधि तल सबसे बड़ा पूर्णांक देता है जो तर्क से कम या बराबर है।
10	प्रिंट करें () विधि rint पूर्णांक को तर्क के लिए निकटतम मान देता है।
1 1	गोल() विधि राउंड निकटतम लंबा या इंट रिटर्न देता है, जैसा कि विधियों रिटर्न प्रकार द्वारा दिया गया है।
12	मिनट () विधि दो तर्कों का छोटा देती है। तर्क इंट, फ्लोट, लॉन्ग, डबल हो सकता है।
13	अधिकतम () विधि अधिकतम दो तर्क देती है। तर्क इंट, फ्लोट, लॉन्ग, डबल हो सकता है।
14	exp () विधि तर्क की शक्ति के लिए प्राकृतिक लघुगणक, ई का आधार लौटाती है।
15	लॉग () विधि तर्क का प्राकृतिक लघुगणक लौटाती है।
16	पॉव () विधि दूसरे तर्क की शक्ति के लिए उठाए गए पहले तर्क का मूल्य लौटाती है।
17	sqrt () विधि तर्क के वर्गमूल को वापस करती है।
18	पाप () विधि निर्दिष्ट डबल मान की साइन लौटाती है।
19	क्योंकि () विधि निर्दिष्ट दोहरे मान का कोसिन लौटाती है।
20	तन () विधि निर्दिष्ट दोहरे मान की स्पर्शरेखा लौटाती है।
21	जैसे की() विधि निर्दिष्ट दोहरे मान की आर्सेन लौटाती है।
22	acos () विधि निर्दिष्ट डबल मान के arccosine देता है।
23	एक भूरा() यह विधि निर्दिष्ट दोहरे मान के अभिजात वर्ग को लौटाती है।
24	atan2 () आयताकार निर्देशांक (x, y) को ध्रुवीय समन्वय (r, थीटा) में परिवर्तित करता है और थीटा को लौटाता है।
25	toDegrees () विधि तर्क मान को डिग्री में परिवर्तित करती है।
26	रेडियन () विधि तर्क मान को रेडियंस में परिवर्तित करती है।
27	यादृच्छिक () विधि का उपयोग 0.0 और 1.0 के बीच एक यादृच्छिक संख्या उत्पन्न करने के लिए किया जाता है। रेंज है: 0.0 = <Math.random <1.0। अंकगणित का उपयोग करके विभिन्न श्रेणियों को प्राप्त किया जा सकता है।

ग्रूवी में स्ट्रिंग टेक्स्ट को संलग्न करके स्ट्रिंग स्ट्रिंग का निर्माण किया जाता है।

ग्रोवी एक स्ट्रिंग शाब्दिक को निरूपित करने के लिए विभिन्न प्रकार प्रदान करता है। ग्रूवी में स्ट्रिंग्स को एकल उद्धरण ('), डबल कोट्स ("), या ट्रिपल कोट्स (" "") में संलग्न किया जा सकता है। इसके अलावा, ट्रिपल कोट द्वारा संलग्न एक ग्रूवी स्ट्रिंग कई पंक्तियों को फैला सकता है।

निम्नलिखित Groovy में तार के उपयोग का एक उदाहरण है -

class Example { 
   static void main(String[] args) { 
      String a = 'Hello Single'; 
      String b = "Hello Double"; 
      String c = "'Hello Triple" + "Multiple lines'";
		
      println(a); 
      println(b); 
      println(c); 
   } 
}

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

Hello Single 
Hello Double 
'Hello TripleMultiple lines'

स्ट्रिंग अनुक्रमण

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

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

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

class Example { 
   static void main(String[] args) { 
      String sample = "Hello world"; 
      println(sample[4]); // Print the 5 character in the string
		
      //Print the 1st character in the string starting from the back 
      println(sample[-1]); 
      println(sample[1..2]);//Prints a string starting from Index 1 to 2 
      println(sample[4..2]);//Prints a string starting from Index 4 back to 2 
      
   } 
}

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

o 
d 
el 
oll

बुनियादी स्ट्रिंग संचालन

पहले चलिए सीखते हैं बुनियादी स्ट्रिंग ऑपरेशन ग्रूवी में। उन्हें नीचे दिया गया है।

क्र.सं.	स्ट्रिंग ऑपरेशन और विवरण
1	दो तारों का संघात स्ट्रिंग्स का संयोजन सरल '+' ऑपरेटर द्वारा किया जा सकता है।
2	स्ट्रिंग दोहराव स्ट्रिंग्स की पुनरावृत्ति सरल '*' ऑपरेटर द्वारा की जा सकती है।
3	स्ट्रिंग लंबाई स्ट्रिंग की लंबाई () विधि द्वारा निर्धारित स्ट्रिंग की लंबाई।

स्ट्रिंग के तरीके

यहां स्ट्रिंग क्लास द्वारा समर्थित विधियों की सूची दी गई है।

क्र.सं.	तरीके और विवरण
1	केंद्र () अंतरिक्ष वर्णों के साथ बाईं और दाईं ओर गद्देदार प्राप्तकर्ता की लंबाई के एक नए स्ट्रिंग की वापसी करता है।
2	compareToIgnoreCase () मामले के अंतर को नजरअंदाज करते हुए, दो तारों की तुलनात्मक रूप से करें।
3	concat () इस स्ट्रिंग के अंत तक निर्दिष्ट स्ट्रिंग का संदर्भ देता है।
4	eachMatch () प्रत्येक रेगेक्स समूह को संसाधित करता है (अगला भाग देखें) दिए गए स्ट्रिंग के मिलान से मेल खाता है।
5	इसी के साथ समाप्त होता है() टेस्ट कि क्या यह स्ट्रिंग निर्दिष्ट प्रत्यय के साथ समाप्त होती है।
6	equalsIgnoreCase () इस स्ट्रिंग की तुलना किसी अन्य स्ट्रिंग से करते हैं, मामले के विचारों की अनदेखी करते हुए।
7	getAt () यह इंडेक्स स्थिति में स्ट्रिंग मान लौटाता है
8	के सूचकांक() निर्दिष्ट विकल्प की पहली घटना के इस स्ट्रिंग के भीतर सूचकांक लौटाता है।
9	मैचों () यह आउटपुट करता है कि एक स्ट्रिंग दी गई नियमित अभिव्यक्ति से मेल खाती है या नहीं।
10	शून्य से () स्ट्रिंग के मान भाग को निकालता है।
1 1	आगे() इस पद्धति को क्लास स्ट्रिंग के लिए ++ ऑपरेटर द्वारा बुलाया जाता है। यह दिए गए स्ट्रिंग में अंतिम चरित्र को बढ़ाता है।
12	padLeft () पैड स्ट्रिंग के साथ बाईं ओर संलग्न रिक्त स्थान के साथ।
13	padRight () पैड स्ट्रिंग के साथ दायीं ओर संलग्न है।
14	प्लस () एक स्ट्रिंग जोड़ता है
15	पिछला() इस विधि को - CharSequence के ऑपरेटर द्वारा कहा जाता है।
16	सबको बदली करें() कैप्चर किए गए समूह की सभी घटनाओं को उस पाठ पर बंद करने के परिणामस्वरूप बदल देता है।
17	उलटना() एक नया स्ट्रिंग बनाता है जो इस स्ट्रिंग का उल्टा है।
18	विभाजित करें() इस स्ट्रिंग को दिए गए नियमित अभिव्यक्ति के मैचों के आसपास विभाजित करता है।
19	सबस्ट्रिंग () एक नया स्ट्रिंग लौटाता है जो इस स्ट्रिंग का एक विकल्प है।
20	toUpperCase () इस स्ट्रिंग के सभी पात्रों को ऊपरी मामले में रूपांतरित करता है।
21	toLowerCase () इस स्ट्रिंग के सभी वर्णों को निम्न स्थिति में परिवर्तित करता है।

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

1..10 - एक समावेशी रेंज का एक उदाहरण
1 .. <10 - एक विशेष रेंज का एक उदाहरण है
'a' .. 'x' - रेंज में वर्ण भी हो सकते हैं
10..1 - रंग भी अवरोही क्रम में हो सकते हैं
'x' .. 'a' - रंग भी वर्णों से मिलकर और अवरोही क्रम में हो सकते हैं।

निम्नलिखित विभिन्न रेंज के लिए उपलब्ध तरीके हैं।

अनु क्रमांक।	तरीके और विवरण
1	शामिल () जाँचता है कि क्या किसी श्रेणी में एक विशिष्ट मान है
2	प्राप्त() इस श्रेणी में निर्दिष्ट स्थान पर तत्व देता है।
3	से मिलता है() इस श्रेणी का निम्न मान प्राप्त करें।
4	शुरू करना() इस रेंज का ऊपरी मूल्य प्राप्त करें।
5	isReverse () क्या यह उलटी सीमा है, पीछे की ओर चलना
6	आकार () इस श्रेणी में तत्वों की संख्या लौटाता है।
7	subList () निर्दिष्ट IndIndex, समावेशी, और tondex, अनन्य के बीच इस श्रेणी के भाग का एक दृश्य देता है

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

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

सूचियों के कुछ उदाहरण निम्नलिखित हैं -

[११, १२, १३, १४] - पूर्णांक मूल्यों की सूची
['कोणीय', 'ग्रूवी', 'जावा'] - स्ट्रिंग्स की एक सूची
[१, २, [३, ४], ५] - एक नेस्टेड सूची
['ग्रूवी', 21, 2.11] - वस्तु संदर्भों की एक विषम सूची
[] - एक खाली सूची

इस अध्याय में, हम ग्रूवी में उपलब्ध सूची विधियों पर चर्चा करेंगे।

अनु क्रमांक।	तरीके और विवरण
1	(जोड़ें) इस सूची के अंत में नया मान जोड़ें।
2	शामिल () यदि यह सूची में निर्दिष्ट मान है तो यह सही है।
3	प्राप्त() इस सूची में निर्दिष्ट स्थान पर तत्व देता है।
4	खाली है() यदि यह सूची में कोई तत्व नहीं है, तो यह सही है
5	शून्य से () संग्रह में निर्दिष्ट किए बिना मूल के तत्वों से बना एक नई सूची बनाता है।
6	प्लस () संग्रह में निर्दिष्ट लोगों के साथ मूल के तत्वों से बना एक नई सूची बनाता है।
7	पॉप() इस सूची से अंतिम आइटम निकालता है
8	हटाना() इस सूची में निर्दिष्ट स्थान पर तत्व को हटाता है।
9	उलटना() एक नई सूची बनाएँ जो मूल सूची के तत्वों को उलट दे
10	आकार () इस सूची में तत्वों की संख्या प्राप्त करता है।
1 1	प्रकार () मूल सूची की एक हल की गई प्रति लौटाता है।

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

मानचित्रों के कुछ उदाहरण निम्नलिखित हैं -

['TopicName': 'Lists', 'TopicName': 'Maps'] - मुख्य मूल्य युग्मों का संग्रह जिसमें प्रमुख और उनके संबंधित मान के रूप में TopicName है।
[:] - एक खाली नक्शा।

इस अध्याय में, हम ग्रूवी में उपलब्ध मानचित्र विधियों पर चर्चा करेंगे।

अनु क्रमांक।	तरीके और विवरण
1	containsKey () क्या इस नक्शे में यह कुंजी है?
2	प्राप्त() इस मानचित्र में कुंजी देखें और संबंधित मान लौटाएं। यदि कुंजी के लिए इस मानचित्र में कोई प्रविष्टि नहीं है, तो वापस लौटें।
3	चाबीगुछा() इस मानचित्र में कुंजियों का एक सेट प्राप्त करें।
4	डाल() इस मानचित्र में निर्दिष्ट कुंजी के साथ निर्दिष्ट मान संबद्ध करता है। यदि इस मानचित्र में पहले इस कुंजी के लिए मैपिंग शामिल है, तो पुराने मान को निर्दिष्ट मान से बदल दिया जाता है।
5	आकार () इस मैप में की-वैल्यू मैपिंग की संख्या लौटाता है।
6	मूल्यों () इस मानचित्र में निहित मूल्यों का एक संग्रह दृश्य लौटाता है।

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

दिनांक()

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

public Date()

Parameters - कोई नहीं।

Return Value

दिनांक ऑब्जेक्ट आवंटित करता है और इसे प्रारंभ करता है ताकि यह उस समय का प्रतिनिधित्व करता है जिस पर इसे आवंटित किया गया था, निकटतम मिलीसेकंड के लिए मापा गया था।

उदाहरण

निम्नलिखित इस विधि के उपयोग का एक उदाहरण है -

class Example { 
   static void main(String[] args) { 
      Date date = new Date(); 
      
      // display time and date using toString() 
      System.out.println(date.toString()); 
   } 
}

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

Thu Dec 10 21:31:15 GST 2015

दिनांक (लंबी मिलीसेक)

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

public Date(long millisec)

Parameters

मिलिसेक - मानक आधार समय के बाद से निर्दिष्ट करने के लिए मिलीसेकंड की संख्या।

Return Value - आवंटित करता है a Date 1 जनवरी, 1970, 00:00:00 GMT अर्थात् मानक आधार समय के बाद से मिलीसेकंड की निर्दिष्ट संख्या का प्रतिनिधित्व करने के लिए ऑब्जेक्ट और इसे इनिशियलाइज़ करता है।

उदाहरण

निम्नलिखित इस विधि के उपयोग का एक उदाहरण है -

class Example {
   static void main(String[] args) {
      Date date = new Date(100);
      
      // display time and date using toString()
      System.out.println(date.toString());
   } 
}

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

Thu Jan 01 04:00:00 GST 1970

दिनांक वर्ग के दिए गए तरीके निम्नलिखित हैं। कक्षा तिथि के सभी तरीकों में जो वर्ष, माह, तिथि, घंटे, मिनट और सेकंड मान को स्वीकार या वापस करते हैं, निम्नलिखित प्रतिनिधित्व उपयोग किए जाते हैं -

एक वर्ष y को पूर्णांक y - 1900 द्वारा दर्शाया जाता है।
एक महीने को 0 से 11 तक पूर्णांक द्वारा दर्शाया जाता है; 0 जनवरी है, 1 फरवरी है, और आगे है; इस प्रकार 11 दिसंबर है।
एक तारीख (महीने का दिन) एक पूर्णांक द्वारा सामान्य तरीके से 1 से 31 तक दर्शाया जाता है।
एक घंटे को एक पूर्णांक द्वारा 0 से 23 तक दर्शाया जाता है। इस प्रकार, आधी रात से 1 बजे तक का घंटा 0 होता है, और दोपहर से 1 बजे का समय 12 घंटे का होता है।
एक मिनट को सामान्य तरीके से 0 से 59 तक पूर्णांक द्वारा दर्शाया जाता है।
एक दूसरे को पूर्णांक से 0 से 61 तक दर्शाया जाता है।

अनु क्रमांक।	तरीके और विवरण
1	उपरांत() यदि यह तिथि निर्दिष्ट तिथि के बाद है तो टेस्ट करें।
2	के बराबर होती है () समानता के लिए दो तिथियों की तुलना करता है। परिणाम सत्य है अगर और केवल अगर तर्क शून्य नहीं है और एक दिनांक ऑब्जेक्ट है जो समय में एक ही बिंदु का प्रतिनिधित्व करता है, इस ऑब्जेक्ट के रूप में मिलीसेकंड तक।
3	से तुलना() ऑर्डर करने के लिए दो तिथियों की तुलना करता है।
4	तार() इस दिनांक ऑब्जेक्ट को स्ट्रिंग में कनवर्ट करता है
5	इससे पहले() यदि यह तिथि निर्दिष्ट तिथि से पहले है तो टेस्ट करें।
6	समय निकालो() 1 जनवरी 1970 के बाद से मिलीसेकंड की संख्या लौटाता है, 00:00:00 GMT इस दिनांक ऑब्जेक्ट द्वारा दर्शाया गया है।
7	निर्धारित समय() 1 जनवरी, 1970 00:00:00 GMT के बाद के समय में एक बिंदु का प्रतिनिधित्व करने के लिए इस दिनांक ऑब्जेक्ट को सेट करता है।

एक नियमित अभिव्यक्ति एक ऐसा पैटर्न है जिसका उपयोग टेक्स्ट में सबस्ट्रिंग खोजने के लिए किया जाता है। ग्रूवी नियमित रूप से ~ "रेगेक्स" अभिव्यक्ति का उपयोग करते हुए मूल भावों का समर्थन करता है। उद्धरणों के भीतर संलग्न पाठ तुलना के लिए अभिव्यक्ति का प्रतिनिधित्व करता है।

उदाहरण के लिए हम एक नियमित अभिव्यक्ति ऑब्जेक्ट बना सकते हैं जैसा कि नीचे दिखाया गया है -

def regex = ~'Groovy'

जब ग्रूवी ऑपरेटर = ~ एक विधेय (बूलियन को लौटाने वाली अभिव्यक्ति) के रूप में प्रकट होता है if तथा whileकथन (अध्याय 8 देखें), बाईं ओर स्ट्रिंग ऑपरेंड को दाईं ओर नियमित अभिव्यक्ति ऑपरेंड के साथ मिलान किया गया है। इसलिए, निम्न में से प्रत्येक मूल्य को सही बताता है।

नियमित अभिव्यक्ति को परिभाषित करते समय, निम्नलिखित विशेष वर्णों का उपयोग किया जा सकता है -

दो विशेष स्थितीय वर्ण हैं जिनका उपयोग किसी पंक्ति की शुरुआत और अंत: कैरट (∧) और डॉलर चिह्न ($) को दर्शाने के लिए किया जाता है।
नियमित अभिव्यक्तियों में क्वांटिफायर भी शामिल हो सकते हैं। प्लस चिह्न (+) एक या अधिक बार दर्शाता है, जो अभिव्यक्ति के पूर्ववर्ती तत्व पर लागू होता है। तारांकन (*) का उपयोग शून्य या अधिक घटनाओं का प्रतिनिधित्व करने के लिए किया जाता है। प्रश्न चिह्न (?) शून्य या एक बार दर्शाता है।
मेटाचैकर {और} का उपयोग पूर्ववर्ती वर्ण के उदाहरणों की एक विशिष्ट संख्या से मेल खाने के लिए किया जाता है।
एक नियमित अभिव्यक्ति में, अवधि प्रतीक (।) किसी भी चरित्र का प्रतिनिधित्व कर सकता है। इसे वाइल्डकार्ड वर्ण के रूप में वर्णित किया गया है।
एक नियमित अभिव्यक्ति में चरित्र वर्ग शामिल हो सकते हैं। चरित्रों के एक सेट को मेटाचेकर्स [और] के रूप में [aeiou] में वर्णित पात्रों के एक सरल अनुक्रम के रूप में दिया जा सकता है। अक्षर या संख्या सीमाओं के लिए, आप [a-z] या [a-mA-M] के रूप में डैश विभाजक का उपयोग कर सकते हैं। वर्ण वर्ग के पूरक को वर्ग रैकेट के भीतर एक प्रमुख कार्यवाहक के रूप में दर्शाया गया है, जैसा कि []a-z] और निर्दिष्ट वर्णों के अलावा सभी वर्णों का प्रतिनिधित्व करता है। नियमित अभिव्यक्तियों के कुछ उदाहरण नीचे दिए गए हैं

'Groovy' =~ 'Groovy' 
'Groovy' =~ 'oo' 
'Groovy' ==~ 'Groovy' 
'Groovy' ==~ 'oo' 
'Groovy' =~ '∧G' 
‘Groovy' =~ 'G$' 
‘Groovy' =~ 'Gro*vy' 'Groovy' =~ 'Gro{2}vy'

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

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

अपवादों को मोटे तौर पर निम्नलिखित श्रेणियों में वर्गीकृत किया जाता है -

Checked Exception - रनटाइम एक्सेप्शन और एरर को छोड़कर थ्रोबेबल क्लास को विस्तारित करने वाली कक्षाओं को चेक किए गए अपवादों के रूप में जाना जाता है। उदाहरण के लिए, SQLException आदि चेक किए गए अपवादों को संकलन-समय पर जांचा जाता है।

एक शास्त्रीय मामला FileNotFoundException है। मान लीजिए कि आपके पास निम्नलिखित कोड है जो आपके एप्लिकेशन को ई ड्राइव में एक फ़ाइल से पढ़ता है।

class Example {
   static void main(String[] args) {
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file);
   } 
}

यदि E ड्राइव में फ़ाइल (file.txt) नहीं है, तो निम्न अपवाद उठाया जाएगा।

पकड़ा गया: java.io.FileNotFoundException: E: \ file.txt (सिस्टम निर्दिष्ट फ़ाइल नहीं ढूँढ सकता)।

java.io.FileNotFoundException: E: \ file.txt (सिस्टम निर्दिष्ट फ़ाइल नहीं ढूँढ सकता)।

Unchecked Exception - RuntimeException का विस्तार करने वाले वर्गों को अनियंत्रित अपवाद के रूप में जाना जाता है, उदाहरण के लिए, ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException आदि। अनियंत्रित अपवादों को संकलन-समय पर चेक नहीं किया जाता है, बल्कि उन्हें रनटाइम पर चेक किया जाता है।

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

class Example {
   static void main(String[] args) {
      def arr = new int[3];
      arr[5] = 5;
   } 
}

जब उपरोक्त कोड निष्पादित किया जाता है तो निम्न अपवाद उठाया जाएगा।

पकड़ा गया: java.lang.ArrayIndexOutOfBoundsException: 5

java.lang.ArrayIndexOutOfBoundsException: 5

Error - त्रुटि अपरिवर्तनीय है जैसे OutOfMemoryError, VirtualMachineError, AssertionError आदि।

ये वे त्रुटियां हैं जिनसे प्रोग्राम कभी उबर नहीं सकता है और इससे प्रोग्राम क्रैश हो जाएगा।

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

पकड़ने के अपवाद

एक विधि एक संयोजन का उपयोग करके एक अपवाद को पकड़ती है try तथा catchकीवर्ड। कोड के आसपास एक कोशिश / कैच ब्लॉक रखा गया है जो एक अपवाद उत्पन्न कर सकता है।

try { 
   //Protected code 
} catch(ExceptionName e1) {
   //Catch block 
}

आपके सभी कोड जो एक अपवाद को बढ़ा सकते हैं, को संरक्षित कोड ब्लॉक में रखा गया है।

कैच ब्लॉक में, आप अपने अपवाद को संभालने के लिए कस्टम कोड लिख सकते हैं ताकि एप्लिकेशन अपवाद से पुनर्प्राप्त हो सके।

आइए एक समान कोड के एक उदाहरण को देखें, जो हमने एक इंडेक्स मान के साथ एक सरणी तक पहुंचने के लिए देखा था, जो कि सरणी के आकार से अधिक है। लेकिन इस बार चलो एक कोशिश / पकड़ ब्लॉक में हमारे कोड को लपेटते हैं।

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(Exception ex) {
         println("Catching the exception");
      }
		
      println("Let's move on after the exception");
   }
}

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

Catching the exception 
Let's move on after the exception

उपरोक्त कोड से, हम कोशिश ब्लॉक में दोषपूर्ण कोड को लपेटते हैं। कैच ब्लॉक में हम केवल अपने अपवाद को पकड़ रहे हैं और एक संदेश को आउटपुट कर रहे हैं कि एक अपवाद उत्पन्न हुआ है।

एकाधिक पकड़ ब्लॉक

कई प्रकार के अपवादों को संभालने के लिए एक से अधिक कैच ब्लॉक हो सकते हैं। प्रत्येक कैच ब्लॉक के लिए, उठाए गए अपवाद के प्रकार के आधार पर आप तदनुसार कोड संभालेंगे।

विशेष रूप से ArrayIndexOutOfBoundsException को पकड़ने के लिए हमारे उपरोक्त कोड को संशोधित करें। निम्नलिखित कोड स्निपेट है।

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      }
		
      println("Let's move on after the exception");
   } 
}

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

Catching the Aray out of Bounds exception 
Let's move on after the exception

उपरोक्त कोड से आप देख सकते हैं कि ArrayIndexOutOfBoundsException कैच ब्लॉक पहले पकड़ा गया है क्योंकि इसका मतलब अपवाद का मानदंड है।

अंत में ब्लॉक करें

finallyब्लॉक एक कोशिश ब्लॉक या कैच ब्लॉक होता है। कोड का एक अंतिम ब्लॉक हमेशा निष्पादित होता है, चाहे एक अपवाद की घटना हो।

अंततः ब्लॉक का उपयोग करने से आप किसी भी क्लीन-टाइप स्टेटमेंट को चला सकते हैं, जिसे आप निष्पादित करना चाहते हैं, भले ही संरक्षित कोड में कुछ भी न हो। इस ब्लॉक का सिंटैक्स नीचे दिया गया है।

try { 
   //Protected code 
} catch(ExceptionType1 e1) { 
   //Catch block 
} catch(ExceptionType2 e2) { 
   //Catch block 
} catch(ExceptionType3 e3) { 
   //Catch block 
} finally {
   //The finally block always executes. 
}

आइए हमारे उपरोक्त कोड को संशोधित करें और अंत में कोड को ब्लॉक करें। निम्नलिखित कोड स्निपेट है।

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      } catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      } finally {
         println("The final block");
      }
		
      println("Let's move on after the exception");
   } 
}

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

Catching the Array out of Bounds exception 
The final block 
Let's move on after the exception

ग्रूवी में उपलब्ध अपवाद तरीके निम्नलिखित हैं -

सार्वजनिक स्ट्रिंग getMessage ()

अपवाद के बारे में एक विस्तृत संदेश देता है। यह संदेश थ्रेडेबल कंस्ट्रक्टर में आरंभिक है।

सार्वजनिक फेंकने योग्य getCause ()

अपवाद का कारण देता है जैसा कि एक थ्रोबेबल ऑब्जेक्ट द्वारा दर्शाया गया है।

सार्वजनिक स्ट्रिंग toString ()

GetMessage () के परिणाम के साथ सम्‍मिलित वर्ग का नाम लौटाता है

सार्वजनिक शून्य प्रिंटस्ट्रेस ()

System.err, त्रुटि आउटपुट स्ट्रीम में स्टैक ट्रेस के साथ () स्ट्रिंग के परिणाम को प्रिंट करता है।

सार्वजनिक StackTraceElement [] getStackTrace ()

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

सार्वजनिक फेंकने योग्य fillInStackTrace ()

स्टैक ट्रेस में किसी भी पिछली जानकारी को जोड़ने के साथ, वर्तमान स्टैक ट्रेस के साथ इस थ्रेडेबल ऑब्जेक्ट के स्टैक ट्रेस को भरता है।

उदाहरण

नीचे दिए गए कुछ तरीकों का उपयोग करके कोड उदाहरण दिया गया है -

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println(ex.toString());
         println(ex.getMessage());
         println(ex.getStackTrace());  
      } catch(Exception ex) {
         println("Catching the exception");
      }finally {
         println("The final block");
      }
		
      println("Let's move on after the exception");
   } 
}

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

java.lang.ArrayIndexOutOfBoundsException: 5 
5 
[org.codehaus.groovy.runtime.dgmimpl.arrays.IntegerArrayPutAtMetaMethod$MyPojoMetaMet 
hodSite.call(IntegerArrayPutAtMetaMethod.java:75), 
org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:48) ,
org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:113) ,
org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:133) ,
Example.main(Sample:8), sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
org.codehaus.groovy.reflection.CachedMethod.invoke(CachedMethod.java:93),
groovy.lang.MetaMethod.doMethodInvoke(MetaMethod.java:325),
groovy.lang.MetaClassImpl.invokeStaticMethod(MetaClassImpl.java:1443),
org.codehaus.groovy.runtime.InvokerHelper.invokeMethod(InvokerHelper.java:893),
groovy.lang.GroovyShell.runScriptOrMainOrTestOrRunnable(GroovyShell.java:287),
groovy.lang.GroovyShell.run(GroovyShell.java:524),
groovy.lang.GroovyShell.run(GroovyShell.java:513),
groovy.ui.GroovyMain.processOnce(GroovyMain.java:652),
groovy.ui.GroovyMain.run(GroovyMain.java:384),
groovy.ui.GroovyMain.process(GroovyMain.java:370),
groovy.ui.GroovyMain.processArgs(GroovyMain.java:129),
groovy.ui.GroovyMain.main(GroovyMain.java:109),
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:109),
org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:131),
sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method),
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57),
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ,
java.lang.reflect.Method.invoke(Method.java:606),
com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)]
 
The final block 
Let's move on after the exception

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

ग्रूवी में एक वर्ग राज्य (डेटा) और उस वर्ग द्वारा परिभाषित वस्तुओं के व्यवहार की घोषणा करता है। इसलिए, एक ग्रूवी वर्ग उस वर्ग के लिए उदाहरण क्षेत्र और विधियाँ दोनों का वर्णन करता है।

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

class Student {
   int StudentID;
   String StudentName;
	
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe"     
   } 
}

गेटटर और सेटर विधियाँ

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

class Student {
   private int StudentID;
   private String StudentName;
	
   void setStudentID(int pID) {
      StudentID = pID;
   }
	
   void setStudentName(String pName) {
      StudentName = pName;
   }
	
   int getStudentID() {
      return this.StudentID;
   }
	
   String getStudentName() {
      return this.StudentName;
   }
	
   static void main(String[] args) {
      Student st = new Student();
      st.setStudentID(1);
      st.setStudentName("Joe");
		
      println(st.getStudentID());
      println(st.getStudentName());
   } 
}

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

1 
Joe

उपरोक्त कार्यक्रम के बारे में निम्नलिखित मुख्य बातों पर ध्यान दें -

कक्षा में छात्र और छात्र दोनों को निजी के रूप में चिह्नित किया जाता है जिसका अर्थ है कि उन्हें कक्षा के बाहर से नहीं पहुँचा जा सकता है।
प्रत्येक उदाहरण सदस्य की अपनी गटर और सेटर विधि होती है। गेट्टर विधि उदाहरण चर का मान लौटाता है, उदाहरण के लिए विधि int getStudentID () और सेटर विधि उदाहरण ID का मान सेट करता है, उदाहरण के लिए विधि - शून्य setStudentName (स्ट्रिंग pName)

उदाहरण के तरीके

यह सामान्य रूप से वर्ग के अंदर और अधिक विधियों को शामिल करने के लिए स्वाभाविक है जो वास्तव में वर्ग के लिए कुछ प्रकार की कार्यक्षमता करता है। हमारे छात्र उदाहरण में, आइए 3 विषयों में छात्र के अंकों को निरूपित करने के लिए Marks1, Marks2 और Marks3 के उदाहरण सदस्यों को शामिल करें। फिर हम एक नया उदाहरण विधि जोड़ेंगे जो छात्र के कुल अंकों की गणना करेगा। इसके बाद कोड कैसा दिखेगा।

निम्नलिखित उदाहरण में, विधि टोटल एक अतिरिक्त इंस्टेंस विधि है जिसमें कुछ तर्क निर्मित होते हैं।

class Student {
   int StudentID;
   String StudentName;
	
   int Marks1;
   int Marks2;
   int Marks3;
	
   int Total() {
      return Marks1+Marks2+Marks3;
   }
	
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName="Joe";
		
      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 30;
		
      println(st.Total());
   }
}

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

कई वस्तुओं का निर्माण

एक वर्ग के कई ऑब्जेक्ट भी बना सकता है। निम्नलिखित इस बात का उदाहरण है कि इसे कैसे प्राप्त किया जा सकता है। यहाँ हम 3 ऑब्जेक्ट्स बना रहे हैं (st, st1 और st2) और उनके इंस्टेंस सदस्यों और उदाहरण के तरीकों को अपने अनुसार बुला रहे हैं।

class Student {
   int StudentID;
   String StudentName;
	
   int Marks1;
   int Marks2;
   int Marks3;
	
   int Total() { 
      return Marks1+Marks2+Marks3;
   } 
	
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe";
		
      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 30;
		
      println(st.Total()); 
   
      Student st1 = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe";
		
      st.Marks1 = 10;
      st.Marks2 = 20;
      st.Marks3 = 40;
		
      println(st.Total());  
        
      Student st3 = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe";
		
      st.Marks1 = 10; 
      st.Marks2 = 20;
      st.Marks3 = 50;
		
      println(st.Total());
   } 
}

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

60 
70 
80

विरासत

वंशानुक्रम को उस प्रक्रिया के रूप में परिभाषित किया जा सकता है जहां एक वर्ग दूसरे के गुणों (तरीकों और क्षेत्रों) का अधिग्रहण करता है। विरासत के उपयोग के साथ सूचना को एक पदानुक्रमित क्रम में प्रबंधनीय बनाया जाता है।

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

का विस्तार

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

व्यक्ति नामक वर्ग बनाना। इस वर्ग में एक उदाहरण सदस्य है जिसका नाम है।
छात्र नामक एक वर्ग बनाना जो व्यक्ति वर्ग से विस्तारित होता है। ध्यान दें कि व्यक्ति वर्ग में नाम उदाहरण सदस्य को छात्र वर्ग में विरासत में मिला है।
स्टूडेंट क्लास कंस्ट्रक्टर में, हम बेस क्लास कंस्ट्रक्टर को बुला रहे हैं।
हमारे छात्र वर्ग में, हम StudentID और Marks1 के 2 अतिरिक्त उदाहरण सदस्य जोड़ रहे हैं।

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
		
      st.Marks1 = 10;
      st.name = "Joe";
		
      println(st.name);
   }
} 

class Person {
   public String name;
   public Person() {}  
} 

class Student extends Person {
   int StudentID
   int Marks1;
	
   public Student() {
      super();
   } 
}

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

Joe

भीतरी वर्ग

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

निम्नलिखित एक बाहरी और आंतरिक वर्ग का एक उदाहरण है। निम्नलिखित उदाहरण में हम निम्नलिखित बातें कर रहे हैं -

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

class Example { 
   static void main(String[] args) { 
      Outer outobj = new Outer(); 
      outobj.name = "Joe"; 
      outobj.callInnerMethod() 
   } 
} 

class Outer { 
   String name;
	
   def callInnerMethod() { 
      new Inner().methodA() 
   } 
	
   class Inner {
      def methodA() { 
         println(name); 
      } 
   } 
	
}

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

Joe

सार वर्ग

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

निम्नलिखित उदाहरण में, ध्यान दें कि व्यक्ति वर्ग अब एक सार वर्ग में बना है और उसे तत्काल नहीं बनाया जा सकता है। यह भी ध्यान दें कि सार वर्ग में DisplayMarks नामक एक सार पद्धति है जिसमें कोई कार्यान्वयन विवरण नहीं है। छात्र वर्ग में कार्यान्वयन विवरण जोड़ना अनिवार्य है।

class Example { 
   static void main(String[] args) { 
      Student st = new Student(); 
      st.StudentID = 1;
		
      st.Marks1 = 10; 
      st.name="Joe"; 
		
      println(st.name); 
      println(st.DisplayMarks()); 
   } 
} 

abstract class Person { 
   public String name; 
   public Person() { } 
   abstract void DisplayMarks();
}
 
class Student extends Person { 
   int StudentID 
   int Marks1; 
	
   public Student() { 
      super(); 
   } 
	
   void DisplayMarks() { 
      println(Marks1); 
   }  
}

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

Joe 
10 
null

इंटरफेस

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

निम्नलिखित groovy में एक इंटरफ़ेस का एक उदाहरण है। निम्नलिखित उदाहरण में हम निम्नलिखित बातें कर रहे हैं -

Marks नामक एक इंटरफ़ेस बनाना और DisplayMarks नामक एक इंटरफ़ेस विधि बनाना।
क्लास की परिभाषा में, हम इंटरफ़ेस को लागू करने के लिए इम्प्लीमेंट कीवर्ड का उपयोग कर रहे हैं।
क्योंकि हम इंटरफ़ेस को लागू कर रहे हैं इसलिए हमें DisplayMarks विधि के लिए कार्यान्वयन प्रदान करना होगा।

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;
      println(st.DisplayMarks());
   } 
} 

interface Marks { 
   void DisplayMarks(); 
} 

class Student implements Marks {
   int StudentID
   int Marks1;
	
   void DisplayMarks() {
      println(Marks1);
   }
}

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

10
null

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

संग्रह के लिए सामान्य

सूची वर्ग जैसे संग्रह वर्गों को सामान्यीकृत किया जा सकता है ताकि आवेदन में केवल उस प्रकार के संग्रह स्वीकार किए जाएं। सामान्यीकृत ArrayList का एक उदाहरण नीचे दिखाया गया है। निम्नलिखित कथन क्या है कि यह केवल सूची आइटम को स्वीकार करता है जो कि प्रकार स्ट्रिंग के हैं -

List<String> list = new ArrayList<String>();

निम्नलिखित कोड उदाहरण में, हम निम्नलिखित कर रहे हैं -

एक सामान्यीकृत ArrayList संग्रह बनाना जो केवल स्ट्रिंग्स को धारण करेगा।
सूची में 3 तार जोड़ें।
सूची में प्रत्येक आइटम के लिए, स्ट्रिंग्स के मूल्य को प्रिंट करना।

class Example {
   static void main(String[] args) {
      // Creating a generic List collection
      List<String> list = new ArrayList<String>();
      list.add("First String");
      list.add("Second String");
      list.add("Third String");
		
      for(String str : list) {
         println(str);
      }
   } 
}

उपरोक्त कार्यक्रम का उत्पादन होगा -

First String 
Second String 
Third String

सामान्यीकृत कक्षाएं

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

निम्नलिखित कार्यक्रम में, हम निम्नलिखित कदम उठा रहे हैं -

हम ListType नामक एक क्लास बना रहे हैं। वर्ग परिभाषा के सामने रखे गए <T> कीवर्ड पर ध्यान दें। यह संकलक को बताता है कि यह वर्ग किसी भी प्रकार को स्वीकार कर सकता है। इसलिए जब हम इस वर्ग की एक वस्तु की घोषणा करते हैं, तो हम घोषणा के दौरान एक प्रकार निर्दिष्ट कर सकते हैं और उस प्रकार को प्लेसहोल्डर / टी> में बदल दिया जाएगा।
सामान्य वर्ग में कक्षा में परिभाषित सदस्य चर के साथ काम करने के लिए सरल गेट्टर और सेटर विधियां हैं।
मुख्य कार्यक्रम में, ध्यान दें कि हम ListType वर्ग की वस्तुओं को घोषित करने में सक्षम हैं, लेकिन विभिन्न प्रकारों के। पहला एक प्रकार का पूर्णांक है और दूसरा प्रकार स्ट्रिंग का है।

class Example {
   static void main(String[] args) {
      // Creating a generic List collection 
      ListType<String> lststr = new ListType<>();
      lststr.set("First String");
      println(lststr.get()); 
		
      ListType<Integer> lstint = new ListType<>();
      lstint.set(1);
      println(lstint.get());
   }
} 

public class ListType<T> {
   private T localt;
	
   public T get() {
      return this.localt;
   }
	
   public void set(T plocal) {
      this.localt = plocal;
   } 
}

उपरोक्त कार्यक्रम का उत्पादन होगा -

First String 
1

लक्षण भाषा का एक संरचनात्मक निर्माण है जो अनुमति देते हैं -

व्यवहार की संरचना।
इंटरफेस के रनटाइम कार्यान्वयन।
स्थिर प्रकार की जाँच / संकलन के साथ संगतता

उन्हें डिफ़ॉल्ट कार्यान्वयन और राज्य दोनों को ले जाने वाले इंटरफेस के रूप में देखा जा सकता है। किसी विशेषता को विशेषता कीवर्ड का उपयोग करके परिभाषित किया गया है।

एक विशेषता का एक उदाहरण नीचे दिया गया है -

trait Marks {
   void DisplayMarks() {
      println("Display Marks");
   } 
}

इसके बाद इंटरफ़ेस को कार्यान्वित करने के लिए कार्यान्वयन कीवर्ड का उपयोग उसी तरह से किया जा सकता है जैसे इंटरफेस।

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10; 
      println(st.DisplayMarks());
   } 
} 

trait Marks { 
   void DisplayMarks() {
      println("Display Marks");
   } 
} 

class Student implements Marks { 
   int StudentID
   int Marks1;
}

अंतर लागू करना

लक्षण इंटरफ़ेस को लागू कर सकते हैं, जिस स्थिति में इंटरफ़ेस कीवर्ड का उपयोग करके इंटरफेस घोषित किए जाते हैं।

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

एक इंटरफ़ेस टोटल विधि DisplayTotal के साथ परिभाषित किया गया है।
लक्षण चिह्न कुल इंटरफ़ेस लागू करता है और इसलिए DisplayTotal विधि के लिए एक कार्यान्वयन प्रदान करने की आवश्यकता है।

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;
		
      println(st.DisplayMarks());
      println(st.DisplayTotal());
   } 
} 

interface Total {
   void DisplayTotal() 
} 

trait Marks implements Total {
   void DisplayMarks() {
      println("Display Marks");
   }
	
   void DisplayTotal() {
      println("Display Total"); 
   } 
} 

class Student implements Marks { 
   int StudentID
   int Marks1;  
}

उपरोक्त कार्यक्रम का उत्पादन होगा -

Display Marks 
Display Total

गुण

एक गुण गुणों को परिभाषित कर सकता है। एक संपत्ति के साथ एक विशेषता का एक उदाहरण नीचे दिया गया है।

निम्नलिखित उदाहरण में, प्रकार पूर्णांक के मार्क्स 1 एक संपत्ति है।

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
		
      println(st.DisplayMarks());
      println(st.DisplayTotal());
   } 
	
   interface Total {
      void DisplayTotal() 
   } 
	
   trait Marks implements Total {
      int Marks1;
		
      void DisplayMarks() {
         this.Marks1 = 10;
         println(this.Marks1);
      }
		
      void DisplayTotal() {
         println("Display Total");
      } 
   } 
	
   class Student implements Marks {
      int StudentID 
   }
}

उपरोक्त कार्यक्रम का उत्पादन होगा -

10 
Display Total

व्यवहार की संरचना

हीरे की समस्या से बचने के लिए, कई तरीकों को नियंत्रित तरीके से लागू करने के लिए लक्षणों का उपयोग किया जा सकता है। निम्नलिखित कोड उदाहरण में, हमने दो लक्षण परिभाषित किए हैं -Marks तथा Total। हमारा छात्र वर्ग दोनों लक्षणों को लागू करता है। चूंकि छात्र वर्ग दोनों लक्षणों का विस्तार करता है, इसलिए यह दोनों विधियों का उपयोग करने में सक्षम है -DisplayMarks तथा DisplayTotal।

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
		
      println(st.DisplayMarks());
      println(st.DisplayTotal()); 
   } 
} 

trait Marks {
   void DisplayMarks() {
      println("Marks1");
   } 
} 

trait Total {
   void DisplayTotal() { 
      println("Total");
   } 
}  

class Student implements Marks,Total {
   int StudentID 
}

उपरोक्त कार्यक्रम का उत्पादन होगा -

Total 
Marks1

लक्षण का विस्तार करना

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

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      println(st.DisplayMarks());
   } 
} 

trait Marks {
   void DisplayMarks() {
      println("Marks1");
   } 
} 

trait Total extends Marks {
   void DisplayMarks() {
      println("Total");
   } 
}  

class Student implements Total {
   int StudentID 
}

उपरोक्त कार्यक्रम का उत्पादन होगा -

Total

एक बंद कोड का एक संक्षिप्त अनाम ब्लॉक है। यह सामान्य रूप से कोड की कुछ पंक्तियों को फैलाता है। एक विधि एक पैरामीटर के रूप में कोड के ब्लॉक को भी ले सकती है। वे प्रकृति में अनाम हैं।

निम्नलिखित एक साधारण क्लोजर का उदाहरण है और यह कैसा दिखता है।

class Example {
   static void main(String[] args) {
      def clos = {println "Hello World"};
      clos.call();
   } 
}

उपरोक्त उदाहरण में, कोड लाइन - {Println "हैलो वर्ल्ड"} को एक क्लोजर के रूप में जाना जाता है। इस पहचानकर्ता द्वारा संदर्भित कोड ब्लॉक को कॉल स्टेटमेंट के साथ निष्पादित किया जा सकता है।

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

Hello World

क्लोजर में औपचारिक पैरामीटर

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

class Example {
   static void main(String[] args) {
      def clos = {param->println "Hello ${param}"};
      clos.call("World");
   } 
}

उपरोक्त कोड उदाहरण में, $ {param} के उपयोग पर ध्यान दें जो एक पैरामीटर लेने के लिए बंद होने का कारण बनता है। क्लोज़.ल स्टेटमेंट के माध्यम से क्लोजर को कॉल करते समय हमारे पास अब क्लोजर के लिए एक पैरामीटर पास करने का विकल्प होता है।

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

Hello World

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

class Example {
   static void main(String[] args) {
      def clos = {println "Hello ${it}"};
      clos.call("World");
   } 
}

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

Hello World

क्लोजर और चर

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

class Example {     
   static void main(String[] args) {
      def str1 = "Hello";
      def clos = {param -> println "${str1} ${param}"}
      clos.call("World");
		
      // We are now changing the value of the String str1 which is referenced in the closure
      str1 = "Welcome";
      clos.call("World");
   } 
}

उपरोक्त उदाहरण में, बंद करने के लिए एक पैरामीटर पारित करने के अलावा, हम str1 नामक एक चर को भी परिभाषित कर रहे हैं। बंद पैरामीटर के साथ चर पर भी ले जाता है।

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

Hello World 
Welcome World

विधियों में क्लोजर का उपयोग करना

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

निम्न उदाहरण दिखाता है कि एक पैरामीटर के रूप में एक बंद विधि को कैसे भेजा जा सकता है।

class Example { 
   def static Display(clo) {
      // This time the $param parameter gets replaced by the string "Inner"         
      clo.call("Inner");
   } 
	
   static void main(String[] args) {
      def str1 = "Hello";
      def clos = { param -> println "${str1} ${param}" }
      clos.call("World");
		
      // We are now changing the value of the String str1 which is referenced in the closure
      str1 = "Welcome";
      clos.call("World");
		
      // Passing our closure to a method
      Example.Display(clos);
   } 
}

उपरोक्त उदाहरण में,

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

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

Hello World 
Welcome World 
Welcome Inner

संग्रह और स्ट्रिंग में क्लोजर

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

सूचियों के साथ क्लोजर का उपयोग करना

निम्न उदाहरण दिखाता है कि सूची के साथ क्लोजर का उपयोग कैसे किया जा सकता है। निम्नलिखित उदाहरण में हम पहले मूल्यों की एक सरल सूची को परिभाषित कर रहे हैं। सूची संग्रह प्रकार तब एक फ़ंक्शन को परिभाषित करता है जिसे कहा जाता है।each। यह फ़ंक्शन पैरामीटर के रूप में एक क्लोजर पर लेता है और सूची के प्रत्येक तत्व के लिए क्लोजर लागू करता है।

class Example {
   static void main(String[] args) {
      def lst = [11, 12, 13, 14];
      lst.each {println it}
   } 
}

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

मैप्स के साथ क्लोजर का उपयोग करना

निम्न उदाहरण दिखाता है कि मैप्स के साथ क्लोजर का उपयोग कैसे किया जा सकता है। निम्नलिखित उदाहरण में हम पहले मुख्य मूल्य वस्तुओं के एक सरल मानचित्र को परिभाषित कर रहे हैं। मानचित्र संग्रह प्रकार तब .each नामक फ़ंक्शन को परिभाषित करता है। यह फ़ंक्शन एक पैरामीटर के रूप में एक क्लोजर पर लेता है और नक्शे के प्रत्येक कुंजी-वैल्यू जोड़े के क्लोजर को लागू करता है।

class Example {
   static void main(String[] args) {
      def mp = ["TopicName" : "Maps", "TopicDescription" : "Methods in Maps"]             
      mp.each {println it}
      mp.each {println "${it.key} maps to: ${it.value}"}
   } 
}

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

TopicName = Maps 
TopicDescription = Methods in Maps 
TopicName maps to: Maps 
TopicDescription maps to: Methods in Maps

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

class Example {
   static void main(String[] args) {
      def lst = [1,2,3,4];
      lst.each {println it}
      println("The list will only display those numbers which are divisible by 2")
      lst.each{num -> if(num % 2 == 0) println num}
   } 
}

उपरोक्त उदाहरण सशर्त दिखाता है यदि (संख्या% 2 == 0) क्लोजर में उपयोग किया जा रहा है जो यह जांचने के लिए उपयोग किया जाता है कि सूची में प्रत्येक आइटम 2 से विभाज्य है या नहीं।

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

1 
2 
3 
4 
The list will only display those numbers which are divisible by 2.
2 
4

क्लोजर के साथ प्रयोग की जाने वाली विधियाँ

क्लोजर स्वयं कुछ तरीके प्रदान करते हैं।

अनु क्रमांक।	तरीके और विवरण
1	लगता है () खोज विधि संग्रह में पहला मान ढूंढती है जो कुछ कसौटी से मेल खाता है।
2	सब ढूँढ़ो() यह क्लोजर स्थिति से मेल खाते ऑब्जेक्ट में सभी मान पाता है।
3	कोई भी () और हर () विधि किसी संग्रह जाँच के प्रत्येक तत्व के माध्यम से पुनरावृत्ति करती है कि क्या एक बूलियन विधेय कम से कम एक तत्व के लिए मान्य है।
4	इकट्ठा () विधि एक संग्रह के माध्यम से पुनरावृत्तियों को इकट्ठा करती है, प्रत्येक तत्व को ट्रांसफार्मर के रूप में बंद करने का उपयोग करके एक नए मूल्य में परिवर्तित करती है।

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

एनोटेशन का उपयोग मुख्य रूप से निम्नलिखित कारणों से किया जाता है -

Information for the compiler - त्रुटियों का पता लगाने या चेतावनी को दबाने के लिए संकलक द्वारा एनोटेशन का उपयोग किया जा सकता है।
Compile-time and deployment-time processing - सॉफ्टवेयर टूल कोड, एक्सएमएल फाइलें और इसके आगे उत्पन्न करने के लिए एनोटेशन जानकारी को संसाधित कर सकते हैं।
Runtime processing - कुछ एनोटेशन रनटाइम पर जांच के लिए उपलब्ध हैं।

ग्रूवी में, एक मूल एनोटेशन निम्नानुसार है -

@interface - साइन चरित्र पर (@) संकलक को इंगित करता है कि निम्नानुसार एक एनोटेशन है।

एक एनोटेशन सदस्यों को परिभाषित कर सकता है the form निकायों के बिना और एक वैकल्पिक डिफ़ॉल्ट मान के तरीके।

एनोटेशन को निम्नलिखित प्रकारों पर लागू किया जा सकता है -

स्ट्रिंग प्रकार

एक स्ट्रिंग के लिए एनोटेशन का एक उदाहरण नीचे दिया गया है -

@interface Simple { 
   String str1() default "HelloWorld"; 
}

ईनम प्रकार

enum DayOfWeek { mon, tue, wed, thu, fri, sat, sun } 
@interface Scheduled {
   DayOfWeek dayOfWeek() 
}

वर्ग प्रकार

@interface Simple {} 
@Simple 
class User {
   String username
   int age
}
 
def user = new User(username: "Joe",age:1); 
println(user.age); 
println(user.username);

एनोटेशन सदस्य मान

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

@interface Example {
   int status() 
}

@Example(status = 1)

क्लोजर एनोटेशन पैरामीटर्स

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

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

@interface OnlyIf {
   Class value() 
}  

@OnlyIf({ number<=6 }) 
void Version6() {
   result << 'Number greater than 6' 
} 

@OnlyIf({ number>=6 }) 
void Version7() {
   result << 'Number greater than 6' 
}

मेटा एनोटेशन

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

@Procedure 
@Master class 
MyMasterProcedure {}

ऐसे मामले में आप एक मेटा-एनोटेशन को परिभाषित कर सकते हैं जो एक साथ कई एनोटेशन को क्लब करता है और मेटा एनोटेशन को विधि पर लागू करता है। तो उपरोक्त उदाहरण के लिए आप एनोटेशन कोलोरेक्टर का उपयोग करके एनोटेशन के संग्रह को निर्धारित कर सकते हैं।

import groovy.transform.AnnotationCollector
  
@Procedure 
@Master 
@AnnotationCollector

एक बार यह हो जाने के बाद, आप निम्न मेटा-एनोटेटर को विधि में लागू कर सकते हैं -

import groovy.transform.AnnotationCollector
  
@Procedure 
@Master 
@AnnotationCollector
  
@MasterProcedure 
class MyMasterProcedure {}

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

XML क्या है?

एक्स्टेंसिबल मार्कअप लैंग्वेज XML एक मार्कअप लैंग्वेज है जैसे HTML या SGML। यह वर्ल्ड वाइड वेब कंसोर्टियम द्वारा अनुशंसित है और एक खुले मानक के रूप में उपलब्ध है। XML SQLbased रीढ़ की आवश्यकता के बिना छोटे से मध्यम मात्रा में डेटा का ट्रैक रखने के लिए बेहद उपयोगी है।

ग्रूवी में एक्सएमएल सपोर्ट

ग्रूवी भाषा एक्सएमएल भाषा का एक समृद्ध समर्थन भी प्रदान करती है। उपयोग की जाने वाली दो सबसे बुनियादी XML कक्षाएं हैं -

XML Markup Builder- ग्रूवी एक ट्री-आधारित मार्कअप जनरेटर, बिल्डरसुपोर्ट का समर्थन करता है, जिसे विभिन्न प्रकार के पेड़-संरचित ऑब्जेक्ट प्रतिनिधित्व बनाने के लिए उप-वर्ग किया जा सकता है। आमतौर पर, इन बिल्डरों का उपयोग XML मार्कअप, HTML मार्कअप का प्रतिनिधित्व करने के लिए किया जाता है। ग्रूवी के मार्कअप जनरेटर कॉल को स्यूडोमेथोड्स को पकड़ता है और उन्हें पेड़ की संरचना के तत्वों या नोड में परिवर्तित करता है। इन स्यूडोमेथोड्स के मापदंडों को नोड्स की विशेषताओं के रूप में माना जाता है। विधि कॉल के भाग के रूप में क्लोज़र्स को परिणामी ट्री नोड के लिए नेस्टेड उपमहाद्वीप माना जाता है।
XML Parser- ग्रूवी XmlParser वर्ग नोड दस्तावेज़ के पेड़ में XML दस्तावेज़ पार्स करने के लिए एक सरल मॉडल नियुक्त करता है। प्रत्येक नोड में XML तत्व, तत्व की विशेषताओं और किसी भी बच्चे के नोड्स का संदर्भ होता है। यह मॉडल अधिकांश सरल XML प्रसंस्करण के लिए पर्याप्त है।

हमारे सभी एक्सएमएल कोड उदाहरणों के लिए, आइए XML फाइल के निर्माण और बाद में फाइल को पढ़ने के लिए निम्न सरल XML फाइल मूवी.xml का उपयोग करें।

<collection shelf = "New Arrivals"> 

   <movie title = "Enemy Behind"> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
	
   <movie title = "Transformers"> 
      <type>Anime, Science Fiction</type>
      <format>DVD</format> 
      <year>1989</year> 
      <rating>R</rating> 
      <stars>8</stars> 
      <description>A schientific fiction</description> 
   </movie> 
	
   <movie title = "Trigun"> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Vash the Stam pede!</description> 
   </movie> 
	
   <movie title = "Ishtar"> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>2</stars> 
      <description>Viewable boredom </description> 
   </movie> 
	
</collection>

XML मार्कअप बिल्डर

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

public MarkupBuilder()

MarkupBuilder का उपयोग संपूर्ण XML दस्तावेज़ के निर्माण के लिए किया जाता है। XML डॉक्यूमेंट पहले XML डॉक्यूमेंट क्लास का ऑब्जेक्ट बनाकर बनाया जाता है। एक बार ऑब्जेक्ट बन जाने के बाद, XML डॉक्यूमेंट के विभिन्न तत्वों को बनाने के लिए एक pseudomethod कहा जा सकता है।

आइए एक उदाहरण देखें कि कैसे एक ब्लॉक बनाया जाए, यानी उपरोक्त एक्सएमएल दस्तावेज़ से एक मूवी तत्व -

import groovy.xml.MarkupBuilder 

class Example {
   static void main(String[] args) {
      def mB = new MarkupBuilder()
		
      // Compose the builder
      mB.collection(shelf : 'New Arrivals') {
         movie(title : 'Enemy Behind')
         type('War, Thriller')
         format('DVD')
         year('2003')
         rating('PG')
         stars(10)
         description('Talk about a US-Japan war') 
      }
   } 
}

उपरोक्त उदाहरण में, निम्नलिखित बातों पर ध्यान देने की आवश्यकता है -

mB.collection() - यह एक मार्कअप जनरेटर है जो <संग्रह> </ संग्रह> का हेड XML टैग बनाता है
movie(title : 'Enemy Behind')- ये स्यूडोमेथोड्स इस विधि से बच्चे के टैग बनाते हैं और मूल्य के साथ टैग बनाते हैं। शीर्षक नामक मान निर्दिष्ट करके, यह वास्तव में इंगित करता है कि तत्व के लिए एक विशेषता बनाने की आवश्यकता है।
XML दस्तावेज़ के शेष तत्वों को बनाने के लिए pseudomethod को एक क्लोजर प्रदान किया जाता है।
क्लास मार्कअपबर्स्ट के लिए डिफ़ॉल्ट कंस्ट्रक्टर को इनिशियलाइज़ किया गया है ताकि जेनरेट किया गया एक्सएमएल स्टैंडर्ड आउटपुट स्ट्रीम को जारी किया जाए

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

<collection shelf = 'New Arrivals'> 
   <movie title = 'Enemy Behind' /> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
</collection>

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

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

import groovy.xml.MarkupBuilder 

class Example {
   static void main(String[] args) {
      def mp = [1 : ['Enemy Behind', 'War, Thriller','DVD','2003', 
         'PG', '10','Talk about a US-Japan war'],
         2 : ['Transformers','Anime, Science Fiction','DVD','1989', 
         'R', '8','A scientific fiction'],
         3 : ['Trigun','Anime, Action','DVD','1986', 
         'PG', '10','Vash the Stam pede'],
         4 : ['Ishtar','Comedy','VHS','1987', 'PG', 
         '2','Viewable boredom ']] 
			
      def mB = new MarkupBuilder()  
		
      // Compose the builder
      def MOVIEDB = mB.collection('shelf': 'New Arrivals') {
         mp.each {
            sd -> 
            mB.movie('title': sd.value[0]) {  
               type(sd.value[1])
               format(sd.value[2])
               year(sd.value[3]) 
               rating(sd.value[4])
               stars(sd.value[4]) 
               description(sd.value[5]) 
            }
         }
      }
   } 
}

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

<collection shelf = 'New Arrivals'> 
   <movie title = 'Enemy Behind'> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>PG</stars> 
      <description>10</description> 
   </movie> 
   <movie title = 'Transformers'> 
      <type>Anime, Science Fiction</type> 
      <format>DVD</format> 
      <year>1989</year>
	  <rating>R</rating> 
      <stars>R</stars> 
      <description>8</description> 
   </movie> 
   <movie title = 'Trigun'> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>PG</stars> 
      <description>10</description> 
   </movie> 
   <movie title = 'Ishtar'> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>PG</stars> 
      <description>2</description> 
   </movie> 
</collection>

XML पार्सिंग

Groovy XmlParser वर्ग एक XML दस्तावेज़ को नोड नोड्स के पेड़ में पार्स करने के लिए एक सरल मॉडल नियुक्त करता है। प्रत्येक नोड में XML तत्व, तत्व की विशेषताओं और किसी भी बच्चे के नोड्स का संदर्भ होता है। यह मॉडल अधिकांश सरल XML प्रसंस्करण के लिए पर्याप्त है।

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

public XmlParser() 
   throws ParserConfigurationException, 
      SAXException

निम्न कोडेश एक उदाहरण बताता है कि XML दस्तावेज़ को पढ़ने के लिए XML पार्सर का उपयोग कैसे किया जा सकता है।

मान लेते हैं कि हमारे पास Movies.xml नामक एक ही दस्तावेज़ है और हम XML दस्तावेज़ को पार्स करना चाहते थे और उपयोगकर्ता को एक उचित आउटपुट प्रदर्शित करना चाहते थे। निम्नलिखित कोडिस यह बताता है कि हम XML दस्तावेज़ की संपूर्ण सामग्री के माध्यम से कैसे पार कर सकते हैं और उपयोगकर्ता के लिए एक उचित प्रतिक्रिया प्रदर्शित कर सकते हैं।

import groovy.xml.MarkupBuilder 
import groovy.util.*

class Example {

   static void main(String[] args) { 
	
      def parser = new XmlParser()
      def doc = parser.parse("D:\\Movies.xml");
		
      doc.movie.each{
         bk->
         print("Movie Name:")
         println "${bk['@title']}" print("Movie Type:") println "${bk.type[0].text()}"
			
         print("Movie Format:")
         println "${bk.format[0].text()}" print("Movie year:") println "${bk.year[0].text()}"
			
         print("Movie rating:")
         println "${bk.rating[0].text()}" print("Movie stars:") println "${bk.stars[0].text()}"
			
         print("Movie description:")
         println "${bk.description[0].text()}"
         println("*******************************")
      }
   }
}

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

Movie Name:Enemy Behind 
Movie Type:War, Thriller 
Movie Format:DVD 
Movie year:2003 
Movie rating:PG 
Movie stars:10 
Movie description:Talk about a US-Japan war 
******************************* 
Movie Name:Transformers 
Movie Type:Anime, Science Fiction 
Movie Format:DVD 
Movie year:1989 
Movie rating:R 
Movie stars:8 
Movie description:A schientific fiction 
******************************* 
Movie Name:Trigun 
Movie Type:Anime, Action
Movie Format:DVD 
Movie year:1986 
Movie rating:PG 
Movie stars:10 
Movie description:Vash the Stam pede! 
******************************* 
Movie Name:Ishtar 
Movie Type:Comedy 
Movie Format:VHS 
Movie year:1987 
Movie rating:PG 
Movie stars:2 
Movie description:Viewable boredom

उपरोक्त कोड के बारे में ध्यान देने योग्य महत्वपूर्ण बातें।

XmlParser वर्ग का एक ऑब्जेक्ट बनाया जा रहा है ताकि इसका उपयोग XML दस्तावेज़ को पार्स करने के लिए किया जा सके।
पार्सर को XML फ़ाइल का स्थान दिया गया है।
प्रत्येक मूवी तत्व के लिए, हम प्रत्येक बच्चे के नोड के माध्यम से ब्राउज़ करने और संबंधित जानकारी प्रदर्शित करने के लिए एक क्लोजर का उपयोग कर रहे हैं।

मूवी तत्व के लिए, हम फिल्म तत्व से जुड़ी शीर्षक विशेषता को प्रदर्शित करने के लिए @ प्रतीक का उपयोग कर रहे हैं।

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

जेवीएम की निगरानी करना

कोई JVM की निगरानी के लिए java.lang.management में उपलब्ध मानक कक्षाओं का उपयोग कर सकता है। निम्न कोड उदाहरण दिखाता है कि यह कैसे किया जा सकता है।

import java.lang.management.*

def os = ManagementFactory.operatingSystemMXBean 
println """OPERATING SYSTEM: 
\tOS architecture = $os.arch 
\tOS name = $os.name \tOS version = $os.version 
\tOS processors = $os.availableProcessors """ def rt = ManagementFactory.runtimeMXBean println """RUNTIME: \tRuntime name = $rt.name 
   \tRuntime spec name = $rt.specName \tRuntime vendor = $rt.specVendor 
   \tRuntime spec version = $rt.specVersion \tRuntime management spec version = $rt.managementSpecVersion 
   """ 

def mem = ManagementFactory.memoryMXBean 
def heapUsage = mem.heapMemoryUsage 
def nonHeapUsage = mem.nonHeapMemoryUsage 

println """MEMORY: 
   HEAP STORAGE: 
      \tMemory committed = $heapUsage.committed \tMemory init = $heapUsage.init 
      \tMemory max = $heapUsage.max \tMemory used = $heapUsage.used NON-HEAP STORAGE: 
      \tNon-heap memory committed = $nonHeapUsage.committed \tNon-heap memory init = $nonHeapUsage.init 
      \tNon-heap memory max = $nonHeapUsage.max \tNon-heap memory used = $nonHeapUsage.used 
   """
  
println "GARBAGE COLLECTION:" 
ManagementFactory.garbageCollectorMXBeans.each { gc ->
   println "\tname = $gc.name" println "\t\tcollection count = $gc.collectionCount"
   println "\t\tcollection time = $gc.collectionTime" String[] mpoolNames = gc.memoryPoolNames mpoolNames.each { mpoolName -> println "\t\tmpool name = $mpoolName"
   } 
}

जब कोड निष्पादित होता है, तो आउटपुट उस सिस्टम के आधार पर अलग-अलग होगा जिस पर कोड चलाया जाता है। आउटपुट का एक नमूना नीचे दिया गया है।

OPERATING SYSTEM: 
   OS architecture = x86 
   OS name = Windows 7 
   OS version = 6.1 
   OS processors = 4
   
RUNTIME: 
   Runtime name = 5144@Babuli-PC 
   Runtime spec name = Java Virtual Machine Specification 
   Runtime vendor = Oracle Corporation 
   Runtime spec version = 1.7 
   Runtime management spec version = 1.2
   
MEMORY: 
   HEAP STORAGE: 
      Memory committed = 16252928 
      Memory init = 16777216 
      Memory max = 259522560 
      Memory used = 7355840
   
NON-HEAP STORAGE: 
   Non-heap memory committed = 37715968 
   Non-heap memory init = 35815424 
   Non-heap memory max = 123731968 
   Non-heap memory used = 18532232 
   
GARBAGE COLLECTION: 
   name = Copy 
   collection count = 15 
   collection time = 47 
   mpool name = Eden Space 
   mpool name = Survivor Space
		
   name = MarkSweepCompact 
      collection count = 0 
      collection time = 0 
		
      mpool name = Eden Space 
      mpool name = Survivor Space 
      mpool name = Tenured Gen 
      mpool name = Perm Gen 
      mpool name = Perm Gen [shared-ro] 
      mpool name = Perm Gen [shared-rw]

मॉनिटरिंग टोमाकट

टॉमकैट की निगरानी के लिए, टॉमकैट शुरू होने पर निम्नलिखित पैरामीटर सेट किया जाना चाहिए -

set JAVA_OPTS = -Dcom.sun.management.jmxremote 
Dcom.sun.management.jmxremote.port = 9004\
 
-Dcom.sun.management.jmxremote.authenticate=false 
Dcom.sun.management.jmxremote.ssl = false

निम्नलिखित कोड JMX का उपयोग करता है जो चल रहे टॉमकैट में उपलब्ध एमबीन्स की खोज करता है, यह निर्धारित करता है कि कौन से वेब मॉड्यूल हैं और प्रत्येक वेब मॉड्यूल के लिए प्रसंस्करण समय निकालें।

import groovy.swing.SwingBuilder
  
import javax.management.ObjectName 
import javax.management.remote.JMXConnectorFactory as JmxFactory 
import javax.management.remote.JMXServiceURL as JmxUrl 
import javax.swing.WindowConstants as WC 
 
import org.jfree.chart.ChartFactory 
import org.jfree.data.category.DefaultCategoryDataset as Dataset 
import org.jfree.chart.plot.PlotOrientation as Orientation 
 
def serverUrl = 'service:jmx:rmi:///jndi/rmi://localhost:9004/jmxrmi' 
def server = JmxFactory.connect(new JmxUrl(serverUrl)).MBeanServerConnection 
def serverInfo = new GroovyMBean(server, 'Catalina:type = Server').serverInfo 
println "Connected to: $serverInfo" def query = new ObjectName('Catalina:*') String[] allNames = server.queryNames(query, null) def modules = allNames.findAll { name -> name.contains('j2eeType=WebModule') }.collect{ new GroovyMBean(server, it) } println "Found ${modules.size()} web modules. Processing ..." 
def dataset = new Dataset() 
 
modules.each { m ->
   println m.name()
   dataset.addValue m.processingTime, 0, m.path 
}

इस अध्याय में बताया गया है कि हम JSON ऑब्जेक्ट्स को पार्स और निर्मित करने के लिए Groovy भाषा का उपयोग कैसे कर सकते हैं।

JSON के कार्य

अनु क्रमांक	समारोह और पुस्तकालय
1	JsonSlurper JsonSlurper एक ऐसा वर्ग है जो ग्रोन डेटा में JSON टेक्स्ट या रीडर सामग्री को पार्स करता है नक्शे, सूचियों और आदिम प्रकार जैसे कि इंटीजर, डबल, बूलियन और स्ट्रिंग जैसी संरचनाएं।
2	JsonOutput यह विधि JSON स्ट्रिंग्स में ग्रूवी वस्तुओं को क्रमबद्ध करने के लिए जिम्मेदार है।

JsonSlurper का उपयोग कर डेटा पार्स करना

JsonSlurper एक ऐसा वर्ग है जो ग्रोवी डेटा स्ट्रक्चर्स जैसे मैप्स, सूचियों और आदिम प्रकारों जैसे इंटेगर, डबल, बुलियन और स्ट्रिंग में JSON टेक्स्ट या रीडर सामग्री को पार्स करता है।

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

def slurper = new JsonSlurper()

JSON स्लॉपर पाठ या पाठक सामग्री को सूचियों और मानचित्रों की एक डेटा संरचना में देता है।

JsonSlurper वर्ग पार्सर कार्यान्वयन के लिए कुछ प्रकारों के साथ आता है। कभी-कभी कुछ स्ट्रिंग्स पार्स करने की बात आने पर आपकी अलग-अलग आवश्यकताएं हो सकती हैं। आइए एक उदाहरण लेते हैं जिसमें किसी को JSON पढ़ने की आवश्यकता होती है जिसे वेब सर्वर से प्रतिक्रिया से वापस किया जाता है। ऐसे में पार्सर JsonParserLax वैरिएंट का उपयोग करना फायदेमंद है। यह पार्सी JSON पाठ में टिप्पणियों के साथ-साथ कोई उद्धरण तार आदि की अनुमति देता है। इस प्रकार के पार्सर को निर्दिष्ट करने के लिए आपको JsonSlurper के ऑब्जेक्ट को परिभाषित करते समय JsonParserType.LAX पार्सर प्रकार का उपयोग करने की आवश्यकता होती है।

आइए नीचे दिए गए इस का एक उदाहरण देखें। उदाहरण HTTP मॉड्यूल का उपयोग करके एक वेब सर्वर से JSON डेटा प्राप्त करने के लिए है। इस प्रकार के ट्रैवर्सल के लिए, सबसे अच्छा विकल्प है कि पार्सर टाइप को JsonParserLax वेरिएंट में सेट किया जाए।

http.request( GET, TEXT ) {
   headers.Accept = 'application/json'
   headers.'User-Agent' = USER_AGENT
	
   response.success = { 
      res, rd ->  
      def jsonText = rd.text 
		
      //Setting the parser type to JsonParserLax
      def parser = new JsonSlurper().setType(JsonParserType.LAX)
      def jsonResp = parser.parseText(jsonText)
   }
}

इसी प्रकार निम्नलिखित अतिरिक्त पार्सर प्रकार ग्रूवी में उपलब्ध हैं -

JsonParserCharArray पार्सर मूल रूप से JSON स्ट्रिंग लेता है और अंतर्निहित वर्ण सरणी पर कार्य करता है। मूल्य रूपांतरण के दौरान यह चरित्र उप-सरणियों ("चॉपिंग" के रूप में जाना जाता एक तंत्र) को कॉपी करता है और व्यक्तिगत रूप से उन पर काम करता है।
JsonFastParser JsonParserCharArray का एक विशेष संस्करण है और सबसे तेज़ पार्सर है। JsonFastParser को इंडेक्स-ओवरले पार्सर के रूप में भी जाना जाता है। दिए गए JSON स्ट्रिंग के पार्सिंग के दौरान, नए चार ऐरे या स्ट्रिंग इंस्टेंसेस बनाने से बचने के लिए जितना संभव हो उतना संभव प्रयास करता है। यह केवल अंतर्निहित मूल चरित्र सरणी की ओर संकेत करता है। इसके अलावा, यह यथासंभव देर से वस्तु निर्माण को धता बताती है।
JsonParserUsingCharacterSource बहुत बड़ी फ़ाइलों के लिए एक विशेष पार्सर है। यह निरंतर जेसीएल विशेषताओं के साथ बड़ी JSON फ़ाइलों (इस मामले में 2MB आकार से अधिक बड़ी फ़ाइलों) को पार्स करने के लिए "वर्ण विंडोिंग" नामक तकनीक का उपयोग करता है।

पार्सिंग पाठ

आइए कुछ उदाहरणों पर गौर करें कि हम JsonSlurper वर्ग का उपयोग कैसे कर सकते हैं।

import groovy.json.JsonSlurper 

class Example {
   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      def object = jsonSlurper.parseText('{ "name": "John", "ID" : "1"}') 
		
      println(object.name);
      println(object.ID);
   } 
}

उपरोक्त उदाहरण में, हम हैं -

पहले JsonSlurper वर्ग का एक उदाहरण बनाना
हम तब JSON पाठ को पार्स करने के लिए JsonSlurper वर्ग के parseText फ़ंक्शन का उपयोग कर रहे हैं।
जब हमें ऑब्जेक्ट मिलता है, तो आप देख सकते हैं कि हम वास्तव में कुंजी के माध्यम से JSON स्ट्रिंग में मानों को एक्सेस कर सकते हैं।

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है -

John 
1

इंजीर्स की पार्सिंग लिस्ट

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

import groovy.json.JsonSlurper 
class Example {
   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      Object lst = jsonSlurper.parseText('{ "List": [2, 3, 4, 5] }')
      lst.each { println it }
   } 
}

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है -

List=[2, 3, 4, 5]

आदिम डेटा प्रकारों की पार्सिंग सूची

JSON पार्सर भी आदिम डेटा प्रकार के स्ट्रिंग, संख्या, ऑब्जेक्ट, ट्रू, गलत और अशक्त का समर्थन करता है। JsonSlurper वर्ग इन JSON प्रकारों को संबंधित Groovy प्रकारों में परिवर्तित करता है।

निम्न उदाहरण दिखाता है कि JSON स्ट्रिंग को पार्स करने के लिए JsonSlurper का उपयोग कैसे करें। और यहां आप देख सकते हैं कि JsonSlurper व्यक्तिगत वस्तुओं को उनके संबंधित आदिम प्रकारों में पार्स करने में सक्षम है।

import groovy.json.JsonSlurper 
class Example {

   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      def obj = jsonSlurper.parseText ''' {"Integer": 12, "fraction": 12.55, "double": 12e13}'''
		
      println(obj.Integer);
      println(obj.fraction);
      println(obj.double); 
   } 
}

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है -

12 
12.55 
1.2E+14

JsonOutput

अब बात करते हैं कि Json में आउटपुट कैसे प्रिंट करें। यह JsonOutput विधि द्वारा किया जा सकता है। यह विधि JSON स्ट्रिंग्स में ग्रूवी वस्तुओं को क्रमबद्ध करने के लिए जिम्मेदार है।

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

Static string JsonOutput.toJson(datatype obj)

Parameters - पैरामीटर डेटाटाइप का एक ऑब्जेक्ट हो सकता है - नंबर, बुलियन, चरित्र, स्ट्रिंग, दिनांक, नक्शा, क्लोजर आदि।

Return type - रिटर्न टाइप एक जसन स्ट्रिंग है।

उदाहरण

निम्नलिखित एक सरल उदाहरण है कि यह कैसे प्राप्त किया जा सकता है।

import groovy.json.JsonOutput 
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([name: 'John', ID: 1])
      println(output);  
   }
}

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है -

{"name":"John","ID":1}

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

import groovy.json.JsonOutput  
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([ new Student(name: 'John',ID:1),
         new Student(name: 'Mark',ID:2)])
      println(output);  
   } 
}
 
class Student {
   String name
   int ID; 
}

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है -

[{"name":"John","ID":1},{"name":"Mark","ID":2}]

ग्रूवी शीर्ष स्तर के बयानों के लिए विधि कॉल के तर्कों के आसपास एक कोष्ठकों को छोड़ देने की अनुमति देता है। इसे "कमांड चेन" फीचर के रूप में जाना जाता है। यह एक्सटेंशन एक ऐसे कोष्ठक-मुक्त विधि कॉल को चेन करने की अनुमति देकर काम करता है, जिसके लिए न तो तर्कों के आसपास कोष्ठक की आवश्यकता होती है, न ही जंजीर कॉल के बीच डॉट्स की।

यदि एक कॉल के रूप में निष्पादित किया जाता है a b c d, यह वास्तव में के बराबर होगा a(b).c(d)।

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

def lst = [1,2,3,4] 
print lst

उपरोक्त कोड प्रिंटलाइन स्टेटमेंट का उपयोग करके कंसोल पर प्रिंट की जाने वाली संख्याओं की सूची दिखाता है। एक डोमेन विशिष्ट भाषा में निम्नानुसार होंगे -

Given the numbers 1,2,3,4
 
Display all the numbers

तो उपरोक्त उदाहरण डोमेन विशिष्ट भाषा की जरूरतों को पूरा करने के लिए प्रोग्रामिंग भाषा के परिवर्तन को दर्शाता है।

आइए एक सरल उदाहरण देखें कि हम ग्रूवी में डीएसएल को कैसे लागू कर सकते हैं -

class EmailDsl {  
   String toText 
   String fromText 
   String body 
	
   /** 
   * This method accepts a closure which is essentially the DSL. Delegate the 
   * closure methods to 
   * the DSL class so the calls can be processed 
   */ 
   
   def static make(closure) { 
      EmailDsl emailDsl = new EmailDsl() 
      // any method called in closure will be delegated to the EmailDsl class 
      closure.delegate = emailDsl
      closure() 
   }
   
   /** 
   * Store the parameter as a variable and use it later to output a memo 
   */ 
	
   def to(String toText) { 
      this.toText = toText 
   }
   
   def from(String fromText) { 
      this.fromText = fromText 
   }
   
   def body(String bodyText) { 
      this.body = bodyText 
   } 
}

EmailDsl.make { 
   to "Nirav Assar" 
   from "Barack Obama" 
   body "How are things? We are doing well. Take care" 
}

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

How are things? We are doing well. Take care

उपरोक्त कोड कार्यान्वयन के बारे में निम्नलिखित बातों पर ध्यान दिया जाना चाहिए -

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

Groovy का groovy-sql मॉड्यूल वर्तमान जावा की JDBC तकनीक पर एक उच्च-स्तरीय अमूर्तता प्रदान करता है। ग्रूवी एसक्यूएल एपीआई विभिन्न प्रकार के डेटाबेस का समर्थन करता है, जिनमें से कुछ नीचे दिखाए गए हैं।

HSQLDB
Oracle
एस क्यू एल सर्वर
MySQL
MongoDB

हमारे उदाहरण में, हम एक उदाहरण के रूप में MySQL DB का उपयोग करने जा रहे हैं। MySQL का उपयोग ग्रूवी के साथ करने के लिए, MySQL jdbc जार फ़ाइल को mysql साइट से डाउनलोड करने के लिए सबसे पहले काम करना है।The forMySQL का मैट नीचे दिखाया जाएगा।

mysql-connector-java-5.1.38-bin

फिर अपने वर्कस्टेशन में उपरोक्त जार फ़ाइल को क्लासपाथ में जोड़ना सुनिश्चित करें।

डेटाबेस कनेक्शन

MySQL डेटाबेस से कनेक्ट करने से पहले, फॉलोइंग सुनिश्चित करें -

आपने एक डेटाबेस बनाया है TESTDB।
आपने TESTDB में एक टेबल EMPLOYEE बनाया है।
इस तालिका में FIRST_NAME, LAST_NAME, AGE, SEX और INCOME हैं।
उपयोगकर्ता ID "testuser" और पासवर्ड "test123" TESTDB तक पहुँचने के लिए निर्धारित हैं।
सुनिश्चित करें कि आपने mysql jar फ़ाइल डाउनलोड की है और फ़ाइल को अपने classpath में जोड़ा है।
आप MySQL बेसिक्स को समझने के लिए MySQL ट्यूटोरियल से गुजरे हैं

निम्न उदाहरण दिखाता है कि MySQL डेटाबेस "TESTDB" के साथ कैसे कनेक्ट किया जाए।

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 
         'testuser', 'test123', 'com.mysql.jdbc.Driver')
			
      // Executing the query SELECT VERSION which gets the version of the database
      // Also using the eachROW method to fetch the result from the database
   
      sql.eachRow('SELECT VERSION()'){ row ->
         println row[0]
      }
		
      sql.close()  
   } 
}

इस स्क्रिप्ट को चलाने के दौरान, यह निम्नलिखित परिणाम उत्पन्न कर रहा है -

5.7.10-log 
The Sql.newInstance method is used to establish a connection to the database.

डेटाबेस तालिका बनाना

डेटाबेस से कनेक्ट करने के बाद अगला चरण हमारे डेटाबेस में टेबल बनाना है। निम्न उदाहरण दिखाता है कि ग्रूवी का उपयोग करके डेटाबेस में एक तालिका कैसे बनाई जाए। Sql वर्ग की निष्पादन विधि का उपयोग डेटाबेस के विरुद्ध कथनों को निष्पादित करने के लिए किया जाता है।

import java.sql.*; 
import groovy.sql.Sql 

class Example { 
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',  
         'test123', 'com.mysql.jdbc.Driver')
			
      def sqlstr = """CREATE TABLE EMPLOYEE ( 
         FIRST_NAME CHAR(20) NOT NULL,
         LAST_NAME CHAR(20),
         AGE INT,
         SEX CHAR(1),
         INCOME FLOAT )""" 
							
      sql.execute(sqlstr);
      sql.close() 
   } 
}

ऑपरेशन डालें

जब आप अपने रिकॉर्ड को डेटाबेस तालिका में बनाना चाहते हैं तो इसकी आवश्यकता होती है।

उदाहरण

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

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) { 
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false
		
      def sqlstr = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME) VALUES ('Mac', 'Mohan', 20, 'M', 2000)""" 
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback") 
      }
		
      sql.close()
   } 
}

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

import java.sql.*; 
import groovy.sql.Sql
 
class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false  
      
      def firstname = "Mac"
      def lastname ="Mohan"
      def age = 20
      def sex = "M"
      def income = 2000  
		
      def sqlstr = "INSERT INTO EMPLOYEE(FIRST_NAME,LAST_NAME, AGE, SEX, 
         INCOME) VALUES " + "(${firstname}, ${lastname}, ${age}, ${sex}, ${income} )"
			
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      } catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
		
      sql.close()
   }
}

पढ़ें ऑपरेशन

किसी भी डेटाबेस पर पढ़ें ऑपरेशन का मतलब डेटाबेस से कुछ उपयोगी जानकारी प्राप्त करना है। एक बार हमारा डेटाबेस कनेक्शन स्थापित हो जाने के बाद, आप इस डेटाबेस में एक प्रश्न बनाने के लिए तैयार हैं।

रीड ऑपरेशन, वर्ग वर्ग की प्रत्येक विधि का उपयोग करके किया जाता है।

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

eachRow(GString gstring, Closure closure)

दिए गए SQL क्वेरी को परिणाम सेट की प्रत्येक पंक्ति के साथ दिए गए क्लोजर को कॉल करता है।

Parameters

Gstring - एसक्यूएल बयान जिसे निष्पादित करने की आवश्यकता है।
Closure- रीड ऑपरेशन से पुनर्प्राप्त पंक्तियों को संसाधित करने के लिए क्लोजर स्टेटमेंट। दिए गए SQL क्वेरी को परिणाम सेट की प्रत्येक पंक्ति के साथ दिए गए क्लोजर को कॉल करता है।

निम्न कोड उदाहरण दिखाता है कि कर्मचारी तालिका से सभी रिकॉर्ड कैसे प्राप्त करें।

import java.sql.*; 
import groovy.sql.Sql
 
class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test123', 'com.mysql.jdbc.Driver')  
			
      sql.eachRow('select * from employee') {
         tp -> 
         println([tp.FIRST_NAME,tp.LAST_NAME,tp.age,tp.sex,tp.INCOME])
      }  
		
      sql.close()
   } 
}

उपरोक्त कार्यक्रम से उत्पादन होगा -

[Mac, Mohan, 20, M, 2000.0]

अद्यतन अद्यतन करें

किसी भी डेटाबेस पर अद्यतन ऑपरेशन का मतलब एक या एक से अधिक रिकॉर्ड को अद्यतन करना है, जो पहले से ही डेटाबेस में उपलब्ध हैं। निम्न प्रक्रिया SEX वाले सभी रिकॉर्ड को 'M' के रूप में अपडेट करती है। यहां, हम सभी पुरुषों के एजीई को एक वर्ष तक बढ़ाते हैं।

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args){
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test@123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false
      def sqlstr = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'" 
	  
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback() 
         println("Transaction rollback")
      }
		
      sql.close()
   } 
}

DELETE ऑपरेशन

DELETE ऑपरेशन की आवश्यकता तब होती है जब आप अपने डेटाबेस से कुछ रिकॉर्ड हटाना चाहते हैं। निम्नलिखित EMPLOYEE से सभी रिकॉर्ड को हटाने की प्रक्रिया है, जहां AGE 20 से अधिक है।

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test@123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false
      def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20"
   
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
   
      sql.close()
   } 
}

लेन-देन करना

लेन-देन एक ऐसा तंत्र है जो डेटा स्थिरता सुनिश्चित करता है। लेनदेन के निम्नलिखित चार गुण हैं -

Atomicity - या तो लेन-देन पूरा हो जाता है या कुछ भी नहीं होता है।
Consistency - लेन-देन सुसंगत अवस्था में शुरू होना चाहिए और सिस्टम को सुसंगत अवस्था में छोड़ना चाहिए।
Isolation - लेन-देन के मध्यवर्ती परिणाम वर्तमान लेनदेन के बाहर दिखाई नहीं देते हैं।
Durability - एक बार लेनदेन किए जाने के बाद, सिस्टम की विफलता के बाद भी प्रभाव लगातार बना रहता है।

लेन-देन को कैसे लागू किया जाए, इसका एक सरल उदाहरण यहां दिया गया है। हमने इस उदाहरण को DELETE ऑपरेशन के अपने पिछले विषय से पहले ही देख लिया है।

def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20" 
 
try {
   sql.execute(sqlstr); 
   sql.commit()
   println("Successfully committed") 
}catch(Exception ex) {
   sql.rollback()
   println("Transaction rollback") 
} 
sql.close()

संचालन करें

प्रतिबद्ध ऑपरेशन वह है जो डेटाबेस को ऑपरेशन के साथ आगे बढ़ने और डेटाबेस के सभी परिवर्तनों को अंतिम रूप देने के लिए कहता है।

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

sql.commit()

रोलबैक ऑपरेशन

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

sql.rollback()

डेटाबेस को डिस्कनेक्ट कर रहा है

डेटाबेस कनेक्शन को डिस्कनेक्ट करने के लिए, बंद विधि का उपयोग करें।

sql.close()

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

स्विंग बिल्डर

ग्रूवी में ग्रूवी में उपलब्ध स्विंग बिल्डरों का उपयोग करके ग्राफिकल यूजर इंटरफेस भी बनाया जा सकता है। स्विंग घटकों को विकसित करने के लिए मुख्य वर्ग स्विंगब्यूलर क्लास है। इस वर्ग में चित्रमय घटक बनाने के लिए कई तरीके हैं जैसे -

JFrame - यह फ्रेम एलिमेंट बनाने के लिए है।
JTextField - इसका उपयोग टेक्स्टफील्ड घटक बनाने के लिए किया जाता है।

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

आपको groovy.swing.wingBuilder और javax.swing। * कक्षाएं आयात करने की आवश्यकता है।
सभी स्वेटिंग एप्लिकेशन में प्रदर्शित होने वाले वेनेटसेट, स्विंगबर्स्ट क्लास का हिस्सा हैं।
फ्रेम के लिए ही, आप फ्रेम के प्रारंभिक स्थान और आकार को निर्दिष्ट कर सकते हैं। आप फ़्रेम का शीर्षक भी निर्दिष्ट कर सकते हैं।
दिखाए जाने वाले फ़्रेम के लिए आपको दृश्यता गुण को सही पर सेट करने की आवश्यकता है।

import groovy.swing.SwingBuilder 
import javax.swing.* 

// Create a builder 
def myapp = new SwingBuilder()

// Compose the builder 
def myframe = myapp.frame(title : 'Tutorials Point', location : [200, 200], 
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE {         
      label(text : 'Hello world')
   } 
	
// The following  statement is used for displaying the form 
frame.setVisible(true)

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है। निम्न आउटपुट एक JFrame के साथ हैलो वर्ल्ड के टेक्स्ट के साथ JLabel दिखाता है।

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

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

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.*
 
// Create a builder 
def myapp = new SwingBuilder() 

// Compose the builder 
def myframe = myapp.frame(title : 'Tutorials Point', location : [200, 200], 
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE) { 
      panel(layout: new GridLayout(3, 2, 5, 5)) { 
         label(text : 'Student Name:', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '', columns : 10) 
			
         label(text : 'Subject Name:', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '', columns : 10)
			
         label(text : 'School Name:', horizontalAlignment : JLabel.RIGHT) 
         textField(text : '', columns : 10) 
      } 
   } 
	
// The following  statement is used for displaying the form 
myframe.setVisible(true)

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है -

इवेंट हैंडलर

अब आइए इवेंट हैंडलर देखें। जब बटन दबाया जाता है तो किसी तरह की प्रोसेसिंग करने के लिए बटन के लिए इवेंट हैंडलर का उपयोग किया जाता है। प्रत्येक बटन स्यूडोमेथोड कॉल में एक्शनपेरफॉर्म पैरामीटर शामिल है। यह एक कोड ब्लॉक को एक क्लोजर के रूप में प्रस्तुत करता है।

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

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

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.* 

def myapp = new SwingBuilder()
  
def buttonPanel = {
   myapp.panel(constraints : BorderLayout.SOUTH) {
	
      button(text : 'Option A', actionPerformed : {
         println 'Option A chosen'
      })
		
      button(text : 'Option B', actionPerformed : {
         println 'Option B chosen'
      })
   }
}
  
def mainPanel = {
   myapp.panel(layout : new BorderLayout()) {
      label(text : 'Which Option do you want', horizontalAlignment : 
      JLabel.CENTER,
      constraints : BorderLayout.CENTER)
      buttonPanel()
   }
}
  
def myframe = myapp.frame(title : 'Tutorials Point', location : [100, 100],
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE){
      mainPanel()
   }
	
myframe.setVisible(true)

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

उपरोक्त उदाहरण की एक और भिन्नता उन तरीकों को परिभाषित करना है जो हैंडलर के रूप में कार्य कर सकते हैं। निम्नलिखित उदाहरण में हम DisplayA और DisplayB के 2 हैंडलर को परिभाषित कर रहे हैं।

import groovy.swing.SwingBuilder 
import javax.swing.* 
import java.awt.* 

def myapp = new SwingBuilder()
  
def DisplayA = {
   println("Option A") 
} 

def DisplayB = {
   println("Option B")
}

def buttonPanel = {
   myapp.panel(constraints : BorderLayout.SOUTH) {
      button(text : 'Option A', actionPerformed : DisplayA) 
      button(text : 'Option B', actionPerformed : DisplayB)
   }
}  

def mainPanel = {
   myapp.panel(layout : new BorderLayout()) {
      label(text : 'Which Option do you want', horizontalAlignment : JLabel.CENTER,
      constraints : BorderLayout.CENTER)
      buttonPanel()
   }
}  

def myframe = myapp.frame(title : 'Tutorials Point', location : [100, 100],
   size : [400, 300], defaultCloseOperation : WindowConstants.EXIT_ON_CLOSE) {
      mainPanel()
   } 
	
myframe.setVisible(true)

उपरोक्त कार्यक्रम का आउटपुट पहले के उदाहरण जैसा ही रहेगा।

डोम बिल्डर

DOM बिल्डर का उपयोग HTML, XHTML और XML पार्स करने और इसे W3C DOM ट्री में बदलने के लिए किया जा सकता है।

निम्न उदाहरण दिखाता है कि DOM बिल्डर का उपयोग कैसे किया जा सकता है।

String records = '''
   <library>
	
      <Student>
         <StudentName division = 'A'>Joe</StudentName>
         <StudentID>1</StudentID>
      </Student>
	  
      <Student>
         <StudentName division = 'B'>John</StudentName>
         <StudentID>2</StudentID>
      </Student>
	  
      <Student>
         <StudentName division = 'C'>Mark</StudentName>
         <StudentID>3</StudentID>
      </Student>
		
   </library>'''
   
def rd = new StringReader(records) 
def doc = groovy.xml.DOMBuilder.parse(rd)

JsonBuilder

JsonBuilder का उपयोग json प्रकार की वस्तुओं को बनाने के लिए किया जाता है।

निम्नलिखित उदाहरण से पता चलता है कि Json बिल्डर का उपयोग कैसे किया जा सकता है।

def builder = new groovy.json.JsonBuilder() 

def root = builder.students {
   student {
      studentname 'Joe'
      studentid '1'
		
      Marks(
         Subject1: 10,
         Subject2: 20,
         Subject3:30,
      )
   } 
} 
println(builder.toString());

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है। आउटपुट स्पष्ट रूप से दर्शाता है कि जौनबिल्डर नोड्स के एक संरचित सेट से जसन ऑब्जेक्ट का निर्माण करने में सक्षम था।

{"students":{"student":{"studentname":"Joe","studentid":"1","Marks":{"Subject1":10,
"S ubject2":20,"Subject3":30}}}}

जॉन्सबिल्डर एक सूची में भी ले सकता है और इसे एक जेन्स ऑब्जेक्ट में बदल सकता है। निम्नलिखित उदाहरण दिखाता है कि यह कैसे पूरा किया जा सकता है।

def builder = new groovy.json.JsonBuilder() 
def lst = builder([1, 2, 3]) 
println(builder.toString());

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है।

[1,2,3]

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

def builder = new groovy.json.JsonBuilder() 

class Student {
   String name  
} 

def studentlist = [new Student (name: "Joe"), new Student (name: "Mark"), 
   new Student (name: "John")] 
	
builder studentlist, { Student student ->name student.name} 
println(builder)

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है।

[{"name":"Joe"},{"name":"Mark"},{"name":"John"}]

NodeBuilder

NodeBuilder का उपयोग मनमाने डेटा से निपटने के लिए नोड ऑब्जेक्ट्स के नेस्टेड पेड़ बनाने के लिए किया जाता है। एक Nodebuilder के उपयोग का एक उदाहरण नीचे दिखाया गया है।

def nodeBuilder = new NodeBuilder() 

def studentlist = nodeBuilder.userlist {
   user(id: '1', studentname: 'John', Subject: 'Chemistry')
   user(id: '2', studentname: 'Joe', Subject: 'Maths')
   user(id: '3', studentname: 'Mark', Subject: 'Physics') 
} 

println(studentlist)

FileTreeBuilder

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

tmpDir = File.createTempDir() 
def fileTreeBuilder = new FileTreeBuilder(tmpDir) 

fileTreeBuilder.dir('main') {
   dir('submain') {
      dir('Tutorial') {
        file('Sample.txt', 'println "Hello World"')
      }
   } 
}

उपर्युक्त कोड के निष्पादन से नमूना मेनटेक्स्ट नामक एक फ़ाइल मुख्य / सबमेन / ट्यूटोरियल में बनाई जाएगी। और sample.txt फ़ाइल में "हैलो वर्ल्ड" का टेक्स्ट होगा।

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

ग्रूवी में उपलब्ध कमांड लाइन विकल्प निम्नलिखित हैं -

कमांड लाइन पैरामीटर	पूरा नाम	विवरण
-सी	--color [= फ्लैग]	ANSI रंगों का उपयोग सक्षम या अक्षम करें
डी	--define = नाम = मूल्य	एक सिस्टम प्रॉपर्टी को परिभाषित करें
आयकर	--terminal = प्रकार	टर्मिनल TYPE का उपयोग करने के लिए निर्दिष्ट करें
-वी	--version	संस्करण प्रदर्शित करें
-classpath		निर्दिष्ट करें कि कक्षा फ़ाइलों को कहाँ खोजें - पहला तर्क होना चाहिए
-cp	--classpath	'-क्लासपथ' के लिए उपनाम
डी	--debug	- डिबग डिबग आउटपुट सक्षम करें
-इ	--evaluate = आर्ग	इंटरेक्टिव सत्र शुरू करते समय विकल्प मुट्ठी का मूल्यांकन करें
एच	--मदद	यह सहायता संदेश प्रदर्शित करें
-q	--चुप	शानदार उत्पादन को दबाएं
-v	--verbose	वर्बोज़ आउटपुट सक्षम करें

निम्नलिखित स्नैपशॉट एक अभिव्यक्ति का सरल उदाहरण दिखाता है जिसे ग्रूवी शेल में निष्पादित किया जाता है। निम्नलिखित उदाहरण में हम सिर्फ ग्रूवी शेल में "हैलो वर्ल्ड" छाप रहे हैं।

कक्षाएं और कार्य

कमांड प्रॉम्प्ट में एक क्लास को परिभाषित करना, एक नई वस्तु बनाना और क्लास पर एक विधि लागू करना बहुत आसान है। निम्न उदाहरण दिखाता है कि इसे कैसे लागू किया जा सकता है। निम्नलिखित उदाहरण में, हम एक सरल विधि के साथ एक सरल छात्र वर्ग बना रहे हैं। कमांड प्रॉम्प्ट में, हम क्लास का एक ऑब्जेक्ट बना रहे हैं और डिस्प्ले मेथड को कॉल कर रहे हैं।

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

आदेश

शेल में कई अलग-अलग कमांड होते हैं, जो शेल के वातावरण में समृद्ध पहुंच प्रदान करते हैं। निम्नलिखित उनकी सूची है और वे क्या करते हैं।

अनु क्रमांक	कमांड & smp; कमांड विवरण
1	:help ((ज) इस मदद संदेश को प्रदर्शित करें
2	? (:?) उपनाम: से: मदद
3	:exit (x) शेल से बाहर निकलें
4	:quit (क्यू) उपनाम: से: बाहर निकलें
5	import (: i) नामस्थान में एक वर्ग आयात करें
6	:display ((घ) वर्तमान बफर प्रदर्शित करें
7	:clear ((c) बफर को साफ़ करें और प्रॉम्प्ट काउंटर को रीसेट करें
8	:show (एस) चर, वर्ग या आयात दिखाएं
9	:inspect (एन) GUI ऑब्जेक्ट ब्राउज़र के साथ एक चर या अंतिम परिणाम का निरीक्षण करें
10	:purge ((पी) शुद्ध चर, कक्षाएं, आयात या प्राथमिकताएं
1 1	:edit (ई) वर्तमान बफ़र संपादित करें
12	:load ((l) फ़ाइल या URL को बफ़र में लोड करें
13	. (:।) उपनाम: से: लोड
14	.save (एस) वर्तमान बफर को एक फ़ाइल में सहेजें
15	.record ((r) वर्तमान सत्र को फ़ाइल में रिकॉर्ड करें
16	:alias (एक) एक उपनाम बनाएँ
17	:set (: =) सेट (या सूची) वरीयताएँ
18	:register ((rc) शेल के साथ एक नई कमांड रजिस्टर करता है
19	:doc ((डी) तर्क के लिए डॉक्टर को प्रदर्शित करने वाली एक ब्राउज़र विंडो खोलता है
20	:history (एच) प्रदर्शन, प्रबंधन और संपादन लाइन इतिहास को याद करते हैं

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

JUnit एक ओपन-सोर्स टेस्टिंग फ्रेमवर्क है जो जावा कोड की स्वचालित इकाई परीक्षण के लिए स्वीकृत उद्योग मानक है। सौभाग्य से, ग्रूवी कक्षाओं के परीक्षण के लिए जेयूनेट ढांचे का आसानी से उपयोग किया जा सकता है। सभी आवश्यक है कि GroovyTestCase वर्ग का विस्तार करना है जो मानक Groovy वातावरण का हिस्सा है। ग्रूवी टेस्ट केस क्लास जूनिट टेस्ट केस पर आधारित है।

सिंपल जूनिट टेस्ट केस लिखना

मान लें कि हमारे पास एप्लिकेशन क्लास फ़ाइल में निम्न वर्ग परिभाषित है -

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.name = "Joe";
      mst.ID = 1;
      println(mst.Display())
   } 
} 
 
public class Student {
   String name;
   int ID;
	
   String Display() {
      return name +ID;
   }  
}

उपरोक्त कार्यक्रम का आउटपुट नीचे दिया गया है।

Joe1

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

टेस्ट केस क्लास ग्रूवटेस्ट क्लास को बढ़ाता है
हम यह सुनिश्चित करने के लिए मुखर कथन का उपयोग कर रहे हैं कि प्रदर्शन विधि सही स्ट्रिंग लौटाती है।

class StudentTest extends GroovyTestCase {
   void testDisplay() {
      def stud = new Student(name : 'Joe', ID : '1')
      def expected = 'Joe1'
      assertToString(stud.Display(), expected)
   }
}

ग्रूवी टेस्ट सूट

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

GroovyTestSuite का उपयोग सभी परीक्षण मामलों को एक में करने के लिए किया जाता है।
निम्नलिखित उदाहरण में, हम मान रहे हैं कि हमारे पास दो परीक्षण केस फाइलें हैं, जिन्हें एक कहा जाता है StudentTest और दूसरा है EmployeeTest जिसमें सभी आवश्यक परीक्षण शामिल हैं।

import groovy.util.GroovyTestSuite 
import junit.framework.Test 
import junit.textui.TestRunner 

class AllTests { 
   static Test suite() { 
      def allTests = new GroovyTestSuite() 
      allTests.addTestSuite(StudentTest.class) 
      allTests.addTestSuite(EmployeeTest.class) 
      return allTests 
   } 
} 

TestRunner.run(AllTests.suite())

ग्रूवी का टेम्प्लेट इंजन एक मेल मर्ज (एक डेटाबेस से पत्र और लिफाफे के लिए स्वचालित रूप से नाम और पते का स्वचालित जोड़) मेल, विशेष रूप से कई पते पर भेजने की सुविधा के लिए संचालित होता है, लेकिन यह बहुत अधिक सामान्य है।

स्ट्रिंग्स में सरल अस्थायी

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

def name = "Groovy" 
println "This Tutorial is about ${name}"

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

सरल टेम्पलेट इंजन

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

def text ='This Tutorial focuses on $TutorialName. In this tutorial you will learn 

about $Topic'  

def binding = ["TutorialName":"Groovy", "Topic":"Templates"]  
def engine = new groovy.text.SimpleTemplateEngine() 
def template = engine.createTemplate(text).make(binding) 

println template

यदि उपरोक्त कोड को groovy में निष्पादित किया जाता है, तो निम्न आउटपुट दिखाया जाएगा।

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

<Student> 
   <name>${name}</name> <ID>${id}</ID> 
   <subject>${subject}</subject> 
</Student>

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

वास्तविक मानों के लिए जगह-धारकों की मैपिंग एक बाध्यकारी और एक SimpleTemplateEngine के माध्यम से की जाती है। बाइंडिंग एक मैप है जिसमें प्लेस-होल्डर्स कीज़ और मानों के रूप में रिप्लेसमेंट हैं।

import groovy.text.* 
import java.io.* 

def file = new File("D:/Student.template") 
def binding = ['name' : 'Joe', 'id' : 1, 'subject' : 'Physics']
				  
def engine = new SimpleTemplateEngine() 
def template = engine.createTemplate(file) 
def writable = template.make(binding) 

println writable

यदि उपरोक्त कोड को groovy में निष्पादित किया जाता है, तो निम्न आउटपुट दिखाया जाएगा। आउटपुट से यह देखा जा सकता है कि संबंधित प्लेसहोल्डर्स में मान सफलतापूर्वक बदल दिए गए हैं।

<Student> 
   <name>Joe</name> 
   <ID>1</ID> 
   <subject>Physics</subject> 
</Student>

StreamingTemplateEngine

StreamingTemplateEngine इंजन ग्रूवी में उपलब्ध एक और टेम्पलगेट इंजन है। यह SimpleTemplateEngine के बराबर है, लेकिन यह बड़े टेम्पलेट के लिए अधिक स्केलेबल बनाते हुए लेखन योग्य क्लोजर का उपयोग करके टेम्पलेट बनाता है। विशेष रूप से यह टेम्पलेट इंजन 64k से बड़े तार को संभाल सकता है।

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

def text = '''This Tutorial is <% out.print TutorialName %> The Topic name 

is ${TopicName}''' 
def template = new groovy.text.StreamingTemplateEngine().createTemplate(text)
  
def binding = [TutorialName : "Groovy", TopicName  : "Templates",]
String response = template.make(binding) 
println(response)

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngine का उपयोग टेम्प्लेटिंग परिदृश्यों में किया जाता है, जहां टेम्पलेट स्रोत और अपेक्षित आउटपुट दोनों XML होने का इरादा रखते हैं। टेम्प्लेट सामान्य का उपयोग करते हैं${expression} and $टेम्पलेट में एक मनमाना अभिव्यक्ति डालने के लिए चर अंकन।

निम्नलिखित का एक उदाहरण है कि XMLTemplateEngine का उपयोग कैसे किया जाता है।

def binding = [StudentName: 'Joe', id: 1, subject: 'Physics'] 
def engine = new groovy.text.XmlTemplateEngine() 

def text = '''\
   <document xmlns:gsp='http://groovy.codehaus.org/2005/gsp'>
      <Student>
         <name>${StudentName}</name> <ID>${id}</ID>
         <subject>${subject}</subject>
      </Student>
   </document> 
''' 

def template = engine.createTemplate(text).make(binding) 
println template.toString()

यदि उपरोक्त कोड को groovy में निष्पादित किया जाता है, तो निम्न आउटपुट दिखाया जाएगा

Joe
    
    
   1
    
    
   Physics

मेटा ऑब्जेक्ट प्रोग्रामिंग या एमओपी का उपयोग गतिशील रूप से तरीकों को लागू करने और मक्खी पर कक्षाएं और तरीके बनाने के लिए भी किया जा सकता है।

अच्छा तो इसका क्या मतलब है? आइए विद्यार्थी नामक एक वर्ग पर विचार करें, जो किसी सदस्य चर या विधियों के साथ एक खाली वर्ग की तरह है। मान लीजिए अगर आपको इस वर्ग पर निम्नलिखित कथनों को आमंत्रित करना था।

Def myStudent = new Student() 
myStudent.Name = ”Joe”; 
myStudent.Display()

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

यह कैसे काम कर सकता है? खैर, इसके लिए वर्कआउट करने के लिए, किसी को ग्रूवी की निष्पादन प्रक्रिया में हुक लगाने के लिए GroovyInterceptable इंटरफ़ेस को लागू करना होगा। इस इंटरफ़ेस के लिए उपलब्ध तरीके निम्नलिखित हैं।

Public interface GroovyInterceptable { 
   Public object invokeMethod(String methodName, Object args) 
   Public object getproperty(String propertyName) 
   Public object setProperty(String propertyName, Object newValue) 
   Public MetaClass getMetaClass() 
   Public void setMetaClass(MetaClass metaClass) 
}

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

गुम गुण

तो आइए एक उदाहरण देखें कि हम लापता गुणों के लिए मेटा ऑब्जेक्ट प्रोग्रामिंग को कैसे लागू कर सकते हैं। निम्नलिखित कुंजी चीजों को निम्नलिखित कोड के बारे में ध्यान दिया जाना चाहिए।

कक्षा छात्र के पास नाम या आईडी परिभाषित कोई सदस्य चर नहीं है।
कक्षा के छात्र GroovyInterceptable इंटरफ़ेस को लागू करता है।
एक पैरामीटर है जिसे डायनामिकप्रॉप्स कहा जाता है जिसका उपयोग सदस्य चर के मूल्य को रखने के लिए किया जाएगा जो कि मक्खी पर बनाए जाते हैं।
रनटाइम के दौरान वर्ग की संपत्ति के मूल्यों को प्राप्त करने और सेट करने के लिए तरीके getproperty और setproperty लागू किए गए हैं।

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;
		
      println(mst.Name);
      println(mst.ID);
   }
}

class Student implements GroovyInterceptable { 
   protected dynamicProps=[:]
	
   void setProperty(String pName,val) {
      dynamicProps[pName] = val
   }
   
   def getProperty(String pName) {
      dynamicProps[pName]
   } 
}

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

Joe 
1

गुम करने की विधियाँ

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

क्लास स्टूडेंट अब इनवोकमैथोड पद्धति को लागू करता है, जिसे इस बात की परवाह किए बिना कहा जाता है कि यह विधि मौजूद है या नहीं।

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;
		
      println(mst.Name);
      println(mst.ID);
      mst.AddMarks();
   } 
}
 
class Student implements GroovyInterceptable {
   protected dynamicProps = [:]  
    
   void setProperty(String pName, val) {
      dynamicProps[pName] = val
   } 
   
   def getProperty(String pName) {
      dynamicProps[pName]
   }
   
   def invokeMethod(String name, Object args) {
      return "called invokeMethod $name $args"
   }
}

निम्न कोडव्यू का आउटपुट नीचे दिखाया गया है। ध्यान दें कि विधि प्रदर्शन मौजूद नहीं होने के बावजूद लापता विधि अपवाद की कोई त्रुटि नहीं है।

Joe 
1

Metaclass

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

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      println mst.getName()
      mst.metaClass.setAttribute(mst, 'name', 'Mark')
      println mst.getName()
   } 
} 

class Student {
   private String name = "Joe";
	
   public String getName() {
      return this.name;
   } 
}

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

Joe 
Mark

विधि याद आ रही है

ग्रूवी मेथमसिंग की अवधारणा का समर्थन करता है। यह विधि invokeMethod से भिन्न है कि यह केवल एक विफल विधि प्रेषण के मामले में लागू किया जाता है, जब दिए गए नाम और / या दिए गए तर्कों के लिए कोई विधि नहीं मिल सकती है। निम्न उदाहरण दिखाता है कि मेथडिसिंग का उपयोग कैसे किया जा सकता है।

class Example {
   static void main(String[] args) {
      Student mst = new Student();
      mst.Name = "Joe";
      mst.ID = 1;
		
      println(mst.Name);
      println(mst.ID);
      mst.AddMarks();
   } 
} 

class Student implements GroovyInterceptable {
   protected dynamicProps = [:]  
    
   void setProperty(String pName, val) {
      dynamicProps[pName] = val
   }
   
   def getProperty(String pName) {
      dynamicProps[pName]
   }
   
   def methodMissing(String name, def args) {         
      println "Missing method"
   }  
}

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

Joe 
1 
Missing method