Groovy-クイックガイド

Groovyは、Javaプラットフォームに基づくオブジェクト指向言語です。Groovy 1.0は2007年1月2日にリリースされ、現在のメジャーリリースはGroovy2.4です。Groovyは、Apache License v2.0を介して配布されます。

Groovyの特徴

Groovyには次の機能があります-

• 静的型付けと動的型付けの両方のサポート。
• 演算子のオーバーロードのサポート。
• リストと連想配列のネイティブ構文。
• 正規表現のネイティブサポート。
• XMLやHTMLなどのさまざまなマークアップ言語のネイティブサポート。
• JavaとGroovyの構文は非常に似ているため、GroovyはJava開発者にとって単純です。
• 既存のJavaライブラリを使用できます。
• Groovyはjava.lang.Objectを拡張します。

Groovyの公式ウェブサイトは http://www.groovy-lang.org/

Groovy環境をセットアップするにはさまざまな方法があります。

Binary download and installation−リンクwww.groovy-lang.org/download.htmlにアクセスして、Windowsインストーラーセクションを取得します。このオプションをクリックして、Groovyインストーラーのダウンロードを開始します。

インストーラーを起動したら、以下の手順に従ってインストールを完了します。

Step 1 −言語インストーラーを選択します。

Step 2 −次の画面で[次へ]ボタンをクリックします。

Step 3 − [同意する]ボタンをクリックします。

Step 4 −デフォルトのコンポーネントを受け入れて、「次へ」ボタンをクリックします。

Step 5 −適切な宛先フォルダを選択し、[次へ]ボタンをクリックします。

Step 6 − [インストール]ボタンをクリックして、インストールを開始します。

Step 7 −インストールが完了したら、[次へ]ボタンをクリックして構成を開始します。

Step 8 −デフォルトのオプションを選択し、「次へ」ボタンをクリックします。

Step 9 −デフォルトのファイルの関連付けを受け入れて、「次へ」ボタンをクリックします。

Step 10 − [完了]ボタンをクリックして、インストールを完了します。

上記の手順を実行すると、Groovyインストールの一部であるGroovyシェルを開始できます。これは、Groovyの本格的な統合開発環境を必要とせずに、Groovy言語のさまざまな側面をテストするのに役立ちます。これは、コマンドプロンプトからコマンドgroovyshを実行することで実行できます。

MavenまたはGradleビルドの一部としてGroovyバイナリを含めたい場合は、次の行を追加できます

Gradle

'org.codehaus.groovy:groovy:2.4.5'

Maven

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

Groovyの基本的な構文を理解するために、最初に簡単なHelloWorldプログラムを見てみましょう。

初めてのHelloWorldプログラムの作成

最初のhelloworldプログラムの作成は、次のコード行を入力するだけです。

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

上記のプログラムを実行すると、次の結果が得られます-

Hello World

Groovyでのインポートステートメント

importステートメントを使用して、コードで使用できる他のライブラリの機能をインポートできます。これは、import キーワード。

次の例は、HTMLまたはXMLマークアップを作成するためにおそらく最も使用されるクラスの1つであるMarkupBuilderクラスの単純なインポートを使用する方法を示しています。

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

デフォルトでは、Groovyのコードには次のライブラリが含まれているため、明示的にインポートする必要はありません。

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のトークン

トークンは、キーワード、識別子、定数、文字列リテラル、または記号のいずれかです。

println(“Hello World”);

上記のコード行には、2つのトークンがあります。1つはキーワードprintlnで、次は「HelloWorld」の文字列リテラルです。

Groovyのコメント

コメントは、コードを文書化するために使用されます。Groovyのコメントは、1行または複数行にすることができます。

単一行コメントは、行の任意の位置で//を使用して識別されます。例を以下に示します-

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

複数行コメントは、最初が/ *で識別され、複数行コメントの最後を識別するために* /で識別されます。

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

セミコロン

Javaプログラミング言語とは異なり、すべてのステートメントの終了後にセミコロンを付ける必要はありません。これはオプションです。

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

上記のプログラムを実行した場合、mainメソッドの両方のステートメントでエラーは発生しません。

識別子

識別子は、変数、関数、またはその他のユーザー定義変数を定義するために使用されます。識別子は、文字、ドル、またはアンダースコアで始まります。数字で始めることはできません。有効な識別子の例を次に示します-

def employeename 
def student1 
def student_name

どこ def Groovyで識別子を定義するために使用されるキーワードです。

これは、HelloWorldプログラムで識別子を使用する方法のコード例です。

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

上記の例では、変数 x 識別子として使用されます。

キーワード

名前が示すキーワードは、Groovyプログラミング言語で予約されている特別な単語です。次の表に、Groovyで定義されているキーワードを示します。

なので	主張する	ブレーク	場合
キャッチ	クラス	const	継続する
def	デフォルト	行う	そうしないと
列挙型	拡張します	false	最終的に
にとって	後藤	もし	実装
インポート	に	instanceof	インターフェース
新着	引く	パッケージ	戻る
素晴らしい	スイッチ	この	スロー
スロー	特性	true	試してみてください
一方

空白

空白は、JavaやGroovyなどのプログラミング言語で使用される用語で、空白、タブ、改行文字、コメントを表します。空白は、ステートメントの一部を別の部分から分離し、コンパイラーがステートメント内の1つの要素を識別できるようにします。

たとえば、次のコード例では、キーワードの間に空白があります defおよび変数x。これは、コンパイラがそれを認識できるようにするためです。def は使用する必要のあるキーワードであり、xは定義する必要のある変数名である必要があります。

def x = 5;

リテラル

リテラルは、Groovyで固定値を表すための表記法です。Groovy言語には、整数、浮動小数点数、文字、および文字列の表記法があります。Groovyプログラミング言語のリテラルの例をいくつか示します-

12 
1.45 
‘a’ 
“aa”

どのプログラミング言語でも、さまざまな種類の情報を格納するためにさまざまな変数を使用する必要があります。変数は、値を格納するために予約されたメモリ位置に他なりません。これは、変数を作成するときに、変数に関連付けられた値を格納するためにメモリにいくらかのスペースを予約することを意味します。

文字列、文字、ワイド文字、整数、浮動小数点、ブール値など、さまざまなデータ型の情報を格納することができます。変数のデータ型に基づいて、オペレーティングシステムはメモリを割り当て、予約済みに格納できるものを決定します。メモリ。

組み込みのデータ型

Groovyは、さまざまな組み込みデータ型を提供します。以下は、Groovyで定義されているデータ型のリストです。

• byte−これはバイト値を表すために使用されます。例は2です。

• short−これは短い数を表すために使用されます。例は10です。

• int−これは整数を表すために使用されます。例は1234です。

• long−これは長い数値を表すために使用されます。例は10000090です。

• float−これは、32ビット浮動小数点数を表すために使用されます。例は12.34です。

• double−これは、64ビット浮動小数点数を表すために使用されます。64ビット浮動小数点数は、場合によっては必要になる可能性のある、より長い10進数表現です。例は12.3456565です。

• char−これは1文字のリテラルを定義します。例は「a」です。

• Boolean −これは、trueまたはfalseのいずれかであるブール値を表します。

• String −これらは、で表されるテキストリテラルです。 the form文字のチェーンの。たとえば、「He​​lloWorld」。

バインドされた値

次の表は、数値リテラルと10進数リテラルの最大許容値を示しています。

バイト	-128〜127
ショート	-32,768〜32,767
int	-2,147,483,648から2,147,483,647
長いです	-9,223,372,036,854,775,808から+9,223,372,036,854,775,807
浮く	1.40129846432481707e-45から3.40282346638528860e + 38
ダブル	4.94065645841246544e-324dから1.79769313486231570e + 308d

クラス数値

タイププリミティブタイプに加えて、次のオブジェクトタイプ（ラッパータイプと呼ばれることもあります）が許可されます-

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

さらに、次のクラスを使用して、任意精度の算術演算をサポートできます。

名前	説明	例
java.math.BigInteger	不変の任意精度の符号付き整数	30g
java.math.BigDecimal	不変の任意精度の符号付き10進数	3.5g

次のコード例は、さまざまな組み込みデータ型の使用方法を示しています。

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

上記のプログラムを実行すると、次の結果が得られます-

5 
100 
10.56 
1.05E41 
30 
3.5

Groovyの変数は、次の2つの方法で定義できます。 native syntax データ型または次は by using the def keyword。変数定義の場合、型名を明示的に指定するか、代わりに「def」を使用する必要があります。これは、Groovyパーサーで必要です。

前の章で説明したように、Groovyには次の基本的なタイプの変数があります-

• byte−これはバイト値を表すために使用されます。例は2です。

• short−これは短い数を表すために使用されます。例は10です。

• int−これは整数を表すために使用されます。例は1234です。

• long−これは長い数値を表すために使用されます。例は10000090です。

• float−これは、32ビット浮動小数点数を表すために使用されます。例は12.34です。

• double−これは、64ビット浮動小数点数を表すために使用されます。64ビット浮動小数点数は、場合によっては必要になる可能性のある、より長い10進数表現です。例は12.3456565です。

• char−これは1文字のリテラルを定義します。例は「a」です。

• Boolean −これは、trueまたはfalseのいずれかであるブール値を表します。

• String −これらは、で表されるテキストリテラルです。 the form文字のチェーンの。たとえば、「He​​lloWorld」。

Groovyでは、配列、構造体、クラスなど、後続の章で説明する追加のタイプの変数も使用できます。

変数宣言

変数宣言は、変数のストレージを作成する場所と量をコンパイラーに指示します。

以下は変数宣言の例です-

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

上記のプログラムを実行すると、次の結果が得られます-

Hello

変数の命名

変数の名前は、文字、数字、および下線文字で構成できます。文字またはアンダースコアで始まる必要があります。Javaが大文字と小文字を区別するプログラミング言語であるように、Groovyは大文字と小文字を区別します。

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

上記のプログラムを実行すると、次の結果が得られます-

5 
6 
Joe

私たちはそれを見ることができます x そして X 大文字と小文字が区別されるため、は2つの異なる変数であり、3番目のケースでは、_Nameがアンダースコアで始まることがわかります。

変数の印刷

println関数を使用して、変数の現在の値を出力できます。次の例は、これを実現する方法を示しています。

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

上記のプログラムを実行すると、次の結果が得られます-

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

演算子は、特定の数学的または論理的操作を実行するようにコンパイラーに指示する記号です。

Groovyには次のタイプの演算子があります-

• 算術演算子
• 関係演算子
• 論理演算子
• ビット演算子
• 代入演算子

算術演算子

Groovy言語は、他の言語と同様に通常の算術演算子をサポートします。以下は、Groovyで使用可能な算術演算子です。

例を表示

オペレーター	説明	例
+	2つのオペランドの追加	1 +2は3を与えます
−	最初のオペランドから2番目のオペランドを減算します	2 −1は1を与えます
*	両方のオペランドの乗算	2 * 2は4を与えます
/	分母による分子の除算	3/2は1.5を与えます
％	モジュラス演算子と整数/浮動小数点除算後の余り	3％2は1を与えます
++	オペランドの値を1ずつインクリメントするために使用されるインクリメント演算子	int x = 5; x ++; xは6を与えます
-	オペランドの値を1だけデクリメントするために使用される増分演算子	int x = 5; バツ - ; xは4を与えます

関係演算子

関係演算子を使用すると、オブジェクトを比較できます。以下は、Groovyで使用可能な関係演算子です。

例を表示

オペレーター	説明	例
==	2つのオブジェクト間の同等性をテストします	2 == 2は真になります
！=	2つのオブジェクトの違いをテストします	3！= 2は真になります
<	左側のオブジェクトが右側のオペランドよりも小さいかどうかを確認します。	2 <3は真になります
<=	左側のオブジェクトが右側のオペランド以下であるかどうかを確認します。	2 <= 3は真になります
>>	左側のオブジェクトが右側のオペランドより大きいかどうかを確認します。	3> 2は真になります
> =	左側のオブジェクトが右側のオペランド以上であるかどうかを確認します。	3> = 2は真になります

論理演算子

論理演算子は、ブール式を評価するために使用されます。Groovyで使用できる論理演算子は次のとおりです。

