Groovy & Gradle: JVM Automation and Build Engineering · レッスン

Groovyのクロージャを理解する

クロージャの概念と定義方法、Groovyにおける多様な活用方法を学びます。

レッスン 2/411 ステップ

「Groovyのクロージャを理解する」はCoddyKit上の無料Groovy & Gradle: JVM Automation and Build Engineeringレッスンです。これはレッスン2/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはGroovy & Gradle: JVM Automation and Build Engineering学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Groovy & Gradle: JVM Automation and Build Engineeringコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

What Are Groovy Closures?

Welcome to the world of Groovy closures! A closure is essentially a block of code that can be treated like a variable.

Think of it as a mini-function you can define, store, and pass around. Closures are a powerful feature that make Groovy code very flexible and concise.

They are first-class citizens, meaning they can be assigned to variables, passed as arguments, and returned from methods.
They can capture variables from their surrounding scope, even after that scope has finished executing.

Basic Closure Syntax

Defining a closure is straightforward. You enclose your code block within curly braces {}. Let's see a simple example:

class Main {
  static void main(String[] args) {
    // Define a simple closure
    def sayHello = {
      println "Hello from a closure!"
    }

    // Call (execute) the closure
    sayHello()
  }
}

Closures with Parameters

Just like methods, closures can accept parameters. You list the parameters before the -> (arrow) operator, followed by the closure's body.

This allows your closure to perform operations based on the input it receives.

class Main {
  static void main(String[] args) {
    // Closure that takes two parameters
    def add = { num1, num2 ->
      return num1 + num2
    }

    // Call the closure with arguments
    def result = add(10, 5)
    println "Sum: ${result}"

    // You can also omit 'return' for the last statement
    def multiply = { a, b -> a * b }
    println "Product: ${multiply(4, 3)}"
  }
}

The 'it' Keyword

When a closure takes exactly one parameter, Groovy provides a special implicit variable called it. You don't need to declare it explicitly.

This makes single-parameter closures even more concise and readable, especially when used with collection methods.

class Main {
  static void main(String[] args) {
    // Closure using 'it' for a single parameter
    def square = { it * it }

    println "Square of 7: ${square(7)}"

    def greetPerson = { "Hello, ${it}!" }
    println greetPerson("Alice")
  }
}

Closures as Method Arguments

One of the most common and powerful uses of closures in Groovy is passing them as arguments to methods. Many Groovy methods, especially those on collections, are designed to accept closures.

If a closure is the last argument to a method, you can place it outside the parentheses, making the code look very clean and DSL-like.

class Main {
  static void main(String[] args) {
    def numbers = [1, 2, 3, 4, 5]

    // Using 'each' with a closure to iterate
    numbers.each { num ->
      println "Number: ${num}"
    }

    println "---"

    // Using 'collect' with a closure to transform
    def doubledNumbers = numbers.collect { it * 2 }
    println "Doubled: ${doubledNumbers}"
  }
}

Capturing Variables: Lexical Scope

Closures have lexical scope, meaning they remember and can access variables from the scope where they were defined, even if that scope no longer exists.

This is a key characteristic that differentiates closures from regular methods and allows them to carry context with them.

class Main {
  static void main(String[] args) {
    def name = "Groovy User" // Variable in the outer scope

    def introduce = {
      // The closure 'introduce' captures 'name'
      println "My name is ${name}."
    }

    introduce() // Calls the closure, accessing 'name'

    name = "CoddyKit Enthusiast" // Change the outer variable
    introduce() // The closure still references the updated 'name'
  }
}

Modifying Captured Variables

Not only can closures access captured variables, but they can also modify them. This creates a powerful way for closures to interact with their surrounding environment.

Be mindful when modifying external variables from within closures, as it can sometimes lead to less predictable code if not managed carefully.

class Main {
  static void main(String[] args) {
    def counter = 0 // A variable to be captured

    def increment = {
      counter++ // Closure modifies the outer 'counter'
      println "Counter is now: ${counter}"
    }

    increment() // Counter: 1
    increment() // Counter: 2
    increment() // Counter: 3

    println "Final counter value: ${counter}"
  }
}

Closure 'call()' Method

While you can execute a closure by simply using parentheses (e.g., myClosure()), closures are actually instances of the groovy.lang.Closure class.

This means they also have a call() method. Using call() is equivalent to direct execution and can sometimes be useful for clarity or when dynamically invoking closures.

class Main {
  static void main(String[] args) {
    def greet = { name ->
      println "Hello, ${name}!"
    }

    // Direct execution
    greet("World")

    // Execution using the call() method
    greet.call("Groovy")

    def add = { a, b -> a + b }
    println add.call(5, 7)
  }
}

Practical Use: Filtering Lists

Let's put closures to work with a practical example: filtering elements from a list. Groovy's collection methods, like findAll, are perfect for this.

You provide a closure that defines the condition for inclusion, and findAll returns a new list containing only the elements that satisfy that condition.

class Main {
  static void main(String[] args) {
    def numbers = [10, 25, 12, 30, 5, 45, 20]

    // Find numbers greater than 20
    def largeNumbers = numbers.findAll { it > 20 }
    println "Numbers > 20: ${largeNumbers}"

    // Find even numbers
    def evenNumbers = numbers.findAll { it % 2 == 0 }
    println "Even numbers: ${evenNumbers}"
  }
}

Closure Concepts Check

Which of the following statements about Groovy Closures are TRUE?

対話的なレッスンで答える

Recap: Understanding Closures

Great job! You've taken a significant step in understanding Groovy's powerful closures.

Here's a quick summary of what we covered:

Closures are code blocks treated as first-class citizens.
They use {} for definition and -> for parameters.
The it keyword simplifies single-parameter closures.
Closures are often passed as method arguments, enhancing Groovy's expressiveness.
They possess lexical scope, capturing and even modifying variables from their surrounding context.

In the next lesson, we'll explore how to apply closures to functional programming patterns in Groovy!

無料で開始

AI チューターと学ぶ Groovy — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 12
レッスン: 48

無料で学習を始めるコース全体を表示

よくある質問

「Groovyのクロージャを理解する」レッスンは無料ですか？

はい。「Groovyのクロージャを理解する」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Groovy & Gradle: JVM Automation and Build Engineeringコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Groovy & Gradle: JVM Automation and Build Engineeringコースには全4レッスンが含まれています。

「Groovyのクロージャを理解する」で何を学びますか？

クロージャの概念と定義方法、Groovyにおける多様な活用方法を学びます。ブラウザで直接実行するハンズオンコードでGroovy & Gradle: JVM Automation and Build Engineeringを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Groovy & Gradle: JVM Automation and Build Engineeringを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのGroovy & Gradle: JVM Automation and Build Engineeringは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン2/4です。

「Groovyのクロージャを理解する」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このGroovy & Gradle: JVM Automation and Build Engineeringレッスンでコードを書いて実行できますか？

はい。すべてのGroovy & Gradle: JVM Automation and Build Engineeringレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Groovy & Gradle: JVM Automation and Build Engineeringに戻る