Groovy - Hızlı Kılavuz

Groovy, Java platformuna dayanan nesne yönelimli bir dildir. Groovy 1.0, Groovy 2.4 ile 2 Ocak 2007'de piyasaya sürüldü. Groovy, Apache License v 2.0 aracılığıyla dağıtılır.

Groovy'nin Özellikleri

Groovy aşağıdaki özelliklere sahiptir -

• Hem statik hem de dinamik yazım desteği.
• Operatör aşırı yükleme desteği.
• Listeler ve ilişkilendirilebilir diziler için yerel sözdizimi.
• Normal ifadeler için yerel destek.
• XML ve HTML gibi çeşitli biçimlendirme dilleri için yerel destek.
• Groovy, Java ve Groovy'nin sözdizimi çok benzer olduğundan Java geliştiricileri için basittir.
• Mevcut Java kitaplıklarını kullanabilirsiniz.
• Groovy, java.lang.Object'i genişletir.

Groovy'nin resmi web sitesi http://www.groovy-lang.org/

Groovy ortam kurulumunu elde etmenin çeşitli yolları vardır.

Binary download and installation- Windows Installer bölümünü almak için www.groovy-lang.org/download.html bağlantısına gidin . Groovy yükleyiciyi indirmeye başlamak için bu seçeneğe tıklayın.

Yükleyiciyi başlattıktan sonra, kurulumu tamamlamak için aşağıda verilen adımları izleyin.

Step 1 - Dil yükleyicisini seçin.

Step 2 - Sonraki ekranda İleri düğmesine tıklayın.

Step 3 - 'Kabul Ediyorum' düğmesini tıklayın.

Step 4 - Varsayılan bileşenleri kabul edin ve İleri düğmesine tıklayın.

Step 5 - Uygun hedef klasörü seçin ve ardından İleri düğmesine tıklayın.

Step 6 - Kurulumu başlatmak için Kur düğmesine tıklayın.

Step 7 - Kurulum tamamlandığında, yapılandırmayı başlatmak için İleri düğmesine tıklayın.

Step 8 - Varsayılan seçenekleri seçin ve İleri düğmesini tıklayın.

Step 9 - Varsayılan dosya ilişkilendirmelerini kabul edin ve İleri düğmesini tıklayın.

Step 10 - Kurulumu tamamlamak için Bitir düğmesine tıklayın.

Yukarıdaki adımlar izlendikten sonra, Groovy için tam teşekküllü bir entegre geliştirme ortamına sahip olmanıza gerek kalmadan Groovy dilinin farklı yönlerini test etmeye yardımcı olan Groovy kurulumunun parçası olan groovy kabuğu başlatabilirsiniz. Bu, groovysh komutunu komut isteminden çalıştırarak yapılabilir.

Harika ikili dosyaları maven veya gradle yapınızın bir parçası olarak dahil etmek istiyorsanız, aşağıdaki satırları ekleyebilirsiniz

Gradle

'org.codehaus.groovy:groovy:2.4.5'

Uzman

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

Groovy'nin temel sözdizimini anlamak için önce basit bir Hello World programına bakalım.

İlk Merhaba Dünya Programınızı Oluşturma

İlk merhaba dünya programınızı oluşturmak, aşağıdaki kod satırını girmek kadar basittir -

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

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello World

Groovy'de İthalat İfadesi

Import deyimi, kodunuzda kullanılabilecek diğer kitaplıkların işlevlerini içe aktarmak için kullanılabilir. Bu,import anahtar kelime.

Aşağıdaki örnek, HTML veya XML biçimlendirmesi oluşturmak için muhtemelen en çok kullanılan sınıflardan biri olan MarkupBuilder sınıfının basit bir içe aktarımının nasıl kullanılacağını gösterir.

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

Varsayılan olarak, Groovy kodunuza aşağıdaki kitaplıkları dahil eder, bu nedenle bunları açıkça içe aktarmanız gerekmez.

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

Groovy'de Jetonlar

Bir belirteç, bir anahtar sözcük, bir tanımlayıcı, bir sabit, bir dize değişmezi veya bir semboldür.

println(“Hello World”);

Yukarıdaki kod satırında, iki simge vardır, birincisi println anahtar sözcüğü ve diğeri "Merhaba Dünya" dize hazır bilgisidir.

Groovy için yorumlar

Kodunuzu belgelemek için yorumlar kullanılır. Groovy'deki yorumlar tek satır veya çok satırlı olabilir.

Tek satır açıklamalar, satırın herhangi bir konumunda // kullanılarak tanımlanır. Aşağıda bir örnek gösterilmiştir -

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

Çok satırlı açıklamalar, çok satırlı yorumun başında / * ve sonunu belirtmek için * / ile tanımlanır.

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

Noktalı virgül

Java programlama dilinden farklı olarak, her ifadenin bitiminden sonra noktalı virgül kullanılması zorunlu değildir, isteğe bağlıdır.

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

Yukarıdaki programı çalıştırırsanız, ana yöntemdeki her iki ifade de herhangi bir hata oluşturmaz.

Tanımlayıcılar

Tanımlayıcılar değişkenleri, işlevleri veya diğer kullanıcı tanımlı değişkenleri tanımlamak için kullanılır. Tanımlayıcılar bir harf, dolar veya alt çizgiyle başlar. Bir sayı ile başlayamazlar. İşte bazı geçerli tanımlayıcı örnekleri -

def employeename 
def student1 
def student_name

nerede def Groovy'de bir tanımlayıcıyı tanımlamak için kullanılan bir anahtar kelimedir.

Hello World programımızda bir tanımlayıcının nasıl kullanılabileceğine dair bir kod örneği.

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'); 
   }
}

Yukarıdaki örnekte, değişken x tanımlayıcı olarak kullanılır.

Anahtar kelimeler

Adından da anlaşılacağı gibi anahtar sözcükler, Groovy Programlama dilinde ayrılmış özel sözcüklerdir. Aşağıdaki tablo Groovy'de tanımlanan anahtar sözcükleri listeler.

gibi	iddia etmek	kırmak	durum
tutmak	sınıf	sabit	devam et
def	varsayılan	yapmak	Başka
Sıralama	genişler	yanlış	En sonunda
için	git	Eğer	uygular
ithalat	içinde	örneği	arayüz
yeni	Çek	paket	dönüş
Süper	değiştirmek	bu	atmak
atar	kişisel özellik	doğru	Deneyin
süre

Beyaz boşluklar

Boşluk, Java ve Groovy gibi bir programlama dilinde boşlukları, sekmeleri, yeni satır karakterlerini ve yorumları tanımlamak için kullanılan terimdir. Boşluk, bir ifadenin bir bölümünü diğerinden ayırır ve derleyicinin bir ifadedeki bir öğenin nerede olduğunu belirlemesini sağlar.

Örneğin, aşağıdaki kod örneğinde, anahtar kelime arasında beyaz bir boşluk var defve x değişkeni. Bu, derleyicinin bunu bilmesi içindef kullanılması gereken anahtar kelimedir ve bu x, tanımlanması gereken değişken adı olmalıdır.

def x = 5;

Değişmezler

Bir literal, groovy'de sabit bir değeri temsil eden bir gösterimdir. Harika dil tam sayılar, kayan nokta sayıları, karakterler ve dizeler için notasyonlara sahiptir. İşte Groovy programlama dilindeki değişmez değer örneklerinden bazıları -

12 
1.45 
‘a’ 
“aa”

Herhangi bir programlama dilinde, çeşitli bilgi türlerini depolamak için çeşitli değişkenler kullanmanız gerekir. Değişkenler, değerleri saklamak için ayrılmış bellek konumlarından başka bir şey değildir. Bu, bir değişken oluşturduğunuzda, değişkenle ilişkili değeri depolamak için bellekte biraz yer ayırdığınız anlamına gelir.

Dize, karakter, geniş karakter, tam sayı, kayan nokta, Boole, vb. Gibi çeşitli veri türlerinin bilgilerini depolamak isteyebilirsiniz. Bir değişkenin veri türüne bağlı olarak, işletim sistemi belleği ayırır ve ayrılmışta nelerin saklanabileceğine karar verir. hafıza.

Yerleşik Veri Türleri

Groovy, çok çeşitli yerleşik veri türleri sunar. Groovy'de tanımlanan veri türlerinin listesi aşağıdadır -

• byte- Bu, bir bayt değerini temsil etmek için kullanılır. Bir örnek 2'dir.

• short- Bu, kısa bir sayıyı temsil etmek için kullanılır. Bir örnek 10'dur.

• int- Bu, tam sayıları temsil etmek için kullanılır. Bir örnek 1234'tür.

• long- Bu, uzun bir sayıyı temsil etmek için kullanılır. Bir örnek 10000090'dır.

• float- Bu, 32 bitlik kayan nokta sayılarını temsil etmek için kullanılır. Bir örnek 12.34'tür.

• double- Bu, bazen gerekli olabilecek daha uzun ondalık sayı temsilleri olan 64 bitlik kayan noktalı sayıları temsil etmek için kullanılır. Bir örnek 12.3456565'tir.

• char- Bu, tek bir karakter değerini tanımlar. Bir örnek "a" dır.

• Boolean - Bu, doğru veya yanlış olabilen bir Boole değerini temsil eder.

• String - Bunlar, içinde temsil edilen metin değişmezleridir the formkarakter zinciri. Örneğin "Merhaba Dünya".

Sınır değerler

Aşağıdaki tablo, sayısal ve ondalık değişmezler için izin verilen maksimum değerleri gösterir.

bayt	-128 ila 127
kısa	-32.768 ila 32.767
int	-2.147.483.648 ile 2.147.483.647
uzun	-9,223,372,036,854,775,808 ile +9,223,372,036,854,775,807 arası
yüzen	1.40129846432481707e-45 ila 3.40282346638528860e + 38
çift	4.94065645841246544e-324d ila 1.79769313486231570e + 308d

Sınıf Sayısal

Türler İlkel türlere ek olarak, aşağıdaki nesne türlerine (bazen sarmalayıcı türleri olarak adlandırılır) izin verilir -

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

Ek olarak, aşağıdaki sınıflar isteğe bağlı kesinlik aritmetiğini desteklemek için kullanılabilir -

İsim	Açıklama	Misal
java.math.BigInteger	Değişmez keyfi hassas işaretli integral sayılar	30 g
java.math.BigDecimal	Değişmez keyfi hassas işaretli ondalık sayılar	3,5 g

Aşağıdaki kod örneği, farklı yerleşik veri türlerinin nasıl kullanılabileceğini gösterir -

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); 
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

5 
100 
10.56 
1.05E41 
30 
3.5

Groovy'deki değişkenler iki şekilde tanımlanabilir - native syntax veri türü için veya sonraki için by using the def keyword. Değişken tanımları için, ya açıkça bir tür adı sağlamak ya da yerine "def" kullanmak zorunludur. Bu, Groovy ayrıştırıcı tarafından gereklidir.

Önceki bölümde açıklandığı gibi Groovy'de aşağıdaki temel değişken türleri vardır -

• byte- Bu, bir bayt değerini temsil etmek için kullanılır. Bir örnek 2'dir.

• short- Bu, kısa bir sayıyı temsil etmek için kullanılır. Bir örnek 10'dur.

• int- Bu, tam sayıları temsil etmek için kullanılır. Bir örnek 1234'tür.

• long- Bu, uzun bir sayıyı temsil etmek için kullanılır. Bir örnek 10000090'dır.

• float- Bu, 32 bitlik kayan nokta sayılarını temsil etmek için kullanılır. Bir örnek 12.34'tür.

• double- Bu, bazen gerekli olabilecek daha uzun ondalık sayı temsilleri olan 64 bitlik kayan noktalı sayıları temsil etmek için kullanılır. Bir örnek 12.3456565'tir.

• char- Bu, tek bir karakter değerini tanımlar. Bir örnek "a" dır.

• Boolean - Bu, doğru veya yanlış olabilen bir Boole değerini temsil eder.

• String - Bunlar, içinde temsil edilen metin değişmezleridir the formkarakter zinciri. Örneğin "Merhaba Dünya".

Groovy ayrıca, sonraki bölümlerde göreceğimiz diziler, yapılar ve sınıflar gibi ek değişken türlerine de izin verir.

Değişken Beyanlar

Değişken bildirimi, derleyiciye değişken için depolamanın nerede ve ne kadar oluşturulacağını söyler.

Aşağıda, değişken bildirimine bir örnek verilmiştir -

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);
   }
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello

Değişkenleri Adlandırma

Bir değişkenin adı harflerden, rakamlardan ve alt çizgi karakterinden oluşabilir. Bir harf veya alt çizgiyle başlamalıdır. Büyük ve küçük harfler farklıdır çünkü Groovy, tıpkı Java gibi büyük / küçük harfe duyarlı bir programlama dili.

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); 
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

5 
6 
Joe

Bunu görebiliriz x ve X büyük / küçük harf duyarlılığı nedeniyle iki farklı değişkendir ve üçüncü durumda, _Name'in bir alt çizgiyle başladığını görebiliriz.

Değişkenleri Yazdırma

Bir değişkenin geçerli değerini println işlevi ile yazdırabilirsiniz. Aşağıdaki örnek bunun nasıl elde edilebileceğini göstermektedir.

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);  
   }
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Operatör, derleyiciye belirli matematiksel veya mantıksal işlemleri gerçekleştirmesini söyleyen bir semboldür.

Groovy aşağıdaki operatör türlerine sahiptir -

• Aritmetik operatörler
• İlişkisel operatörler
• Mantıksal operatörler
• Bitsel operatörler
• Atama operatörleri

Aritmetik operatörler

Groovy dili, herhangi bir dil gibi normal Aritmetik işleçlerini destekler. Aşağıda Groovy'de bulunan Aritmetik operatörler verilmiştir -

Örnek Göster

Şebeke	Açıklama	Misal
+	İki işlenenin eklenmesi	1 + 2 3 verir
-	İlk işlenenden ikinci işleneni çıkarır	2-1 1 verir
*	Her iki işlenenin çarpımı	2 * 2 4 verecek
/	Paydaya göre pay bölümü	3/2 1.5 verecek
%	Modül İşleci ve bir tamsayı / kayan bölümden sonra kalan kısım	% 3 2 1 verir
++	Artımlı operatörler, bir operandın değerini 1 artırmak için kullanılır	int x = 5; x ++; x 6 verecek
-	Artımlı operatörler, bir operandın değerini 1 azaltmak için kullanılır	int x = 5; x--; x 4 verecek

İlişkisel operatörler

İlişkisel operatörler, nesnelerin karşılaştırılmasına izin verir. Groovy'de bulunan ilişkisel operatörler aşağıdadır -

Örnek Göster

Şebeke	Açıklama	Misal
==	İki nesne arasındaki eşitliği test eder	2 == 2 doğru verecektir
! =	İki nesne arasındaki farkı test eder	3! = 2 doğru verecektir
<	Sol nesnelerin sağ işlenenden daha küçük olup olmadığını kontrol eder.	2 <3 doğru verecektir
<=	Sol nesnelerin sağ işlenenden küçük veya ona eşit olup olmadığını kontrol eder.	2 <= 3 doğru verecektir
>	Sol nesnelerin sağ işlenenden daha büyük olup olmadığını kontrol eder.	3> 2 doğru verecektir
> =	Sol nesnelerin sağ işlenenden büyük veya ona eşit olup olmadığını kontrol eder.	3> = 2 doğru verecektir