例を表示

オペレーター	説明	例
&&	これは論理的な「and」演算子です	true && trueはtrueを与えます
||	これは論理的な「または」演算子です	true || trueはtrueを与えます
！	これは論理的な「否定」演算子です	！falseはtrueになります

ビット演算子

Groovyは4つのビット演算子を提供します。以下は、Groovyで使用可能なビット演算子です。

例を表示

シニア番号	オペレーターと説明
1	& これはビット単位の「and」演算子です
2	| これはビット単位の「or」演算子です
3	^ これはビット単位の「xor」または排他的論理和演算子です
4	~ これはビット単位の否定演算子です

これらの演算子を示す真理値表を次に示します。

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

代入演算子

Groovy言語は、代入演算子も提供します。Groovyで使用できる代入演算子は次のとおりです。

例を表示

オペレーター	説明	例
+ =	これにより、右のオペランドが左のオペランドに追加され、結果が左のオペランドに割り当てられます。	def A = 5 A + = 3 出力は8になります
-=	これにより、左のオペランドから右のオペランドが減算され、その結果が左のオペランドに割り当てられます。	def A = 5 A- = 3 出力は2になります
* =	これにより、右のオペランドと左のオペランドが乗算され、その結果が左のオペランドに割り当てられます。	def A = 5 A * = 3 出力は15になります
/ =	これにより、左のオペランドが右のオペランドで除算され、結果が左のオペランドに割り当てられます。	def A = 6 A / = 3 出力は2になります
％=	これは、2つのオペランドを使用してモジュラスを取り、結果を左のオペランドに割り当てます。	def A = 5 A％= 3 出力は2になります

範囲演算子

Groovyは範囲の概念をサポートし、..表記の助けを借りて範囲演算子の表記を提供します。範囲演算子の簡単な例を以下に示します。

def range = 0..5

これは、整数の単純な範囲を定義するだけで、下限が0、上限が5のrangeというローカル変数に格納されます。

次のコードスニペットは、さまざまな演算子の使用方法を示しています。

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

上記のプログラムを実行すると、次の結果が得られます-

から println ステートメントを使用すると、rangeステートメントで定義されている数値の範囲全体が表示されていることがわかります。

getステートメントは、パラメーターとしてインデックス値を受け取る、定義された範囲からオブジェクトを取得するために使用されます。

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

オペレーターの優先順位

次の表に、すべてのGroovy演算子を優先順に示します。

シニア番号	演算子と名前
1	++ -- + - 事前インクリメント/デクリメント、単項プラス、単項マイナス
2	* / % 乗算、div、モジュロ
3	+ - 足し算、引き算
4	== != <=> 等しい、等しくない、と比較する
5	& バイナリ/ビット単位および
6	^ バイナリ/ビットごとのxor
7	| バイナリ/ビット単位または
8	&& 論理的および
9	|| 論理または
10	= **= *= /= %= += -= <<= >>= >>>= &= ^= |= さまざまな代入演算子

これまで、順番に実行されるステートメントを見てきました。さらに、プログラムのロジックの制御フローを変更するステートメントがGroovyで提供されます。次に、それらは詳細に説明する制御ステートメントのフローに分類されます。

S.No.	ステートメントと説明
1	Whileステートメント whileステートメントは、最初に条件式（ブール値）を評価することによって実行され、結果がtrueの場合、whileループ内のステートメントが実行されます。
2	ステートメント用 forステートメントは、一連の値を反復処理するために使用されます。
3	for-inステートメント for-inステートメントは、値のセットを反復処理するために使用されます。

ループ制御ステートメント

S.No.	ステートメントと説明
1	Breakステートメント breakステートメントは、ループ内の制御フローとswitchステートメントを変更するために使用されます。
2	ステートメントを続ける continueステートメントはbreakステートメントを補完します。その使用は、whileループとforループに制限されています。

意思決定構造では、プログラマーは、プログラムによって評価またはテストされる1つ以上の条件と、条件が次のように決定された場合に実行される1つまたは複数のステートメントを指定する必要があります。 true、およびオプションで、条件が次のように決定された場合に実行される他のステートメント false。

シニア番号	ステートメントと説明
1	ifステートメント このステートメントの一般的な動作は、最初に条件がifステートメントで評価されることです。条件が真の場合、ステートメントを実行します。
2	if / elseステートメント このステートメントの一般的な動作は、最初に条件がifステートメントで評価されることです。条件がtrueの場合、その後ステートメントを実行し、else条件の前に停止して、ループを終了します。条件がfalseの場合、elseステートメントブロック内のステートメントを実行してから、ループを終了します。
3	ネストされたIfステートメント 複数のifステートメントを相互に埋め込む必要がある場合があります。
4	Switchステートメント ネストされたif-elseステートメントは非常に一般的であり、頻繁に使用されるため、switchステートメントと呼ばれるより簡単なステートメントが設計されている場合があります。
5	ネストされたSwitchステートメント switchステートメントのネストされたセットを持つことも可能です。

Groovyにあるメソッドは、戻り値の型または defキーワード。メソッドは、任意の数の引数を受け取ることができます。引数を定義するときに、型を明示的に定義する必要はありません。public、private、protectedなどの修飾子を追加できます。デフォルトでは、可視性修飾子が提供されていない場合、メソッドはパブリックです。

最も単純なタイプのメソッドは、以下に示すようなパラメーターのないメソッドです。

def methodName() { 
   //Method code 
}

以下は簡単な方法の例です

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

上記の例では、DisplayNameは、コンソールにテキストを出力するために使用される2つのprintlnステートメントで構成される単純なメソッドです。静的mainメソッドでは、DisplayNameメソッドを呼び出しているだけです。上記のメソッドの出力は次のようになります-

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

メソッドパラメータ

メソッドは、その動作が1つ以上のパラメーターの値によって決定される場合に、より一般的に役立ちます。メソッドパラメータを使用して、呼び出されたメソッドに値を転送できます。パラメータ名は互いに異なっている必要があることに注意してください。

以下に示すようなパラメータを持つ最も単純なタイプのメソッド-

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

以下は、パラメーターを使用した簡単なメソッドの例です。

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

この例では、2つのパラメーターを使用してsumメソッドを作成しています。 a そして b。両方のパラメータはタイプですint。次に、mainメソッドからsumメソッドを呼び出し、値を変数に渡します。a そして b。

上記のメソッドの出力は値15になります。

デフォルトパラメータ

Groovyには、メソッド内のパラメーターのデフォルト値を指定するための規定もあります。パラメータのメソッドに値が渡されない場合は、デフォルトの値が使用されます。デフォルト以外のパラメータとデフォルトのパラメータの両方を使用する場合は、デフォルトのパラメータをパラメータリストの最後に定義する必要があることに注意する必要があります。

以下は、パラメータを使用した簡単な方法の例です。

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

2つの数値を追加するために前に見たのと同じ例を見て、1つのデフォルトパラメータと別のデフォルト以外のパラメータを持つメソッドを作成しましょう-

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

この例では、2つのパラメーターを使用してsumメソッドを作成しています。 a そして b。両方のパラメーターはint型です。この例と前の例の違いは、この場合、のデフォルト値を指定していることです。b したがって、mainメソッドからsumメソッドを呼び出す場合、6である1つの値を渡すだけのオプションがあり、これがパラメーターに割り当てられます。 a 以内 sum 方法。

上記のメソッドの出力は値11になります。

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

2つの値を渡すことでsumメソッドを呼び出すこともできます。上記の例では、6の2つの値を渡します。2番目の値6は、実際にはパラメーターに割り当てられたデフォルト値を置き換えます。 b。

上記のメソッドの出力は値12になります。

メソッドの戻り値

メソッドは、呼び出し元のプログラムに値を返すこともできます。これは、メソッドが何らかの計算を実行してから、呼び出し元のメソッドに目的の値を返す現代のプログラミング言語で必要です。

以下は、戻り値を持つ単純なメソッドの例です。

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

上記の例では、今回はint型のメソッドsumの戻り値の型を指定していることに注意してください。このメソッドでは、returnステートメントを使用して、呼び出し元のメインプログラムに合計値を送信しています。メソッドの値がmainメソッドで使用できるようになったため、println コンソールに値を表示する関数。

上記のメソッドの出力は値11になります。

インスタンスメソッド

メソッドは通常、Java言語と同じように、Groovy内のクラス内に実装されます。クラスは、そのプロパティと動作を定義するさまざまなオブジェクトを作成するための青写真またはテンプレートに他なりません。クラスオブジェクトは、そのクラスによって定義されたプロパティと動作を示します。したがって、動作はクラス内にメソッドを作成することによって定義されます。

クラスについては後の章で詳しく説明しますが、以下はクラスでのメソッド実装の例です。前の例では、メソッドを静的メソッドとして定義しました。これは、クラスから直接これらのメソッドにアクセスできることを意味します。メソッドの次の例は、クラスのオブジェクトを作成することによってメソッドにアクセスするインスタンスメソッドです。繰り返しになりますが、後の章でクラスを確認します。今のところ、メソッドの使用方法を示します。

以下は、メソッドの実装方法の例です。

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

上記の例では、今回はクラスメソッドに静的属性を指定していないことに注意してください。メイン関数では、実際にExampleクラスのインスタンスを作成してから、「ex」オブジェクトのメソッドを呼び出しています。

上記のメソッドの出力は値100になります。

ローカルおよび外部パラメータ名

Groovyは、Javaと同じように、ローカルパラメーターとグローバルパラメーターを持つ機能を提供します。次の例では、lx の関数内でのみスコープを持つローカルパラメータです getX() そして xExampleクラス全体の内部でアクセスできるグローバルプロパティです。変数にアクセスしようとするとlx の外 getX() 関数、エラーが発生します。

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

上記のプログラムを実行すると、次の結果が得られます。

200 
100

プロパティのこのメソッド

Javaの場合と同様に、groovyはを使用してインスタンスメンバーにアクセスできます。 thisキーワード。次の例は、ステートメントを使用する場合の方法を示していますthis.x、インスタンスを参照し、の値を設定します x それに応じて。

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

上記のプログラムを実行すると、コンソールに200の結果が出力されます。

Groovyは、I / Oを操作するときにいくつかのヘルパーメソッドを提供します。Groovyは、ファイルに次の機能を提供するためのより簡単なクラスを提供します。

• ファイルの読み取り
• ファイルへの書き込み
• ファイルツリーのトラバース
• データオブジェクトの読み取りとファイルへの書き込み

これに加えて、ファイルI / O操作には、以下にリストされている通常のJavaクラスをいつでも使用できます。

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

ファイルの読み取り

次の例では、Groovyのテキストファイルのすべての行を出力します。メソッドeachLine は、テキストファイルの各行が確実に読み取られるようにするために、GroovyのFileクラスに組み込まれています。

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

Fileクラスは、ファイル名をパラメーターとして受け取る新しいオブジェクトをインスタンス化するために使用されます。次に、eachLineの関数を受け取り、lineという変数に入れて、それに応じて出力します。

ファイルに次の行が含まれている場合、それらは印刷されます。

line : Example1
line : Example2

ファイルの内容を文字列全体として読み取る

ファイルの内容全体を文字列として取得する場合は、ファイルクラスのtextプロパティを使用できます。次の例は、これを行う方法を示しています。

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

ファイルに次の行が含まれている場合、それらは印刷されます。

line : Example1 
line : Example2

ファイルへの書き込み

ファイルに書き込みたい場合は、writerクラスを使用してテキストをファイルに出力する必要があります。次の例は、これを行う方法を示しています。

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ファイルを開くと、「HelloWorld」という単語がファイルに出力されているのがわかります。

ファイルのサイズを取得する

ファイルのサイズを取得したい場合は、ファイルクラスのlengthプロパティを使用してファイルのサイズを取得できます。次の例は、これを行う方法を示しています。

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

上記のコードは、ファイルのサイズをバイト単位で示しています。

ファイルがディレクトリかどうかのテスト

パスがファイルなのかディレクトリなのかを知りたい場合は、 isFile そして isDirectoryFileクラスのオプション。次の例は、これを行う方法を示しています。

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

上記のコードは次の出力を示します-

