¿Cómo creo y accedo a las variables globales en Groovy?

Necesito almacenar un valor en una variable en un método y luego necesito usar ese valor de esa variable en otro método o cierre. ¿Cómo puedo compartir este valor?

En un script Groovy, el alcance puede ser diferente de lo esperado. Esto se debe a que un script Groovy en sí mismo es una clase con un método que ejecutará el código, pero todo se hace en tiempo de ejecución. Podemos definir una variable para sumar al script omitiendo la definición de tipo o en Groovy 1.8 podemos agregar la anotación @Field.

import groovy.transform.Field

var1 = 'var1'
@Field String var2 = 'var2'
def var3 = 'var3'

void printVars() {
    println var1
    println var2
    println var3 // This won't work, because not in script scope.
}

class Globals {
   static String ouch = "I'm global.."
}

println Globals.ouch

def iamnotglobal=100 // This will not be accessible inside the function

iamglobal=200 // this is global and will be even available inside the 

def func()
{
    log.info "My value is 200. Here you see " + iamglobal
    iamglobal=400
    //log.info "if you uncomment me you will get error. Since iamnotglobal cant be printed here " + iamnotglobal
}
def func2()
{
   log.info "My value was changed inside func to 400 . Here it is = " + iamglobal
}
func()
func2()

aquí la variable iamglobal es una variable global utilizada por func y luego nuevamente disponible para func2

si declaras variable con def , será local, si no usas def es global

Al igual que todos los lenguajes OO, Groovy no tiene un concepto de "global" en sí mismo (a diferencia de, por ejemplo, BASIC, Python o Perl).

Si tiene varios métodos que necesitan compartir la misma variable, use un campo:

class Foo {
    def a;

    def foo() {
        a = 1;
    }
    def bar() {
        print a;
    }
}

Simplemente declare la variable en el alcance de la clase o script, luego acceda desde sus métodos o cierres. Sin un ejemplo, es difícil ser más específico para su problema particular.

Sin embargo, las variables globales generalmente se consideran de mala forma.

¿Por qué no devolver la variable de una función y luego pasarla a la siguiente?

Creo que estás hablando de variables de nivel de clase. Como se mencionó anteriormente, el uso de variables globales / variables de nivel de clase no es una buena práctica.

Si realmente quieres usarlo. y si está seguro de que no habrá impacto ...

Declare cualquier variable fuera del método. a nivel de clase sin el tipo de variable

p.ej:

{
   method()
   {
      a=10
      print(a)
   }

// def a or int a wont work

a=0

}

def sum = 0

// This method stores a value in a global variable.
def add =
{ 
    input1 , input2 ->
    sum = input1 + input2;
}

// This method uses stored value.
def multiplySum =   
{
    input1 ->
        return sum*input1;
}

add(1,2);
multiplySum(10);

¿No pudo encontrar lo que quiere, pero necesita algo como esto? :

​def a = { b -> b = 1 }
​bValue = a()
println b // prints 1

Ahora bValuecontiene el valor de bque es una variable en el cierre a. Ahora puedes hacer cualquier cosa con bValueAvísame si he entendido mal tu pregunta