Groovy #1: Conceitos Básicos

Tempo de leitura: menos de 1 minuto

Em 2011, tive o primeiro contato com o Groovy, foi em uma apresentação na empresa onde trabalho. Nossos arquitetos na época, fizeram uma breve apresentação da linguagem, mostrando algumas vantagem e características que a linguagem tem.

Cara simplesmente me apaixonei pelo que vi, pelo potencial apresentado, pelas facilidades, novidades, e pela integração que a linguagem tem com a plataforma Java. Para mim, programador Java, foi legal saber que não seria tão dolorido aprender uma nova linguagem, um jeito novo de fazer as coisas.

Mas o que é o Groovy?

No site oficial do Groovy, a descrição é a seguinte: “linguagem ágil e dinâmica para a plataforma Java com muitas ferramentas que são inspiradas em linguagens como Python, Ruby e Smalltalk, tornando-as disponíveis aos programadores Java, usando uma sintaxe próxima ao Java”.

A tarefa de aprender Groovy, não é complicada pois as sintaxes são muito parecidas, é possível em uma classe Groovy, chamar uma método Java (ou vice-versa). O que diferencia as duas, são mesmos os recursos adicionais que o Groovy disponibiliza.

Outro ponto importante é que o Groovy não é apenas uma linguagem de script, como muitos dizem. Além de ser uma linguagem script (que funciona muito bem), pode ser compilada, gerando bytecodes de forma transparente, possibilitando assim a integração das linguagens.

Mas como devo começar a escrever código Groovy em minha aplicação Java?

Onde trabalho, começamos pelos testes unitários, por não ser código de produção, ficou mais fácil testar a linguagem, e aprender a usa-la corretamente. Depois migramos para os utilitários, por prover vários recursos adicionais, principalmente para trabalhar com Collections. O passo seguinte foi inovar, pegamos um mecanismo existente, que dava muita manutenção (validação de dados e geração de críticas), e mudamos todo o conceito criação e execução de regras. E por aí foi, hoje contabilizo que 40% do sistema que trabalho é escrito em Groovy.

Principais diferenças com o Java

Ponto e virgula: comando digitados em apenas uma linha, não precisam ser finalizados com “;” como no Java. No entanto, quando usar dois ou mais comandos na mesma linha, aí torna necessário o uso. Ex:

println "Groovy é o cara!"
println "Groovy é o cara!"; println "Tá gostando?"

Parenteses em métodos: Como visto no exemplo acima, não é necessário usar parenteses na chamada de um método, basta passar os parâmetros se houver.

Tudo é um objeto: No Java temos tipo primitivo e não primitivo,  já no Groovy só existe tipo não primitivo, ou seja, tudo é um objeto. Ex:

int valor = 1

Mesmo especificando que você quer uma variável do tipo int, ela será na verdade um objeto Integer.

Conceito de “verdade”: por só trabalhar com objeto, Groovy tem uma facilidade muito legal, qualquer objeto pode retornar um boolean. Qualquer objeto null retorna false em uma condição de decisão. Ex:

String str = "String"
String strNula = null
if (str) "Não está nula" 
if (!strNula) "Está nula"

Todo método retorna alguma coisa: O return passa a ser opcional, não precisa ser declarado e nem informado no método qual é o retorno. Simplesmente o Groovy entendi que o a última linha executada no método é o retorno. Lógico que isso pode deixar o método mais difícil de ser lido e entendido, então use com moderação:

public getIdade(){
     idade
}

Tipagem dinâmica: A definição de tipo de variáveis em Groovy é opcional. Ou seja, não existe a necessidade de definir na declaração qual o tipo da variável. Quando quiser definir uma variável dinâmica, é necessário o uso da palavra reservada “def”. Ex:

def nome = "Eder" // será uma String
def idade = 32 // será um Integer
def peso = 78.5  //será um BigDecimal

Possibilidade de sobrescrever operadores: Ao criar uma classe Groovy é possível sobrescrever operadores como: +, -, * e /. Para isso basta na sua classe, criar um ou todos os métodos, plus, minus, mutiply ou div respectivamente. Ex:

//declaração da classe
class TesteOperador{
   int valor1 = 0
   int valor2 = 0
   def plus(final TesteOperador outroObjeto) {
      valor1 += outroObjeto.valor1
      valor2 += outroObjeto.valor2
      return this
   }
}

//uso do método plus
def var1 = new TesteOperador()
def var2 = new TesteOperador()
var1 + var2

Lista completa disponível aqui.

Getters and Setters: Groovy facilita muito a vida do programador na escrita de beans, não existe a necessidade de declarar por exemplo os gets e sets para cada um dos atributos, todas os atributos definidos ganham os métodos. Sendo assim, não há necessidade de escrevo-los, basta usa-los. Ex:

//declaração do bean
public class Cachorro {
    private String raca 
    private String cor
}
//uso
animal.setRaca("Pastor")
animal.getCor()

O mais interessante, é que, se o acertarmos diretamente o atributo, o Groovy vai desviar a execução do código chamar os metodos gets ou sets conforme a operação, executada. Ex:

animal.cor = "azul" // acessará o método setCor(String)
println animal.raca // acessará o método getRaca()

Espero que tenham gostado, assim que possível listo outros vantagens que o Groovy nos trás.

Abraços.

Fonte:
Groovy Language Documentation