File? false 
Directory? True

ディレクトリの作成

新しいディレクトリを作成したい場合は、 mkdirFileクラスの機能。次の例は、これを行う方法を示しています。

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

ディレクトリE：\ Directoryが存在しない場合は、作成されます。

ファイルの削除

ファイルを削除したい場合は、Fileクラスの削除機能を使用できます。次の例は、これを行う方法を示しています。

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

ファイルが存在する場合は削除されます。

ファイルのコピー

Groovyは、あるファイルから別のファイルにコンテンツをコピーする機能も提供します。次の例は、これを行う方法を示しています。

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ファイルが作成され、Example.txtファイルのすべての内容がこのファイルにコピーされます。

ディレクトリコンテンツの取得

Groovyは、ドライブとドライブ内のファイルを一覧表示する機能も提供します。

次の例は、マシン上のドライブを使用して表示する方法を示しています。 listRoots Fileクラスの機能。

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

マシンで使用可能なドライブに応じて、出力が異なる場合があります。標準的なマシンでは、出力は次のようになります。

C:\ 
D:\

次の例は、を使用して特定のディレクトリ内のファイルを一覧表示する方法を示しています。 eachFile Fileクラスの機能。

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

出力には、ディレクトリE：\ Temp内のすべてのファイルが表示されます。

ディレクトリとそのサブディレクトリ内のすべてのファイルを再帰的に表示する場合は、 eachFileRecurseFileクラスの機能。次の例は、これを行う方法を示しています。

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

出力には、ディレクトリE：\ Tempおよびそのサブディレクトリ（存在する場合）内のすべてのファイルが表示されます。

Groovyは「オプションで」型指定された言語であり、その区別は言語の基本を理解する上で重要なものです。「強く」型付けされた言語であるJavaと比較すると、コンパイラーはすべての変数のすべての型を認識しており、コンパイル時にコントラクトを理解して尊重することができます。これは、メソッド呼び出しがコンパイル時に決定できることを意味します。

Groovyでコードを作成する場合、開発者は型を提供するかどうかを柔軟に選択できます。これにより、実装がいくらか簡単になり、適切に活用すると、堅牢で動的な方法でアプリケーションにサービスを提供できます。

Groovyでは、オプションの入力は「def」キーワードを介して行われます。以下は、の使用例です。def 方法−

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

上記のプログラムから、これらのタイプの値が含まれていても、個々の変数をInteger、float、double、またはstringとして宣言していないことがわかります。

上記のプログラムを実行すると、次の結果が得られます-

100 
100.10 
100.101
HelloWorld

オプションのタイピングは、開発中の強力なユーティリティですが、コードが広大で複雑になりすぎると、開発の後の段階で保守性に問題が生じる可能性があります。

コードベースを保守不可能な混乱に陥らせることなく、Groovyでオプションのタイピングを利用する方法を理解するには、アプリケーションに「ダックタイピング」の哲学を取り入れることが最善です。

ダックタイピングを使用して上記のコードを書き直すと、次のようになります。変数名には、コードをより理解しやすくするために、変数が表す型に似ていることが多い名前が付けられています。

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では、Numbersは実際にはオブジェクトとして表され、それらはすべてIntegerクラスのインスタンスです。オブジェクトに何かをさせるには、そのクラスで宣言されているメソッドの1つを呼び出す必要があります。

Groovyは整数と浮動小数点数をサポートしています。

• 整数は、分数を含まない値です。
• 浮動小数点数は、小数を含む10進値です。

Groovyの数値の例を以下に示します-

Integer x = 5; 
Float y = 1.25;

どこ x 整数型であり、 y フロートです。

groovyの数値がオブジェクトとして定義される理由は、一般に、数値に対して操作を実行する必要があるためです。プリミティブ型にクラスを提供するという概念は、ラッパークラスとして知られています。

デフォルトでは、次のラッパークラスがGroovyで提供されます。

ラッパークラスのオブジェクトには、それぞれのプリミティブデータ型が含まれるかラップされます。プリミティブデータ型をオブジェクトに変換するプロセスはボクシングと呼ばれ、これはコンパイラによって処理されます。オブジェクトを対応するプリミティブ型に戻すプロセスは、ボックス化解除と呼ばれます。

例

以下はボクシングとボックス化解除の例です-

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

上記のプログラムの出力は15になります。上記の例では、5、10、および0の値は、最初に整数変数x、y、およびzにボックス化されます。そして、xとyの加算が実行されると、値は整数型からボックス化されません。

数値メソッド

Groovyの数値はクラスとして表されるため、使用可能なメソッドのリストは次のとおりです。

S.No.	方法と説明
1	xxxValue（） このメソッドは、パラメーターとして数値を受け取り、呼び出されたメソッドに基づいてプリミティブ型を返します。
2	compareTo（） compareToメソッドは、ある数値を別の数値と比較するために使用します。これは、数値の値を比較する場合に役立ちます。
3	equals（） このメソッドは、メソッドを呼び出すNumberオブジェクトが、引数として渡されるオブジェクトと等しいかどうかを判別します。
4	valueOf（） valueOfメソッドは、渡された引数の値を保持する関連するNumberオブジェクトを返します。
5	toString（） このメソッドは、Numberオブジェクトの値を表すStringオブジェクトを取得するために使用されます。
6	parseInt（） このメソッドは、特定の文字列のプリミティブデータ型を取得するために使用されます。parseXxx（）は静的メソッドであり、1つまたは2つの引数を持つことができます。
7	abs（） このメソッドは、引数の絶対値を示します。引数には、int、float、long、double、short、byteを指定できます。
8	ceil（） メソッドceilは、引数以上の最小の整数を返します。
9	床（） メソッドfloorは、引数以下の最大の整数を返します。
10	rint（） メソッドrintは、引数に値が最も近い整数を返します。
11	円形（） メソッドroundは、メソッドの戻り値の型で指定されているように、最も近いlongまたはintを返します。
12	min（） このメソッドは、2つの引数のうち小さい方を返します。引数には、int、float、long、doubleを指定できます。
13	max（） このメソッドは、2つの引数の最大値を提供します。引数には、int、float、long、doubleを指定できます。
14	exp（） このメソッドは、自然対数の底eを引数の累乗に戻します。
15	ログ（） このメソッドは、引数の自然対数を返します。
16	捕虜（） このメソッドは、最初の引数の値を2番目の引数の累乗で返します。
17	sqrt（） このメソッドは、引数の平方根を返します。
18	罪（） このメソッドは、指定されたdouble値のサインを返します。
19	cos（） このメソッドは、指定されたdouble値のコサインを返します。
20	tan（） このメソッドは、指定されたdouble値のタンジェントを返します。
21	asin（） このメソッドは、指定されたdouble値のアークサインを返します。
22	acos（） このメソッドは、指定されたdouble値のアークコサインを返します。
23	日焼け（） このメソッドは、指定されたdouble値のアークタンジェントを返します。
24	atan2（） このメソッドは、直交座標（x、y）を極座標（r、theta）に変換し、シータを返します。
25	toDegrees（） このメソッドは、引数の値を度に変換します。
26	ラジアン（） このメソッドは、引数の値をラジアンに変換します。
27	ランダム（） この方法は、0.0から1.0の間の乱数を生成するために使用されます。範囲は次のとおりです。0.0= <Math.random <1.0。算術演算を使用すると、さまざまな範囲を実現できます。

文字列リテラルは、文字列テキストを引用符で囲むことによってGroovyで構築されます。

Groovyは、文字列リテラルを表すさまざまな方法を提供します。Groovyの文字列は、一重引用符（ '）、二重引用符（“）、または三重引用符（“””）で囲むことができます。さらに、三重引用符で囲まれたGroovy文字列は、複数行にまたがることがあります。

以下は、Groovyでの文字列の使用例です。

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

上記のプログラムを実行すると、次の結果が得られます-

Hello Single 
Hello Double 
'Hello TripleMultiple lines'

文字列インデックス

Groovyの文字列は、順序付けられた文字のシーケンスです。文字列内の個々の文字には、その位置からアクセスできます。これはインデックス位置によって与えられます。

文字列インデックスは0から始まり、文字列の長さより1つ短い値で終わります。Groovyでは、負のインデックスを文字列の末尾からカウントバックすることもできます。

以下は、Groovyでの文字列インデックスの使用例です。

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

上記のプログラムを実行すると、次の結果が得られます-

o 
d 
el 
oll

基本的な文字列操作

まず、groovyでの基本的な文字列操作を学びましょう。それらを以下に示します。

S.No.	文字列の操作と説明
1	2つの文字列の連結 文字列の連結は、単純な「+」演算子で実行できます。
2	文字列の繰り返し 文字列の繰り返しは、単純な「*」演算子で実行できます。
3	文字列の長さ 文字列のlength（）メソッドによって決定される文字列の長さ。

文字列メソッド

Stringクラスでサポートされているメソッドのリストは次のとおりです。

S.No.	方法と説明
1	センター（） 左右にスペース文字が埋め込まれた受信者で構成される長さnumberOfCharsの新しい文字列を返します。
2	compareToIgnoreCase（） 大文字と小文字の違いを無視して、2つの文字列を辞書式に比較します。
3	concat（） 指定された文字列をこの文字列の末尾に連結します。
4	eachMatch（） 指定された文字列の部分文字列に一致する各正規表現グループ（次のセクションを参照）を処理します。
5	extendsWith（） この文字列が指定されたサフィックスで終わるかどうかをテストします。
6	equalsIgnoreCase（） 大文字と小文字の考慮を無視して、この文字列を別の文字列と比較します。
7	getAt（） インデックス位置に文字列値を返します
8	の指標（） 指定された部分文字列が最初に出現するこの文字列内のインデックスを返します。
9	マッチス（） 文字列が指定された正規表現と一致するかどうかを出力します。
10	マイナス（） 文字列の値の部分を削除します。
11	次（） このメソッドは、クラスStringの++演算子によって呼び出されます。指定された文字列の最後の文字をインクリメントします。
12	padLeft（） 左側にスペースを追加して文字列を埋めます。
13	padRight（） 右側にスペースを追加して文字列を埋めます。
14	プラス（） 文字列を追加します
15	前（） このメソッドは、CharSequenceの-演算子によって呼び出されます。
16	replaceAll（） キャプチャされたグループのすべての出現を、そのテキストのクロージャの結果で置き換えます。
17	逆行する（） この文字列の逆である新しい文字列を作成します。
18	スプリット（） 指定された正規表現の一致を中心にこの文字列を分割します。
19	subString（） この文字列の部分文字列である新しい文字列を返します。
20	toUpperCase（） この文字列のすべての文字を大文字に変換します。
21	toLowerCase（） この文字列のすべての文字を小文字に変換します。

範囲は、値のシーケンスを指定するための省略形です。範囲はシーケンスの最初と最後の値で示され、範囲は包括的または排他的です。包括的範囲には最初から最後までのすべての値が含まれ、排他的範囲には最後を除くすべての値が含まれます。Rangeリテラルの例を次に示します-

• 1..10-包括的範囲の例
• 1 .. <10-排他的な範囲の例
• 'a' .. 'x' –範囲は文字で構成することもできます
• 10..1 –範囲は降順でもかまいません
• 'x' .. 'a' –範囲は文字で構成することもでき、降順にすることもできます。

以下は、範囲で使用できるさまざまな方法です。

シニア番号	方法と説明
1	contains（） 範囲に特定の値が含まれているかどうかを確認します
2	取得する（） この範囲内の指定された位置にある要素を返します。
3	から取得（） この範囲の低い方の値を取得します。
4	getTo（） この範囲の上限値を取得します。
5	isReverse（） これは逆の範囲で、逆方向に繰り返されますか
6	サイズ（） この範囲内の要素の数を返します。
7	subList（） 指定されたfromIndex（包括的）とtoIndex（排他的）の間のこの範囲の部分のビューを返します

リストは、データ項目のコレクションを格納するために使用される構造です。Groovyでは、リストは一連のオブジェクト参照を保持します。リスト内のオブジェクト参照は、シーケンス内の位置を占め、整数インデックスによって区別されます。リストリテラルは、コンマで区切られ、角かっこで囲まれた一連のオブジェクトとして表示されます。

