Groovy - คู่มือฉบับย่อ

Groovy เป็นภาษาเชิงวัตถุซึ่งใช้แพลตฟอร์ม Java Groovy 1.0 เปิดตัวในวันที่ 2 มกราคม 2550 โดยมี Groovy 2.4 เป็นรุ่นหลักในปัจจุบัน Groovy เผยแพร่ผ่าน Apache License v 2.0

คุณสมบัติของ Groovy

Groovy มีคุณสมบัติดังต่อไปนี้ -

  • รองรับการพิมพ์ทั้งแบบคงที่และแบบไดนามิก
  • รองรับการทำงานเกินกำลัง
  • ไวยากรณ์ดั้งเดิมสำหรับรายการและอาร์เรย์ที่เชื่อมโยง
  • การสนับสนุนดั้งเดิมสำหรับนิพจน์ทั่วไป
  • การสนับสนุนดั้งเดิมสำหรับภาษามาร์กอัปต่างๆเช่น XML และ HTML
  • Groovy เป็นเรื่องง่ายสำหรับนักพัฒนา Java เนื่องจากไวยากรณ์สำหรับ Java และ Groovy มีความคล้ายคลึงกันมาก
  • คุณสามารถใช้ไลบรารี Java ที่มีอยู่
  • Groovy ขยาย java.lang.Object

เว็บไซต์อย่างเป็นทางการของ Groovy คือ http://www.groovy-lang.org/

มีหลายวิธีในการตั้งค่าสภาพแวดล้อม Groovy

Binary download and installation- ไปที่ลิงค์www.groovy-lang.org/download.htmlเพื่อรับส่วน Windows Installer คลิกที่ตัวเลือกนี้เพื่อเริ่มดาวน์โหลดโปรแกรมติดตั้ง Groovy

เมื่อคุณเปิดโปรแกรมติดตั้งแล้วให้ทำตามขั้นตอนด้านล่างเพื่อทำการติดตั้งให้เสร็จสิ้น

Step 1 - เลือกตัวติดตั้งภาษา

Step 2 - คลิกปุ่มถัดไปในหน้าจอถัดไป

Step 3 - คลิกปุ่ม "ฉันยอมรับ"

Step 4 - ยอมรับส่วนประกอบเริ่มต้นแล้วคลิกปุ่มถัดไป

Step 5 - เลือกโฟลเดอร์ปลายทางที่เหมาะสมจากนั้นคลิกปุ่มถัดไป

Step 6 - คลิกปุ่มติดตั้งเพื่อเริ่มการติดตั้ง

Step 7 - เมื่อการติดตั้งเสร็จสมบูรณ์ให้คลิกปุ่มถัดไปเพื่อเริ่มการกำหนดค่า

Step 8 - เลือกตัวเลือกเริ่มต้นและคลิกปุ่มถัดไป

Step 9 - ยอมรับการเชื่อมโยงไฟล์เริ่มต้นแล้วคลิกปุ่มถัดไป

Step 10 - คลิกปุ่ม Finish เพื่อทำการติดตั้งให้เสร็จสิ้น

เมื่อทำตามขั้นตอนข้างต้นแล้วคุณสามารถเริ่มต้น Groovy shell ซึ่งเป็นส่วนหนึ่งของการติดตั้ง Groovy ที่ช่วยในการทดสอบภาษา Groovy ในแง่มุมต่างๆของเราโดยไม่จำเป็นต้องมีสภาพแวดล้อมการพัฒนาแบบบูรณาการที่สมบูรณ์สำหรับ Groovy ซึ่งสามารถทำได้โดยเรียกใช้คำสั่ง groovysh จากพรอมต์คำสั่ง

หากคุณต้องการรวมไบนารีที่น่าสนใจเป็นส่วนหนึ่งของงานสร้าง maven หรือ gradle ของคุณคุณสามารถเพิ่มบรรทัดต่อไปนี้

Gradle

'org.codehaus.groovy:groovy:2.4.5'

Maven

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

เพื่อให้เข้าใจไวยากรณ์พื้นฐานของ Groovy ก่อนอื่นเรามาดูโปรแกรม Hello World แบบง่ายๆกันก่อน

การสร้างโปรแกรม Hello World ครั้งแรกของคุณ

การสร้างโปรแกรม hello world ครั้งแรกของคุณทำได้ง่ายเพียงแค่ป้อนบรรทัดรหัสต่อไปนี้ -

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 คำสำคัญ.

ตัวอย่างต่อไปนี้แสดงวิธีใช้การนำเข้าคลาส MarkupBuilder แบบง่ายซึ่งน่าจะเป็นคลาสที่ใช้มากที่สุดสำหรับการสร้างมาร์กอัป HTML หรือ XML

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

ในบรรทัดโค้ดด้านบนมีโทเค็นสองแบบอันแรกคือคีย์เวิร์ด println และลำดับต่อไปคือสตริงลิเทอรัลของ“ Hello World”

ความคิดเห็นใน Groovy

ข้อคิดเห็นใช้ในการจัดทำเอกสารรหัสของคุณ ความคิดเห็นใน Groovy อาจเป็นบรรทัดเดียวหรือหลายบรรทัด

ความคิดเห็นบรรทัดเดียวระบุได้โดยใช้ // ที่ตำแหน่งใดก็ได้ในบรรทัด ตัวอย่างแสดงด้านล่าง -

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

ความคิดเห็นหลายบรรทัดถูกระบุด้วย / * ในตอนต้นและ * / เพื่อระบุจุดสิ้นสุดของความคิดเห็นแบบหลายบรรทัด

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

อัฒภาค

ต่างจากภาษาการเขียนโปรแกรม Java ไม่จำเป็นต้องมีเครื่องหมายอัฒภาคหลังสิ้นสุดทุกคำสั่งซึ่งเป็นทางเลือก

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

หากคุณเรียกใช้โปรแกรมข้างต้นข้อความทั้งสองในวิธีการหลักจะไม่สร้างข้อผิดพลาดใด ๆ

ตัวระบุ

ตัวระบุใช้เพื่อกำหนดตัวแปรฟังก์ชันหรือตัวแปรที่ผู้ใช้กำหนดอื่น ๆ ตัวระบุเริ่มต้นด้วยตัวอักษรดอลลาร์หรือขีดล่าง พวกเขาไม่สามารถเริ่มต้นด้วยตัวเลข นี่คือตัวอย่างบางส่วนของตัวระบุที่ถูกต้อง -

def employeename 
def student1 
def student_name

ที่ไหน def เป็นคำหลักที่ใช้ใน Groovy เพื่อกำหนดตัวระบุ

นี่คือตัวอย่างโค้ดของการใช้ตัวระบุในโปรแกรม Hello World ของเรา

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 Programming ตารางต่อไปนี้แสดงรายการคำสำคัญที่กำหนดไว้ใน Groovy

เช่น ยืนยัน หยุดพัก กรณี
จับ ชั้นเรียน const ดำเนินการต่อ
def ค่าเริ่มต้น ทำ อื่น
enum ขยาย เท็จ สุดท้าย
สำหรับ ไปที่ ถ้า ดำเนินการ
นำเข้า ใน อินสแตนซ์ของ อินเตอร์เฟซ
ใหม่ ดึง แพ็คเกจ กลับ
สุดยอด สวิตซ์ นี้ โยน
พ่น ลักษณะ จริง ลอง
ในขณะที่

ช่องว่าง

Whitespace เป็นคำที่ใช้ในภาษาโปรแกรมเช่น Java และ Groovy เพื่ออธิบายช่องว่างแท็บอักขระขึ้นบรรทัดใหม่และข้อคิดเห็น ช่องว่างแยกส่วนหนึ่งของคำสั่งออกจากอีกส่วนหนึ่งและช่วยให้คอมไพเลอร์ระบุตำแหน่งที่องค์ประกอบหนึ่งในคำสั่ง

ตัวอย่างเช่นในตัวอย่างโค้ดต่อไปนี้มีช่องว่างระหว่างคีย์เวิร์ด defและตัวแปร x เพื่อให้คอมไพเลอร์รู้ว่าdef คือคีย์เวิร์ดที่ต้องใช้และ x ควรเป็นชื่อตัวแปรที่ต้องกำหนด

def x = 5;

ตัวอักษร

ลิเทอรัลคือสัญกรณ์สำหรับแสดงค่าคงที่ในรูปแบบ groovy ภาษาที่น่าสนใจมีสัญกรณ์สำหรับจำนวนเต็มตัวเลขทศนิยมอักขระและสตริง นี่คือตัวอย่างบางส่วนของตัวอักษรในภาษาโปรแกรม Groovy -

12 
1.45a’ 
“aa”

ในภาษาโปรแกรมใด ๆ คุณต้องใช้ตัวแปรต่างๆเพื่อจัดเก็บข้อมูลประเภทต่างๆ ตัวแปรไม่ใช่อะไรเลยนอกจากตำแหน่งหน่วยความจำที่สงวนไว้เพื่อเก็บค่า ซึ่งหมายความว่าเมื่อคุณสร้างตัวแปรคุณต้องสงวนพื้นที่ในหน่วยความจำเพื่อเก็บค่าที่เกี่ยวข้องกับตัวแปร

คุณอาจต้องการจัดเก็บข้อมูลประเภทข้อมูลต่างๆเช่นสตริงอักขระอักขระแบบกว้างจำนวนเต็มจุดลอยตัวบูลีนเป็นต้นระบบปฏิบัติการจะจัดสรรหน่วยความจำและตัดสินใจว่าจะจัดเก็บข้อมูลใดในส่วนที่สงวนไว้ หน่วยความจำ.

ประเภทข้อมูลในตัว

Groovy นำเสนอประเภทข้อมูลในตัวที่หลากหลาย ต่อไปนี้เป็นรายการประเภทข้อมูลที่กำหนดไว้ใน Groovy -

  • byte- ใช้เพื่อแสดงค่าไบต์ ตัวอย่างคือ 2

  • short- ใช้เพื่อแสดงตัวเลขสั้น ๆ ตัวอย่างคือ 10

  • int- ใช้แทนจำนวนเต็ม ตัวอย่างคือ 1234

  • long- ใช้เพื่อแสดงจำนวนยาว ตัวอย่างคือ 10000090

  • float- ใช้เพื่อแสดงตัวเลขทศนิยม 32 บิต ตัวอย่างคือ 12.34

  • double- ใช้เพื่อแสดงตัวเลขทศนิยม 64 บิตซึ่งเป็นการแสดงตัวเลขทศนิยมที่ยาวขึ้นซึ่งบางครั้งอาจจำเป็นต้องใช้ ตัวอย่างคือ 12.3456565

  • char- สิ่งนี้กำหนดลิเทอรัลอักขระเดียว ตัวอย่างคือ 'a'

  • Boolean - แสดงถึงค่าบูลีนซึ่งอาจเป็นจริงหรือเท็จก็ได้

  • String - นี่คือตัวอักษรที่แสดงในรูปแบบ the formโซ่อักขระ ตัวอย่างเช่น“ Hello World”

ค่าผูกมัด

ตารางต่อไปนี้แสดงค่าสูงสุดที่อนุญาตสำหรับตัวอักษรตัวเลขและทศนิยม

ไบต์ -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 หมายเลขอินทิกรัลที่ลงนามโดยพลการความแม่นยำไม่เปลี่ยนรูป 30 ก
java.math.BigDecimal ตัวเลขทศนิยมที่ลงนามโดยพลการความแม่นยำไม่เปลี่ยนแปลงไม่ได้ 3.5 ก

ตัวอย่างโค้ดต่อไปนี้แสดงให้เห็นว่าสามารถใช้ชนิดข้อมูลบิวท์อินต่างๆได้อย่างไร -

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 สามารถกำหนดได้สองวิธี - โดยใช้ native syntax สำหรับประเภทข้อมูลหรือถัดไปคือ by using the def keyword. สำหรับคำจำกัดความตัวแปรจำเป็นต้องระบุชื่อประเภทอย่างชัดเจนหรือใช้ "def" ในการแทนที่ สิ่งนี้จำเป็นโดยตัวแยกวิเคราะห์ Groovy

มีประเภทพื้นฐานของตัวแปรดังต่อไปนี้ใน Groovy ตามที่อธิบายไว้ในบทที่แล้ว -

  • byte- ใช้เพื่อแสดงค่าไบต์ ตัวอย่างคือ 2

  • short- ใช้เพื่อแสดงตัวเลขสั้น ๆ ตัวอย่างคือ 10

  • int- ใช้แทนจำนวนเต็ม ตัวอย่างคือ 1234

  • long- ใช้เพื่อแสดงจำนวนยาว ตัวอย่างคือ 10000090

  • float- ใช้เพื่อแสดงตัวเลขทศนิยม 32 บิต ตัวอย่างคือ 12.34

  • double- ใช้เพื่อแสดงตัวเลขทศนิยม 64 บิตซึ่งเป็นการแสดงตัวเลขทศนิยมที่ยาวขึ้นซึ่งบางครั้งอาจจำเป็นต้องใช้ ตัวอย่างคือ 12.3456565

  • char- สิ่งนี้กำหนดลิเทอรัลอักขระเดียว ตัวอย่างคือ 'a'

  • Boolean - แสดงถึงค่าบูลีนซึ่งอาจเป็นจริงหรือเท็จก็ได้

  • String - นี่คือตัวอักษรที่แสดงในรูปแบบ the formโซ่อักขระ ตัวอย่างเช่น“ Hello World”

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

การตั้งชื่อตัวแปร

ชื่อของตัวแปรสามารถประกอบด้วยตัวอักษรตัวเลขและอักขระขีดล่าง ต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง อักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กมีความแตกต่างกันเนื่องจาก Groovy เช่นเดียวกับ Java เป็นภาษาโปรแกรมที่คำนึงถึงตัวพิมพ์เล็กและใหญ่

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

5 
6 
Joe

เราจะเห็นว่า x และ X เป็นตัวแปรสองตัวที่แตกต่างกันเนื่องจากความไวของตัวพิมพ์เล็กและตัวพิมพ์เล็กและในกรณีที่สามเราจะเห็นว่า _Name เริ่มต้นด้วยขีดล่าง

ตัวแปรการพิมพ์

คุณสามารถพิมพ์ค่าปัจจุบันของตัวแปรด้วยฟังก์ชัน 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 มีตัวดำเนินการประเภทต่อไปนี้ -

  • ตัวดำเนินการเลขคณิต
  • ตัวดำเนินการเชิงสัมพันธ์
  • ตัวดำเนินการทางตรรกะ
  • ตัวดำเนินการ Bitwise
  • ตัวดำเนินการมอบหมาย

