Groovy: Uma linguagem dinâmica na JVM

Durante meus estudos, conheci o Groovy. Uma linguagem orientada a objetos , que é mantida pela Apache. Assim como Java 8, o Groovy também implementa técnicas de programação funcional, com um plus de poder ser executado em dois modos diferentes:

Compilado

Pode ser compilado gerando Bytecode para JVM, dessa forma, você só precisa empacotá-lo como biblioteca. Ele também possui, seu sistema de compilação o Gradle, que pode ser usado para criar o Groovy em seus projetos regulares.

Script

Além de usá-lo de forma compilada, você pode usá-lo como uma linguagem de script. Basta escrever seu código Groovy dentro de um arquivo e executar este arquivo chamando (uma vez que o Groovy esteja instalado):

$ groovy your-script.groovy

Vamos começar!

Para plataforma Bash (Mac OSX, Linux, Cygwin, Solaris ou FreeBSD) é muito fácil, você pode usar o SDKMAN. Confira a instalação no site.

Para instalar a versão mais recente e estável do Groovy:

$ sdk install groovy

Em seguida você pode testar a sua instalação:

$ groovy -version

Se você usa Windows, a instalação também podem ser bem simples.

Para plataforma Windows, você pode usar o Scoop. Confira a instalação no site.

Para instalar a versão mais recente e estável do Groovy:

$ scoop install groovy

Verifique a instalação:

$ groovy -version

Pronto!

Agora podemos brincar um pouco com o Groovy.

Variáveis

Aqui podemos usar tipos dinâmicos, ou seja, em tempo de execução o Groovy determinará o tipo da variável, e esse tipo pode até mudar. Para definir uma variável no Groovy usamos a palavra reservada def.

def x = 42

Se você quiser saber que tipo o Groovy determinou para essa variável acrescente a seguinte linha:

def x = 42 
println x.getClass()

Esse código produz a seguinte saída:

class java.lang.Integer

Mas, como eu disse, esse tipo pode mudar. Então se alterarmos esse código e deixa-lo assim:

def x = 42 
println x.getClass()
x = "Hello World"
println x.getClass()

Isso irá produzir a seguinte saída:

class java.lang.Integer 
class java.lang.String

Como você pode ver a variável x mudou seu tipo em tempo de execução. Podemos definir qual o seu tipo, mas se tentasse passar uma String para x, daria uma exceção.

Closure

A Groovy tem suporte para closures, que funcionam muito bem como lambdas do Java 8. Um closure é um bloco anônimo de código executável (digamos uma função) que pode ser passado para variáveis ​​e tem acesso a dados no contexto em que foi definido. Para definir um closure e atribuí-lo a uma variável, você pode escrever da seguinte maneira:

def helloWorld = {   
println "Hello World"
}

A variável helloWorld pode ser executada da seguinte maneira:

helloWorld()

Parâmetros

Você também pode esperar parâmetros na closure e passá-los ao executar:

def power = { int x, int y -> 
return Math.pow(x, y)
}
println power(2, 3) // saída 8.0

A definição de tipo de parâmetros é a mesma como variáveis. Se você definir um tipo, você só pode usar esse tipo, mas você também pode ignorar o tipo de parâmetros e passar o que quiser:

def say = { anything ->
println anything
}
say "Hello World"

Strings

O Groovy tem uma implementação de String bem interessante, chamada GString, que permite fazer interpolação entre Strings de maneira bem simples e elegante.

def x = "World" 
println "Hello, $x"

Isso produziria a saída Hello, World. O conteúdo da variável x é inserido na String. Se você quiser usar instruções mais complexas na sequência de caracteres, você precisa adicionar chaves após o cifrão, por exemplo:

def firstName = "Diego" 
def name = "Rocha"
println "Hello, ${firstName[0]}. $name"

Isso produziria a saída Hello, D. Rocha. Repare que podemos acessar um caracter específico na sequência de caracteres como uma matriz.

O Groovy também possui suporte para Strings de várias linhas. Basta usar três aspas duplas, para criar String multilinha:

def s = """This is 
a multiline
string"""

O Groovy com sua tipagem dinâmica, traz um poder incrível para programação na plataforma Java. Principalmente para aplicar o paradigma funcional, podendo ter funções mais coesas, e menos verbosas. Sem falar na compatibilidade com quase tudo que o Java já possui.

Se quiser aprender mais sobre o Groovy, a Apache disponibiliza uma documentação muito boa.

Até a próxima!

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.