リスト内のデータを処理するには、個々の要素にアクセスできる必要があります。Groovyリストは、インデックス演算子[]を使用してインデックスが付けられます。リストインデックスは、最初の要素を参照するゼロから始まります。

以下はリストのいくつかの例です-

• [11、12、13、14] –整数値のリスト
• ['Angular'、 'Groovy'、 'Java'] –文字列のリスト
• [1、2、[3、4]、5] –ネストされたリスト
• ['Groovy'、21、2.11] –オブジェクト参照の異種リスト
• [] –空のリスト

この章では、Groovyで使用できるリストメソッドについて説明します。

シニア番号	方法と説明
1	追加（） このリストの最後に新しい値を追加します。
2	contains（） このリストに指定された値が含まれている場合はtrueを返します。
3	取得する（） このリストの指定された位置にある要素を返します。
4	isEmpty（） このリストに要素が含まれていない場合はtrueを返します
5	マイナス（） コレクションで指定されていないオリジナルの要素で構成される新しいリストを作成します。
6	プラス（） オリジナルの要素とコレクションで指定された要素で構成される新しいリストを作成します。
7	ポップ（） このリストから最後のアイテムを削除します
8	削除する（） このリストの指定された位置にある要素を削除します。
9	逆行する（） 元のリストの要素を逆にした新しいリストを作成します
10	サイズ（） このリストの要素の数を取得します。
11	ソート（） 元のリストのソートされたコピーを返します。

マップ（連想配列、辞書、テーブル、ハッシュとも呼ばれます）は、オブジェクト参照の順序付けられていないコレクションです。Mapコレクションの要素には、キー値によってアクセスされます。マップで使用されるキーは、どのクラスでもかまいません。Mapコレクションに挿入するときは、キーと値の2つの値が必要です。

以下はマップのいくつかの例です-

• ['TopicName'： 'Lists'、 'TopicName'： 'Maps'] –キーとしてTopicNameとそれぞれの値を持つキーと値のペアのコレクション。

• [：] –空のマップ。

この章では、Groovyで使用できるマップメソッドについて説明します。

シニア番号	方法と説明
1	containsKey（） このマップにはこのキーが含まれていますか？
2	取得する（） このマップでキーを検索し、対応する値を返します。このマップにキーのエントリがない場合は、nullを返します。
3	keySet（） このマップのキーのセットを取得します。
4	put（） 指定された値をこのマップの指定されたキーに関連付けます。このマップに以前にこのキーのマッピングが含まれていた場合、古い値は指定された値に置き換えられます。
5	サイズ（） このマップ内のKey-Valueマッピングの数を返します。
6	values（） このマップに含まれる値のコレクションビューを返します。

クラスDateは、ミリ秒の精度で特定の瞬間を表します。以下に示すように、Dateクラスには2つのコンストラクターがあります。

日付（）

構文

public Date()

Parameters −なし。

Return Value

Dateオブジェクトを割り当てて初期化し、割り当てられた時刻を表すようにします。ミリ秒単位で測定されます。

例

以下は、このメソッドの使用例です。

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

上記のプログラムを実行すると、次の結果が得られます。次の出力は、現在の日付と時刻を示します-

Thu Dec 10 21:31:15 GST 2015

日付（長いミリ秒）

構文

public Date(long millisec)

Parameters

Millisec –標準の基準時間以降に指定するミリ秒数。

Return Value −を割り当てます Date オブジェクトを初期化し、「エポック」と呼ばれる標準の基準時間からの指定されたミリ秒数、つまり1970年1月1日00：00：00GMTを表すように初期化します。

例

以下は、このメソッドの使用例です。

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

上記のプログラムを実行すると、次の結果が得られます-

Thu Jan 01 04:00:00 GST 1970

以下は、Dateクラスの指定されたメソッドです。年、月、日付、時間、分、秒の値を受け入れるか返すクラスDateのすべてのメソッドでは、次の表現が使用されます。

• 年yは、整数y-1900で表されます。

• 月は0から11までの整数で表されます。0は1月、1は2月などです。したがって、11は12月です。

• 日付（日）は、通常の方法で1から31までの整数で表されます。

• 時間は0から23までの整数で表されます。したがって、午前0時から午前1時までの時間は0時間であり、正午から午後1時までの時間は12時間です。

• 分は、通常の方法で0から59までの整数で表されます。

• 秒は0から61までの整数で表されます。

シニア番号	方法と説明
1	after（） この日付が指定された日付より後かどうかをテストします。
2	equals（） 2つの日付を比較して等しいかどうか。結果は、引数がnullでなく、このオブジェクトと同じ時点（ミリ秒）を表すDateオブジェクトである場合にのみtrueになります。
3	compareTo（） 注文の2つの日付を比較します。
4	toString（） このDateオブジェクトを文字列に変換します
5	前（） この日付が指定された日付より前であるかどうかをテストします。
6	時間をもらう（） このDateオブジェクトで表される1970年1月1日00：00：00GMTからのミリ秒数を返します。
7	setTime（） このDateオブジェクトを、1970年1月1日00：00：00GMTからのミリ秒後の時点を表すように設定します。

正規表現は、テキスト内の部分文字列を検索するために使用されるパターンです。Groovyは、〜” regex”式を使用してネイティブに正規表現をサポートします。引用符で囲まれたテキストは、比較のための式を表しています。

たとえば、次のように正規表現オブジェクトを作成できます。

def regex = ~'Groovy'

Groovy演算子=〜が述語（ブール値を返す式）として表示される場合 if そして whileステートメント（第8章を参照）では、左側の文字列オペランドが右側の正規表現オペランドと照合されます。したがって、次のそれぞれが真の値を提供します。

正規表現を定義する場合、次の特殊文字を使用できます-

• 行の開始と終了を示すために使用される2つの特別な位置文字があります。キャレット（∧）とドル記号（$）です。

• 正規表現には数量詞を含めることもできます。プラス記号（+）は、式の前の要素に適用される1回以上を表します。アスタリスク（*）は、0回以上の出現を表すために使用されます。疑問符（？）は、ゼロまたは1回を示します。

• メタ文字{および}は、前の文字の特定の数のインスタンスと一致するために使用されます。

• 正規表現では、ピリオド記号（。）は任意の文字を表すことができます。これはワイルドカード文字として説明されます。

• 正規表現には文字クラスが含まれる場合があります。文字のセットは、[aeiou]のように、メタ文字[および]で囲まれた単純な文字シーケンスとして指定できます。文字または数字の範囲については、[a–z]または[a–mA–M]のようにダッシュ区切り文字を使用できます。文字クラスの補集合は、[∧a–z]のように、正方形のラケット内の先頭のキャレットで示され、指定された文字以外のすべての文字を表します。正規表現の例を以下に示します。

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

アプリケーションの通常のフローを維持できるように、ランタイムエラーを処理するには、プログラミング言語で例外処理が必要です。

例外は通常、アプリケーションの通常のフローを中断します。これが、アプリケーションで例外処理を使用する必要がある理由です。

例外は大きく次のカテゴリに分類されます-

• Checked Exception − RuntimeExceptionとErrorを除いてThrowableクラスを拡張するクラスは、チェック例外（IOException、SQLExceptionなど）と呼ばれます。チェック例外はコンパイル時にチェックされます。

古典的なケースの1つは、FileNotFoundExceptionです。Eドライブ内のファイルから読み取るアプリケーションに次のコードがあるとします。

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

ファイル（file.txt）がEドライブにない場合、次の例外が発生します。

キャッチ：java.io.FileNotFoundException：E：\ file.txt（システムは指定されたファイルを見つけることができません）。

java.io.FileNotFoundException：E：\ file.txt（システムは指定されたファイルを見つけることができません）。

• Unchecked Exception − RuntimeExceptionを拡張するクラスは、チェックされていない例外として知られています。たとえば、ArithmeticException、NullPointerException、ArrayIndexOutOfBoundsExceptionなどです。チェックされていない例外は、コンパイル時にチェックされず、実行時にチェックされます。

古典的なケースの1つは、配列の長さよりも大きい配列のインデックスにアクセスしようとしたときに発生するArrayIndexOutOfBoundsExceptionです。以下は、この種の間違いの典型的な例です。

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

上記のコードを実行すると、次の例外が発生します。

キャッチ：java.lang.ArrayIndexOutOfBoundsException：5

java.lang.ArrayIndexOutOfBoundsException：5

• Error −エラーは回復不能です（例：OutOfMemoryError、VirtualMachineError、AssertionErrorなど）。

これらは、プログラムが回復できないエラーであり、プログラムをクラッシュさせる原因になります。

次の図は、Groovyの例外の階層がどのように編成されているかを示しています。これはすべて、Javaで定義された階層に基づいています。

例外をキャッチする

メソッドは、との組み合わせを使用して例外をキャッチします try そして catchキーワード。例外を生成する可能性のあるコードの周囲にtry / catchブロックが配置されます。

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

例外を発生させる可能性のあるすべてのコードは、保護されたコードブロックに配置されます。

catchブロックでは、アプリケーションが例外から回復できるように、例外を処理するカスタムコードを記述できます。

配列のサイズよりも大きいインデックス値を持つ配列にアクセスするために上で見た同様のコードの例を見てみましょう。しかし今回は、コードをtry / catchブロックでラップしましょう。

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

上記のプログラムを実行すると、次の結果が得られます-

Catching the exception 
Let's move on after the exception

上記のコードから、tryブロックで障害のあるコードをラップします。catchブロックでは、例外をキャッチして、例外が発生したというメッセージを出力しています。

複数のキャッチブロック

複数のタイプの例外を処理するために、複数のcatchブロックを持つことができます。発生した例外のタイプに応じて、catchブロックごとに、それに応じて処理するコードを記述します。

上記のコードを変更して、ArrayIndexOutOfBoundsExceptionを具体的にキャッチしてみましょう。以下はコードスニペットです。

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

上記のプログラムを実行すると、次の結果が得られます-

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

上記のコードから、ArrayIndexOutOfBoundsExceptionキャッチブロックが最初にキャッチされることがわかります。これは、例外の基準を意味するためです。

最後にブロック

ザ・ finallyブロックは、tryブロックまたはcatchブロックの後に続きます。例外の発生に関係なく、コードのfinallyブロックは常に実行されます。

finishブロックを使用すると、保護されたコードで何が起こっても、実行したいクリーンアップタイプのステートメントを実行できます。このブロックの構文を以下に示します。

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

上記のコードを変更して、finallyブロックのコードを追加しましょう。以下はコードスニペットです。

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

上記のプログラムを実行すると、次の結果が得られます-

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

以下は、Groovyで使用可能なExceptionメソッドです。

public String getMessage（）

発生した例外に関する詳細メッセージを返します。このメッセージは、Throwableコンストラクターで初期化されます。

public Throwable getCause（）

Throwableオブジェクトで表される例外の原因を返します。

public String toString（）

getMessage（）の結果と連結されたクラスの名前を返します

public void printStackTrace（）

toString（）の結果をスタックトレースとともにエラー出力ストリームであるSystem.errに出力します。

public StackTraceElement [] getStackTrace（）

スタックトレース上の各要素を含む配列を返します。インデックス0の要素は呼び出しスタックの最上位を表し、配列の最後の要素は呼び出しスタックの最下部のメソッドを表します。

public Throwable fillInStackTrace（）

このThrowableオブジェクトのスタックトレースを現在のスタックトレースで埋め、スタックトレースの以前の情報に追加します。

例

以下は、上記の方法のいくつかを使用したコード例です。

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

上記のプログラムを実行すると、次の結果が得られます-

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

Groovyには、他のオブジェクト指向言語と同様に、プログラミング言語のオブジェクト指向の性質を表すクラスとオブジェクトの概念があります。Groovyクラスは、データとそのデータを操作するメソッドのコレクションです。一緒に、クラスのデータとメソッドは、問題のドメインからのいくつかの実世界のオブジェクトを表すために使用されます。

Groovyのクラスは、そのクラスによって定義されたオブジェクトの状態（データ）と動作を宣言します。したがって、Groovyクラスは、そのクラスのインスタンスフィールドとメソッドの両方を記述します。