ตัวดำเนินการเลขคณิต

ภาษา Groovy สนับสนุนตัวดำเนินการทางคณิตศาสตร์ปกติเป็นภาษาใดก็ได้ ต่อไปนี้เป็นตัวดำเนินการทางคณิตศาสตร์ที่มีอยู่ใน Groovy -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
+ การเพิ่มตัวถูกดำเนินการสองตัว 1 + 2 จะให้ 3
- ลบตัวถูกดำเนินการที่สองจากตัวแรก 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--;

x จะให้ 4

ตัวดำเนินการเชิงสัมพันธ์

ตัวดำเนินการเชิงสัมพันธ์อนุญาตให้เปรียบเทียบวัตถุได้ ต่อไปนี้เป็นตัวดำเนินการเชิงสัมพันธ์ที่มีอยู่ใน Groovy -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
== ทดสอบความเท่าเทียมกันระหว่างสองวัตถุ 2 == 2 จะให้เป็นจริง
! = ทดสอบความแตกต่างระหว่างสองวัตถุ 3! = 2 จะให้จริง
< ตรวจสอบเพื่อดูว่าวัตถุด้านซ้ายน้อยกว่าตัวถูกดำเนินการด้านขวาหรือไม่ 2 <3 จะให้เป็นจริง
<= ตรวจสอบว่าวัตถุด้านซ้ายน้อยกว่าหรือเท่ากับตัวถูกดำเนินการด้านขวาหรือไม่ 2 <= 3 จะให้เป็นจริง
> ตรวจสอบเพื่อดูว่าวัตถุด้านซ้ายมีค่ามากกว่าตัวถูกดำเนินการด้านขวาหรือไม่ 3> 2 จะให้เป็นจริง
> = ตรวจสอบเพื่อดูว่าวัตถุทางซ้ายมากกว่าหรือเท่ากับตัวถูกดำเนินการด้านขวาหรือไม่ 3> = 2 จะให้เป็นจริง

ตัวดำเนินการทางตรรกะ

ตัวดำเนินการทางตรรกะใช้เพื่อประเมินนิพจน์บูลีน ต่อไปนี้เป็นตัวดำเนินการเชิงตรรกะที่มีอยู่ใน Groovy -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
&& นี่คือโอเปอเรเตอร์“ และ” เชิงตรรกะ true && true จะให้จริง
|| นี่คือโอเปอเรเตอร์“ หรือ” เชิงตรรกะ จริง || จริงจะให้จริง
! นี่คือโอเปอเรเตอร์ "ไม่ใช่" เชิงตรรกะ ! เท็จจะให้จริง

ตัวดำเนินการ Bitwise

Groovy มีตัวดำเนินการสี่บิต ต่อไปนี้เป็นตัวดำเนินการระดับบิตที่มีอยู่ใน Groovy -

แสดงตัวอย่าง

ซีเนียร์ No ตัวดำเนินการและคำอธิบาย
1

&

นี่คือโอเปอเรเตอร์“ และ” แบบบิต

2

|

นี่คือโอเปอเรเตอร์“ หรือ” แบบบิต

3

^

นี่คือ "xor" แบบบิตหรือเฉพาะตัวหรือโอเปอเรเตอร์

4

~

นี่คือตัวดำเนินการปฏิเสธแบบบิต

นี่คือตารางความจริงที่แสดงตัวดำเนินการเหล่านี้

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

% = สิ่งนี้ใช้โมดูลัสโดยใช้ตัวถูกดำเนินการสองตัวและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย

def A = 5

ก% = 3

เอาต์พุตจะเป็น 2

ตัวดำเนินการช่วง

Groovy สนับสนุนแนวคิดของช่วงและแสดงสัญกรณ์ของตัวดำเนินการช่วงด้วยความช่วยเหลือของสัญกรณ์ .. ตัวอย่างง่ายๆของตัวดำเนินการช่วงได้รับด้านล่าง

def range = 0..5

นี่เป็นเพียงการกำหนดช่วงของจำนวนเต็มอย่างง่ายโดยเก็บไว้ในตัวแปรท้องถิ่นที่เรียกว่า range โดยมีขอบเขตล่างเป็น 0 และขอบเขตบนเป็น 5

ข้อมูลโค้ดต่อไปนี้แสดงวิธีใช้ตัวดำเนินการต่างๆ

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

ลำดับความสำคัญของตัวดำเนินการ

ตารางต่อไปนี้แสดงตัวดำเนินการที่น่าสนใจทั้งหมดตามลำดับความสำคัญ

ซีเนียร์ No ผู้ดำเนินการและชื่อ
1

++ -- + -

การเพิ่มขึ้น / ลดล่วงหน้า, ยูนารีบวก, ยูนารีลบ

2

* / %

คูณ div โมดูโล

3

+ -

การบวกการลบ

4

== != <=>

เท่ากับไม่เท่ากับเปรียบเทียบกับ

5

&

ไบนารี / bitwise และ

6

^

ไบนารี / บิต xor

7

|

ไบนารี / bitwise หรือ

8

&&

ตรรกะและ

9

||

ตรรกะหรือ

10

= **= *= /= %= += -= <<= >>= >>>= &= ^= |=

ตัวดำเนินการกำหนดต่างๆ

จนถึงตอนนี้เราได้เห็นข้อความที่ถูกดำเนินการทีละคำสั่งในลักษณะตามลำดับ นอกจากนี้คำสั่งยังมีให้ใน Groovy เพื่อปรับเปลี่ยนโฟลว์ของการควบคุมในตรรกะของโปรแกรม จากนั้นจะจัดประเภทเป็นโฟลว์ของงบควบคุมซึ่งเราจะเห็นโดยละเอียด

ส. คำชี้แจงและคำอธิบาย
1 ในขณะที่คำชี้แจง

คำสั่ง while ถูกดำเนินการโดยการประเมินนิพจน์เงื่อนไข (ค่าบูลีน) ก่อนและหากผลลัพธ์เป็นจริงคำสั่งในลูป while จะถูกเรียกใช้

2 สำหรับคำชี้แจง

คำสั่ง for ใช้เพื่อวนซ้ำตามชุดของค่า

3 คำสั่ง for-in

คำสั่ง for-in ใช้เพื่อวนซ้ำผ่านชุดของค่า

คำสั่งควบคุมลูป

ส. คำชี้แจงและคำอธิบาย
1 งบพัก

คำสั่ง break ใช้เพื่อเปลี่ยนลำดับการควบคุมภายในลูปและสลับคำสั่ง

2 ดำเนินการต่อคำชี้แจง

คำสั่งต่อเติมเสริมคำสั่งแบ่ง การใช้งานถูก จำกัด ไว้ในขณะและสำหรับลูป

โครงสร้างการตัดสินใจกำหนดให้โปรแกรมเมอร์ระบุเงื่อนไขอย่างน้อยหนึ่งเงื่อนไขที่จะประเมินหรือทดสอบโดยโปรแกรมพร้อมกับคำสั่งหรือคำสั่งที่จะดำเนินการหากเงื่อนไขถูกกำหนดให้เป็น trueและเป็นทางเลือกที่จะเรียกใช้คำสั่งอื่น ๆ หากเงื่อนไขถูกกำหนดให้เป็น false.

ซีเนียร์ คำชี้แจงและคำอธิบาย
1 ถ้าคำชี้แจง

การทำงานทั่วไปของคำสั่งนี้คือเงื่อนไขแรกจะถูกประเมินในคำสั่ง if หากเงื่อนไขเป็นจริงก็จะรันคำสั่ง

2 if / else คำชี้แจง

การทำงานทั่วไปของคำสั่งนี้คือเงื่อนไขแรกจะถูกประเมินในคำสั่ง if ถ้าเงื่อนไขเป็นจริงมันจะรันคำสั่งหลังจากนั้นและหยุดก่อนเงื่อนไขอื่นและออกจากลูป หากเงื่อนไขเป็นเท็จมันจะรันคำสั่งในบล็อกคำสั่ง else แล้วออกจากลูป

3 คำสั่งซ้อนหาก

บางครั้งมีข้อกำหนดที่จะต้องมีคำสั่ง if หลายรายการที่ฝังอยู่ภายในกันและกัน

4 สลับคำชี้แจง

บางครั้งคำสั่ง if-else ที่ซ้อนกันเป็นเรื่องปกติมากและมักใช้บ่อยจนมีการออกแบบคำสั่งที่ง่ายกว่านี้เรียกว่าคำสั่ง switch

5 คำสั่งสวิตช์ที่ซ้อนกัน

นอกจากนี้ยังเป็นไปได้ที่จะมีชุดคำสั่งสวิตช์ที่ซ้อนกัน

วิธีการที่อยู่ใน Groovy ถูกกำหนดด้วยประเภทการส่งคืนหรือด้วย defคำสำคัญ. วิธีการสามารถรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ ไม่จำเป็นว่าประเภทจะถูกกำหนดอย่างชัดเจนเมื่อกำหนดอาร์กิวเมนต์ สามารถเพิ่มตัวปรับแต่งเช่นสาธารณะส่วนตัวและป้องกันได้ ตามค่าเริ่มต้นหากไม่มีการระบุตัวปรับการมองเห็นวิธีนี้จะเป็นแบบสาธารณะ

วิธีที่ง่ายที่สุดคือวิธีที่ไม่มีพารามิเตอร์ดังที่แสดงด้านล่าง -

def methodName() { 
   //Method code 
}

ต่อไปนี้เป็นตัวอย่างวิธีการง่ายๆ

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

ในตัวอย่างข้างต้น DisplayName เป็นวิธีการง่ายๆซึ่งประกอบด้วยคำสั่ง println สองคำสั่งซึ่งใช้เพื่อส่งออกข้อความบางส่วนไปยังคอนโซล ในวิธีหลักแบบคงที่ของเราเราแค่เรียกเมธอด DisplayName ผลลัพธ์ของวิธีการข้างต้นจะเป็น -

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

พารามิเตอร์วิธีการ

โดยทั่วไปวิธีการจะมีประโยชน์มากขึ้นหากพฤติกรรมของมันถูกกำหนดโดยค่าของพารามิเตอร์อย่างน้อยหนึ่งตัว เราสามารถถ่ายโอนค่าไปยังวิธีการที่เรียกว่าโดยใช้พารามิเตอร์วิธีการ โปรดทราบว่าชื่อพารามิเตอร์ต้องแตกต่างกัน

ประเภทที่ง่ายที่สุดของวิธีการที่มีพารามิเตอร์ดังที่แสดงด้านล่าง -

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

ต่อไปนี้เป็นตัวอย่างวิธีการง่ายๆพร้อมพารามิเตอร์

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

ในตัวอย่างนี้เรากำลังสร้างวิธีการรวมที่มี 2 พารามิเตอร์ a และ b. พารามิเตอร์ทั้งสองเป็นประเภทint. จากนั้นเราจะเรียกวิธี sum จากวิธีการหลักของเราและส่งผ่านค่าไปยังตัวแปรa และ b.

ผลลัพธ์ของวิธีการข้างต้นจะเป็นค่า 15

พารามิเตอร์เริ่มต้น

นอกจากนี้ยังมีข้อกำหนดใน Groovy เพื่อระบุค่าเริ่มต้นสำหรับพารามิเตอร์ภายในเมธอด หากไม่มีการส่งค่าไปยังเมธอดสำหรับพารามิเตอร์ระบบจะใช้ค่าดีฟอลต์ หากใช้ทั้งพารามิเตอร์ที่ไม่ใช่ค่าเริ่มต้นและค่าเริ่มต้นจะต้องสังเกตว่าควรกำหนดพารามิเตอร์เริ่มต้นที่ส่วนท้ายของรายการพารามิเตอร์

ต่อไปนี้เป็นตัวอย่างวิธีการง่ายๆพร้อมพารามิเตอร์ -

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

ลองดูตัวอย่างเดียวกันกับที่เราดูก่อนหน้านี้สำหรับการเพิ่มตัวเลขสองตัวและสร้างวิธีการที่มีค่าเริ่มต้นหนึ่งรายการและพารามิเตอร์อื่นที่ไม่ใช่ค่าเริ่มต้น -

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

ในตัวอย่างนี้เรากำลังสร้างวิธีการรวมที่มีพารามิเตอร์สองตัว a และ b. พารามิเตอร์ทั้งสองเป็นประเภท int ความแตกต่างระหว่างตัวอย่างนี้กับตัวอย่างก่อนหน้าคือในกรณีนี้เรากำลังระบุค่าเริ่มต้นสำหรับb เป็น 5 ดังนั้นเมื่อเราเรียกวิธีการรวมจากวิธีหลักของเราเรามีตัวเลือกในการส่งผ่านค่าเดียวซึ่งก็คือ 6 และจะกำหนดให้กับพารามิเตอร์ a ภายใน sum วิธี.

ผลลัพธ์ของวิธีการข้างต้นจะเป็นค่า 11

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

นอกจากนี้เรายังสามารถเรียกวิธีการรวมโดยการส่ง 2 ค่าในตัวอย่างของเราด้านบนเรากำลังส่ง 2 ค่าจาก 6 ค่าที่สองของ 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 ในวิธีนี้เราใช้คำสั่ง return เพื่อส่งค่า sum ไปยังโปรแกรมหลักที่เรียก เนื่องจากตอนนี้ค่าของเมธอดมีให้สำหรับเมธอดหลักเราจึงใช้ไฟล์println เพื่อแสดงค่าในคอนโซล

ผลลัพธ์ของวิธีการข้างต้นจะเป็นค่า 11

วิธีการอินสแตนซ์

โดยปกติเมธอดจะถูกนำไปใช้ภายในคลาสภายใน Groovy เช่นเดียวกับภาษา Java คลาสไม่ใช่อะไรนอกจากพิมพ์เขียวหรือแม่แบบสำหรับสร้างวัตถุต่าง ๆ ซึ่งกำหนดคุณสมบัติและพฤติกรรมของมัน คลาสอ็อบเจ็กต์แสดงคุณสมบัติและพฤติกรรมที่กำหนดโดยคลาส ดังนั้นพฤติกรรมจึงถูกกำหนดโดยการสร้างวิธีการภายในชั้นเรียน

เราจะเห็นรายละเอียดของคลาสในบทต่อ ๆ ไป แต่ต่อไปนี้เป็นตัวอย่างของการนำเมธอดไปใช้ในคลาส ในตัวอย่างก่อนหน้านี้เราได้กำหนดวิธีการของเราเป็นวิธีการแบบคงที่ซึ่งหมายความว่าเราสามารถเข้าถึงวิธีการเหล่านั้นได้โดยตรงจากคลาส ตัวอย่างถัดไปของวิธีการคือวิธีการอินสแตนซ์ซึ่งวิธีการเข้าถึงได้โดยการสร้างวัตถุของคลาส เราจะเห็นคลาสอีกครั้งในบทต่อไปสำหรับตอนนี้เราจะสาธิตวิธีการใช้งาน

