O que é Groovy - WordPress.com

Tribunal Regional Eleitoral do Tocantins
Secretaria de Tecnologia da Informação
Coordenadoria de Desenvolvimento de Sistemas
Grails
Aula 2: Introdução à linguagem
Groovy
Cleórbete Santos
[email protected]
Michael Schuenck dos Santos
[email protected]
O que é Groovy
●
●
●
●
●
É uma linguagem dinâmica para a plataforma
Java, com sintaxe Java-like;
Groovy é uma linguagem de script (também);
'Groovar' é 'Javar' de maneira especial;
Todo o poder do Java, incluindo suas milhares
de bibliotecas, estão disponíveis em Groovy;
Groovy é 'Java Friendly' (Seamless Integration
& Sintax Alingment);
In the beginning...
●
●
●
●
...it was cold, dark, an empty space...
...mas no dia 29 de agosto de 2003...
...James Strachan publicou em seu blog:
...“minha idéia inicial é fazer uma pequena
linguagem dinâmica, que seja compilada
diretamente em classes Java e que tenha
toda a produtividade elegante encontrada
em Ruby e Python, mas que permita
reusar, estender, implementar e testar
código Java já existente”;
Seamless Integration
●
●
●
●
●
●
●
Groovy 'roda' sem adaptações no JRE;
Groovy faz uso de todas as bibliotecas Java;
Classes Groovy são outra maneira de
expressar classes Java;
Todo tipo em Groovy é subtipo de
Java.lang.object;
Pode-se instanciar uma classe Groovy em uma
classe Java (e vice-versa);
A JVM é inconsciente sobre o código Groovy;
Em suma, Groovy é apenas Java + 1 jar;
Syntax Alignment
●
●
●
●
●
●
Embora diferente, é compreensível;
Java: import java.util.*; Date x = new Date();
Groovy: x = new Date()
Groovy é compacta (cadê o import?);
Groovy não precisa de pontos-e-vírgulas
quando pode entender o código sem eles;
Programadores Java sentem-se em casa;
Lendo um arquivo de texto
●
//Java
●
import java.io.BufferedReader; import java.io.FileReader; import java.io.FileNotFoundException; import java.io.IOException;
●
public class FileTest {
●
public static void main(String[] args) {
●
try {String arquivo = "teste.txt";
●
String linha = "";
●
StringBuilder sb = new StringBuilder();
●
BufferedReader br = new BufferedReader(new FileReader(arquivo));
●
while ((linha = br.readLine()) !=null) {sb.append(line);}
System.out.println("sb.toString() = " + sb.toString());
●
●
} catch (FileNotFoundException e) {
●
System.out.println("e = " + e);
} catch (IOException e) {
●
System.out.println("e = " + e);
●
}
●
}
●
●
}
Lendo um arquivo de texto...
●
//Groovy
println new File(“teste.txt”).text
Comentários
●
#! usr/bin/groovy
●
// comentário de uma linha
●
/* comentário
●
de várias
●
linhas */
●
●
Obs.: O shebang é permitido apenas na
primeira linha;
O shebang faz com que os S.O.'s encontrem o
bootstrap do Groovy e rodem a aplicação;
Import's implícitos
●
Groovy:
. groovy.lang.*
. groovy.util.*
. java.lang.*
. java.util.*
. java.net.*
. java.io.*
. java.math.BigInteger
. java.math.BigDecimal
●
Java: java.lang.*
Classes Groovy
●
●
●
●
●
●
●
Campos e propriedades são idênticos;
Métodos e campos são public (default);
Groovy gera os getters e setters;
Um atributo sem modificador é private e seus
métodos de acesso, public (default);
Se necessário, pode-se sobrescrever os
métodos de acesso;
Acesso externo à classe = uso das
propriedades;
Acesso interno à classe = não uso das
propriedades (acesso direto ao campo);
Exemplo de Acesso aos Campos
●
def livro = new Livro()
//usando a propriedade
livro.setTitulo('O morro dos ventos...');
//usando a propriedade também!
livro.titulo('O morro dos ventos...');
Analisando uma Classe Groovy
●
class Livro{
String titulo
def saudacao(nome){ // def?
print(“Olá, ${nome}!”) // GString
} // Sem return?
}
GString
●
●
●
Em Groovy usa-se aspas duplas ou simples
para strings;
As strings de aspas duplas permitem o uso de
placeholders. Ex.:
def filosofo = 'Sören Kierkegaard'
def livro = 'O desespero humano'
print(“${livro} foi escrito por ${filosofo}”)
A verdade em Groovy
●
●
●
Em C, 0 é false, e outro número é true;
Java exige que o valor represente um boolean;
Em Groovy:
. Boolean: valor true
. Match: um match ser true
. Collection: não estar vazia
. Map: não estar vazio
. String/Gstring: não estar vazia
. Número/Caracter: não ser 0
Lists
●
●
●
Servem para armazenamento de valores;
A recuperação é por meio do índice;
Ex.:
def romanos = [‘’,’I’,’II’,’III’,’IV’,’V’,’VI’]
if (romanos[5]==’V’) // true
romanos[7]=’VII’
if (romanos.size() == 8) // true
Maps
●
●
●
Servem para armazenamento chave/valor;
A recuperação é por meio da chave;
Ex.:
def autores=[1:’Diderot’,
7:’Descartes’,
3:’Voltaire’’]
if (autores[2]==’Descartes’) // true
autores[10]=’Goethe’
if (autores.size()==4) // true
Ranges
●
●
●
“Intervalos para facilitar a vida...”
“... e não existem em Java... oh!”
Ex.:
def intervalo = 1..10
if (intervalo.contains(5)) // true
if (intervalo.size()==10) // true
intervalo.from // = 1
intervalo.to // 10
intervalo.reverse() // 10..1
Closures
●
●
Closure em inglês...
São blocos 'enclausurados' de código tratados
como objetos;
Closures (continuação)
●
Ex.:
def clo = { println “Hello, Kitty!” }
clo() // Escreve “Hello, Kitty!”
def soma = { num1, num2 -> println num1+num2 }
soma(10,5) // Escreve ‘15’
●
●
●
●
●
O token '->' é opcional quando < 2 argumentos;
Há sempre 1 argumento 'it' (implícito);
O 'it' não precisa ser declarado (como o 'this');
Numa chamada sem argumentos, 'it' será null;
Closures sempre retornam um valor (com uso
de return ou não);
Closures (continuação)
●
Ex.:
def clo = { println it+1 }
clo(10) // Escreve ‘11’
●
Ex.:
def x = 5 // var externa
def clo = {num -> println num+x}
clo(10) // Escreve ‘15’
Estruturas de controle
●
●
●
Groovy suporta a mesma estrutura de IF,
Nested IF, e Operador Ternário do Java;
O Switch do Groovy permite vários testes
diferentes;
Groovy suporta o While e o For do Java,
mas o For do Groovy é muito mais prático;
Estruturas de controle
(continuação)
switch ( x ) {
case "foo":
result = "found foo"
case "bar":
result += "bar"
case [4, 5, 6, 'inList']:
result = "list"
break
case 12..30:
result = "range"
break
Estruturas de controle
(continuação)
●
def x = 0 // iteração por range
for ( i in 0..9 ) {
x += i
}
●
def x = 0 // iteração por list
for ( i in [0, 1, 2, 3, 4] ) {
x += i
}
Estruturas de controle
(continuação)
●
array = (0..4).toArray() // iteração por array
x=0
for ( i in array ) {
x += i
}
●
def map = ['abc':1, 'def':2, 'xyz':3] // iteração por map
x=0
for ( e in map ) {
x += e.value
}
Estruturas de controle
(continuação)
●
Os loops podem ser utilizados com as closures:
def stringList = [ "nietzsche", "feuerbach",
"bakunin", "blake", "kant"]
stringList.each() { println "${it}" }
def stringMap = [ "vo":"voltaire", "br":"brönte",
"ma":"macgowan", "sh":"shelley", "st":"stoker"]
stringMap.each() { chave, valor -> println
"Chave: ${chave} / Valor: ${valor}" };
E agora... O momento mais
esperado da aula...
O FIM! :)
Muito obrigado.