Mantıksal operatörler

Mantıksal operatörler, Boole ifadelerini değerlendirmek için kullanılır. Groovy'de bulunan mantıksal operatörler aşağıdadır -

Örnek Göster

Şebeke	Açıklama	Misal
&&	Bu, mantıksal "ve" operatörüdür	true && true verecek
||	Bu, mantıksal "veya" operatörüdür	doğru || doğru doğru verecek
!	Bu, mantıksal "değil" operatörüdür	! false doğru verecektir

Bitsel Operatörler

Groovy, dört bitsel operatör sağlar. Aşağıdakiler Groovy'de bulunan bitsel operatörlerdir -

Örnek Göster

Sr.No	Operatör ve Açıklama
1	& Bu bitsel "ve" operatörüdür
2	| Bu bitsel "veya" operatörüdür
3	^ Bu bitsel "xor" veya Exclusive veya operatördür
4	~ Bu, bitsel olumsuzlama operatörüdür

İşte bu operatörleri gösteren doğruluk tablosu.

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Atama operatörleri

Groovy dili ayrıca atama operatörleri sağlar. Groovy'de bulunan atama operatörleri aşağıdadır -

Örnek Göster

Şebeke	Açıklama	Misal
+ =	Bu, soldaki işlenene sağ işlenen ekler ve sonucu sol işlenenlere atar.	def A = 5 A + = 3 Çıktı 8 olacak
- =	Bu, sağ operandı soldaki operanddan çıkarır ve sonucu sol operanda atar	def A = 5 A- = 3 Çıktı 2 olacak
* =	Bu, sağ işleneni sol işlenenle çarpar ve sonucu sol işlenene atar	def A = 5 A * = 3 Çıktı 15 olacak
/ =	Bu, sol işleneni sağ işlenenle böler ve sonucu sol işlenene atar	def A = 6 A / = 3 Çıktı 2 olacak
% =	Bu, iki işlenen kullanarak modülü alır ve sonucu sol işlenenlere atar	def A = 5 A% = 3 Çıktı 2 olacak

Aralık Operatörleri

Groovy, aralık kavramını destekler ve .. notasyonu yardımıyla aralık operatörlerinin notasyonunu sağlar. Aralık operatörünün basit bir örneği aşağıda verilmiştir.

def range = 0..5

Bu sadece, alt sınırı 0 ve üst sınırı 5 olan aralık adı verilen yerel bir değişkene depolanan basit bir tam sayı aralığını tanımlar.

Aşağıdaki kod parçacığı, çeşitli operatörlerin nasıl kullanılabileceğini gösterir.

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

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

İtibaren println ifadesi, aralık ifadesinde tanımlanan tüm sayı aralığının görüntülendiğini görebilirsiniz.

Get ifadesi, parametre olarak bir dizin değerini alan tanımlanmış aralıktan bir nesne almak için kullanılır.

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

Operatör Önceliği

Aşağıdaki tablo tüm harika operatörleri öncelik sırasına göre listeler.

Sr.No	Operatörler ve İsimler
1	++ -- + - ön artırma / azaltma, tekli artı, tekli eksi
2	* / % çarpma, div, modulo
3	+ - toplama çıkarma
4	== != <=> eşittir, eşit değildir, karşılaştır
5	& ikili / bitsel ve
6	^ ikili / bit tabanlı xor
7	| ikili / bitsel veya
8	&& mantıksal ve
9	|| mantıksal veya
10	= **= *= /= %= += -= <<= >>= >>>= &= ^= |= Çeşitli atama operatörleri

Şimdiye kadar, birbiri ardına sıralı bir şekilde yürütülen ifadeler gördük. Ek olarak, Groovy'de bir programın mantığındaki kontrol akışını değiştirmek için ifadeler sağlanır. Daha sonra, ayrıntılı olarak göreceğimiz kontrol ifadeleri akışı olarak sınıflandırılırlar.

S.No.	İfadeler ve Açıklama
1	While İfadesi While ifadesi önce koşul ifadesi (bir Boole değeri) değerlendirilerek yürütülür ve sonuç doğruysa while döngüsündeki ifadeler çalıştırılır.
2	Açıklama için For ifadesi, bir dizi değeri yinelemek için kullanılır.
3	for-in Bildirimi For-in ifadesi, bir dizi değerde yineleme yapmak için kullanılır.

Döngü Kontrol İfadeleri

S.No.	İfadeler ve Açıklama
1	Break İfadesi Break deyimi, döngülerin ve anahtar deyimlerinin içindeki kontrol akışını değiştirmek için kullanılır.
2	Devam İfadesi Continue ifadesi break ifadesini tamamlar. Kullanımı while ve for döngüleri ile sınırlıdır.

Karar verme yapıları, programcının, program tarafından değerlendirilecek veya test edilecek bir veya daha fazla koşulu, koşulun geçerli olduğu belirlenirse yürütülecek bir ifade veya ifadeyle birlikte belirtmesini gerektirir. trueve isteğe bağlı olarak, koşul olarak belirlenirse yürütülecek diğer ifadeler false.

Sr.No.	İfadeler ve Açıklama
1	if İfadesi Bu ifadenin genel çalışması, ilk olarak if ifadesinde bir koşulun değerlendirilmesidir. Koşul doğruysa, daha sonra ifadeleri yürütür.
2	if / else İfadesi Bu ifadenin genel çalışması, ilk olarak if ifadesinde bir koşulun değerlendirilmesidir. Koşul doğruysa, daha sonra ifadeleri yürütür ve else koşulundan önce durur ve döngüden çıkar. Koşul yanlışsa, daha sonra else deyim bloğundaki ifadeleri yürütür ve döngüden çıkar.
3	İç İçe If İfadesi Bazen birden fazla if ifadesinin birbirinin içine gömülü olması gerekir.
4	Switch İfadesi Bazen iç içe geçmiş if-else ifadesi o kadar yaygındır ve o kadar sık ​​kullanılır ki, switch deyimi adı verilen daha kolay bir ifade tasarlanmıştır.
5	Yuvalanmış Anahtar Bildirimi İç içe geçmiş bir anahtar ifadeleri kümesine sahip olmak da mümkündür.

Groovy'de bir yöntem, bir dönüş türüyle veya defanahtar kelime. Yöntemler herhangi bir sayıda argüman alabilir. Bağımsız değişkenleri tanımlarken türlerin açıkça tanımlanması gerekli değildir. Genel, özel ve korumalı gibi değiştiriciler eklenebilir. Varsayılan olarak, herhangi bir görünürlük değiştiricisi sağlanmadıysa, yöntem geneldir.

Bir yöntemin en basit türü, aşağıda gösterildiği gibi parametresi olmayan yöntemdir -

def methodName() { 
   //Method code 
}

Aşağıda basit bir yöntem örneği verilmiştir

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();
   } 
}

Yukarıdaki örnekte, DisplayName, konsola bazı metinlerin çıktısını almak için kullanılan iki println deyiminden oluşan basit bir yöntemdir. Statik ana yöntemimizde, sadece DisplayName yöntemini çağırıyoruz. Yukarıdaki yöntemin çıktısı -

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

Yöntem Parametreleri

Bir yöntem, davranışı bir veya daha fazla parametrenin değeriyle belirlenirse daha genel olarak kullanışlıdır. Yöntem parametrelerini kullanarak değerleri çağrılan yönteme aktarabiliriz. Parametre adlarının birbirinden farklı olması gerektiğini unutmayın.

Aşağıda gösterildiği gibi parametrelere sahip en basit yöntem türü -

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

Aşağıda, parametrelerle basit bir yöntem örneği verilmiştir

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

Bu örnekte, 2 parametreli bir toplama yöntemi oluşturuyoruz, a ve b. Her iki parametre de tiptedirint. Daha sonra ana yöntemimizden toplam yöntemini çağırıyoruz ve değerleri değişkenlere aktarıyoruza ve b.

Yukarıdaki yöntemin çıktısı 15 değeri olacaktır.

Varsayılan Parametreler

Groovy'de, yöntemler içindeki parametreler için varsayılan değerleri belirtmek için bir hüküm vardır. Parametreler için yönteme herhangi bir değer aktarılmazsa, varsayılan olanlar kullanılır. Hem varsayılan olmayan hem de varsayılan parametreler kullanılırsa, varsayılan parametrelerin parametre listesinin sonunda tanımlanması gerektiğine dikkat edilmelidir.

Aşağıda, parametreli basit bir yöntem örneği verilmiştir -

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

İki sayının eklenmesi için daha önce baktığımız aynı örneğe bakalım ve bir varsayılan ve diğer varsayılan olmayan parametresi olan bir yöntem oluşturalım -

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

Bu örnekte, iki parametreli bir toplama yöntemi oluşturuyoruz, a ve b. Her iki parametre de int türündedir. Bu örnek ile önceki örnek arasındaki fark, bu durumda için varsayılan bir değer belirlememizdir.b 5. Yani ana yöntemimizden toplam yöntemini çağırdığımızda, sadece 6 olan bir değeri geçme seçeneğimiz var ve bu parametreye atanacak a içinde sum yöntem.

Yukarıdaki yöntemin çıktısı 11 değeri olacaktır.

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

Ayrıca 2 değer ileterek de toplama yöntemini çağırabiliriz, yukarıdaki örneğimizde 6'nın 2 değerini geçiyoruz. 6'nın ikinci değeri aslında parametreye atanan varsayılan değerin yerini alacaktır. b.

Yukarıdaki yöntemin çıktısı, 12 değeri olacaktır.

Yöntem Dönüş Değerleri

Yöntemler ayrıca değerleri çağıran programa geri döndürebilir. Bu, bir yöntemin bir çeşit hesaplama yaptığı ve ardından istenen değeri arama yöntemine döndürdüğü modern programlama dilinde gereklidir.

Aşağıda, dönüş değeri olan basit bir yöntem örneği verilmiştir.

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

Yukarıdaki örneğimizde, bu sefer int türünde olan toplam yöntemimiz için bir dönüş türü belirlediğimize dikkat edin. Yöntemde, toplam değeri çağıran ana programa göndermek için return ifadesini kullanıyoruz. Yöntemin değeri artık ana yöntem için mevcut olduğundan,println konsoldaki değeri görüntülemek için işlev.

Yukarıdaki yöntemin çıktısı 11 değeri olacaktır.

Örnek yöntemleri

Yöntemler normalde, Java dili gibi Groovy içindeki sınıflar içinde uygulanır. Bir sınıf, özelliklerini ve davranışlarını tanımlayan farklı nesneler oluşturmak için bir plandan veya bir şablondur. Sınıf nesneleri, kendi sınıfı tarafından tanımlanan özellikleri ve davranışları sergiler. Dolayısıyla davranışlar, sınıfın içinde yöntemler oluşturularak tanımlanır.

Sınıfları daha sonraki bir bölümde daha ayrıntılı olarak göreceğiz, ancak Aşağıda, bir sınıfta yöntem uygulamasına bir örnek verilmiştir. Önceki örneklerimizde, yöntemimizi statik yöntemler olarak tanımlamıştık, bu da bu yöntemlere doğrudan sınıftan erişebileceğimiz anlamına geliyordu. Sonraki yöntem örneği, yöntemlere sınıfın nesneleri oluşturularak erişildiği örnek yöntemleridir. Yine daha sonraki bir bölümde sınıfları göreceğiz, şimdilik yöntemleri nasıl kullanacağımızı göstereceğiz.

Aşağıda, yöntemlerin nasıl uygulanabileceğine dair bir örnek verilmiştir.

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()); 
   } 
}

Yukarıdaki örneğimizde, bu sefer sınıf yöntemlerimiz için statik bir özellik belirlemediğimize dikkat edin. Ana fonksiyonumuzda aslında Example sınıfının bir örneğini yaratıyoruz ve ardından 'ex' nesnesinin yöntemini çağırıyoruz.

Yukarıdaki yöntemin çıktısı 100 değeri olacaktır.

Yerel ve Harici Parametre Adları

Groovy, tesisin tıpkı java gibi yerel ve global parametrelere sahip olmasını sağlar. Aşağıdaki örnekte,lx yalnızca işlevi içinde bir kapsamı olan yerel bir parametredir getX() ve xTüm Example sınıfının içinden erişilebilen global bir özelliktir. Değişkene erişmeye çalışırsaklx dışında getX() fonksiyon, bir hata alacağız.

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

Yukarıdaki programı çalıştırdığımızda aşağıdaki sonucu alacağız.

200 
100

Özellikler için bu yöntem

Tıpkı Java'da olduğu gibi groovy, örnek üyelerine thisanahtar kelime. Aşağıdaki örnek, ifadeyi ne zaman kullandığımızı gösterirthis.x, örneğini ifade eder ve değerini belirler x buna göre.

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());
   }
}

Yukarıdaki programı çalıştırdığımızda konsolda yazdırılan 200 sonucunu alacağız.

Groovy, G / Ç ile çalışırken bir dizi yardımcı yöntem sağlar. Groovy, dosyalar için aşağıdaki işlevleri sağlamak için daha kolay sınıflar sağlar.

• Dosyaları okuma
• Dosyalara yazma
• Dosya ağaçlarının üzerinden geçme
• Veri nesnelerini dosyalara okuma ve yazma

Buna ek olarak, Dosya G / Ç işlemleri için her zaman aşağıda listelenen normal Java sınıflarını kullanabilirsiniz.

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

Dosyaları okuma

Aşağıdaki örnek, Groovy'deki bir metin dosyasının tüm satırlarının çıktısını alacaktır. YöntemeachLine metin dosyasının her satırının okunmasını sağlamak amacıyla Groovy'deki File sınıfında yerleşiktir.

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

File sınıfı, dosya adını parametre olarak alan yeni bir nesneyi başlatmak için kullanılır. Daha sonra eachLine'ın işlevini alır, onu line adlı bir değişkene koyar ve buna göre yazdırır.

Dosya aşağıdaki satırları içeriyorsa, yazdırılacaktır.

line : Example1
line : Example2

Bir Dosyanın İçeriğini Tüm Dize Olarak Okuma

Dosyanın tüm içeriğini bir dize olarak almak istiyorsanız, file sınıfının text özelliğini kullanabilirsiniz. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Dosya aşağıdaki satırları içeriyorsa, yazdırılacaktır.

line : Example1 
line : Example2

Dosyalara Yazma

Dosyalara yazmak istiyorsanız, bir dosyaya metin çıktısı almak için writer sınıfını kullanmanız gerekir. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Example.txt dosyasını açarsanız, dosyaya yazdırılan "Merhaba Dünya" sözcüklerini göreceksiniz.

Bir Dosyanın Boyutunu Alma

Dosyanın boyutunu elde etmek istiyorsanız, dosyanın boyutunu elde etmek için dosya sınıfının length özelliğini kullanabilirsiniz. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Yukarıdaki kod dosyanın boyutunu bayt cinsinden gösterecektir.

Bir Dosyanın Dizin Olup Olmadığını Test Etme

Bir yolun dosya mı yoksa dizin mi olduğunu görmek istiyorsanız, isFile ve isDirectoryFile sınıfının seçeneği. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Yukarıdaki kod aşağıdaki çıktıyı gösterecektir -