ต่อไปนี้เป็นตัวอย่างวิธีการใช้งาน

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

ในตัวอย่างข้างต้นโปรดทราบว่าคราวนี้เราไม่ได้ระบุแอตทริบิวต์แบบคงที่สำหรับเมธอดคลาสของเรา ในฟังก์ชันหลักของเราเรากำลังสร้างอินสแตนซ์ของคลาสตัวอย่างจากนั้นเรียกใช้เมธอดของอ็อบเจ็กต์ 'ex'

ผลลัพธ์ของวิธีการข้างต้นจะเป็นค่า 100

ชื่อพารามิเตอร์ภายในและภายนอก

Groovy ให้สิ่งอำนวยความสะดวกเช่นเดียวกับ java เพื่อให้มีพารามิเตอร์ท้องถิ่นและทั่วโลก ในตัวอย่างต่อไปนี้lx เป็นพารามิเตอร์โลคัลที่มีขอบเขตเฉพาะภายในฟังก์ชันของ getX() และ xเป็นคุณสมบัติส่วนกลางที่สามารถเข้าถึงได้ภายในคลาสตัวอย่างทั้งหมด ถ้าเราพยายามเข้าถึงตัวแปรlx นอก getX() เราจะได้รับข้อผิดพลาด

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

200 
100

วิธีนี้สำหรับ Properties

เช่นเดียวกับใน 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 จัดเตรียมคลาสที่ง่ายขึ้นเพื่อจัดเตรียมฟังก์ชันต่อไปนี้สำหรับไฟล์

  • การอ่านไฟล์
  • การเขียนไฟล์
  • การข้ามต้นไม้ไฟล์
  • การอ่านและเขียนออบเจ็กต์ข้อมูลลงในไฟล์

นอกจากนี้คุณสามารถใช้คลาส Java ปกติที่แสดงด้านล่างสำหรับการดำเนินการ File I / O ได้ตลอดเวลา

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

การอ่านไฟล์

ตัวอย่างต่อไปนี้จะแสดงบรรทัดทั้งหมดของไฟล์ข้อความใน Groovy วิธีการeachLine ถูกสร้างขึ้นในคลาส File ใน Groovy เพื่อจุดประสงค์ในการตรวจสอบว่าแต่ละบรรทัดของไฟล์ข้อความถูกอ่าน

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

คลาสไฟล์ใช้เพื่อสร้างอินสแตนซ์อ็อบเจ็กต์ใหม่ซึ่งใช้ชื่อไฟล์เป็นพารามิเตอร์ จากนั้นใช้ฟังก์ชันของ eachLine นำไปใส่ตัวแปรที่เรียกว่า line และพิมพ์ตามนั้น

หากไฟล์มีบรรทัดต่อไปนี้ระบบจะพิมพ์

line : Example1
line : Example2

การอ่านเนื้อหาของไฟล์เป็นสตริงทั้งหมด

หากคุณต้องการรับเนื้อหาทั้งหมดของไฟล์เป็นสตริงคุณสามารถใช้คุณสมบัติข้อความของคลาสไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

หากไฟล์มีบรรทัดต่อไปนี้ระบบจะพิมพ์

line : Example1 
line : Example2

การเขียนลงไฟล์

ถ้าคุณต้องการเขียนลงไฟล์คุณต้องใช้คลาสนักเขียนเพื่อส่งออกข้อความไปยังไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

หากคุณเปิดไฟล์ Example.txt คุณจะเห็นคำว่า“ Hello World” พิมพ์อยู่ในไฟล์

การรับขนาดของไฟล์

หากคุณต้องการได้ขนาดของไฟล์คุณสามารถใช้คุณสมบัติความยาวของคลาสไฟล์เพื่อรับขนาดของไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

โค้ดด้านบนจะแสดงขนาดของไฟล์เป็นไบต์

ทดสอบว่าไฟล์เป็นไดเร็กทอรีหรือไม่

หากคุณต้องการดูว่าพา ธ เป็นไฟล์หรือไดเร็กทอรีคุณสามารถใช้ไฟล์ isFile และ isDirectoryตัวเลือกของคลาสไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

รหัสด้านบนจะแสดงผลลัพธ์ต่อไปนี้ -

File? false 
Directory? True

การสร้างไดเรกทอรี

หากคุณต้องการสร้างไดเร็กทอรีใหม่คุณสามารถใช้ไฟล์ mkdirฟังก์ชันของคลาสไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

ไดเร็กทอรี E: \ Directory จะถูกสร้างขึ้นหากไม่มีอยู่

การลบไฟล์

หากคุณต้องการลบไฟล์คุณสามารถใช้ฟังก์ชันลบของคลาสไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

ไฟล์จะถูกลบหากมีอยู่

การคัดลอกไฟล์

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 ฟังก์ชันของคลาสไฟล์

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

ผลลัพธ์อาจแตกต่างกันไปขึ้นอยู่กับไดรฟ์ที่มีอยู่ในเครื่องของคุณ ในเครื่องมาตรฐานผลลัพธ์จะคล้ายกับเครื่องต่อไปนี้ -

C:\ 
D:\

ตัวอย่างต่อไปนี้แสดงวิธีแสดงรายการไฟล์ในไดเร็กทอรีเฉพาะโดยใช้ไฟล์ eachFile ฟังก์ชันของคลาสไฟล์

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

ผลลัพธ์จะแสดงไฟล์ทั้งหมดในไดเร็กทอรี E: \ Temp

หากคุณต้องการแสดงไฟล์ทั้งหมดในไดเร็กทอรีและไดเร็กทอรีย่อยแบบวนซ้ำคุณจะต้องใช้ไฟล์ eachFileRecurseฟังก์ชันของคลาสไฟล์ ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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

เอาต์พุตจะแสดงไฟล์ทั้งหมดในไดเร็กทอรี E: \ Temp และในไดเร็กทอรีย่อยหากมีอยู่

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 ในการทำให้ออบเจ็กต์ทำอะไรบางอย่างเราจำเป็นต้องเรียกใช้หนึ่งในวิธีการที่ประกาศไว้ในคลาสของมัน

Groovy รองรับจำนวนเต็มและตัวเลขทศนิยม

  • จำนวนเต็มคือค่าที่ไม่รวมเศษส่วน
  • ตัวเลขทศนิยมคือค่าทศนิยมที่มีเศษทศนิยม

ตัวอย่างตัวเลขใน Groovy แสดงไว้ด้านล่าง -

Integer x = 5; 
Float y = 1.25;

ที่ไหน x เป็นประเภท Integer และ y คือลอย

สาเหตุที่ตัวเลขใน groovy ถูกกำหนดให้เป็นวัตถุโดยทั่วไปเป็นเพราะมีข้อกำหนดในการดำเนินการกับตัวเลข แนวคิดของการจัดหาคลาสเหนือประเภทดั้งเดิมเรียกว่าคลาส wrapper

โดยดีฟอลต์คลาส wrapper ต่อไปนี้มีให้ใน Groovy

อ็อบเจ็กต์ของคลาส wrapper มีหรือรวมชนิดข้อมูลดั้งเดิมตามลำดับ กระบวนการแปลงชนิดข้อมูลดั้งเดิมเป็นวัตถุเรียกว่าการชกมวยและสิ่งนี้ได้รับการดูแลโดยคอมไพเลอร์ กระบวนการแปลงวัตถุกลับไปเป็นประเภทดั้งเดิมที่สอดคล้องกันเรียกว่าการแกะกล่อง

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการชกมวยและการแกะกล่อง -

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 ค่าจะถูกแยกออกจากประเภทจำนวนเต็ม

วิธีการจำนวน

เนื่องจาก Numbers ใน Groovy แสดงเป็นคลาสต่อไปนี้จึงเป็นรายการวิธีการที่พร้อมใช้งาน

ส. วิธีการและคำอธิบาย
1 xxxValue ()

เมธอดนี้ใช้ Number เป็นพารามิเตอร์และส่งคืนชนิดดั้งเดิมตามวิธีการที่เรียกใช้

2 เปรียบเทียบกับ()

วิธีการ CompareTo คือการใช้เปรียบเทียบหมายเลขหนึ่งกับอีกหมายเลขหนึ่ง สิ่งนี้มีประโยชน์หากคุณต้องการเปรียบเทียบมูลค่าของตัวเลข

3 เท่ากับ ()

วิธีการพิจารณาว่าอ็อบเจ็กต์ Number ที่เรียกใช้เมธอดนั้นเท่ากับอ็อบเจ็กต์ที่ส่งผ่านเป็นอาร์กิวเมนต์หรือไม่

4 มูลค่าของ()

เมธอด valueOf ส่งคืน Number Object ที่เกี่ยวข้องซึ่งถือค่าของอาร์กิวเมนต์ที่ส่งผ่าน

5 toString ()

วิธีนี้ใช้เพื่อรับอ็อบเจ็กต์ String ที่แทนค่าของ Number Object

6 parseInt ()

วิธีนี้ใช้เพื่อรับชนิดข้อมูลดั้งเดิมของสตริงที่กำหนด parseXxx () เป็นวิธีการคงที่และสามารถมีหนึ่งหรือสองอาร์กิวเมนต์

7 เอบีเอส ()

วิธีการให้ค่าสัมบูรณ์ของอาร์กิวเมนต์ อาร์กิวเมนต์สามารถเป็น int, float, long, double, short, byte

8 เพดาน ()

เมธอด ceil ให้จำนวนเต็มที่น้อยที่สุดที่มากกว่าหรือเท่ากับอาร์กิวเมนต์

9 ชั้น ()

พื้นเมธอดให้จำนวนเต็มที่มากที่สุดซึ่งน้อยกว่าหรือเท่ากับอาร์กิวเมนต์

10 รินท์ ()

เมธอด rint จะส่งคืนจำนวนเต็มที่ใกล้เคียงที่สุดของค่ากับอาร์กิวเมนต์

11 รอบ()

รอบเมธอดจะส่งคืนค่า long หรือ int ที่ใกล้เคียงที่สุดตามที่กำหนดโดยประเภทการส่งคืนวิธีการ

12 นาที()

วิธีนี้ทำให้อาร์กิวเมนต์ทั้งสองมีขนาดเล็กลง อาร์กิวเมนต์สามารถเป็น int, float, long, double

13 สูงสุด ()

วิธีนี้ให้อาร์กิวเมนต์สูงสุดสองอาร์กิวเมนต์ อาร์กิวเมนต์สามารถเป็น int, float, long, double

14 ประสบการณ์ ()

เมธอดจะคืนค่าฐานของลอการิทึมธรรมชาติ e ให้เป็นพลังของอาร์กิวเมนต์

15 บันทึก ()

เมธอดจะส่งคืนลอการิทึมธรรมชาติของอาร์กิวเมนต์

16 ธาร ()

เมธอดส่งคืนค่าของอาร์กิวเมนต์แรกยกกำลังของอาร์กิวเมนต์ที่สอง

17 sqrt ()

วิธีนี้จะส่งกลับค่ารากที่สองของอาร์กิวเมนต์

18 บาป()

วิธีการคืนค่าไซน์ของค่าคู่ที่ระบุ

19 cos ()

วิธีนี้จะส่งคืนโคไซน์ของค่าคู่ที่ระบุ

20 ผิวสีแทน ()

วิธีการคืนค่าแทนเจนต์ของค่าคู่ที่ระบุ

21 asin ()

วิธีนี้จะส่งคืนอาร์กไซน์ของค่าคู่ที่ระบุ

22 เอคอส ()

เมธอดจะคืนค่าอาร์คโคซีนของค่าคู่ที่ระบุ

23 atan ()

วิธีการคืนค่าอาร์กแทนเจนต์ของค่าคู่ที่ระบุ

24 atan2 ()

วิธีการแปลงพิกัดสี่เหลี่ยม (x, y) เป็นพิกัดเชิงขั้ว (r, theta) และส่งกลับทีต้า

25 ถึงองศา ()

วิธีการแปลงค่าอาร์กิวเมนต์เป็นองศา

26 เรเดียน()

วิธีการแปลงค่าอาร์กิวเมนต์เป็นเรเดียน

27 สุ่ม ()

วิธีนี้ใช้เพื่อสร้างตัวเลขสุ่มระหว่าง 0.0 ถึง 1.0 ช่วงคือ: 0.0 = <Math.random <1.0 ช่วงที่แตกต่างกันสามารถทำได้โดยใช้เลขคณิต

สตริงลิเทอรัลถูกสร้างขึ้นใน Groovy โดยการใส่ข้อความสตริงในใบเสนอราคา

