Groovy & Gradle: JVM Automation and Build Engineering · 강의

Groovy 클로저 이해하기

클로저의 개념과 정의 방법, Groovy에서의 다양한 활용 사례를 배웁니다.

레슨 2/411개 단계

Groovy 클로저 이해하기은(는) CoddyKit의 무료 Groovy & Gradle: JVM Automation and Build Engineering 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 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/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Groovy & Gradle: JVM Automation and Build Engineering 강의 전체를 잠금 해제할 수 있습니다. Groovy & Gradle: JVM Automation and Build Engineering 강의에는 총 4개의 강의가 포함되어 있습니다.

“Groovy 클로저 이해하기”에서 뭘 배우나요?

클로저의 개념과 정의 방법, Groovy에서의 다양한 활용 사례를 배웁니다. 브라우저에서 직접 실행하는 실습 코드로 Groovy & Gradle: JVM Automation and Build Engineering을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Groovy & Gradle: JVM Automation and Build Engineering을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Groovy & Gradle: JVM Automation and Build Engineering은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“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(으)로 돌아가기