File? false 
Directory? True

Bir Dizin Oluşturma

Yeni bir dizin oluşturmak istiyorsanız, mkdirFile sınıfının işlevi. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

E: \ Dizin dizini mevcut değilse oluşturulacaktır.

Bir Dosyayı Silme

Bir dosyayı silmek isterseniz, File sınıfının silme işlevini kullanabilirsiniz. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Dosya varsa silinecektir.

Dosyalar kopyalanıyor

Groovy ayrıca içeriği bir dosyadan diğerine kopyalama işlevi de sağlar. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Example1.txt dosyası oluşturulacak ve Example.txt dosyasının tüm içeriği bu dosyaya kopyalanacaktır.

Dizin İçeriklerini Alma

Groovy ayrıca bir sürücüdeki sürücüleri ve dosyaları listelemek için işlevsellik sağlar.

Aşağıdaki örnek, bir makinedeki sürücülerin, listRoots File sınıfının işlevi.

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

Makinenizde bulunan sürücülere bağlı olarak çıktı değişebilir. Standart bir makinede çıktı aşağıdakine benzer olacaktır -

C:\ 
D:\

Aşağıdaki örnek, belirli bir dizindeki dosyaların nasıl listeleneceğini gösterir. eachFile File sınıfının işlevi.

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

Çıktı, E: \ Temp dizinindeki tüm dosyaları görüntüler.

Bir dizindeki tüm dosyaları ve alt dizinlerini yinelemeli olarak görüntülemek istiyorsanız, o zaman eachFileRecurseFile sınıfının işlevi. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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

Çıktı, E: \ Temp dizinindeki ve varsa alt dizinlerindeki tüm dosyaları görüntüler.

Groovy, "isteğe bağlı olarak" yazılmış bir dildir ve bu ayrım, dilin temellerini anlarken önemli bir noktadır. Derleyicinin her değişken için tüm türleri bildiği ve derleme zamanında sözleşmeleri anlayıp yerine getirebildiği "güçlü" bir dil olan Java ile karşılaştırıldığında. Bu, yöntem çağrılarının derleme zamanında belirlenebileceği anlamına gelir.

Groovy'de kod yazarken, geliştiricilere bir tür sağlama veya vermeme esnekliği verilir. Bu, uygulamada biraz basitlik sunabilir ve doğru bir şekilde kullanıldığında, uygulamanıza sağlam ve dinamik bir şekilde hizmet verebilir.

Groovy'de isteğe bağlı yazım, 'def' anahtar sözcüğü aracılığıyla yapılır. Aşağıda, kullanımının bir örneği verilmiştir.def yöntem -

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); 
   } 
}

Yukarıdaki programdan, bu tür değerleri içerse bile tek tek değişkenleri Tamsayı, float, double veya string olarak tanımlamadığımızı görebiliriz.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

100 
100.10 
100.101
HelloWorld

İsteğe bağlı yazım, geliştirme sırasında güçlü bir yardımcı program olabilir, ancak kodun çok geniş ve karmaşık hale geldiği sonraki geliştirme aşamalarında sürdürülebilirlikte sorunlara yol açabilir.

Groovy'de isteğe bağlı yazmayı kod tabanınızı sürdürülemez bir karmaşaya sokmadan nasıl kullanabileceğinizi anlamak için, uygulamalarınızda "ördek yazma" felsefesini benimsemek en iyisidir.

Yukarıdaki kodu ördek yazarak yeniden yazarsak, aşağıda verilen gibi görünecektir. Değişken isimleri, temsil ettikleri türe benzemeyen ve kodu daha anlaşılır kılan adlardır.

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'de Sayılar aslında nesneler olarak temsil edilir, hepsi Tamsayı sınıfının bir örneğidir. Bir nesnenin bir şey yapmasını sağlamak için, sınıfında bildirilen yöntemlerden birini çağırmamız gerekir.

Groovy, tamsayı ve kayan nokta sayılarını destekler.

• Tam sayı, kesir içermeyen bir değerdir.
• Kayan noktalı sayı, ondalık kesir içeren ondalık bir değerdir.

Groovy'deki sayılara bir örnek aşağıda gösterilmiştir -

Integer x = 5; 
Float y = 1.25;

Nerede x Tamsayı türünde ve y şamandıradır.

Groovy'de sayıların nesneler olarak tanımlanmasının nedeni, genellikle sayılar üzerinde işlem yapmak için gereksinimlerin olmasıdır. İlkel türler yerine bir sınıf sağlama kavramı, sarmalayıcı sınıflar olarak bilinir.

Varsayılan olarak aşağıdaki sarmalayıcı sınıfları Groovy'de sağlanır.

Sarmalayıcı sınıfının nesnesi, ilgili ilkel veri türünü içerir veya sarar. İlkel veri türlerini nesneye dönüştürme işlemine kutu adı verilir ve bu derleyici tarafından halledilir. Nesneyi karşılık gelen ilkel türe dönüştürme işlemine kutudan çıkarma adı verilir.

Misal

Aşağıda bir boks ve kutudan çıkarma örneği verilmiştir -

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);
   }
}

Yukarıdaki programın çıktısı 15 olacaktır. Yukarıdaki örnekte, 5, 10 ve 0 değerleri ilk olarak tamsayı değişkenleri x, y ve z'ye uygun şekilde kutu içine alınmıştır. Ve sonra, x ve y'nin eklenmesi gerçekleştirildiğinde, değerler Tamsayı türlerinden çıkarılır.

Sayı Yöntemleri

Groovy'deki Numbers sınıflar olarak temsil edildiğinden, kullanılabilecek yöntemlerin listesi aşağıdadır.

S.No.	Yöntemler ve Açıklama
1	xxxValue () Bu yöntem, parametre olarak Sayı'yı alır ve çağrılan yönteme göre ilkel bir tür döndürür.
2	karşılaştırmak() CompareTo yöntemi, bir sayıyı diğeriyle karşılaştırmaktır. Sayıların değerini karşılaştırmak istiyorsanız bu yararlıdır.
3	eşittir () Yöntem, yöntemi çağıran Number nesnesinin bağımsız değişken olarak iletilen nesneye eşit olup olmadığını belirler.
4	değeri() ValueOf yöntemi, geçirilen bağımsız değişkenin değerini tutan ilgili Sayı Nesnesini döndürür.
5	toString () Yöntem, Number Object'in değerini temsil eden bir String nesnesi almak için kullanılır.
6	parseInt () Bu yöntem, belirli bir String'in ilkel veri türünü elde etmek için kullanılır. parseXxx () statik bir yöntemdir ve bir veya iki bağımsız değişkene sahip olabilir.
7	abs () Yöntem, argümanın mutlak değerini verir. Argüman int, float, long, double, short, byte olabilir.
8	ceil () Yöntem ceil, bağımsız değişkenden büyük veya ona eşit olan en küçük tamsayıyı verir.
9	kat () Floor yöntemi, bağımsız değişkenden küçük veya ona eşit olan en büyük tamsayıyı verir.
10	rint () Rint yöntemi, değere en yakın tamsayıyı argümana döndürür.
11	yuvarlak () Yöntem turu, yöntem dönüş türü tarafından verildiği gibi en yakın long veya int değerini döndürür.
12	dk () Yöntem, iki bağımsız değişkenden daha küçük olanı verir. Argüman int, float, long, double olabilir.
13	max () Yöntem, iki bağımsız değişkenin maksimumunu verir. Argüman int, float, long, double olabilir.
14	tecrübe() Yöntem, doğal logaritmaların temelini (e) argümanın gücüne döndürür.
15	günlük () Yöntem, argümanın doğal logaritmasını döndürür.
16	pow () Yöntem, ikinci argümanın gücüne yükseltilen ilk argümanın değerini döndürür.
17	sqrt () Yöntem, argümanın karekökünü döndürür.
18	günah() Yöntem, belirtilen çift değerin sinüsünü döndürür.
19	çünkü () Yöntem, belirtilen çift değerin kosinüsünü döndürür.
20	tan () Yöntem, belirtilen çift değerin tanjantını döndürür.
21	de olduğu gibi() Yöntem, belirtilen çift değerin arkini döndürür.
22	acos () Yöntem, belirtilen çift değerin arkkosinüsünü döndürür.
23	atan () Yöntem, belirtilen çift değerin arktanjantını döndürür.
24	atan2 () Yöntem Dikdörtgen koordinatları (x, y) kutupsal koordinata (r, teta) dönüştürür ve teta'yı döndürür.
25	toDegrees () Yöntem, bağımsız değişken değerini derecelere dönüştürür.
26	radyan () Yöntem, bağımsız değişken değerini radyanlara dönüştürür.
27	rastgele () Yöntem, 0.0 ile 1.0 arasında rastgele bir sayı oluşturmak için kullanılır. Aralık: 0.0 = <Math.random <1.0. Aritmetik kullanılarak farklı aralıklar elde edilebilir.

Groovy'de dize metnini tırnak içine alarak bir String değişmezi oluşturulur.

Groovy, bir String değişmezini belirtmek için çeşitli yollar sunar. Groovy'deki dizeler tek tırnak ('), çift tırnak (") veya üçlü tırnak (" "") içine alınabilir. Ayrıca, üçlü tırnak içine alınmış bir Groovy String birden çok satıra yayılabilir.

Aşağıda Groovy'de dizelerin kullanımına bir örnek verilmiştir -

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); 
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello Single 
Hello Double 
'Hello TripleMultiple lines'

Dize Dizini Oluşturma

Groovy'deki dizeler sıralı bir karakter dizisidir. Bir dizedeki münferit karaktere konumu ile erişilebilir. Bu, bir dizin konumu ile verilir.

Dize endeksleri, sıfırdan başlar ve dizenin uzunluğundan bir daha az biter. Groovy, negatif indislerin dizenin sonundan itibaren geriye doğru saymasına da izin verir.

Aşağıda Groovy'de dize indekslemesinin kullanımına bir örnek verilmiştir -

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 
      
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

o 
d 
el 
oll

Temel Dizi İşlemleri

Öncelikle groovy'de temel string işlemlerini öğrenelim. Aşağıda verilmiştir.

S.No.	Dize İşlemi ve Açıklama
1	İki dizenin birleştirilmesi Dizelerin birleştirilmesi basit '+' operatörü ile yapılabilir.
2	Dize Tekrarı Dizelerin tekrarı basit '*' operatörü ile yapılabilir.
3	IP uzunluğu Dizenin length () yöntemiyle belirlenen dizenin uzunluğu.

Dize Yöntemleri

String sınıfı tarafından desteklenen yöntemlerin listesi aşağıdadır.

S.No.	Yöntemler ve Açıklama
1	merkez () Solda ve sağda boşluk karakterleriyle doldurulmuş alıcıdan oluşan numberOfChars uzunluğundaki yeni bir String döndürür.
2	CompareToIgnoreCase () Büyük / küçük harf farklılıklarını göz ardı ederek iki dizgeyi sözlüksel olarak karşılaştırır.
3	concat () Belirtilen String'i bu String'in sonuna birleştirir.
4	eachMatch () Verilen Dizenin her bir normal ifade grubuyla eşleşen alt dizesini işler (sonraki bölüme bakın).
5	uçlarıWith () Bu dizenin belirtilen sonekle bitip bitmediğini test eder.
6	equalsIgnoreCase () Bu Dizeyi başka bir Dize ile karşılaştırır, büyük / küçük harf hususlarını dikkate almaz.
7	ulaşmak() Dizin konumunda dize değerini döndürür
8	indeksi() Belirtilen alt dizenin ilk oluşumunun bu Dize içindeki dizini döndürür.
9	maçlar() Bir String'in verilen normal ifadeyle eşleşip eşleşmediğini bildirir.
10	eksi() String'in değer kısmını kaldırır.
11	Sonraki() Bu yöntem, String sınıfı için ++ operatörü tarafından çağrılır. Verilen Dizedeki son karakteri artırır.
12	padLeft () Dize'yi sola eklenen boşluklarla doldurun.
13	padRight () Dize'yi sağa eklenen boşluklarla doldurun.
14	artı() Bir Dize ekler
15	önceki() Bu yöntem CharSequence için - operatörü tarafından çağrılır.
16	hepsini değiştir() Yakalanan bir grubun tüm oluşumlarını, o metindeki kapanmanın sonucuyla değiştirir.
17	tersine çevirmek() Bu String'in tersi olan yeni bir String oluşturur.
18	Bölünmüş() Bu Dizeyi verilen normal ifadenin eşleşmelerinin etrafına böler.
19	subString () Bu String'in bir alt dizesi olan yeni bir String döndürür.
20	toUpperCase () Bu Dize'deki tüm karakterleri büyük harfe dönüştürür.
21	toLowerCase () Bu Dize'deki tüm karakterleri küçük harfe dönüştürür.

Aralık, bir dizi değer belirtmek için kullanılan kısaltmadır. Bir Aralık, dizideki ilk ve son değerlerle gösterilir ve Aralık kapsayıcı veya dışlayıcı olabilir. Kapsayıcı Aralık, birinciden sonuncuya kadar tüm değerleri içerirken, özel bir Aralık, sonuncusu dışındaki tüm değerleri içerir. İşte Range değişmez değerlerine bazı örnekler -

• 1..10 - Kapsayıcı Aralık örneği
• 1 .. <10 - Özel Aralık örneği
• 'a' .. 'x' - Aralıklar ayrıca karakterlerden oluşabilir
• 10..1 - Aralıklar azalan sırada da olabilir
• 'x' .. 'a' - Aralıklar ayrıca karakterlerden oluşabilir ve azalan sırada olabilir.

Aşağıda, aralıklar için kullanılabilen çeşitli yöntemler bulunmaktadır.

Sr.No.	Yöntemler ve Açıklama
1	içerir () Bir aralığın belirli bir değer içerip içermediğini kontrol eder
2	almak() Bu Aralıkta belirtilen konumdaki öğeyi döndürür.
3	dan almak() Bu Aralığın düşük değerini alın.
4	getTo () Bu Aralığın üst değerini alın.
5	isReverse () Bu, geriye doğru yinelenen ters bir Aralık mı
6	boyut() Bu Aralıktaki öğelerin sayısını döndürür.
7	subList () Bu Aralığın belirtilen fromIndex, inclusive ve toIndex arasındaki kısmının bir görünümünü verir.

Liste, bir veri öğeleri koleksiyonunu depolamak için kullanılan bir yapıdır. Groovy'de Liste, bir dizi nesne referansını tutar. Bir Listedeki nesne referansları, dizide bir pozisyon kaplar ve bir tamsayı indeksi ile ayırt edilir. Bir Liste değişmezi, virgülle ayrılmış ve köşeli parantez içine alınmış bir dizi nesne olarak sunulur.

Bir listedeki verileri işlemek için tek tek öğelere erişebilmeliyiz. Groovy Listeler, indeksleme operatörü [] kullanılarak indekslenir. Liste endeksleri, ilk öğeyi ifade eden sıfırdan başlar.

Aşağıda bazı liste örnekleri verilmiştir -