Groovy มีหลายวิธีในการแสดงถึงตัวอักษรสตริง สตริงใน Groovy สามารถอยู่ในเครื่องหมายคำพูดเดี่ยว (') อัญประกาศคู่ (“) หรือเครื่องหมายคำพูดสามคำ (“””) นอกจากนี้ Groovy String ที่ล้อมรอบด้วยเครื่องหมายคำพูดสามคำอาจครอบคลุมได้หลายบรรทัด

ต่อไปนี้เป็นตัวอย่างของการใช้สตริงใน Groovy -

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

Hello Single 
Hello Double 
'Hello TripleMultiple lines'

การจัดทำดัชนีสตริง

สตริงใน Groovy เป็นลำดับของอักขระ อักขระแต่ละตัวในสตริงสามารถเข้าถึงได้ตามตำแหน่ง สิ่งนี้กำหนดโดยตำแหน่งดัชนี

ดัชนีสตริงเริ่มต้นที่ศูนย์และสิ้นสุดที่หนึ่งน้อยกว่าความยาวของสตริง Groovy ยังอนุญาตให้ดัชนีเชิงลบนับย้อนกลับจากจุดสิ้นสุดของสตริง

ต่อไปนี้เป็นตัวอย่างของการใช้การสร้างดัชนีสตริงใน 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 พวกเขาได้รับด้านล่าง

ส. การทำงานของสตริงและคำอธิบาย
1 การเชื่อมต่อของสองสตริง

การต่อสตริงสามารถทำได้โดยตัวดำเนินการ '+' แบบธรรมดา

2 การทำซ้ำสตริง

การทำซ้ำของสตริงสามารถทำได้โดยตัวดำเนินการ '*' แบบธรรมดา

3 ความยาวสตริง

ความยาวของสตริงที่กำหนดโดยวิธี length () ของสตริง

วิธีการสตริง

นี่คือรายการวิธีการที่คลาส String รองรับ

ส. วิธีการและคำอธิบาย
1 ศูนย์()

ส่งคืนสตริงใหม่ของความยาว numberOfChars ซึ่งประกอบด้วยผู้รับเบาะทางซ้ายและขวาด้วยอักขระเว้นวรรค

2 CompareToIgnoreCase ()

เปรียบเทียบสองสตริงตามศัพท์โดยไม่สนใจความแตกต่างของตัวพิมพ์

3 ประสาน ()

เชื่อมสตริงที่ระบุเข้ากับจุดสิ้นสุดของสตริงนี้

4 แต่ละแมตช์ ()

ประมวลผลแต่ละกลุ่ม regex (ดูหัวข้อถัดไป) ที่จับคู่สตริงย่อยของสตริงที่กำหนด

5 ลงท้ายด้วย()

ทดสอบว่าสตริงนี้ลงท้ายด้วยคำต่อท้ายที่ระบุหรือไม่

6 เท่ากับIgnoreCase ()

เปรียบเทียบสตริงนี้กับสตริงอื่นโดยไม่สนใจการพิจารณากรณี

7 getAt ()

ส่งคืนค่าสตริงที่ตำแหน่งดัชนี

8 indexOf ()

ส่งคืนดัชนีภายในสตริงของการเกิดครั้งแรกของสตริงย่อยที่ระบุ

9 การแข่งขัน ()

แสดงว่าสตริงตรงกับนิพจน์ทั่วไปที่กำหนดหรือไม่

10 ลบ()

ลบส่วนค่าของ String

11 ต่อไป()

เมธอดนี้เรียกโดยตัวดำเนินการ ++ สำหรับคลาส String เพิ่มอักขระสุดท้ายในสตริงที่กำหนด

12 padLeft ()

วางสตริงโดยเว้นวรรคต่อท้ายด้านซ้าย

13 padRight ()

วางสตริงโดยเว้นวรรคต่อท้ายด้านขวา

14 บวก ()

ต่อท้ายสตริง

15 ก่อนหน้า ()

วิธีนี้เรียกโดยตัวดำเนินการ - สำหรับ CharSequence

16 แทนที่ทั้งหมด()

แทนที่เหตุการณ์ที่เกิดขึ้นทั้งหมดของกลุ่มที่บันทึกโดยผลของการปิดข้อความนั้น

17 ย้อนกลับ ()

สร้างสตริงใหม่ซึ่งเป็นสิ่งที่ตรงกันข้ามกับสตริงนี้

18 แยก ()

แยกสตริงนี้รอบการแข่งขันของนิพจน์ทั่วไปที่กำหนด

19 subString ()

ส่งคืนสตริงใหม่ที่เป็นสตริงย่อยของสตริงนี้

20 toUpperCase ()

แปลงอักขระทั้งหมดในสตริงนี้เป็นตัวพิมพ์ใหญ่

21 toLowerCase ()

แปลงอักขระทั้งหมดในสตริงนี้เป็นตัวพิมพ์เล็ก

ช่วงคือชวเลขสำหรับระบุลำดับของค่า ช่วงจะแสดงด้วยค่าแรกและค่าสุดท้ายในลำดับและช่วงสามารถรวมหรือเอกสิทธิ์ได้ ช่วงรวมรวมค่าทั้งหมดตั้งแต่ค่าแรกถึงค่าสุดท้ายในขณะที่ช่วงพิเศษจะรวมค่าทั้งหมดยกเว้นค่าสุดท้าย นี่คือตัวอย่างบางส่วนของ Range literals -

  • 1..10 - ตัวอย่างของช่วงรวม
  • 1 .. <10 - ตัวอย่างของช่วงพิเศษ
  • 'a' .. 'x' - ช่วงยังสามารถประกอบด้วยอักขระ
  • 10..1 - ช่วงสามารถเรียงลำดับจากมากไปหาน้อยได้เช่นกัน
  • 'x' .. 'a' - ช่วงยังสามารถประกอบด้วยอักขระและเรียงลำดับจากมากไปหาน้อย

ต่อไปนี้เป็นวิธีการต่างๆสำหรับช่วง

ซีเนียร์ วิธีการและคำอธิบาย
1 ประกอบด้วย ()

ตรวจสอบว่าช่วงมีค่าเฉพาะหรือไม่

2 รับ ()

ส่งคืนองค์ประกอบที่ตำแหน่งที่ระบุในช่วงนี้

3 getFrom ()

รับค่าที่ต่ำกว่าของช่วงนี้

4 ได้รับการ, ได้รับการกระทำ()

รับค่าสูงสุดของช่วงนี้

5 isReverse ()

นี่คือช่วงที่กลับด้านหรือย้อนกลับ

6 ขนาด()

ส่งคืนจำนวนองค์ประกอบในช่วงนี้

7 รายการย่อย ()

ส่งกลับมุมมองของส่วนของช่วงนี้ระหว่างที่ระบุ fromIndex, inclusive และ toIndex, exclusive

รายการเป็นโครงสร้างที่ใช้ในการจัดเก็บชุดข้อมูล ใน Groovy รายการจะมีลำดับของการอ้างอิงวัตถุ การอ้างอิงวัตถุในรายการครอบครองตำแหน่งในลำดับและแยกความแตกต่างด้วยดัชนีจำนวนเต็ม ลิเทอรัลลิสต์จะแสดงเป็นชุดของอ็อบเจ็กต์ที่คั่นด้วยคอมมาและอยู่ในวงเล็บเหลี่ยม

ในการประมวลผลข้อมูลในรายการเราต้องสามารถเข้าถึงแต่ละองค์ประกอบได้ Groovy Lists จัดทำดัชนีโดยใช้ตัวดำเนินการจัดทำดัชนี [] ดัชนีรายการเริ่มต้นที่ศูนย์ซึ่งหมายถึงองค์ประกอบแรก

ต่อไปนี้เป็นตัวอย่างรายการ -

  • [11, 12, 13, 14] - รายการค่าจำนวนเต็ม
  • ['Angular', 'Groovy', 'Java'] - รายการสตริง
  • [1, 2, [3, 4], 5] - รายการที่ซ้อนกัน
  • ['Groovy', 21, 2.11] - รายการอ้างอิงออบเจ็กต์ที่แตกต่างกัน
  • [] - รายการว่างเปล่า

ในบทนี้เราจะพูดถึงวิธีการแสดงรายการที่มีอยู่ใน Groovy

ซีเนียร์ วิธีการและคำอธิบาย
1 เพิ่ม()

ต่อท้ายค่าใหม่ต่อท้ายรายการนี้

2 ประกอบด้วย ()

ส่งคืนจริงหากรายการนี้มีค่าที่ระบุ

3 รับ ()

ส่งคืนองค์ประกอบที่ตำแหน่งที่ระบุในรายการนี้

4 มันว่างเปล่า()

ส่งคืนจริงหากรายการนี้ไม่มีองค์ประกอบ

5 ลบ()

สร้างรายการใหม่ที่ประกอบด้วยองค์ประกอบของต้นฉบับโดยไม่ได้ระบุไว้ในคอลเล็กชัน

6 บวก ()

สร้างรายการใหม่ที่ประกอบด้วยองค์ประกอบของต้นฉบับพร้อมกับที่ระบุในคอลเลกชัน

7 ป๊อป ()

ลบรายการสุดท้ายออกจากรายการนี้

8 ลบ ()

ลบองค์ประกอบในตำแหน่งที่ระบุในรายการนี้

9 ย้อนกลับ ()

สร้างรายการใหม่ที่ย้อนกลับองค์ประกอบของรายการเดิม

10 ขนาด()

รับจำนวนองค์ประกอบในรายการนี้

11 เรียงลำดับ ()

ส่งคืนสำเนาที่เรียงลำดับของรายการต้นฉบับ

แผนที่ (หรือเรียกอีกอย่างว่าอาร์เรย์เชื่อมโยงพจนานุกรมตารางและแฮช) คือชุดการอ้างอิงวัตถุที่ไม่เรียงลำดับ องค์ประกอบในคอลเล็กชันแผนที่เข้าถึงได้โดยค่าคีย์ คีย์ที่ใช้ในแผนที่สามารถเป็นคลาสใดก็ได้ เมื่อเราแทรกลงในคอลเลคชันแผนที่จำเป็นต้องมีค่าสองค่าคือคีย์และค่า

ต่อไปนี้เป็นตัวอย่างแผนที่ -

  • ['TopicName': 'Lists', 'TopicName': 'Maps'] - คอลเลกชันของคู่ค่าคีย์ที่มี TopicName เป็นคีย์และค่าตามลำดับ

  • [:] - แผนที่ว่างเปล่า

ในบทนี้เราจะพูดถึงวิธีการแผนที่ที่มีใน Groovy

ซีเนียร์ วิธีการและคำอธิบาย
1 ประกอบด้วยคีย์ ()

แผนที่นี้มีคีย์นี้หรือไม่

2 รับ ()

ค้นหาคีย์ในแผนที่นี้และส่งคืนค่าที่เกี่ยวข้อง หากไม่มีรายการในแผนที่นี้สำหรับคีย์ให้คืนค่า null

3 ชุดคีย์ ()

รับชุดกุญแจในแผนที่นี้

4 ใส่ ()

เชื่อมโยงค่าที่ระบุกับคีย์ที่ระบุในแผนที่นี้ หากแผนที่นี้ก่อนหน้านี้มีการแม็พสำหรับคีย์นี้ค่าเก่าจะถูกแทนที่ด้วยค่าที่ระบุ

5 ขนาด()

ส่งคืนจำนวนการแมปคีย์ - ค่าในแผนที่นี้

6 ค่า ()

ส่งคืนมุมมองคอลเลกชันของค่าที่มีอยู่ในแผนที่นี้

วันที่ของคลาสแสดงถึงช่วงเวลาที่เฉพาะเจาะจงโดยมีความแม่นยำระดับมิลลิวินาที คลาส Date มีตัวสร้างสองตัวดังที่แสดงด้านล่าง

วันที่ ()

ไวยากรณ์

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

มิลลิวินาที - จำนวนมิลลิวินาทีที่จะระบุตั้งแต่เวลาฐานมาตรฐาน

Return Value - จัดสรรก Date วัตถุและเริ่มต้นเพื่อแสดงจำนวนมิลลิวินาทีที่ระบุตั้งแต่เวลาฐานมาตรฐานที่เรียกว่า "ยุค" คือ 1 มกราคม 1970 00:00:00 GMT

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของการใช้วิธีนี้ -

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

Thu Jan 01 04:00:00 GST 1970

ต่อไปนี้เป็นวิธีการที่กำหนดของคลาส Date ในวิธีการทั้งหมดของคลาส Date ที่ยอมรับหรือคืนค่าปีเดือนวันที่ชั่วโมงนาทีและวินาทีจะใช้การแทนค่าต่อไปนี้ -

  • ปี y แสดงด้วยจำนวนเต็ม y - 1900

  • เดือนแสดงด้วยจำนวนเต็มตั้งแต่ 0 ถึง 11 0 คือมกราคม 1 กุมภาพันธ์และอื่น ๆ ดังนั้นวันที่ 11 ธันวาคม

  • วันที่ (วันของเดือน) แสดงด้วยจำนวนเต็มตั้งแต่ 1 ถึง 31 ในลักษณะปกติ

  • ชั่วโมงแสดงด้วยจำนวนเต็มตั้งแต่ 0 ถึง 23 ดังนั้นชั่วโมงตั้งแต่เที่ยงคืนถึง 01.00 น. คือชั่วโมง 0 และชั่วโมงจากเที่ยงถึง 13.00 น. คือชั่วโมง 12

  • นาทีแสดงด้วยจำนวนเต็มตั้งแต่ 0 ถึง 59 ในลักษณะปกติ

  • วินาทีแทนด้วยจำนวนเต็มตั้งแต่ 0 ถึง 61

ซีเนียร์ วิธีการและคำอธิบาย
1 หลังจาก()

ทดสอบว่าวันนี้อยู่หลังวันที่ระบุหรือไม่

2 เท่ากับ ()

เปรียบเทียบวันที่สองวันเพื่อความเท่าเทียมกัน ผลลัพธ์จะเป็นจริงก็ต่อเมื่ออาร์กิวเมนต์ไม่เป็นโมฆะและเป็นอ็อบเจ็กต์ Date ที่แสดงถึงจุดเวลาเดียวกันเป็นมิลลิวินาทีเป็นอ็อบเจ็กต์นี้

3 เปรียบเทียบกับ()

เปรียบเทียบสองวันสำหรับการสั่งซื้อ

4 toString ()

แปลงวัตถุ Date นี้เป็น String

5 ก่อน()

ทดสอบว่าวันนี้อยู่ก่อนวันที่ระบุหรือไม่

6 getTime ()

ส่งคืนจำนวนมิลลิวินาทีตั้งแต่วันที่ 1 มกราคม 1970 00:00:00 GMT แทนด้วยวัตถุ Date นี้

7 ตั้งเวลา()

ตั้งค่าออบเจ็กต์ Date นี้เพื่อแทนจุดในเวลาซึ่งเป็นมิลลิวินาทีของเวลาหลังจากวันที่ 1 มกราคม 1970 00:00:00 GMT

นิพจน์ทั่วไปคือรูปแบบที่ใช้เพื่อค้นหาสตริงย่อยในข้อความ Groovy รองรับนิพจน์ทั่วไปโดยใช้นิพจน์ ~” regex” ข้อความที่อยู่ในใบเสนอราคาแสดงถึงนิพจน์สำหรับการเปรียบเทียบ

ตัวอย่างเช่นเราสามารถสร้างวัตถุนิพจน์ทั่วไปดังที่แสดงด้านล่าง -

def regex = ~'Groovy'

เมื่อตัวดำเนินการ Groovy = ~ ปรากฏเป็นเพรดิเคต (นิพจน์ที่ส่งคืนบูลีน) ใน if และ whileคำสั่ง (ดูบทที่ 8) ตัวถูกดำเนินการสตริงทางด้านซ้ายจะจับคู่กับตัวถูกดำเนินการนิพจน์ทั่วไปทางด้านขวา ดังนั้นสิ่งต่อไปนี้จึงให้ค่าเป็นจริง

เมื่อกำหนดนิพจน์ทั่วไปสามารถใช้อักขระพิเศษต่อไปนี้ -

  • มีอักขระตำแหน่งพิเศษสองตัวที่ใช้เพื่อแสดงจุดเริ่มต้นและจุดสิ้นสุดของบรรทัด: คาเร็ต (∧) และเครื่องหมายดอลลาร์ ($)

  • นิพจน์ทั่วไปยังสามารถรวมตัวระบุปริมาณ เครื่องหมายบวก (+) แทนหนึ่งครั้งขึ้นไปซึ่งใช้กับองค์ประกอบก่อนหน้าของนิพจน์ เครื่องหมายดอกจัน (*) ใช้เพื่อแสดงถึงเหตุการณ์ที่เกิดขึ้นเป็นศูนย์หรือมากกว่า เครื่องหมายคำถาม (?) หมายถึงศูนย์หรือครั้งเดียว

  • metacharacter {and} ใช้เพื่อจับคู่อินสแตนซ์จำนวนเฉพาะของอักขระที่อยู่ข้างหน้า

  • ในนิพจน์ทั่วไปสัญลักษณ์จุด (.) สามารถแทนอักขระใดก็ได้ สิ่งนี้อธิบายว่าเป็นอักขระตัวแทน

  • นิพจน์ทั่วไปอาจรวมถึงคลาสอักขระ ชุดอักขระสามารถกำหนดให้เป็นลำดับของอักขระที่อยู่ในอักขระเมตาคาแร็กเตอร์ [และ] เช่นเดียวกับ [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 - คลาสที่ขยายคลาส Throwable ยกเว้น RuntimeException และ Error เรียกว่าข้อยกเว้นที่ตรวจสอบเช่น EGIOException, SQLException เป็นต้นข้อยกเว้นที่ตรวจสอบจะถูกตรวจสอบในเวลาคอมไพล์

กรณีคลาสสิกหนึ่งคือ FileNotFoundException สมมติว่าคุณมีโค้ดต่อไปนี้ในแอปพลิเคชันของคุณซึ่งอ่านจากไฟล์ในไดรฟ์ E

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

หากไม่มีไฟล์ (file.txt) ในไดรฟ์ E ข้อยกเว้นต่อไปนี้จะถูกเพิ่มขึ้น

Caught: java.io.FileNotFoundException: E: \ file.txt (ระบบไม่พบไฟล์ที่ระบุ)

java.io.FileNotFoundException: E: \ file.txt (ระบบไม่พบไฟล์ที่ระบุ)

  • Unchecked Exception - คลาสที่ขยาย RuntimeException เรียกว่าข้อยกเว้นที่ไม่ได้ตรวจสอบเช่น ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException เป็นต้นข้อยกเว้นที่ไม่ได้ตรวจสอบจะไม่ถูกตรวจสอบในเวลาคอมไพล์ แต่จะถูกตรวจสอบที่รันไทม์

กรณีคลาสสิกอย่างหนึ่งคือ ArrayIndexOutOfBoundsException ซึ่งเกิดขึ้นเมื่อคุณพยายามเข้าถึงดัชนีของอาร์เรย์ที่มากกว่าความยาวของอาร์เรย์ ต่อไปนี้เป็นตัวอย่างทั่วไปของความผิดพลาดประเภทนี้

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

เมื่อรหัสข้างต้นถูกเรียกใช้ข้อยกเว้นต่อไปนี้จะถูกเพิ่มขึ้น

จับ: java.lang.ArrayIndexOutOfBoundsException: 5

java.lang.ArrayIndexOutOfBoundsException: 5

  • Error - ข้อผิดพลาดไม่สามารถกู้คืนได้เช่น OutOfMemoryError, VirtualMachineError, AssertionError เป็นต้น

นี่เป็นข้อผิดพลาดที่โปรแกรมไม่สามารถกู้คืนได้และจะทำให้โปรแกรมหยุดทำงาน

แผนภาพต่อไปนี้แสดงวิธีการจัดลำดับชั้นของข้อยกเว้นใน 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

จากรหัสด้านบนเราสรุปรหัสที่ผิดพลาดในบล็อกลอง ในบล็อก catch เราเพิ่งตรวจจับข้อยกเว้นของเราและแสดงข้อความว่ามีข้อยกเว้นเกิดขึ้น

หลาย Catch Blocks

หนึ่งสามารถมีหลายบล็อกเพื่อจัดการกับข้อยกเว้นหลายประเภท สำหรับแต่ละบล็อกจับขึ้นอยู่กับประเภทของข้อยกเว้นที่เพิ่มขึ้นคุณจะเขียนโค้ดเพื่อจัดการตามนั้น

มาแก้ไขโค้ดด้านบนของเราเพื่อจับ 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 catch block ถูกจับได้ก่อนเพราะมันหมายถึงเกณฑ์ของข้อยกเว้น

สุดท้ายบล็อก

finallyบล็อกเป็นไปตามบล็อกลองหรือบล็อกจับ ในที่สุดบล็อกโค้ดจะดำเนินการเสมอโดยไม่คำนึงถึงการเกิดข้อยกเว้น

การใช้บล็อกในที่สุดช่วยให้คุณสามารถเรียกใช้คำสั่งประเภทการล้างข้อมูลที่คุณต้องการดำเนินการได้ไม่ว่าจะเกิดอะไรขึ้นในรหัสที่ได้รับการป้องกัน ไวยากรณ์สำหรับบล็อกนี้แสดงไว้ด้านล่าง

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

มาแก้ไขโค้ดด้านบนของเราและเพิ่มบล็อคโค้ดในที่สุด ต่อไปนี้เป็นข้อมูลโค้ด

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

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

ต่อไปนี้เป็นวิธีการยกเว้นที่มีอยู่ใน Groovy -

String สาธารณะ getMessage ()

ส่งคืนข้อความโดยละเอียดเกี่ยวกับข้อยกเว้นที่เกิดขึ้น ข้อความนี้เริ่มต้นในตัวสร้าง Throwable

getCause สาธารณะโยนได้ ()

ส่งคืนสาเหตุของข้อยกเว้นที่แสดงโดยวัตถุ Throwable

สาธารณะ String toString ()

ส่งคืนชื่อของคลาสที่เชื่อมต่อกับผลลัพธ์ของ getMessage ()

โมฆะสาธารณะ printStackTrace ()

พิมพ์ผลลัพธ์ของ toString () พร้อมกับการติดตามสแต็กไปยัง System.err สตรีมเอาต์พุตข้อผิดพลาด

StackTraceElement สาธารณะ [] getStackTrace ()

ส่งคืนอาร์เรย์ที่มีแต่ละองค์ประกอบในการติดตามสแต็ก องค์ประกอบที่ดัชนี 0 แสดงถึงด้านบนสุดของ call stack และองค์ประกอบสุดท้ายในอาร์เรย์แสดงถึงวิธีการที่ด้านล่างของ call stack

สาธารณะ 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 ซึ่งมีสองช่อง -StudentID และ StudentName. ในฟังก์ชันหลักเรากำลังสร้างออบเจ็กต์ของคลาสนี้และกำหนดค่าให้กับStudentID และ StudentName ของวัตถุ

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

วิธี getter และ setter

ในภาษาการเขียนโปรแกรมใด ๆ การซ่อนสมาชิกอินสแตนซ์ด้วยคีย์เวิร์ดส่วนตัวมักเป็นวิธีปฏิบัติและให้เมธอด 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 อินสแตนซ์ตัวอย่างเช่นเมธอด - โมฆะ setStudentName (สตริง 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

มรดก

การสืบทอดสามารถกำหนดเป็นกระบวนการที่คลาสหนึ่งได้รับคุณสมบัติ (วิธีการและฟิลด์) ของอีกคลาสหนึ่ง ด้วยการใช้มรดกข้อมูลจะถูกจัดการได้ตามลำดับชั้น

คลาสที่สืบทอดคุณสมบัติของอื่น ๆ เรียกว่าคลาสย่อย (คลาสที่ได้รับคลาสย่อย) และคลาสที่มีคุณสมบัติสืบทอดเรียกว่าซูเปอร์คลาส (คลาสพื้นฐานคลาสพาเรนต์)

ขยาย

extendsคือคีย์เวิร์ดที่ใช้สืบทอดคุณสมบัติของคลาส ด้านล่างเป็นไวยากรณ์ของคำหลักขยาย ในตัวอย่างต่อไปนี้เรากำลังทำสิ่งต่อไปนี้ -

  • การสร้างคลาสที่เรียกว่าบุคคล คลาสนี้มีสมาชิกอินสแตนซ์หนึ่งชื่อเรียกว่าชื่อ

  • การสร้างคลาสที่เรียกว่า Student ซึ่งขยายมาจากคลาส Person โปรดสังเกตว่าสมาชิกอินสแตนซ์ชื่อที่กำหนดไว้ในคลาส Person จะได้รับการสืบทอดในคลาส Student

  • ในตัวสร้างคลาสนักเรียนเรากำลังเรียกตัวสร้างคลาสพื้นฐาน

  • ในชั้นเรียนนักเรียนของเราเรากำลังเพิ่มสมาชิกอีก 2 อินสแตนซ์ของ StudentID และ Marks1

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 ซึ่งจะเป็นคลาสชั้นนอกของเรา
  • การกำหนดสตริงที่เรียกว่าชื่อในคลาสชั้นนอกของเรา
  • การสร้างคลาสภายในหรือชั้นที่ซ้อนกันภายในคลาสชั้นนอกของเรา
  • โปรดสังเกตว่าในคลาสภายในเราสามารถเข้าถึงสมาชิกอินสแตนซ์ชื่อที่กำหนดไว้ในคลาสชั้นนอก
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

คลาสนามธรรม

คลาสนามธรรมแสดงถึงแนวคิดทั่วไปดังนั้นจึงไม่สามารถสร้างอินสแตนซ์ได้ถูกสร้างขึ้นเพื่อเป็นคลาสย่อย สมาชิกของพวกเขารวมถึงสาขา / คุณสมบัติและวิธีนามธรรมหรือรูปธรรม วิธีการนามธรรมไม่มีการนำไปใช้และต้องดำเนินการโดยคลาสย่อยที่เป็นรูปธรรม คลาสบทคัดย่อต้องประกาศด้วยคีย์เวิร์ดนามธรรม วิธีการบทคัดย่อจะต้องประกาศด้วยคำสำคัญที่เป็นนามธรรม

ในตัวอย่างต่อไปนี้โปรดทราบว่าคลาส 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

อินเทอร์เฟซ

อินเทอร์เฟซกำหนดสัญญาที่คลาสต้องปฏิบัติตาม อินเทอร์เฟซกำหนดรายการวิธีการที่จำเป็นต้องดำเนินการเท่านั้น แต่ไม่ได้กำหนดการใช้งานวิธีการ ต้องมีการประกาศอินเทอร์เฟซโดยใช้คีย์เวิร์ดของอินเทอร์เฟซ อินเทอร์เฟซกำหนดเฉพาะลายเซ็นของวิธีการ วิธีการของอินเทอร์เฟซอยู่เสมอ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

Generics เปิดใช้งานประเภท (คลาสและอินเทอร์เฟซ) เป็นพารามิเตอร์เมื่อกำหนดคลาสอินเตอร์เฟสและวิธีการ เช่นเดียวกับพารามิเตอร์ที่เป็นทางการที่คุ้นเคยมากขึ้นซึ่งใช้ในการประกาศวิธีการพารามิเตอร์ประเภทเป็นวิธีที่ให้คุณใช้รหัสเดิมซ้ำกับอินพุตที่แตกต่างกันได้ ความแตกต่างคืออินพุตไปยังพารามิเตอร์ที่เป็นทางการคือค่าในขณะที่อินพุตเพื่อพิมพ์พารามิเตอร์เป็นประเภท

ทั่วไปสำหรับคอลเล็กชัน

คลาสคอลเลกชันเช่นคลาสรายการสามารถเป็นแบบทั่วไปเพื่อให้ยอมรับเฉพาะคอลเลกชันประเภทนั้นในแอปพลิเคชัน ตัวอย่างของ ArrayList ทั่วไปแสดงอยู่ด้านล่าง สิ่งที่คำสั่งต่อไปนี้ทำคือยอมรับเฉพาะรายการที่เป็นสตริงชนิด -

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

In the following code example, we are doing the following −

  • Creating a Generalized ArrayList collection which will hold only Strings.
  • Add 3 strings to the list.
  • For each item in the list, printing the value of the strings.
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);
      }
   } 
}