以下は、Groovyのクラスの例です。クラスの名前はStudentで、2つのフィールドがあります–StudentID そして StudentName。main関数では、このクラスのオブジェクトを作成し、に値を割り当てています。StudentID そして StudentName オブジェクトの。

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

getterおよびsetterメソッド

どのプログラミング言語でも、privateキーワードでインスタンスメンバーを非表示にし、代わりにインスタンス変数の値を設定および取得するためのgetterメソッドとsetterメソッドを提供することが常に慣例です。次の例は、これを行う方法を示しています。

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

上記のプログラムを実行すると、次の結果が得られます-

1 
Joe

上記のプログラムに関する以下の重要なポイントに注意してください-

• クラスでは、studentIDとstudentNameの両方がプライベートとしてマークされています。これは、クラスの外部からアクセスできないことを意味します。

• 各インスタンスメンバーには、独自のgetterメソッドとsetterメソッドがあります。getterメソッドはインスタンス変数の値を返します（例：メソッドint getStudentID（））。setterメソッドはインスタンスIDの値を設定します（例：method --void setStudentName（String pName））。

インスタンスメソッド

通常、クラス内に、実際にクラスに対して何らかの機能を実行するメソッドを追加するのは自然なことです。学生の例では、Marks1、Marks2、Marks3のインスタンスメンバーを追加して、3つの科目の学生のマークを示します。次に、学生の合計点数を計算する新しいインスタンスメソッドを追加します。コードは次のようになります。

次の例では、メソッドTotalは、いくつかのロジックが組み込まれている追加のインスタンスメソッドです。

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

上記のプログラムを実行すると、次の結果が得られます-

60

複数のオブジェクトの作成

クラスの複数のオブジェクトを作成することもできます。以下は、これを実現する方法の例です。ここでは、3つのオブジェクト（st、st1、st2）を作成し、それに応じてそれらのインスタンスメンバーとインスタンスメソッドを呼び出しています。

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

上記のプログラムを実行すると、次の結果が得られます-

60 
70 
80

継承

継承は、あるクラスが別のクラスのプロパティ（メソッドとフィールド）を取得するプロセスとして定義できます。継承を使用すると、情報が階層順に管理できるようになります。

otherのプロパティを継承するクラスはサブクラス（派生クラス、子クラス）と呼ばれ、プロパティが継承されるクラスはスーパークラス（基本クラス、親クラス）と呼ばれます。

拡張します

extendsクラスのプロパティを継承するために使用されるキーワードです。以下に、extendsキーワードの構文を示します。次の例では、次のことを行っています-

• Personというクラスを作成します。このクラスには、nameという名前のインスタンスメンバーが1つあります。

• Personクラスから拡張するStudentというクラスを作成します。Personクラスで定義されているnameインスタンスメンバーは、Studentクラスに継承されることに注意してください。

• Studentクラスのコンストラクターでは、基本クラスのコンストラクターを呼び出しています。

• Studentクラスでは、StudentIDとMarks1の2つのインスタンスメンバーを追加しています。

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

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

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

上記のプログラムを実行すると、次の結果が得られます-

Joe

インナークラス

内部クラスは別のクラス内で定義されます。囲んでいるクラスは、通常どおり内部クラスを使用できます。一方、内部クラスは、プライベートであっても、それを含むクラスのメンバーにアクセスできます。囲んでいるクラス以外のクラスは、内部クラスにアクセスできません。

以下は、OuterクラスとInnerクラスの例です。次の例では、次のことを行っています-

• 外側のクラスとなるOuterというクラスを作成します。
• Outerクラスでnameという文字列を定義します。
• Outerクラス内にInnerクラスまたはネストされたクラスを作成します。
• 内部クラスでは、外部クラスで定義された名前インスタンスメンバーにアクセスできることに注意してください。

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

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

上記のプログラムを実行すると、次の結果が得られます-

Joe

抽象クラス

抽象クラスは一般的な概念を表すため、サブクラス化するために作成されてインスタンス化することはできません。それらのメンバーには、フィールド/プロパティおよび抽象メソッドまたは具象メソッドが含まれます。抽象メソッドには実装がなく、具象サブクラスで実装する必要があります。抽象クラスは、abstractキーワードで宣言する必要があります。抽象メソッドもabstractキーワードで宣言する必要があります。

次の例では、Personクラスが抽象クラスになり、インスタンス化できないことに注意してください。また、実装の詳細がない抽象クラスにはDisplayMarksと呼ばれる抽象メソッドがあることに注意してください。学生クラスでは、実装の詳細を追加する必要があります。

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

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

上記のプログラムを実行すると、次の結果が得られます-

Joe 
10 
null

インターフェイス

インターフェースは、クラスが準拠する必要のあるコントラクトを定義します。インターフェイスは、実装する必要のあるメソッドのリストのみを定義し、メソッドの実装は定義しません。インターフェイスは、interfaceキーワードを使用して宣言する必要があります。インターフェイスはメソッドシグネチャのみを定義します。インターフェイスのメソッドは常にpublic。インターフェイスで保護されたメソッドまたはプライベートメソッドを使用するとエラーになります。

以下は、groovyのインターフェースの例です。次の例では、次のことを行っています-

• Marksと呼ばれるインターフェイスを作成し、DisplayMarksと呼ばれるインターフェイスメソッドを作成します。

• クラス定義では、implementsキーワードを使用してインターフェイスを実装しています。

• インターフェイスを実装しているため、DisplayMarksメソッドの実装を提供する必要があります。

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

interface Marks { 
   void DisplayMarks(); 
} 

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

上記のプログラムを実行すると、次の結果が得られます-

10
null

ジェネリックスを使用すると、クラス、インターフェイス、およびメソッドを定義するときに、型（クラスとインターフェイス）をパラメーターにすることができます。メソッド宣言で使用されるより馴染みのある仮パラメーターと同様に、型パラメーターは、同じコードを異なる入力で再利用する方法を提供します。違いは、仮パラメーターへの入力が値であるのに対し、型パラメーターへの入力は型であるということです。

コレクションのジェネリック

Listクラスなどのコレクションクラスは、そのタイプのコレクションのみがアプリケーションで受け入れられるように一般化できます。一般化されたArrayListの例を以下に示します。次のステートメントは、文字列タイプのリストアイテムのみを受け入れるということです。

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

次のコード例では、次のことを行っています。

• 文字列のみを保持するGeneralizedArrayListコレクションを作成します。
• リストに3つの文字列を追加します。
• リスト内の各項目について、文字列の値を出力します。

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

上記のプログラムの出力は次のようになります-

First String 
Second String 
Third String

一般化されたクラス

クラス全体を一般化することもできます。これにより、クラスは任意のタイプを受け入れ、それに応じてそれらのタイプを操作する際の柔軟性が高まります。これを実現する方法の例を見てみましょう。

次のプログラムでは、次の手順を実行しています-

• ListTypeというクラスを作成しています。クラス定義の前に配置された<T>キーワードに注意してください。これは、このクラスが任意の型を受け入れることができることをコンパイラーに通知します。したがって、このクラスのオブジェクトを宣言するときに、宣言中に型を指定すると、その型がプレースホルダー<T>に置き換えられます。

• 汎用クラスには、クラスで定義されたメンバー変数を操作するための単純なgetterメソッドとsetterメソッドがあります。

• メインプログラムでは、ListTypeクラスのオブジェクトを宣言できますが、タイプが異なることに注意してください。最初のものは整数型で、2番目のものは文字列型です。

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

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

上記のプログラムの出力は次のようになります-

First String 
1

特性は、次のことを可能にする言語の構造的構成概念です。

• 行動の構成。
• インターフェイスのランタイム実装。
• 静的型チェック/コンパイルとの互換性

これらは、デフォルトの実装と状態の両方を保持するインターフェースと見なすことができます。特性は、traitキーワードを使用して定義されます。

特性の例を以下に示します-

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

次に、implementキーワードを使用して、インターフェースと同様の方法でトレイトを実装できます。

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

インターフェースの実装

トレイトはインターフェースを実装する場合があります。その場合、インターフェースはimplementsキーワードを使用して宣言されます。

インターフェイスを実装するトレイトの例を以下に示します。次の例では、次の重要なポイントに注意することができます。

• インターフェイスTotalは、メソッドDisplayTotalで定義されます。

• トレイトマークはTotalインターフェイスを実装しているため、DisplayTotalメソッドの実装を提供する必要があります。

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

interface Total {
   void DisplayTotal() 
} 

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

class Student implements Marks { 
   int StudentID
   int Marks1;  
}

上記のプログラムの出力は次のようになります-

Display Marks 
Display Total

プロパティ

特性はプロパティを定義する場合があります。プロパティを持つ特性の例を以下に示します。

次の例では、整数型のMarks1がプロパティです。

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

上記のプログラムの出力は次のようになります-

10 
Display Total

行動の構成

特性を使用して、制御された方法で多重継承を実装し、ダイヤモンドの問題を回避できます。次のコード例では、2つの特性を定義しています–Marks そして Total。私たちの学生クラスは両方の特性を実装しています。学生クラスは両方の特性を拡張するため、両方の方法にアクセスできます–DisplayMarks そして DisplayTotal。

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

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

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

class Student implements Marks,Total {
   int StudentID 
}

上記のプログラムの出力は次のようになります-

Total 
Marks1

特性の拡張

トレイトは別のトレイトを拡張する場合があります。その場合は、 extendsキーワード。次のコード例では、TotalトレイトをMarksトレイトで拡張しています。

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

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

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

class Student implements Total {
   int StudentID 
}

上記のプログラムの出力は次のようになります-

Total

クロージャは、短い匿名のコードブロックです。通常、数行のコードにまたがっています。メソッドは、コードのブロックをパラメーターとして受け取ることもできます。それらは本質的に匿名です。

以下は、単純なクロージャの例とその外観です。

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

上記の例では、コード行-{println "HelloWorld"}はクロージャと呼ばれます。この識別子によって参照されるコードブロックは、callステートメントで実行できます。

上記のプログラムを実行すると、次の結果が得られます-

Hello World

クロージャの仮パラメータ

クロージャには、Groovyのメソッドと同じように、より便利にするための仮パラメータを含めることもできます。

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

上記のコード例では、クロージャーがパラメーターを受け取るようにする$ {param}の使用に注意してください。clos.callステートメントを介してクロージャーを呼び出すときに、パラメーターをクロージャーに渡すオプションがあります。

上記のプログラムを実行すると、次の結果が得られます-

Hello World

次の図は、前の例を繰り返して同じ結果を生成しますが、それと呼ばれる暗黙の単一パラメーターを使用できることを示しています。ここで「it」はGroovyのキーワードです。

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

上記のプログラムを実行すると、次の結果が得られます-

Hello World

クロージャと変数

より正式には、クロージャは、クロージャが定義された時点で変数を参照できます。以下は、これを実現する方法の例です。

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

上記の例では、クロージャーにパラメーターを渡すことに加えて、str1という変数も定義しています。クロージャーは、パラメーターとともに変数も引き受けます。

上記のプログラムを実行すると、次の結果が得られます-

Hello World 
Welcome World

メソッドでのクロージャの使用

クロージャは、メソッドのパラメータとしても使用できます。Groovyでは、リストやコレクションなどのデータ型に組み込まれているメソッドの多くに、パラメーター型としてクロージャーがあります。

次の例は、クロージャをパラメータとしてメソッドに送信する方法を示しています。

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

上記の例では、

• クロージャを引数として取るDisplayという静的メソッドを定義しています。

• 次に、mainメソッドでクロージャを定義し、それをパラメータとしてDisplayメソッドに渡します。

上記のプログラムを実行すると、次の結果が得られます-

Hello World 
Welcome World 
Welcome Inner

コレクションと文字列のクロージャ

いくつかのList、Map、およびStringメソッドは、引数としてクロージャを受け入れます。これらのデータ型でクロージャを使用する方法の例を見てみましょう。

リストでのクロージャの使用

次の例は、クロージャをリストで使用する方法を示しています。次の例では、最初に値の簡単なリストを定義しています。次に、リストコレクションタイプは、と呼ばれる関数を定義します。each。この関数は、パラメーターとしてクロージャを取り、リストの各要素にクロージャを適用します。

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