• [11, 12, 13, 14] - Tam sayı değerlerinin listesi
• ['Angular', 'Groovy', 'Java'] - Dizelerin listesi
• [1, 2, [3, 4], 5] - İç içe geçmiş bir liste
• ['Groovy', 21, 2.11] - Nesne referanslarının heterojen bir listesi
• [] - Boş bir liste

Bu bölümde, Groovy'de bulunan liste yöntemlerini tartışacağız.

Sr.No.	Yöntemler ve Açıklama
1	Ekle() Yeni değeri bu Listenin sonuna ekleyin.
2	içerir () Bu Liste belirtilen değeri içeriyorsa doğru döndürür.
3	almak() Bu Listede belirtilen konumdaki öğeyi döndürür.
4	boş() Bu Liste hiçbir öğe içermiyorsa doğru döndürür
5	eksi() Koleksiyonda belirtilenler olmadan orijinalin öğelerinden oluşan yeni bir Liste oluşturur.
6	artı() Koleksiyonda belirtilenlerle birlikte orijinalin öğelerinden oluşan yeni bir Liste oluşturur.
7	pop() Bu listeden son öğeyi kaldırır
8	Kaldırmak() Bu Listede belirtilen konumdaki elemanı kaldırır.
9	tersine çevirmek() Orijinal Listenin unsurlarının tersi olan yeni bir Liste oluşturun
10	boyut() Bu Listedeki elemanların sayısını elde eder.
11	çeşit() Orijinal Listenin sıralı bir kopyasını döndürür.

Bir Harita (ilişkilendirilebilir dizi, sözlük, tablo ve karma olarak da bilinir), nesne referanslarının sırasız bir koleksiyonudur. Bir Harita koleksiyonundaki öğelere bir anahtar değerle erişilir. Bir Haritada kullanılan anahtarlar herhangi bir sınıftan olabilir. Bir Map koleksiyonuna eklediğimizde, iki değer gereklidir: anahtar ve değer.

Aşağıda bazı harita örnekleri verilmiştir -

• ['TopicName': 'Listeler', 'TopicName': 'Haritalar'] - Anahtar olarak TopicName ve ilgili değerlerine sahip anahtar değer çiftleri koleksiyonları.

• [:] - Boş bir harita.

Bu bölümde, Groovy'de bulunan harita yöntemlerini tartışacağız.

Sr.No.	Yöntemler ve Açıklama
1	içerirKey () Bu Harita bu anahtarı içeriyor mu?
2	almak() Bu Haritadaki anahtarı arayın ve karşılık gelen değeri döndürün. Bu haritada anahtar için bir giriş yoksa, null değerini döndürün.
3	anahtar seti() Bu Haritadan bir Anahtar Seti edinin.
4	koymak() Belirtilen değeri bu Haritadaki belirtilen anahtarla ilişkilendirir. Bu Harita daha önce bu anahtar için bir eşleme içeriyorsa, eski değer belirtilen değerle değiştirilir.
5	boyut() Bu Haritadaki anahtar / değer eşlemelerinin sayısını döndürür.
6	değerler () Bu Haritadaki değerlerin bir koleksiyon görünümünü döndürür.

Tarih sınıfı, milisaniye hassasiyetiyle belirli bir anı temsil eder. Date sınıfının aşağıda gösterildiği gibi iki kurucusu vardır.

Tarih ()

Sözdizimi

public Date()

Parameters - Yok.

Return Value

Bir Date nesnesini ayırır ve onu en yakın milisaniyeye göre ölçülen, tahsis edildiği zamanı temsil edecek şekilde başlatır.

Misal

Aşağıda bu yöntemin kullanımına bir örnek verilmiştir -

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

Yukarıdaki programı çalıştırdığımızda aşağıdaki sonucu alacağız. Aşağıdaki çıktı size geçerli tarih ve saati verecektir -

Thu Dec 10 21:31:15 GST 2015

Tarih (uzun milisaniye)

Sözdizimi

public Date(long millisec)

Parameters

Milisaniye - Standart temel süreden beri belirtilecek milisaniye sayısı.

Return Value - bir Date nesnesini oluşturur ve 1 Ocak 1970 00:00:00 GMT olarak bilinen "epoch" olarak bilinen standart temel zamandan beri belirtilen milisaniye sayısını temsil edecek şekilde başlatır.

Misal

Aşağıda bu yöntemin kullanımına bir örnek verilmiştir -

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

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Thu Jan 01 04:00:00 GST 1970

Aşağıda Date sınıfının verilen yöntemleri verilmiştir. Yıl, ay, tarih, saat, dakika ve saniye değerlerini kabul eden veya döndüren tüm Date sınıf yöntemlerinde aşağıdaki temsiller kullanılır -

• Bir y yılı, y - 1900 tamsayısı ile temsil edilir.

• Bir ay, 0 ile 11 arasında bir tamsayı ile temsil edilir; 0 Ocak, 1 Şubat ve diğerleri; dolayısıyla 11 Aralık.

• Bir tarih (ayın günü), olağan şekilde 1'den 31'e kadar bir tamsayı ile temsil edilir.

• Bir saat, 0'dan 23'e bir tamsayı ile temsil edilir. Dolayısıyla, gece yarısından 1'e kadar olan saat 0. saattir ve öğleden 13.00'e kadar olan saat 12'dir.

• Bir dakika, olağan şekilde 0'dan 59'a bir tamsayı ile temsil edilir.

• Bir saniye, 0 ile 61 arasında bir tamsayı ile temsil edilir.

Sr.No.	Yöntemler ve Açıklama
1	sonra() Bu tarihin belirtilen tarihten sonra olup olmadığını test eder.
2	eşittir () Eşitlik için iki tarihi karşılaştırır. Sonuç, ancak ve ancak bağımsız değişken boş değilse ve bu nesneyle aynı noktayı milisaniyeye kadar temsil eden bir Date nesnesiyse doğrudur.
3	karşılaştırmak() Sipariş için iki Tarihi karşılaştırır.
4	toString () Bu Date nesnesini bir String nesnesine dönüştürür
5	önce() Bu tarihin belirtilen tarihten önce olup olmadığını test eder.
6	getTime () Bu Date nesnesi tarafından temsil edilen 1 Ocak 1970 00:00:00 GMT'den bu yana geçen milisaniye sayısını döndürür.
7	ayarlanan zaman() Bu Date nesnesini, 1 Ocak 1970 00:00:00 GMT'den sonraki milisaniyeler olan bir zaman noktasını temsil edecek şekilde ayarlar.

Normal ifade, metindeki alt dizeleri bulmak için kullanılan bir kalıptır. Groovy, ~ ”regex” ifadesini kullanarak yerel olarak normal ifadeleri destekler. Alıntılar içinde yer alan metin, karşılaştırma için ifadeyi temsil eder.

Örneğin, aşağıda gösterildiği gibi bir normal ifade nesnesi oluşturabiliriz -

def regex = ~'Groovy'

Groovy operatörü = ~, bir yüklem (Boolean döndüren ifade) olarak göründüğünde if ve whiledeyimler (bkz. Bölüm 8), soldaki String işleneni, sağdaki normal ifade işleneniyle eşleştirilir. Bu nedenle, aşağıdakilerin her biri doğru değeri verir.

Normal ifadeyi tanımlarken aşağıdaki özel karakterler kullanılabilir -

• Bir satırın başlangıcını ve sonunu belirtmek için kullanılan iki özel konumsal karakter vardır: düzeltme işareti (∧) ve dolar işareti ($).

• Normal ifadeler ayrıca nicelik belirteçleri içerebilir. Artı işareti (+), ifadenin önceki öğesine uygulanan bir veya daha fazla zamanı temsil eder. Yıldız işareti (*), sıfır veya daha fazla oluşumu temsil etmek için kullanılır. Soru işareti (?) Sıfırı veya bir defa gösterir.

• Meta karakter {ve}, önceki karakterin belirli sayıda örneğini eşleştirmek için kullanılır.

• Normal ifadede nokta sembolü (.) Herhangi bir karakteri temsil edebilir. Bu, joker karakter olarak tanımlanır.

• Normal bir ifade, karakter sınıflarını içerebilir. Bir dizi karakter, [aeiou] 'da olduğu gibi meta karakterler [ve] içine alınmış basit bir karakter dizisi olarak verilebilir. Harf veya sayı aralıkları için, [a – z] veya [a – mA – M] 'de olduğu gibi bir tire ayırıcısı kullanabilirsiniz. Bir karakter sınıfının tamamlayıcısı, kare raketler içinde [∧a – z] 'de olduğu gibi baştaki bir düzeltme işareti ile gösterilir ve belirtilenler dışındaki tüm karakterleri temsil eder. Normal ifadelerin bazı örnekleri aşağıda verilmiştir.

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

Çalışma zamanı hatalarını işlemek için herhangi bir programlama dilinde istisna işleme gerekir, böylece uygulamanın normal akışı korunabilir.

İstisna, normalde uygulamanın normal akışını bozar, bu nedenle uygulamamızda İstisna işlemeyi kullanmamız gerekir.

İstisnalar genel olarak aşağıdaki kategorilere ayrılır -

• Checked Exception - RuntimeException ve Error dışında Throwable sınıfını genişleten sınıflar, denetlenen istisnalar olarak bilinir, örn .IOException, SQLException vb. Kontrol edilen istisnalar derleme zamanında kontrol edilir.

Klasik bir durum FileNotFoundException'dır. Uygulamanızda E sürücüsündeki bir dosyadan okuyan aşağıdaki koda sahip olduğunuzu varsayalım.

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

Dosya (file.txt) E sürücüsünde yoksa, aşağıdaki istisna ortaya çıkar.

Yakalandı: java.io.FileNotFoundException: E: \ file.txt (Sistem belirtilen dosyayı bulamıyor).

java.io.FileNotFoundException: E: \ file.txt (Sistem belirtilen dosyayı bulamıyor).

• Unchecked Exception - RuntimeException'ı genişleten sınıflar denetlenmemiş istisnalar olarak bilinir, örn. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException vb. Denetlenmeyen istisnalar, çalışma zamanında denetlenmek yerine derleme zamanında denetlenmez.

Klasik bir durum, dizinin uzunluğundan daha büyük olan bir dizinin dizinine erişmeye çalıştığınızda gerçekleşen ArrayIndexOutOfBoundsException durumudur. Aşağıda, bu tür bir hatanın tipik bir örneği verilmiştir.

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

Yukarıdaki kod çalıştırıldığında aşağıdaki istisna ortaya çıkacaktır.

Yakalandı: java.lang.ArrayIndexOutOfBoundsException: 5

java.lang.ArrayIndexOutOfBoundsException: 5

• Error - Hata düzeltilemez, örneğin OutOfMemoryError, VirtualMachineError, AssertionError vb.

Bunlar, programın asla düzeltemeyeceği ve programın çökmesine neden olacak hatalardır.

Aşağıdaki diyagram, Groovy'deki istisnalar hiyerarşisinin nasıl düzenlendiğini gösterir. Hepsi Java'da tanımlanan hiyerarşiye dayanmaktadır.

İstisnaları Yakalama

Bir yöntem, bir try ve catchanahtar kelimeler. Bir istisna oluşturabilecek kodun etrafına bir dene / yakala bloğu yerleştirilir.

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

Bir istisna oluşturabilecek tüm kodunuz Korumalı kod bloğuna yerleştirilir.

Yakalama bloğunda, uygulamanın istisnadan kurtarabilmesi için istisnanızı işlemek için özel kod yazabilirsiniz.

Dizinin boyutundan daha büyük bir dizin değerine sahip bir diziye erişmek için yukarıda gördüğümüz benzer kodun bir örneğine bakalım. Ama bu sefer kodumuzu bir dene / yakala bloğuna saralım.

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");
   }
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Catching the exception 
Let's move on after the exception

Yukarıdaki koddan, hatalı kodu try bloğunda sardık. Catch bloğunda sadece bizim istisnamızı yakalıyoruz ve bir istisnanın meydana geldiğine dair bir mesaj çıkarıyoruz.

Çoklu Yakalama Blokları

Birden çok istisna türünü işlemek için birden fazla yakalama bloğu olabilir. Her catch bloğu için, ortaya çıkan istisna türüne bağlı olarak, onu uygun şekilde işlemek için kod yazarsınız.

ArrayIndexOutOfBoundsException'ı özellikle yakalamak için yukarıdaki kodumuzu değiştirelim. Kod parçacığı aşağıdadır.

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");
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Yukarıdaki koddan ArrayIndexOutOfBoundsException yakalama bloğunun ilk olarak yakalandığını görebilirsiniz çünkü istisnanın ölçütü anlamına gelir.

Sonunda Engelle

finallyblok bir try bloğunu veya bir catch bloğunu takip eder. Nihayetinde bir kod bloğu, bir İstisnanın ortaya çıkmasına bakılmaksızın her zaman yürütülür.

Nihayet bloğunun kullanılması, korumalı kodda ne olursa olsun, yürütmek istediğiniz herhangi bir temizleme türü ifadesini çalıştırmanıza olanak tanır. Bu bloğun sözdizimi aşağıda verilmiştir.

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

Yukarıdaki kodumuzu değiştirelim ve son kod bloğunu ekleyelim. Kod parçacığı aşağıdadır.

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");
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Groovy'de bulunan İstisna yöntemleri aşağıdadır -

public String getMessage ()

Oluşan istisna hakkında ayrıntılı bir mesaj verir. Bu mesaj Throwable yapıcısında başlatılır.

public Throwable getCause ()

Throwable nesne tarafından temsil edildiği şekliyle istisnanın nedenini döndürür.

public String toString ()

GetMessage () sonucuyla birleştirilen sınıfın adını verir

public void printStackTrace ()

ToString () sonucunu yığın izlemeyle birlikte System.err, hata çıktı akışı olarak yazdırır.

genel StackTraceElement [] getStackTrace ()

Yığın izlemesindeki her bir öğeyi içeren bir dizi döndürür. 0 dizinindeki öğe, çağrı yığınının üstünü temsil eder ve dizideki son öğe, çağrı yığınının altındaki yöntemi temsil eder.

public Throwable fillInStackTrace ()

Bu Throwable nesnesinin yığın izlemesini, yığın izlemedeki önceki bilgilere ekleyerek geçerli yığın izlemesiyle doldurur.

Misal

Aşağıda, yukarıda verilen yöntemlerden bazılarını kullanan kod örneği verilmiştir -

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");
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Groovy'de, diğer herhangi bir Nesne Yönelimli dilde olduğu gibi, programlama dilinin nesnel yönelimli doğasını temsil eden sınıflar ve nesneler kavramı vardır. Groovy sınıfı, bir veri koleksiyonudur ve bu veriler üzerinde çalışan yöntemlerdir. Birlikte, bir sınıfın verileri ve yöntemleri, problem etki alanından bazı gerçek dünya nesnelerini temsil etmek için kullanılır.

Groovy'deki bir sınıf, bu sınıf tarafından tanımlanan nesnelerin durumunu (verileri) ve davranışını bildirir. Dolayısıyla, bir Groovy sınıfı, bu sınıf için hem örnek alanlarını hem de yöntemleri açıklar.

Aşağıda Groovy'deki bir sınıf örneği verilmiştir. Sınıfın adı Öğrenci'dir ve iki alanı vardır -StudentID ve StudentName. Ana işlevde, bu sınıfın bir nesnesini oluşturuyoruz veStudentID ve StudentName nesnenin.

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