The output of the above program would be −

First String 
Second String 
Third String

Generalized Classes

The entire class can also be generalized. This makes the class more flexible in accepting any types and working accordingly with those types. Let’s look at an example of how we can accomplish this.

In the following program, we are carrying out the following steps −

  • We are creating a class called ListType. Note the <T> keywords placed in front of the class definition. This tells the compiler that this class can accept any type. So when we declare an object of this class, we can specify a type during the the declaration and that type would be replaced in the placeholder <T>

  • The generic class has simple getter and setter methods to work with the member variable defined in the class.

  • In the main program, notice that we are able to declare objects of the ListType class, but of different types. The first one is of the type Integer and the second one is of the type String.

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

The output of the above program would be −

First String 
1

Traits are a structural construct of the language which allow −

  • Composition of behaviors.
  • Runtime implementation of interfaces.
  • Compatibility with static type checking/compilation

They can be seen as interfaces carrying both default implementations and state. A trait is defined using the trait keyword.

An example of a trait is given below −

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

One can then use the implement keyword to implement the trait in the similar way as interfaces.

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

Implementing Interfaces

Traits may implement interfaces, in which case the interfaces are declared using the implements keyword.

An example of a trait implementing an interface is given below. In the following example the following key points can be noted.

  • An interface Total is defined with the method DisplayTotal.

  • The trait Marks implements the Total interface and hence needs to provide an implementation for the DisplayTotal method.

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

The output of the above program would be −

Display Marks 
Display Total

Properties

A trait may define properties. An example of a trait with a property is given below.

In the following example, the Marks1 of type integer is a property.

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

The output of the above program would be −

10 
Display Total

Composition of Behaviors

Traits can be used to implement multiple inheritance in a controlled way, avoiding the diamond issue. In the following code example, we have defined two traits – Marks and Total. Our Student class implements both traits. Since the student class extends both traits, it is able to access the both of the methods – DisplayMarks and 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 
}

The output of the above program would be −

Total 
Marks1

Extending Traits

Traits may extend another trait, in which case you must use the extends keyword. In the following code example, we are extending the Total trait with the Marks trait.

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 
}

The output of the above program would be −

Total

A closure is a short anonymous block of code. It just normally spans a few lines of code. A method can even take the block of code as a parameter. They are anonymous in nature.

Following is an example of a simple closure and what it looks like.

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

In the above example, the code line - {println "Hello World"} is known as a closure. The code block referenced by this identifier can be executed with the call statement.

When we run the above program, we will get the following result −