上記のプログラムを実行すると、次の結果が得られます-

11 
12 
13 
14

マップでのクロージャの使用

次の例は、マップでクロージャを使用する方法を示しています。次の例では、最初にKeyValueアイテムの単純なマップを定義しています。次に、マップコレクションタイプは.eachという関数を定義します。この関数は、パラメーターとしてクロージャを取り、マップの各キーと値のペアにクロージャを適用します。

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

上記のプログラムを実行すると、次の結果が得られます-

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

多くの場合、コレクションのメンバー間で反復し、要素が何らかの基準を満たしている場合にのみロジックを適用したい場合があります。これは、クロージャー内の条件ステートメントで簡単に処理できます。

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

上記の例は、リスト内の各項目が2で割り切れるかどうかを確認するために使用されるクロージャで使用されている条件付きif（num％2 == 0）式を示しています。

上記のプログラムを実行すると、次の結果が得られます-

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

クロージャで使用されるメソッド

クロージャー自体がいくつかの方法を提供します。

シニア番号	方法と説明
1	find（） findメソッドは、いくつかの基準に一致するコレクションの最初の値を検索します。
2	findAll（） クロージャ条件に一致する受信オブジェクト内のすべての値を検索します。
3	any（）＆every（） メソッドanyは、コレクションの各要素を反復処理して、ブール述語が少なくとも1つの要素に対して有効かどうかを確認します。
4	collect（） メソッドcollectは、コレクションを反復処理し、クロージャーをトランスフォーマーとして使用して各要素を新しい値に変換します。

注釈はメタデータの形式であり、プログラム自体の一部ではないプログラムに関するデータを提供します。注釈は、注釈を付けるコードの操作に直接影響を与えません。

注釈は主に次の理由で使用されます-

• Information for the compiler −コンパイラは注釈を使用して、エラーを検出したり、警告を抑制したりできます。

• Compile-time and deployment-time processing −ソフトウェアツールは、注釈情報を処理して、コードやXMLファイルなどを生成できます。

• Runtime processing −一部の注釈は実行時に調べることができます。

Groovyでは、基本的な注釈は次のようになります-

@ interface-アットマーク文字（@）は、後に続くものが注釈であることをコンパイラーに示します。

注釈は、のメンバーを定義できます the form 本体とオプションのデフォルト値のないメソッドの。

注釈は次のタイプに適用できます-

文字列型

文字列の注釈の例を以下に示します-

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

列挙型

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

クラスタイプ

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

アノテーションメンバーの値

アノテーションを使用する場合は、デフォルト値を持たないメンバーを少なくともすべて設定する必要があります。以下に例を示します。定義後にアノテーションExampleを使用する場合は、値を割り当てる必要があります。

@interface Example {
   int status() 
}

@Example(status = 1)

クロージャー注釈パラメーター

Groovyの注釈の優れた機能は、クロージャを注釈値としても使用できることです。したがって、注釈はさまざまな式で使用できます。

これに関する例を以下に示します。アノテーションOnlyifは、クラス値に基づいて作成されます。次に、アノテーションは、数値変数の値に基づいて結果変数に異なるメッセージを投稿する2つのメソッドに適用されます。

@interface OnlyIf {
   Class value() 
}  

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

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

メタアノテーション

これは、groovyの注釈の非常に便利な機能です。以下に示すように、メソッドに複数のアノテーションがある場合があります。複数の注釈があると、これが面倒になる場合があります。

@Procedure 
@Master class 
MyMasterProcedure {}

このような場合、複数のアノテーションをまとめるメタアノテーションを定義し、そのメタアノテーションをメソッドに適用できます。したがって、上記の例では、AnnotationCollectorを使用してアノテーションのコレクションを最初に定義できます。

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

これが完了したら、次のメタアノテーターをメソッドに適用できます-

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

XMLは、オペレーティングシステムや開発言語に関係なく、プログラマーが他のアプリケーションで読み取ることができるアプリケーションを開発できるようにする、移植可能なオープンソース言語です。これは、アプリケーション間でデータを交換するために使用される最も一般的な言語の1つです。

XMLとは何ですか？

Extensible Markup Language XMLは、HTMLやSGMLによく似たマークアップ言語です。これは、World Wide Web Consortiumによって推奨されており、オープンスタンダードとして利用できます。XMLは、SQLベースのバックボーンを必要とせずに、少量から中量のデータを追跡するのに非常に役立ちます。

GroovyでのXMLサポート

Groovy言語は、XML言語の豊富なサポートも提供します。使用される2つの最も基本的なXMLクラスは次のとおりです。

• XML Markup Builder− Groovyは、ツリーベースのマークアップジェネレータであるBuilderSupportをサポートしています。このジェネレータは、サブクラス化して、さまざまなツリー構造のオブジェクト表現を作成できます。通常、これらのビルダーは、XMLマークアップ、HTMLマークアップを表すために使用されます。Groovyのマークアップジェネレーターは、疑似メソッドの呼び出しをキャッチし、それらをツリー構造の要素またはノードに変換します。これらの疑似メソッドのパラメーターは、ノードの属性として扱われます。メソッド呼び出しの一部としてのクロージャは、結果のツリーノードのネストされたサブコンテンツと見なされます。

• XML Parser− Groovy XmlParserクラスは、XMLドキュメントをノードインスタンスのツリーに解析するための単純なモデルを採用しています。各ノードには、XML要素の名前、要素の属性、および子ノードへの参照があります。このモデルは、ほとんどの単純なXML処理に十分です。

すべてのXMLコード例について、次の単純なXMLファイルmovies.xmlを使用して、XMLファイルを作成し、その後ファイルを読み取ります。

<collection shelf = "New Arrivals"> 

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

XMLマークアップビルダー

構文

public MarkupBuilder()

MarkupBuilderは、XMLドキュメント全体を構築するために使用されます。XMLドキュメントは、最初にXMLドキュメントクラスのオブジェクトを作成することによって作成されます。オブジェクトが作成されると、疑似メソッドを呼び出してXMLドキュメントのさまざまな要素を作成できます。

上記のXMLドキュメントから1つのブロック、つまり1つのムービー要素を作成する方法の例を見てみましょう。

import groovy.xml.MarkupBuilder 

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

上記の例では、次の点に注意する必要があります-

• mB.collection() −これは、<collection> </ collection>のヘッドXMLタグを作成するマークアップジェネレーターです。

• movie(title : 'Enemy Behind')−これらの疑似メソッドは、このメソッドを使用して子タグを作成し、値を使用してタグを作成します。タイトルと呼ばれる値を指定することにより、これは実際には要素の属性を作成する必要があることを示します。

• XMLドキュメントの残りの要素を作成するために、疑似メソッドにクロージャが提供されます。

• クラスMarkupBuilderのデフォルトのコンストラクターは、生成されたXMLが標準出力ストリームに発行されるように初期化されます。

上記のプログラムを実行すると、次の結果が得られます-

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

XMLドキュメント全体を作成するには、次のことを行う必要があります。

• 要素のさまざまな値を格納するには、マップエントリを作成する必要があります。
• マップの各要素について、各要素に値を割り当てています。

import groovy.xml.MarkupBuilder 

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

上記のプログラムを実行すると、次の結果が得られます-

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

XML解析

Groovy XmlParserクラスは、XMLドキュメントをノードインスタンスのツリーに解析するための単純なモデルを採用しています。各ノードには、XML要素の名前、要素の属性、および子ノードへの参照があります。このモデルは、ほとんどの単純なXML処理に十分です。

構文

public XmlParser() 
   throws ParserConfigurationException, 
      SAXException

次のコードは、XMLパーサーを使用してXMLドキュメントを読み取る方法の例を示しています。

Movies.xmlという同じドキュメントがあり、XMLドキュメントを解析して、ユーザーに適切な出力を表示したいとします。次のコードは、XMLドキュメントのコンテンツ全体をトラバースして、ユーザーに適切な応答を表示する方法のスニペットです。

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

class Example {

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

上記のプログラムを実行すると、次の結果が得られます-

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

上記のコードについて注意すべき重要な点。

• クラスXmlParserのオブジェクトは、XMLドキュメントの解析に使用できるように形成されています。

• パーサーには、XMLファイルの場所が指定されます。

• 各ムービー要素について、クロージャを使用して各子ノードを参照し、関連情報を表示しています。

movie要素自体については、@記号を使用して、movie要素に付加されたtitle属性を表示しています。

JMXは、Java仮想環境と関係のあるすべてのアプリケーションを監視するために使用されるデファクトスタンダードです。GroovyがJavaの真上にあることを考えると、GroovyはJavaを使用したJMXですでに行われた膨大な量の作業を活用できます。

JVMの監視

JVMの監視を実行するために、java.lang.managementで使用可能な標準クラスを使用できます。次のコード例は、これを行う方法を示しています。

import java.lang.management.*

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

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

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

コードが実行されるとき、出力はコードが実行されるシステムによって異なります。出力のサンプルを以下に示します。

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

Tomcatの監視

Tomcatを監視するには、Tomcatの起動時に次のパラメータを設定する必要があります-

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

次のコードは、JMXを使用して、実行中のTomcatで使用可能なMBeanを検出し、どのWebモジュールであるかを判別し、各Webモジュールの処理時間を抽出します。

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 
}

この章では、Groovy言語を使用してJSONオブジェクトを解析および生成する方法について説明します。

JSON関数

シニア番号	関数とライブラリ
1	JsonSlurper JsonSlurperは、JSONテキストまたはリーダーコンテンツをGroovyデータに解析するクラスです。 マップ、リスト、整数、倍精度、ブール、文字列などのプリミティブ型などの構造。
2	JsonOutput このメソッドは、GroovyオブジェクトをJSON文字列にシリアル化する役割を果たします。

JsonSlurperを使用したデータの解析

JsonSlurperは、JSONテキストまたはリーダーコンテンツをGroovyデータ構造（マップ、リスト、整数、倍精度、ブール、文字列などのプリミティブ型）に解析するクラスです。

構文

def slurper = new JsonSlurper()

JSON slurperは、テキストまたはリーダーのコンテンツをリストとマップのデータ構造に解析します。

JsonSlurperクラスには、パーサー実装用のバリアントがいくつか付属しています。特定の文字列の解析に関しては、要件が異なる場合があります。Webサーバーからの応答から返されるJSONを読み取る必要がある場合を考えてみましょう。このような場合、パーサーJsonParserLaxバリアントを使用すると便利です。このパーシーは、JSONテキスト内のコメントを許可し、引用符文字列などを許可しません。この種のパーサーを指定するには、JsonSlurperのオブジェクトを定義するときにJsonParserType.LAXパーサータイプを使用する必要があります。

以下に示すこの例を見てみましょう。この例は、httpモジュールを使用してWebサーバーからJSONデータを取得するためのものです。このタイプのトラバーサルの場合、最良のオプションは、パーサータイプをJsonParserLaxバリアントに設定することです。

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

同様に、Groovyでは次の追加のパーサータイプを使用できます。

• JsonParserCharArrayパーサーは、基本的にJSON文字列を受け取り、基になる文字配列を操作します。値の変換中に、文字のサブ配列（「チョッピング」と呼ばれるメカニズム）をコピーし、それらを個別に操作します。

• JsonFastParserは、JsonParserCharArrayの特別なバリアントであり、最速のパーサーです。JsonFastParserは、インデックスオーバーレイパーサーとも呼ばれます。指定されたJSON文字列の解析中に、新しいchar配列またはStringインスタンスの作成を回避するために可能な限り努力します。基になる元の文字配列へのポインタのみを保持します。さらに、オブジェクトの作成を可能な限り遅らせます。

• JsonParserUsingCharacterSourceは、非常に大きなファイル用の特別なパーサーです。これは、「文字ウィンドウ処理」と呼ばれる手法を使用して、一定のパフォーマンス特性を持つ大きなJSONファイル（この場合は2MBを超えるサイズのファイルを意味します）を解析します。

テキストの解析

JsonSlurperクラスを使用する方法の例をいくつか見てみましょう。

import groovy.json.JsonSlurper 

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

上記の例では、次のようになります。