alıcı ve ayarlayıcı Yöntemleri

Herhangi bir programlama dilinde, örnek üyelerini private anahtar sözcüğüyle gizlemek ve bunun yerine örnek değişkenlerinin değerlerini buna göre ayarlamak ve almak için alıcı ve ayarlayıcı yöntemler sağlamak her zaman bir uygulamadır. Aşağıdaki örnek bunun nasıl yapılabileceğini göstermektedir.

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());
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

1 
Joe

Yukarıdaki programla ilgili aşağıdaki temel noktalara dikkat edin -

• Sınıfta hem studentID hem de studentName özel olarak işaretlenir, bu da sınıf dışından erişilemeyeceği anlamına gelir.

• Her örnek üyenin kendi alıcı ve ayarlayıcı yöntemi vardır. Getter yöntemi, örnek değişkeninin değerini döndürür, örneğin yöntem int getStudentID () ve ayarlayıcı yöntemi, örnek kimliğinin değerini ayarlar, örneğin yöntem - void setStudentName (String pName)

Örnek Yöntemleri

Normalde sınıfın içine, sınıf için bir çeşit işlevsellik sağlayan daha fazla yöntem eklemek doğaldır. Öğrenci örneğimizde, öğrencinin 3 konudaki notlarını belirtmek için Marks1, Marks2 ve Marks3 örnek üyelerini ekleyelim. Daha sonra öğrencinin toplam puanını hesaplayacak yeni bir örnek yöntemi ekleyeceğiz. Kodun nasıl görüneceği aşağıdadır.

Aşağıdaki örnekte, Toplam yöntemi, içinde yerleşik bir mantık bulunan ek bir Örnek yöntemidir.

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());
   }
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

60

Birden Çok Nesne Oluşturma

Ayrıca bir sınıfın birden çok nesnesini de oluşturabilirsiniz. Aşağıda bunun nasıl başarılabileceğinin bir örneği var. Burada 3 nesne oluşturuyoruz (st, st1 ve st2) ve buna göre örnek üyelerini ve örnek yöntemlerini çağırıyoruz.

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());
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

60 
70 
80

Miras

Kalıtım, bir sınıfın diğerinin özelliklerini (yöntemleri ve alanları) elde ettiği süreç olarak tanımlanabilir. Kalıtımın kullanılmasıyla, bilgiler hiyerarşik bir sırayla yönetilebilir hale getirilir.

Diğerinin özelliklerini miras alan sınıf, alt sınıf (türetilmiş sınıf, alt sınıf) olarak bilinir ve özellikleri miras alınan sınıf, üst sınıf (temel sınıf, ana sınıf) olarak bilinir.

Uzatmalar

extendsbir sınıfın özelliklerini devralmak için kullanılan anahtar kelimedir. Aşağıda, extends anahtar kelimesinin sözdizimi verilmiştir. Aşağıdaki örnekte aşağıdaki şeyleri yapıyoruz -

• Kişi adında bir sınıf oluşturmak. Bu sınıfın ad adında bir örnek üyesi vardır.

• Person sınıfından uzanan Öğrenci adlı bir sınıf oluşturmak. Person sınıfında tanımlanan ad örneği üyesinin Student sınıfında miras alındığına dikkat edin.

• Student sınıfı yapıcısında, temel sınıf yapıcısını çağırıyoruz.

• Öğrenci sınıfımıza, StudentID ve Marks1'in 2 ek örnek üyesini ekliyoruz.

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();
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Joe

İç Sınıflar

İç sınıflar başka bir sınıf içinde tanımlanır. Çevreleyen sınıf, her zamanki gibi iç sınıfı kullanabilir. Öte yandan, bir iç sınıf, özel olsalar bile, kendi çevreleyen sınıfının üyelerine erişebilir. Çevreleyen sınıf dışındaki sınıfların iç sınıflara erişmesine izin verilmez.

Aşağıda bir Outer ve Inner sınıfına bir örnek verilmiştir. Aşağıdaki örnekte aşağıdaki şeyleri yapıyoruz -

• Dış sınıfımız olacak Outer adında bir sınıf oluşturmak.
• Outer sınıfımızda isim denen bir dizge tanımlama.
• Outer sınıfımızın içinde bir Inner veya yuvalanmış sınıf oluşturmak.
• İç sınıfta Outer sınıfta tanımlanan örnek üye adına erişebildiğimizi unutmayın.

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); 
      } 
   } 
	
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Joe

Soyut Sınıflar

Soyut sınıflar, genel kavramları temsil eder, bu nedenle alt sınıflara ayrılmak üzere yaratılmaları nedeniyle somutlaştırılamazlar. Üyeleri, alanları / özellikleri ve soyut veya somut yöntemleri içerir. Soyut yöntemlerin uygulaması yoktur ve somut alt sınıflar tarafından uygulanmalıdır. Abstract sınıfları abstract anahtar sözcüğü ile bildirilmelidir. Soyut yöntemler ayrıca abstract anahtar sözcüğü ile bildirilmelidir.

Aşağıdaki örnekte, Person sınıfının artık soyut bir sınıf haline getirildiğini ve somutlaştırılamayacağını unutmayın. Ayrıca, soyut sınıfta, uygulama ayrıntısı içermeyen DisplayMarks adlı soyut bir yöntem olduğunu unutmayın. Öğrenci sınıfında uygulama detaylarının eklenmesi zorunludur.

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); 
   }  
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Joe 
10 
null

Arayüzler

Bir arayüz, bir sınıfın uyması gereken bir sözleşmeyi tanımlar. Bir arabirim yalnızca uygulanması gereken yöntemlerin bir listesini tanımlar, ancak yöntemlerin uygulanmasını tanımlamaz. Bir arabirim, arabirim anahtar sözcüğü kullanılarak bildirilmelidir. Bir arabirim yalnızca yöntem imzalarını tanımlar. Bir arayüzün yöntemleri her zamanpublic. Arabirimlerde korumalı veya özel yöntemlerin kullanılması bir hatadır.

Aşağıda, harika bir arayüzün bir örneğidir. Aşağıdaki örnekte aşağıdaki şeyleri yapıyoruz -

• Marks adlı bir arabirim oluşturmak ve DisplayMarks adlı bir arabirim yöntemi oluşturmak.

• Sınıf tanımında, arayüzü uygulamak için implements anahtar sözcüğünü kullanıyoruz.

• Arayüzü uyguladığımız için, DisplayMarks yöntemi için uygulama sağlamamız gerekiyor.

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);
   }
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

10
null

Generics, sınıfları, arabirimleri ve yöntemleri tanımlarken türlerin (sınıflar ve arabirimler) parametre olmasını sağlar. Yöntem bildirimlerinde kullanılan daha tanıdık biçimsel parametreler gibi, tür parametreleri, aynı kodu farklı girdilerle yeniden kullanmanız için bir yol sağlar. Aradaki fark, biçimsel parametrelere yönelik girdilerin değer olması, parametre türü girdilerinin ise tür olmasıdır.

Koleksiyonlar için Genel

List sınıfı gibi koleksiyon sınıfları, uygulamada yalnızca bu türdeki koleksiyonların kabul edilmesi için genelleştirilebilir. Genelleştirilmiş ArrayList'in bir örneği aşağıda gösterilmiştir. Aşağıdaki ifadenin yaptığı şey, yalnızca string türünde olan liste öğelerini kabul etmesidir -

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

Aşağıdaki kod örneğinde, aşağıdakileri yapıyoruz -

• Yalnızca Dizeleri tutacak bir Genelleştirilmiş ArrayList koleksiyonu oluşturma.
• Listeye 3 dize ekleyin.
• Listedeki her öğe için dizelerin değeri yazdırılır.

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);
      }
   } 
}

Yukarıdaki programın çıktısı şu olacaktır:

First String 
Second String 
Third String

Genelleştirilmiş Sınıflar

Tüm sınıf da genelleştirilebilir. Bu, sınıfı herhangi bir türü kabul etme ve bu türlere göre çalışma konusunda daha esnek hale getirir. Bunu nasıl başarabileceğimize dair bir örneğe bakalım.

Aşağıdaki programda aşağıdaki adımları gerçekleştiriyoruz -

• ListType adında bir sınıf oluşturuyoruz. Sınıf tanımının önüne yerleştirilen <T> anahtar kelimelerine dikkat edin. Bu, derleyiciye bu sınıfın herhangi bir türü kabul edebileceğini söyler. Bu nedenle, bu sınıfın bir nesnesini bildirdiğimizde, bildirim sırasında bir tür belirtebiliriz ve bu tür <T> yer tutucusunda değiştirilir.

• Genel sınıf, sınıfta tanımlanan üye değişkeni ile çalışmak için basit alıcı ve ayarlayıcı yöntemlere sahiptir.

• Ana programda, ListType sınıfının, ancak farklı türlerdeki nesneleri bildirebildiğimize dikkat edin. Birincisi Tamsayı tipindedir ve ikincisi String tipindedir.

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;
   } 
}

Yukarıdaki programın çıktısı şu olacaktır:

First String 
1

Özellikler, dilin yapısal bir yapısıdır;

• Davranışların bileşimi.
• Arayüzlerin çalışma zamanı uygulaması.
• Statik tip kontrol / derleme ile uyumluluk

Hem varsayılan uygulamaları hem de durumu taşıyan arayüzler olarak görülebilirler. Bir özellik, trait anahtar sözcüğü kullanılarak tanımlanır.

Aşağıda bir özellik örneği verilmiştir -

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

Daha sonra, özelliği arabirimlerle benzer şekilde uygulamak için uygulama anahtar sözcüğü kullanılabilir.

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;
}

Arayüzlerin Uygulanması

Özellikler arayüzler uygulayabilir, bu durumda arayüzler implements anahtar sözcüğü kullanılarak bildirilir.

Bir arayüz uygulayan bir özellik örneği aşağıda verilmiştir. Aşağıdaki örnekte aşağıdaki kilit noktalar not edilebilir.

• Toplam arabirim, DisplayTotal yöntemiyle tanımlanır.

• Özellik İşaretleri, Toplam arayüzünü uygular ve bu nedenle DisplayTotal yöntemi için bir uygulama sağlamalıdır.

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;  
}

Yukarıdaki programın çıktısı şu olacaktır:

Display Marks 
Display Total

Özellikleri

Bir özellik, özellikleri tanımlayabilir. Bir özelliğe sahip bir özellik örneği aşağıda verilmiştir.

Aşağıdaki örnekte, tamsayı türündeki Marks1 bir özelliktir.

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 
   }
}

Yukarıdaki programın çıktısı şu olacaktır:

10 
Display Total

Davranışların Bileşimi

Özellikler, çoklu kalıtımı kontrollü bir şekilde uygulamak için elmas sorunundan kaçınmak için kullanılabilir. Aşağıdaki kod örneğinde, iki özellik tanımladık -Marks ve Total. Öğrenci sınıfımız her iki özelliği de uygular. Öğrenci sınıfı her iki özelliği de genişlettiğinden, her iki yönteme de erişebilir -DisplayMarks ve 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 
}

Yukarıdaki programın çıktısı şu olacaktır:

Total 
Marks1

Özellikleri Genişletmek

Özellikler başka bir özelliği genişletebilir, bu durumda extendsanahtar kelime. Aşağıdaki kod örneğinde, Total özelliğini Marks özelliği ile genişletiyoruz.

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 
}

Yukarıdaki programın çıktısı şu olacaktır:

Total

Kapatma, kısa ve anonim bir kod bloğudur. Normalde birkaç satırlık bir kodu kapsar. Bir yöntem, kod bloğunu bir parametre olarak bile alabilir. Doğası gereği anonimdirler.

Aşağıda basit bir kapatma örneği ve neye benzediğini görebilirsiniz.

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

Yukarıdaki örnekte, kod satırı - {println "Merhaba Dünya"} kapanış olarak bilinir. Bu tanımlayıcı tarafından referans verilen kod bloğu, call deyimi ile yürütülebilir.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello World

Kapanışlarda biçimsel parametreler

Kapanışlar ayrıca onları Groovy'deki yöntemler gibi daha kullanışlı hale getirmek için biçimsel parametreler içerebilir.

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

Yukarıdaki kod örneğinde, kapatmanın bir parametre almasına neden olan $ {param} kullanımına dikkat edin. Clos.call deyimi aracılığıyla closure çağrısı yaparken, artık closure'a bir parametre geçirme seçeneğimiz var.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello World

Sonraki resim, önceki örneği tekrarlar ve aynı sonucu üretir, ancak kullanılabileceği gibi atıfta bulunulan örtük tek bir parametrenin olduğunu gösterir. Burada 'it' Groovy'de bir anahtar kelimedir.

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

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello World

Kapanışlar ve Değişkenler

Daha resmi olarak, kapanışlar, kapanış tanımlandığı anda değişkenlere atıfta bulunabilir. Aşağıda bunun nasıl başarılabileceğine dair bir örnek verilmiştir.

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");
   } 
}

Yukarıdaki örnekte, kapanışa bir parametre aktarmanın yanı sıra, str1 adlı bir değişken de tanımlıyoruz. Kapanış ayrıca değişkeni parametre ile birlikte alır.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello World 
Welcome World

Yöntemlerde Kapatmaları Kullanma

Kapanışlar, yöntemlere parametre olarak da kullanılabilir. Groovy'de, Listeler ve koleksiyonlar gibi veri türleri için yerleşik yöntemlerin çoğu, parametre türü olarak kapanışlara sahiptir.

Aşağıdaki örnek, bir kapatmanın bir yönteme parametre olarak nasıl gönderilebileceğini gösterir.

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);
   } 
}

Yukarıdaki örnekte,

• Bir kapanışı argüman olarak alan Display adında statik bir yöntem tanımlıyoruz.

• Daha sonra ana yöntemimizde bir kapanış tanımlıyor ve bunu parametre olarak Display yöntemimize geçiriyoruz.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

Hello World 
Welcome World 
Welcome Inner

Koleksiyonlarda ve Dizede Kapanışlar

Birkaç List, Map ve String yöntemi, bir kapanışı bağımsız değişken olarak kabul eder. Bu veri türlerinde kapanışların nasıl kullanılabileceğine dair bir örneğe bakalım.

Kapanışları Listelerle Kullanma

Aşağıdaki örnek, Closure'ların Listelerle nasıl kullanılabileceğini gösterir. Aşağıdaki örnekte önce basit bir değerler listesi tanımlıyoruz. Liste toplama türü daha sonra adı verilen bir işlevi tanımlar.each. Bu işlev, bir parametre olarak bir kapanışı alır ve kapanışı listenin her bir öğesine uygular.

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

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

11 
12 
13 
14

Kapatmaları Haritalar ile Kullanma

Aşağıdaki örnek, kapanışların Haritalar ile nasıl kullanılabileceğini gösterir. Aşağıdaki örnekte ilk önce basit bir anahtar değer öğeleri Haritası tanımlıyoruz. Harita koleksiyonu türü daha sonra .each adlı bir işlevi tanımlar. Bu işlev, bir parametre olarak bir kapanışı alır ve kapanışı haritanın her bir anahtar / değer çiftine uygular.

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}"}
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Çoğu zaman, bir koleksiyonun üyeleri arasında yineleme yapmak ve yalnızca öğe bazı kriterleri karşıladığında bazı mantıkları uygulamak isteyebiliriz. Bu, kapanışta bir koşullu ifade ile kolayca ele alınır.

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}
   } 
}