Hello World

Formal parameters in closures

Closures can also contain formal parameters to make them more useful just like methods in Groovy.

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

ในตัวอย่างโค้ดด้านบนให้สังเกตการใช้ $ {param} ซึ่งทำให้การปิดรับพารามิเตอร์ เมื่อเรียกการปิดโดยใช้คำสั่ง closed.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 เมธอด inbuilt จำนวนมากสำหรับชนิดข้อมูลเช่นรายการและคอลเลคชันมีการปิดเป็นชนิดพารามิเตอร์

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถส่งการปิดไปยังเมธอดเป็นพารามิเตอร์ได้อย่างไร

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 ซึ่งใช้การปิดเป็นอาร์กิวเมนต์

  • จากนั้นเราจะกำหนดการปิดในวิธีการหลักของเราและส่งต่อไปยังวิธีการแสดงผลของเราเป็นพารามิเตอร์

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

Hello World 
Welcome World 
Welcome Inner

การปิดในคอลเลกชันและสตริง

วิธีการรายการแผนที่และสตริงหลายวิธียอมรับการปิดเป็นอาร์กิวเมนต์ ลองดูตัวอย่างวิธีใช้การปิดในประเภทข้อมูลเหล่านี้

การใช้การปิดกับรายการ

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการปิดสามารถใช้กับรายการได้อย่างไร ในตัวอย่างต่อไปนี้เราจะกำหนดรายการค่าอย่างง่ายก่อน จากนั้นประเภทการรวบรวมรายการจะกำหนดฟังก์ชันที่เรียกว่าeach. ฟังก์ชันนี้ใช้การปิดเป็นพารามิเตอร์และใช้การปิดกับแต่ละองค์ประกอบของรายการ

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

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

11 
12 
13 
14

การใช้การปิดกับแผนที่

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการปิดสามารถใช้กับแผนที่ได้อย่างไร ในตัวอย่างต่อไปนี้เราจะกำหนดแผนผังรายการคีย์ค่าอย่างง่ายก่อน จากนั้นประเภทการรวบรวมแผนที่จะกำหนดฟังก์ชันที่เรียกว่า. 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}
   } 
}

ตัวอย่างข้างต้นแสดงนิพจน์เงื่อนไข if (num% 2 == 0) ที่ใช้ในการปิดซึ่งใช้เพื่อตรวจสอบว่าแต่ละรายการในรายการหารด้วย 2 ได้หรือไม่

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังนี้ -

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

วิธีการที่ใช้กับการปิด

การปิดตัวเองมีวิธีการบางอย่าง

ซีเนียร์ วิธีการและคำอธิบาย
1 หา()

วิธีการค้นหาจะค้นหาค่าแรกในคอลเล็กชันที่ตรงกับบางเกณฑ์

2 ค้นหาทั้งหมด ()

พบว่าค่าทั้งหมดในวัตถุที่รับตรงกับเงื่อนไขการปิด

3 ใด ๆ () และทุก ()

วิธีใด ๆ ที่วนซ้ำผ่านแต่ละองค์ประกอบของคอลเลกชันเพื่อตรวจสอบว่าเพรดิเคตบูลีนใช้ได้กับอย่างน้อยหนึ่งองค์ประกอบหรือไม่

4 เก็บ()

วิธีการรวบรวมวนซ้ำผ่านคอลเลกชันโดยแปลงแต่ละองค์ประกอบเป็นค่าใหม่โดยใช้การปิดเป็นหม้อแปลง

คำอธิบายประกอบเป็นรูปแบบของข้อมูลเมตาโดยให้ข้อมูลเกี่ยวกับโปรแกรมที่ไม่ได้เป็นส่วนหนึ่งของโปรแกรม คำอธิบายประกอบไม่มีผลโดยตรงต่อการทำงานของรหัสที่ใส่คำอธิบายประกอบ

คำอธิบายประกอบส่วนใหญ่จะใช้ด้วยเหตุผลดังต่อไปนี้ -

  • Information for the compiler - คอมไพเลอร์สามารถใช้คำอธิบายประกอบเพื่อตรวจหาข้อผิดพลาดหรือระงับคำเตือน

  • Compile-time and deployment-time processing - เครื่องมือซอฟต์แวร์สามารถประมวลผลข้อมูลคำอธิบายประกอบเพื่อสร้างโค้ดไฟล์ XML และอื่น ๆ

  • Runtime processing - คำอธิบายประกอบบางส่วนสามารถตรวจสอบได้ที่รันไทม์

ใน Groovy คำอธิบายประกอบพื้นฐานมีลักษณะดังนี้ -

@interface - อักขระเครื่องหมาย at (@) บ่งชี้ให้คอมไพเลอร์ทราบว่าสิ่งที่ตามมาคือคำอธิบายประกอบ

คำอธิบายประกอบอาจกำหนดสมาชิกใน the form ของวิธีการที่ไม่มีร่างกายและค่าเริ่มต้นที่เป็นทางเลือก

คำอธิบายประกอบสามารถใช้ได้กับประเภทต่อไปนี้ -

ประเภทสตริง

ตัวอย่างของคำอธิบายประกอบสำหรับสตริงมีให้ด้านล่าง -

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

ประเภท Enum

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

ประเภทชั้นเรียน

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

คำอธิบายประกอบค่าสมาชิก

เมื่อใช้คำอธิบายประกอบจำเป็นต้องตั้งค่าสมาชิกอย่างน้อยทั้งหมดที่ไม่มีค่าเริ่มต้น ตัวอย่างได้รับด้านล่าง เมื่อใช้ตัวอย่างคำอธิบายประกอบหลังจากกำหนดแล้วจำเป็นต้องมีค่าที่กำหนดให้

@interface Example {
   int status() 
}

@Example(status = 1)

พารามิเตอร์คำอธิบายประกอบการปิด

คุณลักษณะที่ดีของคำอธิบายประกอบใน Groovy คือคุณสามารถใช้การปิดเป็นค่าคำอธิบายประกอบได้เช่นกัน ดังนั้นคำอธิบายประกอบจึงสามารถใช้ได้กับนิพจน์ที่หลากหลาย

ตัวอย่างได้รับด้านล่างนี้ คำอธิบายประกอบ Onlyif ถูกสร้างขึ้นตามค่าคลาส จากนั้นคำอธิบายประกอบจะถูกนำไปใช้กับสองวิธีที่โพสต์ข้อความที่แตกต่างกันไปยังตัวแปรผลลัพธ์ตามค่าของตัวแปรตัวเลข

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

ในกรณีนี้คุณสามารถกำหนด meta-annotation ซึ่งรวมคำอธิบายประกอบหลาย ๆ รายการเข้าด้วยกันและใช้ meta annotation กับวิธี ดังนั้นสำหรับตัวอย่างข้างต้นคุณสามารถกำหนดคอลเลกชันของคำอธิบายประกอบโดยใช้ AnnotationCollector

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

เมื่อเสร็จแล้วคุณสามารถใช้ meta-annotator ต่อไปนี้กับวิธีการ -

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

XML เป็นภาษาโอเพ่นซอร์สแบบพกพาที่ช่วยให้โปรแกรมเมอร์สามารถพัฒนาแอปพลิเคชันที่แอปพลิเคชันอื่นสามารถอ่านได้โดยไม่คำนึงถึงระบบปฏิบัติการและ / หรือภาษาพัฒนาการ นี่เป็นหนึ่งในภาษาทั่วไปที่ใช้ในการแลกเปลี่ยนข้อมูลระหว่างแอปพลิเคชัน

XML คืออะไร?

Extensible Markup Language XML เป็นภาษามาร์กอัปเหมือนกับ HTML หรือ SGML สิ่งนี้แนะนำโดย World Wide Web Consortium และพร้อมใช้งานในรูปแบบมาตรฐานเปิด XML มีประโยชน์อย่างยิ่งสำหรับการติดตามข้อมูลจำนวนน้อยถึงปานกลางโดยไม่ต้องใช้แบ็คโบน SQLbased

รองรับ XML ใน Groovy

ภาษา Groovy ยังให้การสนับสนุนภาษา XML ที่หลากหลาย คลาส XML พื้นฐานที่สุดสองคลาสที่ใช้คือ -

  • XML Markup Builder- Groovy รองรับตัวสร้างมาร์กอัปแบบต้นไม้ BuilderSupport ซึ่งสามารถแบ่งเป็นคลาสย่อยเพื่อสร้างการแสดงวัตถุที่มีโครงสร้างแบบต้นไม้ได้หลากหลาย โดยทั่วไปตัวสร้างเหล่านี้ใช้เพื่อแสดงมาร์กอัป XML มาร์กอัป HTML ตัวสร้างมาร์กอัปของ Groovy จับการเรียกไปยังวิธีปลอมและแปลงเป็นองค์ประกอบหรือโหนดของโครงสร้างต้นไม้ พารามิเตอร์ของ pseudomethods เหล่านี้ถือเป็นแอตทริบิวต์ของโหนด การปิดเป็นส่วนหนึ่งของการเรียกใช้เมธอดถือเป็นเนื้อหาย่อยที่ซ้อนกันสำหรับโหนดต้นไม้ที่เป็นผลลัพธ์

  • 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 ด้านบน -

import groovy.xml.MarkupBuilder 

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

ในตัวอย่างข้างต้นต้องสังเกตสิ่งต่อไปนี้ -

  • mB.collection() - นี่คือตัวสร้างมาร์กอัปที่สร้างแท็ก XML ส่วนหัวของ <collection> </collection>

  • movie(title : 'Enemy Behind')- หลอกเหล่านี้สร้างแท็กลูกด้วยวิธีนี้สร้างแท็กด้วยค่า โดยการระบุค่าที่เรียกว่า title สิ่งนี้บ่งชี้ว่าต้องสร้างแอตทริบิวต์สำหรับองค์ประกอบ

  • การปิดถูกจัดเตรียมไว้ให้กับวิธีปลอมเพื่อสร้างองค์ประกอบที่เหลือของเอกสาร 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

  • สำหรับองค์ประกอบภาพยนตร์แต่ละรายการเราใช้การปิดเพื่อเรียกดูโหนดลูกแต่ละโหนดและแสดงข้อมูลที่เกี่ยวข้อง

สำหรับองค์ประกอบภาพยนตร์เราใช้สัญลักษณ์ @ เพื่อแสดงแอตทริบิวต์ title ที่แนบมากับองค์ประกอบภาพยนตร์

JMX เป็นมาตรฐาน defacto ซึ่งใช้สำหรับการมอนิเตอร์แอพพลิเคชั่นทั้งหมดที่เกี่ยวข้องกับสภาพแวดล้อมของ Java virual เนื่องจาก Groovy ตั้งอยู่บน Java โดยตรง Groovy สามารถใช้ประโยชน์จากงานจำนวนมหาศาลที่ทำไปแล้วสำหรับ JMX ด้วย Java

การตรวจสอบ JVM

เราสามารถใช้คลาสมาตรฐานที่มีอยู่ใน java.lang.management เพื่อดำเนินการมอนิเตอร์ JVM ตัวอย่างโค้ดต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร

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 เพื่อค้นหา MBeans ที่มีอยู่ใน Tomcat ที่รันอยู่กำหนดโมดูลเว็บและแยกเวลาในการประมวลผลสำหรับแต่ละโมดูลเว็บ

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

ซีเนียร์ No ฟังก์ชันและไลบรารี
1

JsonSlurper

JsonSlurper เป็นคลาสที่แยกวิเคราะห์ข้อความ JSON หรือเนื้อหาผู้อ่านเป็นข้อมูล Groovy

โครงสร้างเช่นแผนที่รายการและประเภทดั้งเดิมเช่น Integer, Double, Boolean และ String

2

JsonOutput

วิธีนี้รับผิดชอบในการต่ออนุกรมวัตถุ Groovy เป็นสตริง JSON

การแยกวิเคราะห์ข้อมูลโดยใช้ JsonSlurper

JsonSlurper เป็นคลาสที่แยกวิเคราะห์ข้อความ JSON หรือเนื้อหาผู้อ่านลงในโครงสร้างข้อมูล Groovy เช่นแผนที่รายการและประเภทดั้งเดิมเช่น Integer, Double, Boolean และ String

ไวยากรณ์

def slurper = new JsonSlurper()

JSON slurper แยกวิเคราะห์ข้อความหรือเนื้อหาของผู้อ่านในโครงสร้างข้อมูลของรายการและแผนที่

คลาส JsonSlurper มาพร้อมกับตัวแปรสองสามตัวสำหรับการใช้งานตัวแยกวิเคราะห์ บางครั้งคุณอาจมีข้อกำหนดที่แตกต่างกันเมื่อต้องแยกวิเคราะห์สตริงบางอย่าง ลองมาดูตัวอย่างที่เราต้องอ่าน JSON ซึ่งส่งคืนจากการตอบสนองจากเว็บเซิร์ฟเวอร์ ในกรณีนี้คุณควรใช้ตัวแปร JsonParserLax ตัวแยกวิเคราะห์ พาร์ซีนี้อนุญาตให้แสดงความคิดเห็นในข้อความ JSON และไม่มีสตริงคำพูดเป็นต้นในการระบุตัวแยกวิเคราะห์ประเภทนี้คุณต้องใช้ประเภทตัวแยกวิเคราะห์ JsonParserType.LAX เมื่อกำหนดอ็อบเจ็กต์ของ JsonSlurper

ลองดูตัวอย่างที่ระบุด้านล่าง ตัวอย่างคือการรับข้อมูล JSON จากเว็บเซิร์ฟเวอร์โดยใช้โมดูล http สำหรับการส่งผ่านประเภทนี้ตัวเลือกที่ดีที่สุดคือการตั้งค่าประเภทตัววิเคราะห์เป็นตัวแปร 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 ที่กำหนดให้พยายามอย่างหนักที่สุดเพื่อหลีกเลี่ยงการสร้างอาร์เรย์ถ่านหรืออินสแตนซ์สตริงใหม่ เพียงแค่เก็บพอยน์เตอร์ไปยังอาร์เรย์อักขระดั้งเดิมเท่านั้น นอกจากนี้ยังเลื่อนการสร้างวัตถุให้ช้าที่สุด

  • JsonParserUsingCharacterSource เป็นตัวแยกวิเคราะห์พิเศษสำหรับไฟล์ขนาดใหญ่มาก โดยใช้เทคนิคที่เรียกว่า "character windowing" เพื่อแยกวิเคราะห์ไฟล์ 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

  • จากนั้นเราจะใช้ฟังก์ชัน parseText ของคลาส JsonSlurper เพื่อแยกวิเคราะห์ข้อความ JSON

  • เมื่อเราได้รับวัตถุคุณจะเห็นว่าเราสามารถเข้าถึงค่าในสตริง JSON ได้ผ่านทางคีย์

