O documento descreve o padrão de projeto Template Method em Groovy. O Template Method define os passos de um algoritmo e permite que subclasses implementem um ou mais desses passos. O exemplo mostra uma classe abstrata Accumulator com um método accumulate genérico e subclasses Sum e Product que implementam o método doAccumulate de forma diferente.

1. TemplateMethodPattern
Usando
Eriko Morais
erikopa@gmail.com
em Linguagem Dinâmica

2. OqueéoGroovy
● Groovy é uma linguagem de programação orientada a objetos
desenvolvida para a plataforma Java como alternativa à
linguagem de programação Java. Groovy possui
características de Python, Ruby e Smalltalk.
● Groovy utiliza uma sintaxe similar à de Java, é compilada
dinamicamente para bytecode Java, e integra-se
transparentemente com outros códigos e bibliotecas Java.

3. Características
Groovy possui algumas características não presentes no Java
padrão:
● Tipagem estática e tipagem dinâmica
● Sintaxe nativa para listas, arrays associativos, vetores,
e expressões regulares
● Clausuras (Clojures)
● Sobrecarga de operadores

4. templatemethodpattern
“O Template Method define os passos de um algoritmo e
permite que a implementação de um ou mais desses passos seja
fornecida por subclasses.”
Eric Freeman & Elisabeth Freeman - Use a Cabeça! Padrões de Projeto - 2nd ed.- p. 213

5. templatemethodpattern

6. Exemplo
abstract class Accumulator {
protected initial
abstract doAccumulate(total, v)
def accumulate(values) {
def total = initial
values.each { v -> total = doAccumulate(total,
v) }
total
}
}
class Sum extends Accumulator {
def Sum() { initial = 0 }
def doAccumulate(total, v) { total + v }
}
class Product extends Accumulator {
def Product() { initial = 1 }
def doAccumulate(total, v) {
total * v }
}
println new
Sum().accumulate([1,2,3,4])
println new
Product().accumulate([1,2,3,4])
http://groovy-lang.org/design-patterns.html#_template_method_pattern

7. Simplificando
Você pode ter o resultado similar injetando um método usando
Closures.
Closure addAll = { total, item -> total += item }
def accumulated = [1, 2, 3, 4].inject(0, addAll)
println accumulated // => 10
Closure multAll = { total, item -> total *= item }
accumulated = [1, 2, 3, 4].inject(1, multAll)
println accumulated // => 24
Usando closures desta forma
parece mais com o padrão de
Strategy, mas se
percebermos que o método de
injeção built-in é a parte
genérica do algoritmo para
o nosso método de modelo,
em seguida, os Closures
tornam as peças
personalizadas do padrão
Template Method.
http://groovy-lang.org/design-patterns.html#_template_method_pattern

8. Umareferênciarápida
Imagem retirada de http://python.pro.br/wiki/index.php?title=Design_patterns

9. Obrigado!
Mais sobre a linguagem em:
http://www.groovy-lang.org/