Yukarıdaki örnek, listedeki her bir öğenin 2'ye bölünebilir olup olmadığını kontrol etmek için kullanılan kapanışta kullanılan koşullu if (num% 2 == 0) ifadesini gösterir.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Closures ile kullanılan yöntemler

Kapakların kendileri bazı yöntemler sağlar.

Sr.No.	Yöntemler ve Açıklama
1	bul () Find yöntemi, bir koleksiyondaki bazı ölçütlerle eşleşen ilk değeri bulur.
2	hepsini bul() Kapanma koşuluyla eşleşen alıcı nesnedeki tüm değerleri bulur.
3	herhangi () ve her () Yöntem, bir Boolean yükleminin en az bir öğe için geçerli olup olmadığını kontrol ederek bir koleksiyonun her öğesini yineler.
4	toplamak() Toplama yöntemi, bir koleksiyon aracılığıyla yinelenir, her öğeyi transformatör olarak kapatmayı kullanarak yeni bir değere dönüştürür.

Ek açıklamalar , programın bir parçası olmayan bir program hakkında veri sağladıkları bir meta veri biçimidir. Açıklamaların, ekledikleri kodun işleyişi üzerinde doğrudan bir etkisi yoktur.

Ek açıklamalar esas olarak aşağıdaki nedenlerle kullanılır -

• Information for the compiler - Ek açıklamalar, derleyici tarafından hataları tespit etmek veya uyarıları bastırmak için kullanılabilir.

• Compile-time and deployment-time processing - Yazılım araçları kod, XML dosyaları vb. Oluşturmak için açıklama bilgilerini işleyebilir.

• Runtime processing - Çalışma zamanında incelenmek üzere bazı ek açıklamalar mevcuttur.

Groovy'de temel bir açıklama aşağıdaki gibi görünür -

@interface - at işareti karakteri (@) derleyiciye, onu izleyen şeyin bir açıklama olduğunu gösterir.

Ek açıklama, içindeki üyeleri tanımlayabilir the form gövdesi olmayan yöntemler ve isteğe bağlı bir varsayılan değer.

Ek açıklamalar aşağıdaki türlere uygulanabilir -

Dize Türü

Bir dize için bir Ek Açıklama örneği aşağıda verilmiştir -

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

Enum türü

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

Sınıf türü

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

Ek Açıklama Üye Değerleri

Bir açıklama kullanıldığında, en azından varsayılan bir değeri olmayan tüm üyelerin ayarlanması gerekir. Aşağıda bir örnek verilmiştir. Ek açıklama Örneği tanımlandıktan sonra kullanıldığında, kendisine atanmış bir değere sahip olması gerekir.

@interface Example {
   int status() 
}

@Example(status = 1)

Kapanış Açıklama Parametreleri

Groovy'deki ek açıklamaların iyi bir özelliği, bir kapanışı da açıklama değeri olarak kullanabilmenizdir. Bu nedenle ek açıklamalar çok çeşitli ifadelerle kullanılabilir.

Aşağıda bununla ilgili bir örnek verilmiştir. Onlyif ek açıklaması, bir sınıf değerine göre oluşturulur. Daha sonra açıklama, sayı değişkeninin değerine bağlı olarak sonuç değişkenine farklı mesajlar gönderen iki yönteme uygulanır.

@interface OnlyIf {
   Class value() 
}  

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

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

Meta Açıklamaları

Bu, groovy'deki ek açıklamaların oldukça kullanışlı bir özelliğidir. Aşağıda gösterildiği gibi bir yöntem için birden fazla ek açıklamaya sahip olabileceğiniz zamanlar olabilir. Bazen bu, birden fazla ek açıklamaya sahip olmak için karmaşık hale gelebilir.

@Procedure 
@Master class 
MyMasterProcedure {}

Böyle bir durumda, birden çok ek açıklamayı birlikte kulüpleyen ve meta ek açıklamayı yönteme uygulayan bir meta açıklama tanımlayabilirsiniz. Dolayısıyla, yukarıdaki örnek için AnnotationCollector'ı kullanarak annotation koleksiyonunu ilk olarak tanımlayabilirsiniz.

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

Bu yapıldıktan sonra, aşağıdaki meta açıklayıcıyı yönteme uygulayabilirsiniz -

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

XML, programcıların işletim sistemi ve / veya geliştirme dilinden bağımsız olarak diğer uygulamalar tarafından okunabilen uygulamalar geliştirmesine olanak tanıyan taşınabilir, açık kaynaklı bir dildir. Bu, uygulamalar arasında veri alışverişi için kullanılan en yaygın dillerden biridir.

XML nedir?

Genişletilebilir Biçimlendirme Dili XML, HTML veya SGML'ye çok benzer bir biçimlendirme dilidir. Bu, World Wide Web Konsorsiyumu tarafından önerilir ve açık bir standart olarak mevcuttur. XML, SQL tabanlı bir omurga gerektirmeden küçük ila orta büyüklükteki verileri izlemek için son derece kullanışlıdır.

Groovy'de XML Desteği

Groovy dili ayrıca XML dili için zengin bir destek sağlar. Kullanılan en temel iki XML sınıfı şunlardır:

• XML Markup BuilderGroovy, çeşitli ağaç yapılı nesne temsilleri yapmak için alt sınıflara ayrılabilen ağaç tabanlı BuilderSupport'u destekler. Genellikle, bu oluşturucular XML biçimlendirmesini, HTML biçimlendirmesini temsil etmek için kullanılır. Groovy'nin işaretleme üreteci, sözde yöntemlere yapılan çağrıları yakalar ve bunları bir ağaç yapısının öğelerine veya düğümlerine dönüştürür. Bu sözde yöntemlerin parametreleri, düğümlerin nitelikleri olarak kabul edilir. Yöntem çağrısının bir parçası olarak kapanışlar, ortaya çıkan ağaç düğümü için iç içe geçmiş alt içerik olarak kabul edilir.

• XML Parser- Groovy XmlParser sınıfı, bir XML belgesini bir Node örnekleri ağacına ayrıştırmak için basit bir model kullanır. Her Düğüm, XML öğesinin adına, öğenin niteliklerine ve tüm alt Düğümlere referanslara sahiptir. Bu model, çoğu basit XML işleme için yeterlidir.

Tüm XML kodu örneklerimiz için, XML dosyasının oluşturulması ve ardından dosyayı okumak için aşağıdaki basit XML dosyası movies.xml'yi kullanalım.

<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 İşaretleme Oluşturucu

Sözdizimi

public MarkupBuilder()

MarkupBuilder, XML belgesinin tamamını oluşturmak için kullanılır. XML belgesi, önce XML belge sınıfının bir nesnesi oluşturularak oluşturulur. Nesne oluşturulduktan sonra, XML belgesinin çeşitli öğelerini oluşturmak için bir sözde yöntem çağrılabilir.

Yukarıdaki XML belgesinden bir bloğun, yani bir film öğesinin nasıl oluşturulacağına dair bir örneğe bakalım -

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') 
      }
   } 
}

Yukarıdaki örnekte, aşağıdaki noktalara dikkat edilmelidir -

• mB.collection() - Bu, <collection> </collection> baş XML etiketini oluşturan bir biçimlendirme oluşturucudur.

• movie(title : 'Enemy Behind')- Bu sözde yöntemler, bu yöntemle alt etiket oluşturarak değeri olan etiketi oluşturur. Title adında bir değer belirterek, bu aslında öğe için bir özniteliğin oluşturulması gerektiğini gösterir.

• XML belgesinin kalan öğelerini oluşturmak için sözde yönteme bir kapatma sağlanır.

• MarkupBuilder sınıfı için varsayılan yapıcı, üretilen XML'in standart çıkış akışına verilmesi için başlatılır.

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

<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 belgesinin tamamını oluşturmak için aşağıdaki şeylerin yapılması gerekir.

• Elemanların farklı değerlerini saklamak için bir harita girişinin oluşturulması gerekir.
• Haritanın her bir öğesi için, her bir öğeye değer atıyoruz.

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]) 
            }
         }
      }
   } 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

<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 Ayrıştırma

Groovy XmlParser sınıfı, bir XML belgesini bir Node örnekleri ağacına ayrıştırmak için basit bir model kullanır. Her Düğüm, XML öğesinin adına, öğenin niteliklerine ve tüm alt Düğümlere referanslara sahiptir. Bu model, çoğu basit XML işleme için yeterlidir.

Sözdizimi

public XmlParser() 
   throws ParserConfigurationException, 
      SAXException

Aşağıdaki kodlar, XML ayrıştırıcısının bir XML belgesini okumak için nasıl kullanılabileceğinin bir örneğini gösterir.

Farz edelim ki Movies.xml adında aynı belgeye sahibiz ve XML belgesini ayrıştırıp kullanıcıya uygun bir çıktı görüntülemek istedik. Aşağıdaki kod, XML belgesinin tüm içeriğinde nasıl gezinebileceğimizi ve kullanıcıya nasıl uygun bir yanıt gösterebileceğimizi gösteren bir parçadır.

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("*******************************")
      }
   }
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

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

Yukarıdaki kodla ilgili dikkat edilmesi gereken önemli noktalar.

• XmlParser sınıfının bir nesnesi, XML belgesini ayrıştırmak için kullanılabilmesi için oluşturuluyor.

• Ayrıştırıcıya XML dosyasının konumu verilir.

• Her film öğesi için, her bir alt düğümde gezinmek ve ilgili bilgileri görüntülemek için bir kapanış kullanıyoruz.

Movie öğesinin kendisi için, movie öğesine eklenen title niteliğini görüntülemek için @ sembolünü kullanıyoruz.

JMX, Java sanal ortamı ile herhangi bir ilgisi olan tüm uygulamaları izlemek için kullanılan fiili standarttır. Groovy'nin doğrudan Java'nın üzerinde olduğu göz önüne alındığında, Groovy, Java ile JMX için halihazırda yapılmış olan muazzam miktardaki işten yararlanabilir.

JVM'yi izleme

JVM'nin izlenmesini gerçekleştirmek için java.lang.management içinde bulunan standart sınıflar kullanılabilir. Aşağıdaki kod örneği, bunun nasıl yapılabileceğini gösterir.

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"
   } 
}

Kod yürütüldüğünde, çıktı, kodun çalıştırıldığı sisteme bağlı olarak değişecektir. Çıktının bir örneği aşağıda verilmiştir.

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]

Tomcat'i izleme

Tomcat'i izlemek için tomcat başlatıldığında aşağıdaki parametre ayarlanmalıdır -

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

Aşağıdaki kod, çalışan Tomcat'teki kullanılabilir MBean'leri keşfetmek, hangilerinin web modüllerini belirlemek ve her web modülü için işlem süresini çıkarmak için JMX'i kullanır.

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 
}

Bu bölüm, JSON nesnelerini ayrıştırmak ve üretmek için Groovy dilini nasıl kullanabileceğimizi kapsar.

JSON İşlevleri

Sr.No	İşlev ve Kitaplıklar
1	JsonSlurper JsonSlurper, JSON metnini veya okuyucu içeriğini Groovy verilerine ayrıştıran bir sınıftır Haritalar, listeler ve Tamsayı, Double, Boolean ve String gibi ilkel türler gibi yapılar.
2	JsonOutput Bu yöntem, Groovy nesnelerini JSON dizelerine serileştirmekten sorumludur.

JsonSlurper kullanarak Verileri Ayrıştırma

JsonSlurper, JSON metnini veya okuyucu içeriğini haritalar, listeler ve Integer, Double, Boolean ve String gibi ilkel türler gibi Groovy veri Yapılarına ayrıştıran bir sınıftır.

Sözdizimi

def slurper = new JsonSlurper()

JSON bulamaç, metni veya okuyucu içeriğini listeler ve haritaların veri yapısına ayrıştırır.

JsonSlurper sınıfı, ayrıştırıcı uygulamaları için birkaç değişkenle birlikte gelir. Bazen belirli dizeleri ayrıştırmaya gelince farklı gereksinimleriniz olabilir. Bir web sunucusundan gelen yanıttan dönen JSON'un okunması gereken bir örneği ele alalım. Böyle bir durumda ayrıştırıcı JsonParserLax varyantını kullanmak faydalıdır. Bu parsee, JSON metninde yorumlara izin verir ve alıntı dizeleri vb. İçermez. Bu tür ayrıştırıcıyı belirtmek için, JsonSlurper nesnesini tanımlarken JsonParserType.LAX ayrıştırıcı türünü kullanmanız gerekir.

Aşağıda verilen bunun bir örneğini görelim. Örnek, http modülünü kullanarak bir web sunucusundan JSON verilerini almak içindir. Bu tür çapraz geçiş için en iyi seçenek ayrıştırıcı türünün JsonParserLax değişkenine ayarlanmasıdır.

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)
   }
}

Benzer şekilde, aşağıdaki ek ayrıştırıcı türleri Groovy'de mevcuttur -

• JsonParserCharArray ayrıştırıcısı temelde bir JSON dizesi alır ve temel alınan karakter dizisi üzerinde çalışır. Değer dönüştürme sırasında, karakter alt dizilerini ("doğrama" olarak bilinen bir mekanizma) kopyalar ve bunlar üzerinde ayrı ayrı çalışır.

• JsonFastParser, JsonParserCharArray'in özel bir çeşididir ve en hızlı ayrıştırıcıdır. JsonFastParser, aynı zamanda dizin-yer paylaşımı ayrıştırıcısı olarak da bilinir. Verilen JSON String'in ayrıştırılması sırasında, yeni char dizileri veya String örnekleri oluşturmaktan kaçınmak için mümkün olduğunca çok çalışır. Yalnızca temeldeki orijinal karakter dizisine işaretçileri tutar. Ek olarak, nesne oluşturmayı mümkün olduğu kadar geciktirir.

• JsonParserUsingCharacterSource, çok büyük dosyalar için özel bir ayrıştırıcıdır. Sabit performans özelliklerine sahip büyük JSON dosyalarını (bu durumda büyük, 2MB boyutunun üzerindeki dosyalar anlamına gelir) ayrıştırmak için "karakter pencereleme" adı verilen bir teknik kullanır.

Metni Ayrıştırma

JsonSlurper sınıfını nasıl kullanabileceğimize dair bazı örneklere bir göz atalım.

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);
   } 
}

Yukarıdaki örnekte biz -

• Önce JsonSlurper sınıfının bir örneğini oluşturma

• Daha sonra bazı JSON metnini ayrıştırmak için JsonSlurper sınıfının parseText işlevini kullanıyoruz.

• Nesneyi aldığımızda, JSON dizesindeki değerlere aslında anahtar aracılığıyla erişebildiğimizi görebilirsiniz.

Yukarıdaki programın çıktısı aşağıda verilmiştir -

John 
1

Tamsayıların Ayrıştırma Listesi

JsonSlurper ayrıştırma yönteminin başka bir örneğine bakalım. Aşağıdaki örnekte, tamsayıların bir listesini alıyoruz. Aşağıdaki koddan, her birinin List yöntemini kullanabildiğimizi ve ona bir kapatma geçirebileceğimizi fark edeceksiniz.

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 }
   } 
}