ผลลัพธ์ของโปรแกรมข้างต้นแสดงไว้ด้านล่าง -

John 
1

การแยกวิเคราะห์รายการจำนวนเต็ม

ลองดูตัวอย่างอื่นของวิธีการแยกวิเคราะห์ JsonSlurper ในตัวอย่างต่อไปนี้เรากำลังยกรายการจำนวนเต็ม คุณจะสังเกตได้จากรหัสต่อไปนี้ว่าเราสามารถใช้วิธีการรายการของแต่ละรายการและส่งต่อไปได้

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

ผลลัพธ์ของโปรแกรมข้างต้นแสดงไว้ด้านล่าง -

List=[2, 3, 4, 5]

การแยกวิเคราะห์รายการประเภทข้อมูลดั้งเดิม

ตัวแยกวิเคราะห์ JSON ยังสนับสนุนชนิดข้อมูลพื้นฐานของสตริงตัวเลขอ็อบเจ็กต์จริงเท็จและ 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 - พารามิเตอร์สามารถเป็นอ็อบเจ็กต์ของประเภทข้อมูล - Number, Boolean, character, String, Date, Map, closed เป็นต้น

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 อนุญาตให้หนึ่งละเว้นวงเล็บรอบอาร์กิวเมนต์ของการเรียกใช้เมธอดสำหรับคำสั่งระดับบนสุด สิ่งนี้เรียกว่าคุณลักษณะ "command chain" ส่วนขยายนี้ทำงานโดยอนุญาตให้เชื่อมโยงการเรียกเมธอดแบบไม่ต้องใช้วงเล็บดังกล่าวโดยไม่ต้องใช้วงเล็บรอบอาร์กิวเมนต์หรือจุดระหว่างการโทรแบบล่าม

หากการโทรดำเนินการเป็น 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

ตัวอย่างข้างต้นแสดงให้เห็นถึงการเปลี่ยนแปลงของภาษาโปรแกรมเพื่อตอบสนองความต้องการของภาษาเฉพาะโดเมน

ลองดูตัวอย่างง่ายๆว่าเราสามารถใช้ DSL ใน Groovy ได้อย่างไร -

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 จะสร้างอินสแตนซ์และมอบหมายการโทรทั้งหมดในการปิดอินสแตนซ์ นี่คือกลไกที่ส่วน "ถึง" และ "จาก" จบลงด้วยการเรียกใช้เมธอดในคลาส EmailDsl

  • เมื่อเรียกเมธอด to () เราจะจัดเก็บข้อความในอินสแตนซ์เพื่อจัดรูปแบบในภายหลัง

  • ตอนนี้เราสามารถเรียกเมธอด EmailDSL ด้วยภาษาที่เข้าใจง่ายสำหรับผู้ใช้ปลายทาง

โมดูล groovy-sql ของ Groovy มอบสิ่งที่เป็นนามธรรมในระดับที่สูงกว่าเทคโนโลยี JDBC ของ Java ในปัจจุบัน Groovy sql API รองรับฐานข้อมูลที่หลากหลายซึ่งบางส่วนแสดงไว้ด้านล่าง

  • HSQLDB
  • Oracle
  • เซิร์ฟเวอร์ SQL
  • MySQL
  • MongoDB

ในตัวอย่างของเราเราจะใช้ MySQL DB เป็นตัวอย่าง ในการใช้ MySQL กับ Groovy สิ่งแรกที่ต้องทำคือดาวน์โหลดไฟล์ MySQL jdbc jar จากไซต์ mysqlThe forเสื่อของ MySQL จะแสดงด้านล่าง

mysql-connector-java-5.1.38-bin

จากนั้นให้แน่ใจว่าได้เพิ่มไฟล์ jar ด้านบนไปยัง classpath ในเวิร์กสเตชันของคุณ

การเชื่อมต่อฐานข้อมูล

ก่อนเชื่อมต่อกับฐานข้อมูล MySQL โปรดตรวจสอบสิ่งต่อไปนี้ -

  • คุณได้สร้างฐานข้อมูล TESTDB
  • คุณได้สร้างตาราง EMPLOYEE ใน TESTDB
  • ตารางนี้มีฟิลด์ FIRST_NAME, LAST_NAME, AGE, SEX และ INCOME
  • ID ผู้ใช้ "testuser" และรหัสผ่าน "test123" ถูกตั้งค่าให้เข้าถึง TESTDB
  • ตรวจสอบให้แน่ใจว่าคุณได้ดาวน์โหลดไฟล์ jar mysql และเพิ่มไฟล์ลงใน classpath ของคุณ
  • คุณได้อ่านบทช่วยสอน MySQL เพื่อทำความเข้าใจเกี่ยวกับ MySQL Basics

ตัวอย่างต่อไปนี้แสดงวิธีการเชื่อมต่อกับฐานข้อมูล 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 เมธอด execute ของคลาส Sql ใช้ในการรันคำสั่งกับฐานข้อมูล

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

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

แทรกการทำงาน

จำเป็นเมื่อคุณต้องการสร้างระเบียนของคุณลงในตารางฐานข้อมูล

ตัวอย่าง

ตัวอย่างต่อไปนี้จะแทรกบันทึกในตารางพนักงาน รหัสจะถูกวางไว้ในบล็อก try catch ดังนั้นหากเรียกใช้เรกคอร์ดสำเร็จธุรกรรมจะถูกผูกมัดกับฐานข้อมูล หากการทำธุรกรรมล้มเหลวการย้อนกลับจะเสร็จสิ้น

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

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

สมมติว่าคุณต้องการเพียงแค่เลือกบางแถวตามเกณฑ์ โค้ดต่อไปนี้แสดงวิธีเพิ่มตัวยึดพารามิเตอร์เพื่อค้นหาค่า ตัวอย่างข้างต้นสามารถเขียนเพื่อรับพารามิเตอร์ดังที่แสดงในโค้ดต่อไปนี้ สัญลักษณ์ $ ใช้เพื่อกำหนดพารามิเตอร์ซึ่งสามารถถูกแทนที่ด้วยค่าเมื่อคำสั่ง sql ถูกเรียกใช้งาน

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

อ่านการทำงาน

การอ่านการดำเนินการบนฐานข้อมูลหมายถึงการดึงข้อมูลที่เป็นประโยชน์จากฐานข้อมูล เมื่อสร้างการเชื่อมต่อฐานข้อมูลของเราแล้วคุณก็พร้อมที่จะทำการสืบค้นในฐานข้อมูลนี้

การดำเนินการอ่านดำเนินการโดยใช้เมธอด eachRow ของคลาส sql

ไวยากรณ์

eachRow(GString gstring, Closure closure)

ดำเนินการสืบค้น SQL ที่กำหนดโดยเรียกการปิดที่กำหนดกับแต่ละแถวของชุดผลลัพธ์

Parameters

  • Gstring - คำสั่ง sql ที่ต้องดำเนินการ

  • Closure- คำสั่งปิดเพื่อประมวลผลแถวที่ดึงมาจากการดำเนินการอ่าน ดำเนินการสืบค้น SQL ที่กำหนดโดยเรียกการปิดที่กำหนดกับแต่ละแถวของชุดผลลัพธ์

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการดึงข้อมูลทั้งหมดจากตารางพนักงาน

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

ผลลัพธ์จากโปรแกรมด้านบนจะเป็น -

[Mac, Mohan, 20, M, 2000.0]

อัปเดตการทำงาน

UPDATE การทำงานบนฐานข้อมูลหมายถึงการอัปเดตระเบียนตั้งแต่หนึ่งรายการขึ้นไปซึ่งมีอยู่แล้วในฐานข้อมูล ขั้นตอนต่อไปนี้จะอัปเดตระเบียนทั้งหมดที่มี SEX เป็น 'M' ที่นี่เราเพิ่มอายุของผู้ชายทุกคนขึ้นหนึ่งปี

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

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

ลบการดำเนินการ

จำเป็นต้องดำเนินการ DELETE เมื่อคุณต้องการลบบางระเบียนออกจากฐานข้อมูลของคุณ ต่อไปนี้เป็นขั้นตอนในการลบบันทึกทั้งหมดจาก EMPLOYEE ที่ AGE มากกว่า 20

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

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

การทำธุรกรรม

ธุรกรรมเป็นกลไกที่ทำให้ข้อมูลมีความสอดคล้องกัน ธุรกรรมมีคุณสมบัติสี่ประการดังต่อไปนี้ -

  • Atomicity - ไม่ว่าธุรกรรมจะเสร็จสมบูรณ์หรือไม่มีอะไรเกิดขึ้นเลย

  • Consistency - ธุรกรรมต้องเริ่มต้นในสถานะที่สอดคล้องกันและปล่อยให้ระบบอยู่ในสถานะที่สอดคล้องกัน

  • Isolation - ผลลัพธ์ระดับกลางของธุรกรรมจะไม่ปรากฏนอกธุรกรรมปัจจุบัน

  • Durability - เมื่อทำธุรกรรมแล้วผลกระทบจะคงอยู่แม้ระบบจะล้มเหลวก็ตาม

นี่คือตัวอย่างง่ายๆในการใช้ธุรกรรม เราได้เห็นตัวอย่างนี้แล้วจากหัวข้อก่อนหน้าของการดำเนินการ DELETE

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

ดำเนินการ

การดำเนินการคอมมิตคือสิ่งที่บอกให้ฐานข้อมูลดำเนินการต่อไปและทำการเปลี่ยนแปลงทั้งหมดในฐานข้อมูล

ในตัวอย่างข้างต้นสิ่งนี้ทำได้โดยข้อความต่อไปนี้ -

sql.commit()

การดำเนินการย้อนกลับ

หากคุณไม่พอใจกับการเปลี่ยนแปลงอย่างน้อยหนึ่งรายการและต้องการเปลี่ยนกลับการเปลี่ยนแปลงเหล่านั้นทั้งหมดให้ใช้วิธีย้อนกลับ ในตัวอย่างข้างต้นสิ่งนี้ทำได้โดยข้อความต่อไปนี้ -

sql.rollback()

การยกเลิกการเชื่อมต่อฐานข้อมูล

ในการยกเลิกการเชื่อมต่อฐานข้อมูลให้ใช้วิธีปิด

sql.close()

ในระหว่างขั้นตอนการพัฒนาซอฟต์แวร์บางครั้งนักพัฒนาใช้เวลาส่วนใหญ่ในการสร้างโครงสร้างข้อมูลคลาสโดเมน XML เลย์เอาต์ GUI สตรีมเอาต์พุตและบางครั้งโค้ดที่ใช้สร้างข้อกำหนดเฉพาะเหล่านี้ส่งผลให้เกิดการเปลี่ยนข้อมูลโค้ดเดียวกันของ code ในหลาย ๆ ที่ นี่คือจุดที่ผู้สร้าง Groovy เข้ามามีบทบาท Groovy มีผู้สร้างที่สามารถใช้เพื่อสร้างวัตถุและโครงสร้างมาตรฐานได้ เครื่องมือสร้างเหล่านี้ช่วยประหยัดเวลาเนื่องจากนักพัฒนาไม่จำเป็นต้องเขียนโค้ดของตัวเองเพื่อสร้างตัวสร้างเหล่านี้ ใน couse ของบทนี้เราจะดูผู้สร้างต่างๆที่มีอยู่ใน groovy

ตัวสร้างวงสวิง

นอกจากนี้คุณยังสามารถสร้างส่วนต่อประสานผู้ใช้แบบกราฟิกโดยใช้ตัวสร้างวงสวิงที่มีอยู่ใน groovy คลาสหลักสำหรับการพัฒนาส่วนประกอบสวิงคือคลาส SwingBuilder คลาสนี้มีหลายวิธีในการสร้างส่วนประกอบกราฟิกเช่น -

  • JFrame - ใช้สำหรับสร้างองค์ประกอบเฟรม

  • JTextField - ใช้สำหรับสร้างคอมโพเนนต์ฟิลด์ข้อความ

ลองดูตัวอย่างง่ายๆในการสร้างแอปพลิเคชัน Swing โดยใช้คลาส SwingBuilder ในตัวอย่างต่อไปนี้คุณจะเห็นประเด็นต่อไปนี้ -

  • คุณต้องนำเข้าคลาส 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)

ผลลัพธ์ของโปรแกรมข้างต้นแสดงไว้ด้านล่าง ผลลัพธ์ต่อไปนี้แสดง JFrame พร้อมกับ JLabel พร้อมข้อความ Hello World

ลองดูตัวอย่างถัดไปของเราสำหรับการสร้างหน้าจอป้อนข้อมูลด้วยกล่องข้อความ ในตัวอย่างต่อไปนี้เราต้องการสร้างแบบฟอร์มที่มีกล่องข้อความสำหรับชื่อนักเรียนเรื่องและชื่อโรงเรียน ในตัวอย่างต่อไปนี้คุณสามารถดูประเด็นสำคัญต่อไปนี้ -

  • เรากำลังกำหนดเค้าโครงสำหรับการควบคุมของเราบนหน้าจอ ในกรณีนี้เรากำลังใช้เค้าโครงกริด
  • เรากำลังใช้คุณสมบัติการจัดตำแหน่งสำหรับป้ายกำกับของเรา
  • เรากำลังใช้เมธอด 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)

ผลลัพธ์ของโปรแกรมข้างต้นแสดงไว้ด้านล่าง -

ตัวจัดการเหตุการณ์

ตอนนี้เรามาดูตัวจัดการเหตุการณ์ ตัวจัดการเหตุการณ์ใช้สำหรับปุ่มเพื่อดำเนินการประมวลผลบางประเภทเมื่อกดปุ่ม แต่ละปุ่มเรียก pseudomethod ประกอบด้วยพารามิเตอร์ 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)

ผลลัพธ์ของโปรแกรมข้างต้นแสดงไว้ด้านล่าง เมื่อคุณคลิกที่ปุ่มใดปุ่มหนึ่งข้อความที่ต้องการจะถูกส่งไปยังหน้าจอบันทึกของคอนโซล

อีกรูปแบบหนึ่งของตัวอย่างข้างต้นคือการกำหนดวิธีการที่สามารถทำหน้าที่เป็นตัวจัดการ ในตัวอย่างต่อไปนี้เรากำลังกำหนดตัวจัดการ 2 ตัวของ DisplayA และ DisplayB

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 สามารถใช้สำหรับการแยกวิเคราะห์ HTML, XHTML และ XML และแปลงเป็นโครงสร้าง W3C DOM

