Groovy est un langage de programmation orienté objet pour la plateforme Java, qui facilite la syntaxe pour les développeurs Java en intégrant des concepts de langages de script tels que Python et Ruby. Il prend en charge le typage statique et dynamique, ainsi que des fonctionnalités comme les fermetures et les collections, tout en étant compatible avec le bytecode Java. Groovy se distingue par sa simplicité, sa lisibilité et sa courbe d'apprentissage douce, notamment grâce à des méthodes pratiques comme les 'Groovy Koans' pour apprendre le langage.

1. Conception d'Applications
Interactives :
Applications Web et JEE
Séance #3
Groovy

2. Introduction à Groovy

3. Origine
James Strachan to Bob McWhirter in 2003:
Wouldn’t it be “groovy” if we could have native
syntax for lists, maps and regexs in Java
like in most scripting languages?
Wouldn’t it be “groovy” if we could have
duck typing in Java?
Wouldn’t it be “groovy” if we had
closures and properties in Java?

4. Groovy
Langage de POO destiné à la plate-forme Java
● Inspiré de Python, Ruby et Smalltalk
● Syntaxe très proche de Java
● Compilé
○ soit à la volée dynamiquement
○ soit classiquement vers bytecode

5. Groovy
Langage de POO destiné à la plate-forme Java
● Typages statique et dynamique
● Support natif pour listes, maps, et
expressions régulières
● Fermetures ou clôtures (closures)
● Surcharge des opérateurs
http://groovy.codehaus.org/

6. Intégration avec Java
○ Groovy génère du bytecode Java pour la JVM
■ Same strings, same regex S
■ Same APIs — JDK, collections, 3rd party, etc.
■ Same security model, same threading model
■ Same OO concepts
○ Compilation croisée
■ Compilateur groovyc pour Java et Groovy
■ Interopérabilité et mixité parfaite

7. Objectifs de Groovy
● Faciliter la vie du développeur Java
○ Un sur-ensemble de Java
○ Très facile à apprendre
● Aussi rapide et sur que Java
○ Avec validation de typage et compilation statiques
● Expressif, concis et légible

8. Un programme en Java
public class HelloWorld {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public String greet() {
return quot;Hello quot;+ name;
}
public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
helloWorld.setName("Groovy");
System.out.println(helloWorld.greet());
}
}

9. Un programme en Groovy
public class HelloWorld {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public String greet() {
return quot;Hello quot;+ name;
}
public static void main(String[] args) {
HelloWorld helloWorld = new HelloWorld();
helloWorld.setName("Groovy");
System.out.println(helloWorld.greet());
}
}

10. Le même programme bien
récrit en Groovy
class HelloWorld {
String name
def greet() {
"Hello $name"
}
}
def helloWorld = new HelloWorld(name: "Groovy")
println helloWorld.greet()

11. Le développeur Java, déjà
un développeur Groovy
● Code Java valable
Code Groovy valable
○ Dans 90% des cas
● Courbe d'apprentissage très douce

12. Déclaration de classes
● Même aspect qu'une déclaration Java
○ Le modificateur par défaut est publique
class HelloWorld {
String name
String greet() {
"Hello $name"
}
}

13. Plein de choses optionnelles
● Les points-virgules en fin de ligntye
● Le typage des variables et méthodes
● Les mots clés return et public
● Les parenthèses dans les appels aux méthodes

14. Typage optionnel
● Possibilité d'utiliser le typage statique
○ Comme dans Java
● Possibilité d'utiliser le typage dynamique
○ en remplaçant le type par le mot clé def
● Pas besoin de def pour les paramètres formelles
○ pour les des méthodes ou closures
def helloWorld = new HelloWorld(name: "Groovy")

15. Appel aux méthodes
● Dans les appels aux méthodes avec des paramètres on
peut omettre les parenthèses
def a = "Toto"
print(a)
print a
method(a, b)
method a, b
move(from:"ici", to:"là bas")
move from:"ici", to:"là bas"
list.each({ println it })
list.each(){ println it }
list.each { println it }

16. Scripts
● Script : du code Groovy non enfermé dans
une déclaration de classe
○ Pas besoin d'une méthode main
class HelloWorld {
String name
String greet() {
"Hello $name"
}
}
def helloWorld = new HelloWorld(name: "Groovy")
println helloWorld.greet()

17. Propriétés
● Les propriétés d'une classe sont déclarées
comme attributs de la classe
○ Des getters et setters sont générés lors de la
compilation/interprétation
class Beer {
String name
String brewery
String country
double alcohol
}

18. Opérateurs