Yukarıdaki programın çıktısı aşağıda verilmiştir -

List=[2, 3, 4, 5]

İlkel Veri türlerinin Listesini Ayrıştırma

JSON ayrıştırıcısı aynı zamanda string, number, object, true, false ve null gibi ilkel veri türlerini de destekler. JsonSlurper sınıfı, bu JSON türlerini karşılık gelen Groovy türlerine dönüştürür.

Aşağıdaki örnek, bir JSON dizesini ayrıştırmak için JsonSlurper öğesinin nasıl kullanılacağını gösterir. Ve burada JsonSlurper'ın tek tek öğeleri kendi ilkel türlerine ayrıştırabildiğini görebilirsiniz.

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); 
   } 
}

Yukarıdaki programın çıktısı aşağıda verilmiştir -

12 
12.55 
1.2E+14

JsonOutput

Şimdi Json'da çıktıların nasıl yazdırılacağından bahsedelim. Bu, JsonOutput yöntemi ile yapılabilir. Bu yöntem, Groovy nesnelerini JSON dizelerine serileştirmekten sorumludur.

Sözdizimi

Static string JsonOutput.toJson(datatype obj)

Parameters - Parametreler bir veri türünün nesnesi olabilir - Sayı, Boole, karakter, Dize, Tarih, Harita, kapanış vb.

Return type - Dönüş türü bir json dizesidir.

Misal

Aşağıda bunun nasıl başarılabileceğine dair basit bir örnek verilmiştir.

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

Yukarıdaki programın çıktısı aşağıda verilmiştir -

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

JsonOutput, düz eski, harika nesneler için de kullanılabilir. Aşağıdaki örnekte, aslında Student türündeki nesneleri JsonOutput yöntemine geçirdiğimizi görebilirsiniz.

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; 
}

Yukarıdaki programın çıktısı aşağıda verilmiştir -

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

Groovy, üst düzey ifadeler için bir yöntem çağrısının argümanlarının etrafındaki parantezlerin çıkarılmasına izin verir. Bu, "komut zinciri" özelliği olarak bilinir. Bu uzantı, birinin bu tür parantez içermeyen yöntem çağrılarını zincirlemesine izin vererek çalışır, argümanlar etrafında parantezler veya zincirleme çağrılar arasında noktalar gerektirmez.

Bir çağrı olarak yürütülürse a b c d, bu aslında eşdeğer olacaktır a(b).c(d).

DSL veya Etki Alanına özgü dil, Groovy'de yazılan kodu, ortak kullanıcı tarafından kolayca anlaşılır hale getirecek şekilde basitleştirmeyi amaçlamaktadır. Aşağıdaki örnek, alana özel bir dile sahip olmanın tam olarak ne anlama geldiğini gösterir.

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

Yukarıdaki kod, println ifadesi kullanılarak konsola yazdırılan numaraların bir listesini gösterir. Etki alanına özel bir dilde komutlar şu şekilde olacaktır:

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

Dolayısıyla yukarıdaki örnek, programlama dilinin bir alana özgü dilin ihtiyaçlarını karşılayacak şekilde dönüşümünü göstermektedir.

Groovy'de DSL'leri nasıl uygulayabileceğimize dair basit bir örneğe bakalım -

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" 
}

Yukarıdaki programı çalıştırdığımızda şu sonucu alacağız -

How are things? We are doing well. Take care

Yukarıdaki kod uygulaması hakkında aşağıdakilere dikkat edilmelidir -

• Bir kapanışı kabul eden statik bir yöntem kullanılır. Bu, çoğunlukla bir DSL uygulamasının sorunsuz bir yoludur.

• E-posta örneğinde, EmailDsl sınıfının bir make yöntemi vardır. Bir örnek oluşturur ve kapanıştaki tüm çağrıları örneğe delege eder. Bu, "to" ve "from" bölümlerinin, EmailDsl sınıfı içindeki yöntemleri yürüttüğü mekanizmadır.

• To () yöntemi çağrıldığında, metni daha sonra biçimlendirme için örnekte saklarız.

• Artık EmailDSL yöntemini son kullanıcılar için anlaşılması kolay olan kolay bir dille arayabiliriz.

Groovy'nin groovy-sql modülü, mevcut Java'nın JDBC teknolojisi üzerinde daha yüksek düzeyde bir soyutlama sağlar. Groovy sql API, bazıları aşağıda gösterilen çok çeşitli veritabanlarını destekler.

• HSQLDB
• Oracle
• SQL Server
• MySQL
• MongoDB

Örneğimizde, örnek olarak MySQL DB kullanacağız. MySQL'i Groovy ile kullanmak için yapılacak ilk şey MySQL jdbc jar dosyasını mysql sitesinden indirmektir.The forMySQL'in matı aşağıda gösterilecektir.

mysql-connector-java-5.1.38-bin

Ardından, yukarıdaki jar dosyasını iş istasyonunuzdaki sınıf yoluna eklediğinizden emin olun.

Veritabanı Bağlantısı

Bir MySQL veritabanına bağlanmadan önce aşağıdakilerden emin olun -

• Bir TESTDB veritabanı oluşturdunuz.
• TESTDB'de EMPLOYEE tablosu oluşturdunuz.
• Bu tabloda FIRST_NAME, LAST_NAME, AGE, SEX ve INCOME alanları var.
• "Testuser" kullanıcı kimliği ve "test123" şifresi TESTDB'ye erişmek için ayarlanmıştır.
• Mysql jar dosyasını indirdiğinizden ve dosyayı sınıf yolunuza eklediğinizden emin olun.
• MySQL Temellerini anlamak için MySQL eğitiminden geçtiniz

Aşağıdaki örnek, MySQL veritabanı "TESTDB" ile nasıl bağlanılacağını gösterir.

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()  
   } 
}

Bu komut dosyasını çalıştırırken aşağıdaki sonucu üretiyor -

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

Veritabanı Tablosu Oluşturma

Veritabanına bağlandıktan sonraki adım, veritabanımızda tabloları oluşturmaktır. Aşağıdaki örnek, Groovy kullanılarak veritabanında nasıl tablo oluşturulacağını gösterir. Sql sınıfının execute yöntemi, veritabanına karşı ifadeleri yürütmek için kullanılır.

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() 
   } 
}

İşlem Ekle

Kayıtlarınızı bir veritabanı tablosunda oluşturmak istediğinizde gereklidir.

Misal

Aşağıdaki örnek, çalışan tablosuna bir kayıt ekleyecektir. Kod, bir try catch bloğuna yerleştirilir, böylece kayıt başarılı bir şekilde yürütülürse, işlem veritabanına kaydedilir. İşlem başarısız olursa, geri alma yapılır.

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()
   } 
}

Bir kritere göre yalnızca belirli satırları seçmek isteyip istemediğinizi varsayalım. Aşağıdaki kodlar, değerleri aramak için bir parametre yer tutucusunu nasıl ekleyebileceğinizi gösterir. Yukarıdaki örnek, aşağıdaki kodda gösterildiği gibi parametreleri almak için de yazılabilir. $ Sembolü, daha sonra sql ifadesi yürütüldüğünde değerlerle değiştirilebilecek bir parametre tanımlamak için kullanılır.

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()
   }
}

OKUMA İşlemi

Herhangi bir veritabanı üzerinde OKUMA İşlemi, veritabanından bazı yararlı bilgileri almak anlamına gelir. Veritabanı bağlantımız kurulduktan sonra, bu veritabanına bir sorgulama yapmaya hazırsınız.

Okuma işlemi sql sınıfının eachRow yöntemi kullanılarak gerçekleştirilir.

Sözdizimi

eachRow(GString gstring, Closure closure)

Sonuç kümesinin her satırıyla verilen Kapanışı çağırarak verilen SQL sorgusunu gerçekleştirir.

Parameters

• Gstring - Yürütülmesi gereken sql ifadesi.

• Closure- Okuma işleminden alınan satırları işlemek için kapanış ifadesi. Sonuç kümesinin her satırıyla verilen Kapanışı çağırarak verilen SQL sorgusunu gerçekleştirir.

Aşağıdaki kod örneği, tüm kayıtların çalışan tablosundan nasıl getirileceğini gösterir.

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()
   } 
}

Yukarıdaki programdan elde edilen çıktı -

[Mac, Mohan, 20, M, 2000.0]

Güncelleme İşlemi

GÜNCELLEME Herhangi bir veritabanı üzerinde işlem, veritabanında zaten mevcut olan bir veya daha fazla kaydı güncellemek anlamına gelir. Aşağıdaki prosedür, SEX olan tüm kayıtları 'M' olarak günceller. Burada tüm erkeklerin YAŞ'ını bir yıl artırıyoruz.

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 İşlemi

Veritabanınızdan bazı kayıtları silmek istediğinizde DELETE işlemi gereklidir. Aşağıda, AGE'nin 20'den fazla olduğu ÇALIŞAN'dan tüm kayıtları silme prosedürü verilmiştir.

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()
   } 
}

İşlemlerin Gerçekleştirilmesi

İşlemler, veri tutarlılığını sağlayan bir mekanizmadır. İşlemler aşağıdaki dört özelliğe sahiptir -

• Atomicity - Ya bir işlem tamamlanır ya da hiçbir şey olmaz.

• Consistency - Bir işlem tutarlı bir durumda başlamalı ve sistemi tutarlı bir durumda bırakmalıdır.

• Isolation - Bir işlemin ara sonuçları cari işlemin dışında görünmez.

• Durability - Bir işlem yapıldığında, sistem hatasından sonra bile etkiler kalıcıdır.

İşte işlemlerin nasıl uygulanacağına dair basit bir örnek. Bu örneği daha önce SİLME işleminin önceki konumuzdan görmüştük.

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()

İşlemi Tamamla

Kaydetme işlemi, veritabanına işleme devam etmesini ve veritabanındaki tüm değişiklikleri sonuçlandırmasını söyleyen şeydir.

Yukarıdaki örneğimizde, bu aşağıdaki ifadeyle elde edilir -

sql.commit()

Geri Alma İşlemi

Bir veya daha fazla değişiklikten memnun değilseniz ve bu değişiklikleri tamamen geri almak istiyorsanız, geri alma yöntemini kullanın. Yukarıdaki örneğimizde, bu aşağıdaki ifadeyle elde edilir -

sql.rollback()

Veritabanlarının Bağlantısını Kesme

Veritabanı bağlantısını kesmek için, kapatma yöntemini kullanın.

sql.close()

Yazılım geliştirme sürecinde, bazen geliştiriciler Veri yapıları, etki alanı sınıfları, XML, GUI Düzenleri, Çıktı akışları vb. Oluşturmak için çok zaman harcarlar ve bazen bu belirli gereksinimleri oluşturmak için kullanılan kod, aynı parçacığın tekrarlanmasına neden olur. birçok yerde kod. Groovy inşaatçılarının devreye girdiği yer burasıdır. Groovy, standart nesneler ve yapılar oluşturmak için kullanılabilecek inşaatçılara sahiptir. Bu oluşturucular, geliştiricilerin bu oluşturucuları oluşturmak için kendi kodlarını yazmaları gerekmediğinden zamandan tasarruf sağlar. Bu bölümün yanında, groovy'de bulunan farklı inşaatçılara bakacağız.

Salıncak Oluşturucu

Groovy'de, groovy'de bulunan swing yapıcıları kullanarak grafiksel kullanıcı arayüzleri de oluşturulabilir. Salıncak bileşenlerini geliştirmek için ana sınıf, SwingBuilder sınıfıdır. Bu sınıf, aşağıdakiler gibi grafik bileşenleri oluşturmak için birçok yönteme sahiptir:

• JFrame - Bu çerçeve elemanını oluşturmak içindir.

• JTextField - Bu, metin alanı bileşenini oluşturmak için kullanılır.

SwingBuilder sınıfını kullanarak bir Swing uygulamasının nasıl oluşturulacağına dair basit bir örneğe bakalım. Aşağıdaki örnekte, aşağıdaki noktaları görebilirsiniz -

• Groovy.swing.SwingBuilder ve javax.swing. * Sınıflarını içe aktarmanız gerekir.

• Swing uygulamasında görüntülenen bileşenlerin tümü SwingBuilder sınıfının parçasıdır.

• Çerçevenin kendisi için, çerçevenin başlangıç ​​konumunu ve boyutunu belirleyebilirsiniz. Ayrıca çerçevenin başlığını da belirtebilirsiniz.

• Çerçevenin gösterilmesi için Visibility özelliğini true olarak ayarlamanız gerekir.

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)

Yukarıdaki programın çıktısı aşağıda verilmiştir. Aşağıdaki çıktı, Hello World metniyle birlikte bir JLabel ile birlikte bir JFrame gösterir.

Metin kutuları ile bir giriş ekranı oluşturmak için bir sonraki örneğimize bakalım. Aşağıdaki örnekte, Öğrenci adı, konu ve Okul Adı için metin kutuları olan bir form oluşturmak istiyoruz. Aşağıdaki örnekte, aşağıdaki temel noktaları görebilirsiniz -

• Ekrandaki kontrollerimiz için bir düzen tanımlıyoruz. Bu durumda Grid Layout kullanıyoruz.
• Etiketlerimiz için bir hizalama özelliği kullanıyoruz.
• Metin kutularını ekranda görüntülemek için textField yöntemini kullanıyoruz.

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)

Yukarıdaki programın çıktısı aşağıda verilmiştir -

Etkinlik sahipleri

Şimdi olay işleyicilere bakalım. Olay işleyicileri, bir düğmeye basıldığında bir tür işlem gerçekleştirmek için düğme için kullanılır. Her düğme sözde yöntem çağrısı, actionPerformed parametresini içerir. Bu, kapanış olarak sunulan bir kod bloğunu temsil eder.

2 düğmeli bir ekran oluşturmak için bir sonraki örneğimize bakalım. Herhangi bir düğmeye basıldığında, konsol ekranına ilgili bir mesaj gönderilir. Aşağıdaki örnekte, aşağıdaki temel noktaları görebilirsiniz -

• Tanımlanan her düğme için actionPerformed yöntemini kullanıyoruz ve düğmeye tıklandığında konsola bazı çıktılar göndermek için bir kapanış tanımlıyoruz.

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)

Yukarıdaki programın çıktısı aşağıda verilmiştir. Herhangi bir düğmeyi tıkladığınızda, gerekli mesaj konsol günlük ekranına gönderilir.

Yukarıdaki örneğin başka bir varyasyonu, işleyici olarak hareket edebilen yöntemleri tanımlamaktır. Aşağıdaki örnekte, DisplayA ve DisplayB için 2 işleyici tanımlıyoruz.

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)

Yukarıdaki programın çıktısı önceki örnekle aynı kalacaktır.

DOM Oluşturucu

DOM oluşturucu, HTML, XHTML ve XML ayrıştırmak ve bunu bir W3C DOM ağacına dönüştürmek için kullanılabilir.

Aşağıdaki örnek, DOM oluşturucunun nasıl kullanılabileceğini gösterir.

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 türü nesneler oluşturmak için kullanılır.

Aşağıdaki örnek, Json oluşturucunun nasıl kullanılabileceğini gösterir.

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());