ตัวอย่างต่อไปนี้แสดงวิธีใช้ตัวสร้าง DOM

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

JsonBuilder

JsonBuilder ใช้สำหรับสร้างวัตถุประเภท json

ตัวอย่างต่อไปนี้แสดงวิธีใช้ตัวสร้าง Json

def builder = new groovy.json.JsonBuilder() 

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

ผลลัพธ์ของโปรแกรมข้างต้นแสดงไว้ด้านล่าง เอาต์พุต 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 ใช้สำหรับสร้างต้นไม้ที่ซ้อนกันของอ็อบเจ็กต์โหนดสำหรับจัดการข้อมูลโดยพลการ ตัวอย่างการใช้งาน 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 จะมีข้อความ“ Hello World”

Groovy shell ที่เรียกว่า groovysh สามารถใช้ในการประเมินนิพจน์ที่ไม่เหมาะสมกำหนดคลาสและรันโปรแกรมง่ายๆได้อย่างง่ายดาย เชลล์บรรทัดคำสั่งได้รับการติดตั้งเมื่อติดตั้ง Groovy

ต่อไปนี้เป็นตัวเลือกบรรทัดคำสั่งที่มีอยู่ใน Groovy -

พารามิเตอร์บรรทัดคำสั่ง ชื่อเต็ม รายละเอียด
-ค - สี [= FLAG] เปิดหรือปิดการใช้สี ANSI
-D --define = NAME = VALUE กำหนดคุณสมบัติของระบบ
- ท - เทอร์มินัล = TYPE ระบุประเภทเทอร์มินัลที่จะใช้
-V - รุ่น แสดงเวอร์ชัน
- คลาสพา ธ ระบุตำแหน่งที่จะค้นหาไฟล์คลาส - ต้องเป็นอาร์กิวเมนต์แรก
-cp - คลาสพา ธ นามแฝงสำหรับ '-classpath'
-d --debug --debug เปิดใช้งานเอาต์พุตการดีบัก
-e --evaluate = arg ประเมินตัวเลือกกำปั้นเมื่อเริ่มเซสชันแบบโต้ตอบ
-h --ช่วยด้วย แสดงข้อความช่วยเหลือนี้
-q --เงียบ ปราบปรามการส่งออกที่ไม่จำเป็น
-v - คำกริยา เปิดใช้งานเอาต์พุต verbose

สแน็ปช็อตต่อไปนี้แสดงตัวอย่างง่ายๆของนิพจน์ที่ดำเนินการในเชลล์ Groovy ในตัวอย่างต่อไปนี้เราจะพิมพ์คำว่า“ Hello World” ลงในเปลือกที่มีขนาดใหญ่

ชั้นเรียนและหน้าที่

มันง่ายมากที่จะกำหนดคลาสในพรอมต์คำสั่งสร้างอ็อบเจกต์ใหม่และเรียกใช้เมธอดบนคลาส ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถนำไปใช้งานได้อย่างไร ในตัวอย่างต่อไปนี้เรากำลังสร้างคลาส Student แบบง่ายด้วยวิธีการง่ายๆ ในพรอมต์คำสั่งเองเรากำลังสร้างออบเจ็กต์ของคลาสและเรียกใช้เมธอด Display

มันง่ายมากที่จะกำหนดวิธีการในพรอมต์คำสั่งและเรียกใช้เมธอด สังเกตว่าเมธอดถูกกำหนดโดยใช้ชนิด def โปรดทราบว่าเราได้รวมพารามิเตอร์ที่เรียกว่า name ซึ่งจะถูกแทนที่ด้วยค่าจริงเมื่อมีการเรียกวิธีการแสดง ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถนำไปใช้งานได้อย่างไร

คำสั่ง

เชลล์มีคำสั่งที่แตกต่างกันจำนวนมากซึ่งให้การเข้าถึงสภาพแวดล้อมของเชลล์อย่างสมบูรณ์ ต่อไปนี้เป็นรายชื่อของพวกเขาและสิ่งที่พวกเขาทำ

ซีเนียร์ No คำสั่ง & 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) แสดงจัดการและเรียกคืนประวัติการแก้ไขบรรทัด

หน่วยพื้นฐานของระบบเชิงวัตถุคือคลาส ดังนั้นการทดสอบหน่วยจึงประกอบด้วย testig ภายในคลาส แนวทางที่ใช้คือการสร้างออบเจ็กต์ของคลาสภายใต้การทดสอบและใช้เพื่อตรวจสอบว่าเมธอดที่เลือกดำเนินการตามที่คาดไว้ ไม่ใช่ทุกวิธีที่สามารถทดสอบได้เนื่องจากการทดสอบแต่ละสิ่งไม่ใช่เรื่องจริงเสมอไป แต่การทดสอบหน่วยควรดำเนินการสำหรับวิธีการที่สำคัญและสำคัญ

JUnit เป็นเฟรมเวิร์กการทดสอบแบบโอเพนซอร์สซึ่งเป็นมาตรฐานอุตสาหกรรมที่ยอมรับสำหรับการทดสอบหน่วยอัตโนมัติของโค้ด Java โชคดีที่กรอบงาน JUnit สามารถใช้ทดสอบคลาส Groovy ได้อย่างง่ายดาย สิ่งที่ต้องมีคือการขยายคลาส GroovyTestCase ที่เป็นส่วนหนึ่งของสภาพแวดล้อม Groovy มาตรฐาน คลาสกรณีทดสอบ Groovy ขึ้นอยู่กับกรณีทดสอบของ Junit

การเขียน Simple Junit Test Case

สมมติว่าเรามีคลาสต่อไปนี้ที่กำหนดไว้ในไฟล์คลาสแอ็พพลิเคชัน -

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

และตอนนี้สมมติว่าเราต้องการเขียนกรณีทดสอบสำหรับชั้นเรียนนักเรียน กรณีทดสอบทั่วไปจะมีลักษณะดังต่อไปนี้ จำเป็นต้องสังเกตประเด็นต่อไปนี้เกี่ยวกับรหัสต่อไปนี้ -

  • คลาสกรณีทดสอบขยายคลาส GroovyTestCase
  • เรากำลังใช้คำสั่งยืนยันเพื่อให้แน่ใจว่าวิธีการแสดงผลส่งคืนสตริงที่ถูกต้อง
class StudentTest extends GroovyTestCase {
   void testDisplay() {
      def stud = new Student(name : 'Joe', ID : '1')
      def expected = 'Joe1'
      assertToString(stud.Display(), expected)
   }
}

ชุดทดสอบ Groovy

โดยปกติเมื่อจำนวนการทดสอบหน่วยเพิ่มขึ้นการดำเนินการกรณีทดสอบทั้งหมดทีละหน่วยจะเป็นเรื่องยาก ดังนั้น Groovy จึงจัดเตรียมสิ่งอำนวยความสะดวกในการสร้างชุดทดสอบที่สามารถห่อหุ้มกรณีทดสอบทั้งหมดไว้ในหน่วยลอจิกเดียว โค้ดโค้ดต่อไปนี้แสดงให้เห็นว่าสามารถทำได้อย่างไร ควรสังเกตสิ่งต่อไปนี้เกี่ยวกับรหัส -

  • GroovyTestSuite ใช้เพื่อห่อหุ้มกรณีทดสอบทั้งหมดให้เป็นหนึ่งเดียว

  • ในตัวอย่างต่อไปนี้เราสมมติว่าเรามีไฟล์เคสการทดสอบสองไฟล์ไฟล์หนึ่งเรียกว่า StudentTest และอีกอย่างคือ EmployeeTest ซึ่งประกอบด้วยการทดสอบที่จำเป็นทั้งหมด

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

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

TestRunner.run(AllTests.suite())

เอ็นจิ้นเทมเพลตของ Groovy ทำงานเหมือนจดหมายเวียน (การเพิ่มชื่อและที่อยู่โดยอัตโนมัติจากฐานข้อมูลไปยังจดหมายและซองจดหมายเพื่ออำนวยความสะดวกในการส่งจดหมายโดยเฉพาะการโฆษณาไปยังที่อยู่จำนวนมาก) แต่โดยทั่วไปแล้ว

Simple Templating ใน Strings

หากคุณยกตัวอย่างง่ายๆด้านล่างเราจะกำหนดตัวแปรชื่อเพื่อเก็บสตริง "Groovy" ก่อน ในคำสั่ง println เราใช้สัญลักษณ์ $ เพื่อกำหนดพารามิเตอร์หรือเทมเพลตที่สามารถแทรกค่าได้

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

หากโค้ดด้านบนถูกเรียกใช้อย่างไม่เป็นระเบียบผลลัพธ์ต่อไปนี้จะแสดงขึ้น ผลลัพธ์แสดงให้เห็นอย่างชัดเจนว่า $ name ถูกแทนที่ด้วยค่าที่กำหนดโดยคำสั่ง def

Simple Template Engine

ต่อไปนี้เป็นตัวอย่างของ SimpleTemplateEngine ที่ช่วยให้คุณสามารถใช้สคริปต์เล็ตที่มีลักษณะคล้าย JSP และนิพจน์ EL ในเทมเพลตของคุณเพื่อสร้างข้อความที่เป็นพารามิเตอร์ เครื่องมือสร้างเทมเพลตช่วยให้คุณสามารถผูกรายการพารามิเตอร์และค่าเพื่อให้สามารถแทนที่ในสตริงที่มีตัวยึดตำแหน่งที่กำหนดไว้

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

about $Topic'  

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

println template

หากโค้ดด้านบนถูกเรียกใช้อย่างไม่เป็นระเบียบผลลัพธ์ต่อไปนี้จะแสดงขึ้น

ตอนนี้เรามาใช้คุณลักษณะเทมเพลตสำหรับไฟล์ XML ในขั้นตอนแรกให้เพิ่มรหัสต่อไปนี้ในไฟล์ชื่อ Student.template ในไฟล์ต่อไปนี้คุณจะสังเกตเห็นว่าเราไม่ได้เพิ่มค่าที่แท้จริงสำหรับองค์ประกอบ แต่เป็นตัวยึดตำแหน่ง ชื่อ $$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

หากโค้ดด้านบนถูกเรียกใช้อย่างไม่เป็นระเบียบผลลัพธ์ต่อไปนี้จะแสดงขึ้น จากผลลัพธ์จะเห็นได้ว่าค่าถูกแทนที่สำเร็จในตัวยึดตำแหน่งที่เกี่ยวข้อง

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

StreamingTemplateEngine

เอ็นจิ้น StreamingTemplateEngine เป็นเครื่องมือสร้างเทมเพลตอื่นที่มีอยู่ใน Groovy ซึ่งเทียบเท่ากับ SimpleTemplateEngine แต่สร้างเทมเพลตโดยใช้การปิดแบบเขียนได้ทำให้สามารถปรับขนาดได้มากขึ้นสำหรับเทมเพลตขนาดใหญ่ โดยเฉพาะเอ็นจิ้นเทมเพลตนี้สามารถจัดการสตริงที่มีขนาดใหญ่กว่า 64k

ต่อไปนี้เป็นตัวอย่างวิธีใช้ StreamingTemplateEngine -

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

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

หากโค้ดด้านบนถูกเรียกใช้อย่างไม่เป็นระเบียบผลลัพธ์ต่อไปนี้จะแสดงขึ้น

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngine ถูกใช้ในสถานการณ์จำลองที่ซึ่งทั้งแหล่งเทมเพลตและเอาต์พุตที่คาดหวังมีไว้สำหรับ XML เทมเพลตใช้แบบปกติ${expression} and $สัญกรณ์ตัวแปรเพื่อแทรกนิพจน์ที่กำหนดเองลงในเทมเพลต

ต่อไปนี้เป็นตัวอย่างวิธีใช้ XMLTemplateEngine

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

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

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

หากโค้ดด้านบนถูกเรียกใช้อย่างไม่เป็นระเบียบผลลัพธ์ต่อไปนี้จะแสดงขึ้น

Joe
    
    
   1
    
    
   Physics

การเขียนโปรแกรม Meta object หรือ MOP สามารถใช้เพื่อเรียกใช้เมธอดแบบไดนามิกและยังสร้างคลาสและเมธอดได้ทันที

แล้วนี่หมายความว่าอย่างไร? ลองพิจารณาคลาสที่เรียกว่า Student ซึ่งเป็นคลาสว่างที่ไม่มีตัวแปรหรือเมธอดสมาชิก สมมติว่าคุณต้องเรียกใช้คำสั่งต่อไปนี้ในคลาสนี้

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

ขณะนี้อยู่ในการเขียนโปรแกรม meta object แม้ว่าคลาสจะไม่มีชื่อตัวแปรสมาชิกหรือวิธีการแสดง () โค้ดด้านบนจะยังคงใช้งานได้

วิธีการทำงานนี้? เพื่อให้ได้ผลเราต้องใช้อินเทอร์เฟซ GroovyInterceptable เพื่อเชื่อมต่อกับกระบวนการดำเนินการของ Groovy ต่อไปนี้เป็นวิธีการที่ใช้ได้สำหรับอินเทอร์เฟซนี้

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 () มันจะถูกเรียกใช้สำหรับทุกเมธอดที่มีอยู่หรือไม่มีอยู่

ไม่มีคุณสมบัติ

ลองดูตัวอย่างวิธีที่เราสามารถใช้ Meta Object Programming สำหรับคุณสมบัติที่ขาดหายไป ควรสังเกตสิ่งสำคัญต่อไปนี้เกี่ยวกับรหัสต่อไปนี้

  • คลาส Student ไม่มีตัวแปรสมาชิกที่เรียกว่า Name หรือ ID ที่กำหนด

  • นักเรียนชั้นเรียนใช้อินเทอร์เฟซ 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

ไม่มีวิธีการ

ลองดูตัวอย่างวิธีที่เราสามารถใช้ Meta Object Programming สำหรับคุณสมบัติที่ขาดหายไป ควรสังเกตสิ่งสำคัญต่อไปนี้เกี่ยวกับรหัสต่อไปนี้ -

  • ขณะนี้คลาส 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"
   }
}

ผลลัพธ์ของรหัสต่อไปนี้จะแสดงด้านล่าง โปรดทราบว่าไม่มีข้อผิดพลาดของ Method Exception ที่หายไปแม้ว่าจะไม่มี Method Display อยู่ก็ตาม

Joe 
1

Metaclass

ฟังก์ชันนี้เกี่ยวข้องกับการใช้งาน MetaClass ในการใช้งานเริ่มต้นคุณสามารถเข้าถึงฟิลด์โดยไม่ต้องเรียกใช้ getters และ setters ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการใช้ฟังก์ชัน 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