• 最初にJsonSlurperクラスのインスタンスを作成します

• 次に、JsonSlurperクラスのparseText関数を使用して、JSONテキストを解析します。

• オブジェクトを取得すると、キーを介してJSON文字列の値に実際にアクセスできることがわかります。

上記のプログラムの出力を以下に示します-

John 
1

整数のリストの解析

JsonSlurper解析メソッドの別の例を見てみましょう。次の例では、整数のリストを一時停止しています。次のコードから、それぞれのListメソッドを使用して、クロージャを渡すことができることがわかります。

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

上記のプログラムの出力を以下に示します-

List=[2, 3, 4, 5]

プリミティブデータ型のリストの解析

JSONパーサーは、文字列、数値、オブジェクト、true、false、およびnullのプリミティブデータ型もサポートします。JsonSlurperクラスは、これらのJSONタイプを対応するGroovyタイプに変換します。

次の例は、JsonSlurperを使用してJSON文字列を解析する方法を示しています。ここで、JsonSlurperが個々のアイテムをそれぞれのプリミティブ型に解析できることがわかります。

import groovy.json.JsonSlurper 
class Example {

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

上記のプログラムの出力を以下に示します-

12 
12.55 
1.2E+14

JsonOutput

それでは、Jsonで出力を印刷する方法について説明しましょう。これは、JsonOutputメソッドによって実行できます。このメソッドは、GroovyオブジェクトをJSON文字列にシリアル化する役割を果たします。

構文

Static string JsonOutput.toJson(datatype obj)

Parameters −パラメータは、データ型のオブジェクトにすることができます–数値、ブール値、文字、文字列、日付、マップ、クロージャなど。

Return type −戻り値の型はjson文字列です。

例

以下は、これを実現する方法の簡単な例です。

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

上記のプログラムの出力を以下に示します-

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

JsonOutputは、昔ながらのグルーヴィーなオブジェクトにも使用できます。次の例では、Student型のオブジェクトを実際にJsonOutputメソッドに渡していることがわかります。

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

上記のプログラムの出力を以下に示します-

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

Groovyを使用すると、最上位ステートメントのメソッド呼び出しの引数を括弧で囲むことができます。これは「コマンドチェーン」機能として知られています。この拡張機能は、このような括弧なしのメソッド呼び出しをチェーンできるようにすることで機能し、引数を括弧で囲んだり、チェーンされた呼び出しの間にドットを入れたりする必要はありません。

呼び出しが次のように実行された場合 a b c d、これは実際にはと同等になります a(b).c(d)。

DSLまたはドメイン固有の言語は、Groovyで記述されたコードを単純化して、一般ユーザーが簡単に理解できるようにすることを目的としています。次の例は、ドメイン固有言語を持つことの正確な意味を示しています。

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

上記のコードは、printlnステートメントを使用してコンソールに出力される番号のリストを示しています。ドメイン固有言語では、コマンドは次のようになります。

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

したがって、上記の例は、ドメイン固有言語のニーズを満たすためのプログラミング言語の変換を示しています。

GroovyでDSLを実装する方法の簡単な例を見てみましょう-

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

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

上記のプログラムを実行すると、次の結果が得られます-

How are things? We are doing well. Take care

上記のコード実装については、次の点に注意する必要があります。

• クロージャを受け入れる静的メソッドが使用されます。これは主にDSLを実装するための手間のかからない方法です。

• 電子メールの例では、クラスEmailDslにmakeメソッドがあります。インスタンスを作成し、クロージャー内のすべての呼び出しをインスタンスに委任します。これは、「to」セクションと「from」セクションが最終的にEmailDslクラス内のメソッドを実行するメカニズムです。

• to（）メソッドが呼び出されると、後でフォーマットするためにテキストをインスタンスに保存します。

• これで、エンドユーザーが理解しやすい簡単な言語でEmailDSLメソッドを呼び出すことができます。

Groovyのgroovy-sqlモジュールは、現在のJavaのJDBCテクノロジーを超える高レベルの抽象化を提供します。Groovy sql APIは、さまざまなデータベースをサポートしています。その一部を以下に示します。

• HSQLDB
• Oracle
• SQLサーバー
• MySQL
• MongoDB

この例では、例としてMySQLDBを使用します。GroovyでMySQLを使用するには、最初にmysqlサイトからMySQL jdbcjarファイルをダウンロードします。The forMySQLのマットを以下に示します。

mysql-connector-java-5.1.38-bin

次に、上記のjarファイルをワークステーションのクラスパスに追加してください。

データベース接続

MySQLデータベースに接続する前に、次のことを確認してください。

• データベースTESTDBを作成しました。
• TESTDBにテーブルEMPLOYEEを作成しました。
• このテーブルには、フィールドFIRST_NAME、LAST_NAME、AGE、SEX、およびINCOMEがあります。
• TESTDBにアクセスするためのユーザーID「testuser」とパスワード「test123」が設定されています。
• mysql jarファイルをダウンロードし、そのファイルをクラスパスに追加したことを確認してください。
• MySQLの基本を理解するためにMySQLチュートリアルを完了しました

次の例は、MySQLデータベース「TESTDB」に接続する方法を示しています。

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

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

このスクリプトを実行している間、次の結果が生成されます-

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

データベーステーブルの作成

データベースに接続した後の次のステップは、データベースにテーブルを作成することです。次の例は、Groovyを使用してデータベースにテーブルを作成する方法を示しています。Sqlクラスのexecuteメソッドは、データベースに対してステートメントを実行するために使用されます。

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

挿入操作

レコードをデータベーステーブルに作成する場合に必要です。

例

次の例では、employeeテーブルにレコードを挿入します。コードはtrycatchブロックに配置されるため、レコードが正常に実行された場合、トランザクションはデータベースにコミットされます。トランザクションが失敗した場合、ロールバックが実行されます。

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

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

基準に基づいて特定の行だけを選択したい場合を考えてみましょう。次のコードは、値を検索するためのパラメータープレースホルダーを追加する方法を示しています。上記の例は、次のコードに示すように、パラメーターを取り込むように作成することもできます。$記号は、SQLステートメントの実行時に値に置き換えることができるパラメーターを定義するために使用されます。

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

READ操作

任意のデータベースでのREAD操作は、データベースからいくつかの有用な情報をフェッチすることを意味します。データベース接続が確立されると、このデータベースにクエリを実行する準備が整います。

読み取り操作は、SQLクラスのeachRowメソッドを使用して実行されます。

構文

eachRow(GString gstring, Closure closure)

結果セットの各行で指定されたクロージャーを呼び出す指定されたSQLクエリを実行します。

Parameters

• Gstring −実行する必要のあるSQLステートメント。

• Closure−読み取り操作から取得された行を処理するためのクロージャーステートメント。結果セットの各行で指定されたクロージャーを呼び出す指定されたSQLクエリを実行します。

次のコード例は、employeeテーブルからすべてのレコードをフェッチする方法を示しています。

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

上記のプログラムからの出力は次のようになります-

[Mac, Mohan, 20, M, 2000.0]

更新操作

UPDATE任意のデータベースでの操作とは、データベースですでに使用可能な1つ以上のレコードを更新することを意味します。次の手順では、SEXが「M」であるすべてのレコードを更新します。ここでは、すべての男性のAGEを1年増やします。

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

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

DELETE操作

データベースから一部のレコードを削除する場合は、DELETE操作が必要です。以下は、AGEが20を超えるEMPLOYEEからすべてのレコードを削除する手順です。

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

トランザクションの実行

トランザクションは、データの整合性を保証するメカニズムです。トランザクションには次の4つのプロパティがあります-

• Atomicity −トランザクションが完了するか、まったく何も起こりません。

• Consistency −トランザクションは一貫性のある状態で開始し、システムを一貫性のある状態のままにする必要があります。

• Isolation −トランザクションの中間結果は、現在のトランザクションの外部には表示されません。

• Durability −トランザクションがコミットされると、システム障害が発生した後でも、影響は持続します。

これは、トランザクションを実装する方法の簡単な例です。この例は、以前のDELETE操作のトピックからすでに見てきました。

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

コミット操作

コミット操作は、操作を続行し、データベースへのすべての変更を確定するようにデータベースに指示するものです。

上記の例では、これは次のステートメントによって実現されます。

sql.commit()

ロールバック操作

1つ以上の変更に満足できず、それらの変更を完全に元に戻したい場合は、ロールバック方式を使用してください。上記の例では、これは次のステートメントによって実現されます。

sql.rollback()

データベースの切断

データベース接続を切断するには、closeメソッドを使用します。

sql.close()

ソフトウェア開発の過程で、開発者はデータ構造、ドメインクラス、XML、GUIレイアウト、出力ストリームなどの作成に多くの時間を費やすことがあります。また、これらの特定の要件を作成するために使用されるコードによって、同じスニペットが繰り返されることもあります。多くの場所でコード。ここでGroovyビルダーが活躍します。Groovyには、標準のオブジェクトと構造を作成するために使用できるビルダーがあります。これらのビルダーは、開発者がこれらのビルダーを作成するために独自のコードを作成する必要がないため、時間を節約できます。この章では、Groovyで利用できるさまざまなビルダーについて説明します。

スイングビルダー

groovyでは、groovyで利用可能なスイングビルダーを使用してグラフィカルユーザーインターフェイスを作成することもできます。スイングコンポーネントを開発するためのメインクラスはSwingBuilderクラスです。このクラスには、次のようなグラフィカルコンポーネントを作成するための多くのメソッドがあります。

• JFrame −これはフレーム要素を作成するためのものです。

• JTextField −これはテキストフィールドコンポーネントの作成に使用されます。

SwingBuilderクラスを使用してSwingアプリケーションを作成する方法の簡単な例を見てみましょう。次の例では、次の点を確認できます-

• groovy.swing.SwingBuilderクラスとjavax.swing。*クラスをインポートする必要があります。

• Swingアプリケーションに表示されるすべてのコンポーネントは、SwingBuilderクラスの一部です。

• フレーム自体については、フレームの初期位置とサイズを指定できます。フレームのタイトルを指定することもできます。

• フレームを表示するには、Visibilityプロパティをtrueに設定する必要があります。

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)

上記のプログラムの出力を以下に示します。次の出力は、HelloWorldのテキストを含むJLabelとともにJFrameを示しています。

テキストボックスを使用して入力画面を作成するための次の例を見てみましょう。次の例では、学生名、科目、学校名のテキストボックスを持つフォームを作成します。次の例では、次の重要なポイントを確認できます-

• 画面上のコントロールのレイアウトを定義しています。この場合、グリッドレイアウトを使用しています。
• ラベルには配置プロパティを使用しています。
• 画面にテキストボックスを表示するためにtextFieldメソッドを使用しています。

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)

上記のプログラムの出力を以下に示します-

イベントハンドラー

それでは、イベントハンドラーを見てみましょう。イベントハンドラーは、ボタンが押されたときに何らかの処理を実行するためにボタンに使用されます。各ボタンの疑似メソッド呼び出しには、actionPerformedパラメーターが含まれています。これは、クロージャとして提示されるコードブロックを表します。

2つのボタンを持つ画面を作成するための次の例を見てみましょう。いずれかのボタンを押すと、対応するメッセージがコンソール画面に送信されます。次の例では、次の重要なポイントを確認できます-

• 定義されたボタンごとに、actionPerformedメソッドを使用し、ボタンがクリックされたときにコンソールに出力を送信するクロージャを定義しています。

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

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

上記のプログラムの出力を以下に示します。いずれかのボタンをクリックすると、必要なメッセージがコンソールログ画面に送信されます。

上記の例の別のバリエーションは、ハンドラーとして機能できるメソッドを定義することです。次の例では、DisplayAとDisplayBの2つのハンドラーを定義しています。

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

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

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

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

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

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

上記のプログラムの出力は、前の例と同じままです。

DOMビルダー

DOM Builderは、HTML、XHTML、およびXMLを解析し、それをW3CDOMツリーに変換するために使用できます。

次の例は、DOMビルダーの使用方法を示しています。

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

JsonBuilder

JsonBuilderは、jsonタイプのオブジェクトを作成するために使用されます。