Yukarıdaki programın çıktısı aşağıda verilmiştir. Çıktı clearlt, Jsonbuilder'ın json nesnesini yapılandırılmış bir düğüm kümesinden oluşturabildiğini gösterir.

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

Jsonbuilder ayrıca bir listeyi alıp bir json nesnesine dönüştürebilir. Aşağıdaki örnek bunun nasıl gerçekleştirilebileceğini göstermektedir.

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

Yukarıdaki programın çıktısı aşağıda verilmiştir.

[1,2,3]

JsonBuilder, sınıflar için de kullanılabilir. Aşağıdaki örnek, bir sınıfın nesnelerinin nasıl json oluşturucunun girdileri haline gelebileceğini gösterir.

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)

Yukarıdaki programın çıktısı aşağıda verilmiştir.

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

NodeBuilder

NodeBuilder, rastgele verileri işlemek için Node nesnelerinin iç içe geçmiş ağaçlarını oluşturmak için kullanılır. Bir Nodebuilder kullanımının bir örneği aşağıda gösterilmiştir.

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, bir belirtimden bir dosya dizin yapısı oluşturmak için bir oluşturucudur. Aşağıda FileTreeBuilder'ın nasıl kullanılabileceğine dair bir örnek verilmiştir.

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

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

Yukarıdaki kodun çalıştırılmasıyla main / submain / Tutorial klasöründe sample.txt adlı bir dosya oluşturulacaktır. Ve sample.txt dosyası "Merhaba Dünya" metnine sahip olacaktır.

Groovysh olarak bilinen Groovy kabuğu, harika ifadeleri değerlendirmek, sınıfları tanımlamak ve basit programları çalıştırmak için kolayca kullanılabilir. Groovy kurulduğunda komut satırı kabuğu yüklenir.

Groovy'de bulunan komut satırı seçenekleri şunlardır -

Komut satırı parametresi	Ad Soyad	Detaylar
-C	--renk [= BAYRAĞ]	ANSI renklerinin kullanımını etkinleştirin veya devre dışı bırakın
-D	--define = AD = DEĞER	Bir sistem özelliği tanımlayın
-T	--terminal = TÜR	Kullanılacak terminal tipini belirtin
-V	--version	Sürümü göster
-sınıf yolu		Sınıf dosyalarının nerede bulunacağını belirtin - ilk bağımsız değişken olmalıdır
-cp	--classpath	'-Sınıf yolu' takma adları
-d	- hata ayıklama	--debug Hata ayıklama çıktısını etkinleştir
-e	--evaluate = arg	Etkileşimli oturumu başlatırken seçenek yumruğunu değerlendirin
-h	--Yardım	Bu yardım mesajını göster
-q	--sessiz	Gereksiz çıktıyı bastırın
-v	--verbose	Ayrıntılı çıktıyı etkinleştir

Aşağıdaki anlık görüntü, Groovy kabuğunda yürütülen bir ifadenin basit bir örneğini gösterir. Aşağıdaki örnekte, sadece harika kabukta "Merhaba Dünya" yazıyoruz.

Sınıflar ve Fonksiyonlar

Komut isteminde bir sınıf tanımlamak, yeni bir nesne oluşturmak ve sınıfta bir yöntemi çağırmak çok kolaydır. Aşağıdaki örnek, bunun nasıl uygulanabileceğini göstermektedir. Aşağıdaki örnekte, basit bir yöntemle basit bir Öğrenci sınıfı oluşturuyoruz. Komut isteminin kendisinde, sınıfın bir nesnesini oluşturuyoruz ve Display yöntemini çağırıyoruz.

Komut isteminde bir yöntem tanımlamak ve yöntemi çağırmak çok kolaydır. Yöntemin def türü kullanılarak tanımlandığını unutmayın. Ayrıca, Display yöntemi çağrıldığında gerçek değerle değiştirilen ad adında bir parametre eklediğimizi unutmayın. Aşağıdaki örnek, bunun nasıl uygulanabileceğini göstermektedir.

Komutlar

Kabuğun, kabuğun ortamına zengin erişim sağlayan bir dizi farklı komutu vardır. Aşağıda bunların listesi ve yaptıkları yer almaktadır.

Sr.No	Command & smp; Komut Açıklama
1	:help (: h) Bu yardım mesajını göster
2	? (:?) Takma ad:: yardım
3	:exit (: x) Kabuktan çık
4	:quit (: q) Takma ad:: çıkış
5	import (: i) Bir sınıfı ad alanına aktarın
6	:display (: d) Geçerli arabelleği görüntüle
7	:clear (: c) Arabelleği temizleyin ve istem sayacını sıfırlayın
8	:show (: S) Değişkenleri, sınıfları veya içe aktarmaları göster
9	:inspect (: n) GUI nesne tarayıcısıyla bir değişkeni veya son sonucu inceleyin
10	:purge (: p) Değişkenleri, sınıfları, içe aktarmaları veya tercihleri ​​temizle
11	:edit (: e) Geçerli arabelleği düzenle
12	:load (: l) Arabelleğe bir dosya veya URL yükle
13	. (:.) Takma ad:: yükleme
14	.save (: s) Geçerli arabelleği bir dosyaya kaydet
15	.record (: r) Geçerli oturumu bir dosyaya kaydedin
16	:alias (: a) Bir takma ad oluşturun
17	:set (: =) Tercihleri ​​ayarlayın (veya listeleyin)
18	:register (: rc) Kabuk ile yeni bir komut kaydeder
19	:doc (: D) Bağımsız değişken için dokümanı görüntüleyen bir tarayıcı penceresi açar
20	:history (: H) Düzenleme satırı geçmişini görüntüleyin, yönetin ve geri çağırın

Nesne yönelimli bir sistemin temel birimi sınıftır. Bu nedenle birim testi, bir sınıf içindeki testlerden oluşur. Uygulanan yaklaşım, test edilen sınıfın bir nesnesini oluşturmak ve seçilen yöntemlerin beklendiği gibi çalışıp çalışmadığını kontrol etmek için kullanmaktır. Her şeyi tek tek test etmek her zaman pratik olmadığı için her yöntem test edilemez. Ancak, kilit ve kritik yöntemler için birim testi yapılmalıdır.

JUnit, Java kodunun otomatik birim testi için kabul edilen endüstri standardı olan açık kaynaklı bir test çerçevesidir. Neyse ki, JUnit çerçevesi, Groovy sınıflarını test etmek için kolayca kullanılabilir. Gereken tek şey, standart Groovy ortamının parçası olan GroovyTestCase sınıfını genişletmektir. Groovy test senaryosu sınıfı Junit test senaryosuna dayanmaktadır.

Basit Bir Junit Test Vakası Yazma

Bir uygulama sınıfı dosyasında aşağıdaki sınıfın tanımlandığını varsayalım -

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;
   }  
}

Yukarıdaki programın çıktısı aşağıda verilmiştir.

Joe1

Şimdi de Öğrenci sınıfı için bir test senaryosu yazmak istediğimizi varsayalım. Tipik bir test durumu aşağıdaki gibi görünür. Aşağıdaki kodla ilgili olarak aşağıdaki noktalara dikkat edilmesi gerekir -

• Test durumu sınıfı GroovyTestCase sınıfını genişletir
• Display yönteminin doğru dizeyi döndürdüğünden emin olmak için assert ifadesini kullanıyoruz.

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

Harika Test Paketi

Normalde birim testlerin sayısı arttıkça, tüm test durumlarını tek tek yürütmeye devam etmek zorlaşır. Bu nedenle Groovy, tüm test olaylarını tek bir mantıksal birimde toplayabilen bir test paketi oluşturmak için bir tesis sağlar. Aşağıdaki kodlayıcı, bunun nasıl başarılabileceğini göstermektedir. Kod hakkında aşağıdaki hususlara dikkat edilmelidir -

• GroovyTestSuite, tüm test senaryolarını tek bir teste almak için kullanılır.

• Aşağıdaki örnekte, biri adında iki test vaka dosyamız olduğunu varsayıyoruz. StudentTest ve diğeri EmployeeTest gerekli tüm testleri içeren.

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())

Groovy'nin şablon motoru, bir adres mektup birleştirme gibi çalışır (özellikle reklam olmak üzere birçok adrese posta göndermeyi kolaylaştırmak için bir veritabanından harflere ve zarflara adların ve adreslerin otomatik olarak eklenmesi), ancak çok daha geneldir.

Dizelerde Basit Şablon Oluşturma

Aşağıdaki basit örneği alırsanız, önce "Groovy" dizesini tutmak için bir isim değişkeni tanımlıyoruz. Println deyiminde, bir değerin eklenebileceği bir parametre veya şablon tanımlamak için $ sembolünü kullanıyoruz.

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

Yukarıdaki kod harika bir şekilde çalıştırılırsa, aşağıdaki çıktı gösterilecektir. Çıktı, $ adının def ifadesiyle atanan değerle değiştirildiğini açıkça gösterir.

Basit Şablon Motoru

Aşağıda, parametrize metin oluşturmak için şablonunuzda JSP benzeri komut dosyaları ve EL ifadeleri kullanmanıza olanak tanıyan bir SimpleTemplateEngine örneği verilmiştir. Şablon oluşturma motoru, tanımlı yer tutuculara sahip dizede değiştirilebilmeleri için bir parametre listesi ve değerleri bağlamanıza olanak tanır.

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

Yukarıdaki kod harika bir şekilde çalıştırılırsa, aşağıdaki çıktı gösterilecektir.

Şimdi bir XML dosyası için şablon oluşturma özelliğini kullanalım. İlk adım olarak aşağıdaki kodu Student.template adlı bir dosyaya ekleyelim. Aşağıdaki dosyada öğeler için gerçek değerleri değil, yer tutucuları eklediğimizi fark edeceksiniz. Yani $ isim,$is and $konu, çalışma zamanında değiştirilmesi gerekecek yer tutucular olarak yerleştirilir.

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

Şimdi yukarıdaki şablonu gerçek değerlerle değiştirmek için kullanılabilecek işlevselliği eklemek için Groovy betik kodumuzu ekleyelim. Aşağıdaki kodla ilgili olarak aşağıdaki hususlara dikkat edilmelidir.

• Yer tutucuların gerçek değerlerle eşlenmesi, bir bağlama ve bir SimpleTemplateEngine aracılığıyla yapılır. Bağlama, yer tutucuların anahtar olarak ve değiştirmelerin değerler olduğu bir Haritadır.

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

Yukarıdaki kod harika bir şekilde çalıştırılırsa, aşağıdaki çıktı gösterilecektir. Çıktıdan, değerlerin ilgili yer tutucularda başarıyla değiştirildiği görülebilir.

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

StreamingTemplateEngine

StreamingTemplateEngine motoru, Groovy'de bulunan başka bir şablon oluşturma motorudur. Bu, SimpleTemplateEngine ile eşdeğerdir, ancak şablonu büyük şablonlar için daha ölçeklenebilir hale getiren yazılabilir kapaklar kullanarak oluşturur. Özellikle bu şablon motoru 64k'den büyük dizeleri işleyebilir.

Aşağıda, StreamingTemplateEngine'in nasıl kullanıldığına dair bir örnek verilmiştir -

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)

Yukarıdaki kod harika bir şekilde çalıştırılırsa, aşağıdaki çıktı gösterilecektir.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngine, hem şablon kaynağının hem de beklenen çıktının XML olması amaçlanan şablon oluşturma senaryolarında kullanılır. Şablonlar normal kullanır${expression} and $şablona rastgele bir ifade eklemek için değişken gösterimler.

Aşağıda, XMLTemplateEngine'in nasıl kullanıldığına dair bir örnek verilmiştir.

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()

Yukarıdaki kod harika bir şekilde yürütülürse, aşağıdaki çıktı gösterilecektir

Joe
    
    
   1
    
    
   Physics

Meta nesne programlama veya MOP, yöntemleri dinamik olarak çağırmak ve ayrıca anında sınıflar ve yöntemler oluşturmak için kullanılabilir.

Peki bu ne anlama geliyor? Üye değişkenleri veya yöntemleri olmayan bir tür boş sınıf olan Öğrenci adlı bir sınıfı düşünelim. Bu sınıfta aşağıdaki ifadeleri çağırmanız gerekip gerekmediğini varsayalım.

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

Artık meta nesne programlamasında, sınıfın üye değişkeni Adına veya Display () yöntemine sahip olmasa bile, yukarıdaki kod yine de çalışacaktır.

Bu nasıl işleyebilir? Bunun işe yaraması için GroovyInterceptable arayüzünün Groovy'nin yürütme sürecine bağlanması için uygulanması gerekir. Bu arayüz için mevcut yöntemler aşağıdadır.

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) 
}

Dolayısıyla, yukarıdaki arayüz açıklamasında, invokeMethod () 'u uygulamak zorunda kalırsanız, var olan veya olmayan her yöntem için çağrılacağını varsayalım.

Eksik Özellikler

Öyleyse, eksik Özellikler için Meta Nesne Programlamayı nasıl uygulayabileceğimizin bir örneğine bakalım. Aşağıdaki kod hakkında aşağıdaki önemli hususlara dikkat edilmelidir.

• Öğrenci sınıfının Adı veya kimliği tanımlı üye değişkeni yoktur.

• Öğrenci sınıfı GroovyInterceptable arayüzünü uygular.

• Anında yaratılan üye değişkenlerin değerini tutmak için kullanılacak olan dynamicProps adlı bir parametre vardır.

• Getproperty ve setproperty yöntemleri, çalışma zamanında sınıfın özelliklerinin değerlerini almak ve ayarlamak için uygulanmıştır.

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]
   } 
}

Aşağıdaki kodun çıktısı şu olacaktır:

Joe 
1

Eksik yöntemler

Öyleyse, eksik Özellikler için Meta Nesne Programlamayı nasıl uygulayabileceğimizin bir örneğine bakalım. Aşağıdaki kod hakkında aşağıdaki önemli hususlara dikkat edilmelidir -

• Öğrenci sınıfı artık yöntemin var olup olmadığına bakılmaksızın çağrılan invokeMethod yöntemini uygular.

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"
   }
}

Aşağıdaki kodun çıktısı aşağıda gösterilecektir. Görüntüleme yöntemi mevcut olmasa bile, Yöntem İstisnası'nı kaçırma hatası olmadığını unutmayın.

Joe 
1

Metasınıf

Bu işlevsellik, MetaClass uygulamasıyla ilgilidir. Varsayılan uygulamada alanlara alıcılarını ve ayarlayıcılarını çağırmadan erişebilirsiniz. Aşağıdaki örnek, metaClass işlevini kullanarak sınıftaki özel değişkenlerin değerini nasıl değiştirebileceğimizi gösterir.

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;
   } 
}

Aşağıdaki kodun çıktısı şu olacaktır:

Joe 
Mark

Yöntem Eksik

Groovy, methodMissing kavramını destekler. Bu yöntem, verilen ad ve / veya verilen argümanlar için hiçbir yöntem bulunamadığında, yalnızca başarısız bir yöntem gönderimi durumunda çağrılması açısından invokeMethod'dan farklıdır. Aşağıdaki örnek, methodMissing'in nasıl kullanılabileceğini gösterir.

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"
   }  
}

Aşağıdaki kodun çıktısı şu olacaktır:

Joe 
1 
Missing method