19. Chaînes de caractères
● Exemples
'literal String'
'''literal
multiline String'''
def lang = 'Groovy'
"GString for $lang"
"$lang has ${lang.size()} chars"
"""multiline GString with
late eval at ${-> new Date()}"""
text = "Hello
text[0]
text[0..4]
text[0..<4]
text[-1]
text[-6..-1]
World!"
// returns "H"
// returns "Hello"
// returns "Hell"
// returns "!" (last char)
// "World!"(last 6 to last char)

20. Gammes de valeurs
● Exemples
assert (0..10).contains(5)
assert (0.0..10.0).containsWithinBounds(3.5)
for (item in 0..10) { println item }
for (item in 10..0) { println item }
(0..<10).each { println it }

21. Listes et maps
● Listes et maps sont des éléments de
première classe dans Groovy
○ Syntaxe adaptée, simplification
// Une liste vide
def a=[]
//Ajoutons des élements
a.add("toto")
a.add("titi")
//Listons les contenus
print a
//Résultat : [toto, titi]

22. Manipulation des listes
[1,2,3,4] == (1..4)
[1,2,3] + [1] == [1,2,3,1]
[1,2,3] << 1 == [1,2,3,1]
[1,2,3,1] - [1] == [2,3]
[1,2,3] * 2 == [1,2,3,1,2,3]
[1,[2,3]].flatten() == [1,2,3]
[1,2,3].reverse() == [3,2,1]
[1,2,3].disjoint([4,5,6]) == true
[1,2,3].intersect([4,3,1]) == [3,1]
[1,2,3].collect{ it+3 } == [4,5,6]
[1,2,3,1].unique().size() == 3
[1,2,3,1].count(1) == 2
[1,2,3,4].min() == 1
[1,2,3,4].max() == 4
[1,2,3,4].sum() == 10
[4,2,1,3].sort() == [1, 2, 3, 4]
[4,2,1,3].findAll{it%2 == 0} == [4,2]
[['a', 'b'], [1, 2]].transpose() == [['a', 1], ['b', 2]]

23. Manipulation des listes
def anims = ['cat','kangaroo','koala']
assert anims[2] == 'koala'
assert anims[0..1,2] == ['cat','kangaroo','koala']
def kanims = anims[1..2]
assert anims.findAll{it =~ /k.*/} == kanims
assert anims.find{ it =~ /k.*/} == kanims[0]
assert anims.grep(~/k.*/) == kanims
assert anims.join(' ') == 'cat kangaroo koala'
anims.remove(1)
assert anims == ['cat','koala']
anims.each { println it }
Des indexes négatives indiquent la fin de la liste
def list = [0,1,2]
assert list[-1] == 2
assert list[-1..0] == list.reverse()
assert list == [list.head()] + list.tail()

24. Maps
Syntaxe semblable à celle des listes
def map = [a:0, b:1]
def empty = [:]
Pour récupérer une valeur on peut :
● mettre la clé entre crochets
● mettre la clé comme une propriété de la map
● utiliser la méthode get
assert map['a'] == 0
assert map.b == 1
map['a'] = 'x'
map.b = 'y'
assert map == [a:'x', b:'y']
assert map.c == null
assert map.get('c', 2) == 2
assert map.c == 2

25. Manipulation des maps
Des méthodes d'itération permettent de parcourir la map en
s'appliquant à chaque couple clé/valeur
map.each { entry ->
println entry.key
println entry.value
}
map.each { key, value -> println "$key $value" }
for (entry in map) {
println "$entry.key $entry.value"
}
assert map.every { it.value.size() == 1 }
assert map.any { it.key % 4 == 0 }

26. Closures (fermetures)
● Des fonctions qui capturent des références à
l'environnement dans lequel ils s'exécutent
○ Des objets de première classe en Groovy
a = [1,2,3]
a.each({ x -> println x * x })
a.each { x -> println x * x }
a.each { println it * it }
def squareIt = { println it * it }
a.each(squareIt)
a.each squareIt

27. Closures (fermetures)
● Paramètres dans une closure

28. Comment apprendre
Groovy ?
Je ne vais pas passer une heure à vos passer
des slides
● Méthode peu efficace
Tentons quelque chose de nouveau
● Approche pratique
Essayons les Groovy Koans !
Groovy Koans ? Kesaco ?

29. Koans
Une nouvelle façon d'apprendre un langage
● Des petits cas pratiques
○ Sous la forme de suites de tests unitaires
● Chaque cas orienté pour un concept
○ Et un ensemble de tests qui ne passent pas
● Objectif : réparer les tests pour qu'ils
passent
○ Et apprendre le langage en passant
Méthode d'apprentissage différente et éfficace !

30. Groovy Koans :
Learn Groovy with the Koans
http://groovykoans.org/

31. C'est l'heure des Groovy Koans !