次の例は、Jsonビルダーの使用方法を示しています。

def builder = new groovy.json.JsonBuilder() 

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

上記のプログラムの出力を以下に示します。出力clearltは、Jsonbuilderが構造化されたノードのセットからjsonオブジェクトを構築できたことを示しています。

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

jsonbuilderは、リストを取り込んでjsonオブジェクトに変換することもできます。次の例は、これを実現する方法を示しています。

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

上記のプログラムの出力を以下に示します。

[1,2,3]

jsonBuilderはクラスにも使用できます。次の例は、クラスのオブジェクトがjsonビルダーへの入力になる方法を示しています。

def builder = new groovy.json.JsonBuilder() 

class Student {
   String name  
} 

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

上記のプログラムの出力を以下に示します。

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

NodeBuilder

NodeBuilderは、任意のデータを処理するためのNodeオブジェクトのネストされたツリーを作成するために使用されます。Nodebuilderの使用例を以下に示します。

def nodeBuilder = new NodeBuilder() 

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

println(studentlist)

FileTreeBuilder

FileTreeBuilderは、仕様からファイルディレクトリ構造を生成するためのビルダーです。以下は、FileTreeBuilderの使用方法の例です。

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

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

上記のコードを実行すると、sample.txtというファイルがmain / submain / Tutorialフォルダーに作成されます。また、sample.txtファイルには「HelloWorld」というテキストが含まれます。

groovyshとして知られるGroovyシェルは、groovy式の評価、クラスの定義、および単純なプログラムの実行に簡単に使用できます。Groovyがインストールされると、コマンドラインシェルがインストールされます。

Groovyで使用できるコマンドラインオプションは次のとおりです。

コマンドラインパラメータ	フルネーム	詳細
-C	--color [= FLAG]	ANSIカラーの使用を有効または無効にします
-D	--define = NAME = VALUE	システムプロパティを定義する
-T	--terminal = TYPE	使用する端末のタイプを指定します
-V	- バージョン	バージョンを表示する
-クラスパス		クラスファイルの場所を指定します–最初の引数である必要があります
-cp	-クラスパス	'-classpath'のエイリアス
-d	- デバッグ	--debugデバッグ出力を有効にする
-e	--evaluate = arg	インタラクティブセッションを開始するときにオプションの拳を評価する
-h	- 助けて	このヘルプメッセージを表示する
-q	- 静か	余分な出力を抑制します
-v	-詳細	詳細出力を有効にする

次のスナップショットは、Groovyシェルで実行されている式の簡単な例を示しています。次の例では、Groovyシェルに「HelloWorld」を印刷しています。

クラスと関数

コマンドプロンプトでクラスを定義し、新しいオブジェクトを作成し、クラスのメソッドを呼び出すのは非常に簡単です。次の例は、これを実装する方法を示しています。次の例では、単純なメソッドを使用して単純なStudentクラスを作成しています。コマンドプロンプト自体で、クラスのオブジェクトを作成し、Displayメソッドを呼び出しています。

コマンドプロンプトでメソッドを定義し、そのメソッドを呼び出すのは非常に簡単です。メソッドはdefタイプを使用して定義されていることに注意してください。また、Nameというパラメータが含まれていることにも注意してください。このパラメータは、Displayメソッドが呼び出されたときに実際の値に置き換えられます。次の例は、これを実装する方法を示しています。

コマンド

シェルには、シェルの環境への豊富なアクセスを提供するさまざまなコマンドがあります。以下はそれらのリストとそれらが何をするかです。

シニア番号	コマンド＆smp; コマンドの説明
1	:help （：h）このヘルプメッセージを表示する
2	? （：？）エイリアス：： help
3	:exit （：x）シェルを終了します
4	:quit （：q）エイリアス：： exit
5	import （：i）クラスを名前空間にインポートします
6	:display （：d）現在のバッファを表示します
7	:clear （：c）バッファをクリアし、プロンプトカウンタをリセットします
8	:show （：S）変数、クラス、またはインポートを表示します
9	:inspect （：n）GUIオブジェクトブラウザで変数または最後の結果を検査します
10	:purge （：p）変数、​​クラス、インポート、または設定をパージします
11	:edit （：e）現在のバッファを編集します
12	:load （：l）ファイルまたはURLをバッファにロードします
13	. （：。）エイリアス：： load
14	.save （：s）現在のバッファをファイルに保存します
15	.record （：r）現在のセッションをファイルに記録します
16	:alias （：a）エイリアスを作成する
17	:set （：=）設定（またはリスト）設定
18	:register （：rc）新しいコマンドをシェルに登録します
19	:doc （：D）引数のドキュメントを表示するブラウザウィンドウを開きます
20	:history （：H）編集行の履歴を表示、管理、および呼び出す

オブジェクト指向システムの基本単位はクラスです。したがって、単体テストはクラス内のテストで構成されます。採用されたアプローチは、テスト中のクラスのオブジェクトを作成し、それを使用して、選択されたメソッドが期待どおりに実行されることを確認することです。すべてのものをテストすることが常に実用的であるとは限らないため、すべての方法をテストできるわけではありません。ただし、重要で重要な方法については、単体テストを実施する必要があります。

JUnitは、Javaコードの自動単体テストで認められている業界標準であるオープンソースのテストフレームワークです。幸い、JUnitフレームワークはGroovyクラスのテストに簡単に使用できます。必要なのは、標準のGroovy環境の一部であるGroovyTestCaseクラスを拡張することだけです。Groovyテストケースクラスは、Junitテストケースに基づいています。

簡単なJUnitテストケースの作成

アプリケーションクラスファイルで次のクラスが定義されていると仮定します-

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

上記のプログラムの出力を以下に示します。

Joe1

そして今、Studentクラスのテストケースを書きたいとしましょう。典型的なテストケースは次のようになります。以下のコードについては、以下の点に注意する必要があります。

• テストケースクラスはGroovyTestCaseクラスを拡張します
• Displayメソッドが正しい文字列を返すようにするためにassertステートメントを使用しています。

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

Groovyテストスイート

通常、単体テストの数が増えると、すべてのテストケースを1つずつ実行し続けることが難しくなります。したがって、Groovyは、すべてのテストケースを1つの論理ユニットにカプセル化できるテストスイートを作成する機能を提供します。次のコードスニペットは、これを実現する方法を示しています。コードについては、次の点に注意してください。

• GroovyTestSuiteは、すべてのテストケースを1つにカプセル化するために使用されます。

• 次の例では、2つのテストケースファイルがあり、1つは StudentTest もう1つは EmployeeTest これには、必要なすべてのテストが含まれています。

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

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

TestRunner.run(AllTests.suite())

Groovyのテンプレートエンジンは、差し込み印刷（多くのアドレスへのメール、特に広告の送信を容易にするために、データベースから文字や封筒に名前とアドレスを自動的に追加する）のように動作しますが、はるかに一般的です。

文字列での単純なテンプレート

以下の簡単な例では、最初に文字列「Groovy」を保持する名前変数を定義しています。printlnステートメントでは、$記号を使用して、値を挿入できるパラメーターまたはテンプレートを定義しています。

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

上記のコードをgroovyで実行すると、次の出力が表示されます。出力は、$ nameがdefステートメントによって割り当てられた値に置き換えられたことを明確に示しています。

シンプルなテンプレートエンジン

以下は、パラメータ化されたテキストを生成するために、テンプレートでJSPのようなスクリプトレットとEL式を使用できるようにするSimpleTemplateEngineの例です。テンプレートエンジンを使用すると、パラメーターとその値のリストをバインドして、プレースホルダーが定義されている文字列でそれらを置き換えることができます。

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

about $Topic'  

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

println template

上記のコードをgroovyで実行すると、次の出力が表示されます。

XMLファイルのテンプレート機能を使用してみましょう。最初のステップとして、Student.templateというファイルに次のコードを追加しましょう。次のファイルでは、要素の実際の値ではなく、プレースホルダーが追加されていることがわかります。だから$ name、$is and $件名はすべてプレースホルダーとして配置され、実行時に置き換える必要があります。

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

次に、Groovyスクリプトコードを追加して、上記のテンプレートを実際の値に置き換えるために使用できる機能を追加しましょう。次のコードについては、次の点に注意してください。

• プレースホルダーの実際の値へのマッピングは、バインディングとSimpleTemplateEngineを介して行われます。バインディングは、プレースホルダーをキーとして、置換を値として持つマップです。

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

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

println writable

上記のコードをgroovyで実行すると、次の出力が表示されます。出力から、関連するプレースホルダーで値が正常に置き換えられていることがわかります。

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

StreamingTemplateEngine

StreamingTemplateEngineエンジンは、Groovyで使用できるもう1つのテンプレートエンジンです。これはSimpleTemplateEngineと同等ですが、書き込み可能なクロージャを使用してテンプレートを作成し、大きなテンプレートに対してよりスケーラブルにします。具体的には、このテンプレートエンジンは64kを超える文字列を処理できます。

以下は、StreamingTemplateEngineの使用例です。

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

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

上記のコードをgroovyで実行すると、次の出力が表示されます。

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngineは、テンプレートソースと期待される出力の両方がXMLであることが意図されているテンプレートシナリオで使用されます。テンプレートは通常を使用します${expression} and $テンプレートに任意の式を挿入するための変数表記。

以下は、XMLTemplateEngineの使用方法の例です。

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

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

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

上記のコードをgroovyで実行すると、次の出力が表示されます。

Joe
    
    
   1
    
    
   Physics

メタオブジェクトプログラミングまたはMOPを使用して、メソッドを動的に呼び出したり、クラスやメソッドをその場で作成したりできます。

では、これはどういう意味ですか？Studentというクラスを考えてみましょう。これは、メンバー変数やメソッドのない空のクラスの一種です。このクラスで次のステートメントを呼び出す必要があると仮定します。

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

メタオブジェクトプログラミングでは、クラスにメンバー変数NameまたはメソッドDisplay（）がなくても、上記のコードは引き続き機能します。

これはどのように機能しますか？これがうまくいくためには、Groovyの実行プロセスにフックするGroovyInterceptableインターフェースを実装する必要があります。このインターフェースで使用できるメソッドは次のとおりです。

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

したがって、上記のインターフェースの説明で、invokeMethod（）を実装する必要がある場合、存在する、または存在しないすべてのメソッドに対して呼び出されると仮定します。

欠落しているプロパティ

それでは、不足しているプロパティに対してメタオブジェクトプログラミングを実装する方法の例を見てみましょう。次の重要事項は、次のコードについて注意する必要があります。

• クラスStudentには、NameまたはIDと呼ばれるメンバー変数が定義されていません。

• クラスStudentは、GroovyInterceptableインターフェイスを実装します。

• その場で作成されるメンバー変数の値を保持するために使用されるdynamicPropsと呼ばれるパラメーターがあります。

• getpropertyメソッドとsetpropertyメソッドは、実行時にクラスのプロパティの値を取得および設定するために実装されています。

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

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

次のコードの出力は次のようになります-

Joe 
1

欠落しているメソッド

それでは、不足しているプロパティに対してメタオブジェクトプログラミングを実装する方法の例を見てみましょう。次の重要事項は、次のコードについて注意する必要があります-

• クラスStudentは、メソッドが存在するかどうかに関係なく呼び出されるinvokeMethodメソッドを実装するようになりました。

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

次のコードの出力を以下に示します。メソッドDisplayが存在しなくても、メソッド例外が欠落しているというエラーはないことに注意してください。

Joe 
1

メタクラス

この機能は、MetaClassの実装に関連しています。デフォルトの実装では、ゲッターとセッターを呼び出さずにフィールドにアクセスできます。次の例は、metaClass関数を使用して、クラス内のプライベート変数の値を変更する方法を示しています。

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

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

次のコードの出力は次のようになります-

Joe 
Mark

メソッドがありません

GroovyはmethodMissingの概念をサポートしています。このメソッドは、指定された名前や指定された引数のメソッドが見つからない場合に、メソッドのディスパッチが失敗した場合にのみ呼び出されるという点で、invokeMethodとは異なります。次の例は、methodMissingの使用方法を示しています。

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

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

次のコードの出力は次のようになります-

Joe 
1 
Missing method