def

Groovy
Mateus Maso, Vanoir Zacaron, Vicente
Coral, Lucas Just Meller
Tópicos
1) Introdução
2) Histórico
5) Características da Linguagem
6) Groovy Beans
6) Groovy vs Java
7) Frameworks (Grails, Griffon, Gaelyk)
8) Exemplo de aplicação em Grails
Introdução
• Groovy é uma linguagem ágil e dinâmica que roda sobre a
JVM.
• Groovy possui características de Python, Ruby e Smalltalk.
• Groovy utiliza uma sintaxe similar à de Java, é compilada
dinamicamente para bytecode Java, e integra-se com outros
códigos e bibliotecas Java.
• Assim como Java, Groovy também é Orientada a Objetos,
porém também pode-se programar de forma procedural com
a mesma.
• Utiliza tipagem dinâmica, forte e duck.
Histórico
• A primeira menção ao Groovy foi vista no blog de James
Strachan em Agosto de 2003;
• Em 2 de janeiro de 2007 foi publicada a primeira versão
(1.0) do Groovy
•
Em dezembro de 2007 a versão 1.1 Final foi entregue e
imediatamente se constituiu como Groovy 1.5 devido ao
grande avanço obtido.
“Groovy é uma linguagem ágil e dinâmica para a plataforma
Java com muitas características inspiradas em linguagens
como Python, Ruby e Smalltalk, disponibilizando-as para os
desenvolvedores utlizando uma sintaxe similar à de Java
[GROOVY, 2009]”
Características da Linguagem
•
•
•
•
•
Def (Tipagem dinamica)
Closures
Methods Signature
Collections
Operators, Categories e Mixins
Def
O que é tipagem dinâmica?
•Em Groovy também representada por “def”.
•Usado para indicar que você não se importa ou não sabe o tipo de
variável representado.
•Groovy parser não acusa nenhum tipo de erro.
•É possivel usar esta expressão tanto para variáveis locais, atributos
de uma classe e retorno de método.
•Reconhece void como um tipo de retorno vazio.
Regra importante: "def" não é uma representação de "Object”.
Exemplo: Def
def dynamic = 1
dynamic = "Eu sou uma String guardada num tipo dinamico"
int typed = 2
typed = "Eu sou uma String guardada num tipo int
estático??" // throws ClassCastException
def name = "Joao"
println name.toUpperCase()
// nao precisa de castObject name = ”Joao";
Object name = "Maria"
System.out.println(((String) name).toUpperCase());
// precisa de cast
Closures
O que são Closures?
•"bloco de código" ou um ponteiro para método.
•Pedaço de código definido e executado naquele ponto.
•Possui algumas propriedades especiais:
- Variáveis implícitas "it",
- Passagem de argumentos
- Consegue usar variáveis livres (fora da closure)
- Parâmetro de método (mandar um “método” para um método)
Exemplo: Closures
//Closure com variavel implícita
def closure1 = { print it }
closure1("olá") //ola
//Closure com argumento
def closure2 = { a, b ->
print a+b
}
closure2(5, 7) //12
Exemplo: Closures
//Closure como parametro de método
def list = ['a','b','c','d']
def newList = []
def closure3 = { it.toUpperCase() }
list.collect(newList, closure3)
//Equivalente a:
list.collect(newList) {
it.toUpperCase()
}
println newList //["A", "B", "C", "D"]​
​
Method Signature
Como é invocado métodos?
•Parêntesis "()" opcional
•Múltiplos parâmetros (em lista)
•Parâmetros com mapeamento
•Declaração de throws opcional
•Suporta duck typing
Exemplo: Method Signature
class Duck {
String nome
def quack(... args) {
println "I am a Duck called ${nome} ${args.length}"
}
}
class Frog {
String nome
def quack(... args) {
println "I am a Frog called ${nome} ${args.length}"
}
}
def quackers = [new Duck(nome: "Donald"), new Frog(nome: "Feioso")]
for (q in quackers) {
q.quack 1, true, "Teste"
}
Collections
Como são representadas as coleções?
•Suporte nativo de lists, maps e ranges.
•List: [0, true, "Joao", ...]
•Map: [”chave": "valor", ...]
•Range: -5..10 ou 'a'..'z'
•each{}, find{}, findAll{}, sort{}, collect{}
Exemplo: Collections
def list = [5, 6, 7, 8]
def map = ["nome":"Mateus", "idade":19]
def range = 0..10
list.sort { it } //[5, 6, 7, 8]
map.find { key, value ->
key == "nome" && value == "Mateus"
} //nome=Mateus
list.findAll { value -> value > 6 } //[7, 8]
range.each { println it } //conta ate 10
Operators, Categories e Mixins
Operadores especiais em Groovy:
•as e in
•?.
(null-safe)
•*.
(coleção)
•?:
(condição)
•=˜ e ==˜ (expressão regular)
Categories e Mixin em Groovy:
•Agregam funções e atributos para uma classe
•Melhor uso em classes JDK e third-party (nao mexer no código)
Exemplo: Operators, Categories e Mixins
interface Estudante {
def estudar()
}
class Aluno implements Estudante {
String nome
Integer idade
def estudar() { println "estudando.." }
}
Aluno aluno1 = new Aluno(nome: "Mateus", idade: 19)
Aluno aluno2 = new Aluno(nome: "Lucas", idade: 20)
Aluno aluno3 = null
Exemplo: Operators
//Operador .?
println aluno3.nome //throws NullPointerException
println aluno3?.nome //ok
//Operador .*
def alunos = [aluno1, aluno2]
println alunos*.idade.sum() / alunos.size()
//Operador in
println aluno1 in Estudante //true
println aluno1 in Object
//true
//Operador as
def estudante = {
estudar: println "estudante nao aluno”
} as Estudante
estudante.estudar()
//19.5
Exemplo: Categories e Mixins
@Category(Aluno)
class AlunoDorminhoco {
def dormir() { println "zzzzz" }
}
@Mixin(AlunoDorminhoco)
class Aluno implements Estudante {
[...]
}
aluno1.dormir() //zzzzz
Groovy Beans vs Java Beans
Qual é a vantagem de usar Groovy
Beans?
•JavaBeans com sintaxe simplificada
•Construtor dinâmico (mapa com valores)
•Gera getter e setter sem precisar declarar
•Listeners e forma de closures
Exemplo: Groovy Beans
class Customer {
Integer id
String name
void setName(String name) {
this.name = "Senhor "+name
}
}
Customer customer = new Customer()
customer.id = 1234
//set
customer.name = "Manolo"
//set
println customer.id
println customer.name
//get = 1234
//get = Senhor Manolo
Groovy vs Java
•
•
•
•
•
•
Condição: objeto null = false, objeto com referencia = true
Finalização com ponto e vírgula opcional
Return opcional
Switch com strings, ranges, etc.
Concatenar por ${} dentro de strings ””
SwingBuilter: simplifica a declaracao, o posicionamento e os
eventos dos elementos Swing (Java)
Caracteristicas do Groovy inexistente
no java
•
•
•
•
Closure.
Sintaxe nativa para listas e mapas.
Interação polifórmica no switch-case.
Tipo dinâmico ou estático são aceitáveis, por isso pode-se
omitir o tipo na hora de declarar métodos ou variáveis.
• Pode-se embutir expressões lógicas dentro de um String.
• Sintaxe simplificada para escrever beans, com facilidade de
adição e manipulação nas propriedades de eventos
listeners.
Frameworks (utilizaçao)
• Grails: heavyweight web framework (MVC)
http://grails.org/
• Griffon: desktop framework (MVC)
http://griffon.codehaus.org/
• Gaelyk: lightweight web framework pra Google App Engine
http://gaelyk.appspot.com/
Exemplo aplicação Grails
"Como fazer um Twitter em 5 minutos"
“I can honestly say if someone had shown me
the Programming Scala book by Martin Odersky, Lex
Spoon & Bill Venners back in 2003 I’d probably have
never created Groovy.” –James Strachan.
Referências
http://groovy.codehaus.org/
http://groovyconsole.appspot.com/