Chapitre Les bases du language Groovy La programmation Objet en Groovy {{ resumeCollapse ? '-' : '+' }} Résumé Cette leçon présente les bases de la programmation objet en Groovy Dernière modification : Dec 08 , 2024 {{ !slideMode ? "Passer en mode diapositive" : "Passer en mode lecture" }} Le langage Groovy : instructions et OOP Created by Sylvain Leroy ## Instructions de base ## Déclaration de variables ```language-groovy int x = 1 def y = 1 var z = 1 j = 1 ``` ## Affectations de variables (1/2) ```language-groovy x = 1 println x x = false println x x = "Hi" println x ``` ## Appels de méthodes ```language-groovy def myMethod() { // ... } def myOtherMethod(someArg1, someArg2) { // ... } myMethod() // OK myMethod // error myOtherMethod(2, 3) // OK myOtherMethod 4, 5 // OK ``` ## Résultats ```language-groovy 1 Wed Jun 09 20:44:58 UTC 2021 -3.1499392 false Hi ``` ## Affectations de variables (2/2) ```language-groovy def (a, b, c) = [10, 20, 'foo'] assert a == 10 && b == 20 && c == 'foo' def (int i, String j) = [10, 'foo'] assert i == 10 && j == 'foo' def nums = [1, 3, 5] def a, b, c (a, b, c) = nums assert a == 1 && b == 3 && c == 5 ``` ## Instruction switch L'instruction **switch** ressemble fortement à celle Java mais avec de nombreuses améliorations. * Utilisation des litéraux de classe pour tester le type de l'instance * Utilisation d'expression régulière qui teste le toString() de l'expression * Utilisation de collections : l'expression est vérifie si la valeur est comprise dans la collection, cela fonctionne également avec les **intervalles**. * Les closures peuvent également être utilisées. La valeur de la Closure est évaluée avec le "Groovy truth". * Sinon, la valeur est comparée avec l'expression du switch * Quand une closure est utilisée, le paramètre it prend la valeur du switch. ### Structures de contrôle ```language-groovy def x = 1.23 def result = "" switch ( x ) { case "foo": result = "found foo" // lets fall through case "bar": result += "bar" case [4, 5, 6, 'inList']: result = "list" break case 12..30: result = "range" break case Integer: result = "integer" break case Number: result = "number" break case ~/fo*/: // toString() representation of x matches the pattern? result = "foo regex" break case { it <0 }: // or { x <0 } result="negative" break default: result="default" } assert result =="number" ``` ### Structures de contrôle ```language-groovy def x = false def y = false if ( !x ) { x = true } assert x == true if ( x ) { x = false } else { y = true } assert x == y ``` ## Déclaration de méthodes ```language-groovy int add( int a, int b) { // Similar as in Java return a + b; } add( int a, int b) { // Omitted returned type return a + b; } add( int a, int b) { // Omitted returned type and return and semi-column a + b } def add( int a, int b) { // Using def keyword return a + b; } ``` ## Les structures de données ### Les structures de données disponibles en Groovy * Les structures classiques Java : * **classes** * **classes abstraites** * **interfaces** * **enums** * Les traits ### Déclaration de classes ``` class Person { String name Integer age private String gender; def increaseAge(Integer years) { this.age += years } } ``` ### Déclaration de classes * Les classes et les méthodes sans modificateur de visibilité sont automatiquement publics. * La visibilité "package private" nécessite une annotation spéciale. * Les attributs sans visibilité sont transformés en **propriétés** automatiquement. Une **propriété** comprend un attribut, son getter et son setter. ### Immutabilité ``` @Immutable class Coordinates { double latitude double longitude double getAt(int idx) { if (idx == 0) latitude else if (idx == 1) longitude else throw new Exception("Wrong coordinate index, use 0 or 1") } } ``` ### Interfaces ``` interface Marks { void DisplayMarks(); } class Student implements Marks { int StudentID int Marks1; void DisplayMarks() { println(Marks1); } } ``` ### Déstructuration d'objets ``` def coordinates = new Coordinates(latitude: 43.23, longitude: 3.67) def (la, lo) = coordinates assert la == 43.23 assert lo == 3.67 ``` ## Les traits ### Les traits Les Traits sont des structures de données du langage Groovy qui permettent : * La composition de comportements * L'implémentation à l'exécution d'interface * Surcharger le comportement par défaut de méthodes * La compatibilité avec le typage statique et la compilation native ### Les traits sont assez proches de la notion d'interface et du comportement via le mot clé **default** en Java 8. ### Exemple 1 ```language-groovy trait VolCapacité { String vol() { "Je vole" } } ``` ### Utilisation du trait ```language-groovy class Oiseau implements VolCapacité {} def o = new Oiseau() assert o.vol() == "Je vole" ``` ### Définition de propriétés ```language-groovy trait Named { String name } class Person implements Named {} def p = new Person(name: 'Bob') assert p.name == 'Bob' assert p.getName() == 'Bob' ``` ### Composition de traits ```language-groovy trait VolCapacité { String vol() { "Je vole" } } trait ParoleCapacité { String parle() { "Je parle" } } class Canard implements VolCapacité, ParoleCapacité {} def d = new Canard() assert d.vol() == "Je vole" assert d.parle() == "Je parle" ``` ### Surcharge d'opérateurs (1/2) | Opérateur | Méthode | |--------------|---------------| | `a + b` | a.plus(b) | | `a - b` | a.minus(b) | | `a * b` | a.multiply(b) | | `a / b` | a.div(b) | | `a % b` | a.mod(b) | | `a++ or ++a` | a.next() | | `a-- or --a` | a.previous() | | `a**b` | a.power(b) | | `a ¦ b` | a.or(b) | | `a & b` | a.and(b) | | `a ^ b` | a.xor(b) | | `~a` | a.negate() | | `a[b]` | a.getAt(b) | | `a[b] = c` | a.putAt(b,c) | ### Surcharge d'opérateurs (2/2) | Opérateur | Méthode | |-------------------------|-------------------------| | `a << b` | a.leftShift(b) | | `a >> b` | a.rightShift(b) | | `a >>> b` | a.rightShiftUnsigned(b) | | `switch(a) { case b: }` | b.isCase(a) | | `a == b` | a.equals(b) | | `a != b` | !a.equals(b) | | `a <=> b` | a.compareTo(b) | | `a > b` | a.compareTo(b) > 0 | | `a >= b` | a.compareTo(b) >= 0 | | `a < b` | a.compareTo(b) < 0 | | `a <= b` | a.compareTo(b) <= 0 | # Fin de la leçon Le langage Groovy : instructions et OOP Created by Sylvain Leroy ## Instructions de base ## Déclaration de variables ```language-groovy int x = 1 def y = 1 var z = 1 j = 1 ``` ## Affectations de variables (1/2) ```language-groovy x = 1 println x x = false println x x = "Hi" println x ``` ## Appels de méthodes ```language-groovy def myMethod() { // ... } def myOtherMethod(someArg1, someArg2) { // ... } myMethod() // OK myMethod // error myOtherMethod(2, 3) // OK myOtherMethod 4, 5 // OK ``` ## Résultats ```language-groovy 1 Wed Jun 09 20:44:58 UTC 2021 -3.1499392 false Hi ``` ## Affectations de variables (2/2) ```language-groovy def (a, b, c) = [10, 20, 'foo'] assert a == 10 && b == 20 && c == 'foo' def (int i, String j) = [10, 'foo'] assert i == 10 && j == 'foo' def nums = [1, 3, 5] def a, b, c (a, b, c) = nums assert a == 1 && b == 3 && c == 5 ``` ## Instruction switch L'instruction **switch** ressemble fortement à celle Java mais avec de nombreuses améliorations. * Utilisation des litéraux de classe pour tester le type de l'instance * Utilisation d'expression régulière qui teste le toString() de l'expression * Utilisation de collections : l'expression est vérifie si la valeur est comprise dans la collection, cela fonctionne également avec les **intervalles**. * Les closures peuvent également être utilisées. La valeur de la Closure est évaluée avec le "Groovy truth". * Sinon, la valeur est comparée avec l'expression du switch * Quand une closure est utilisée, le paramètre it prend la valeur du switch. ### Structures de contrôle ```language-groovy def x = 1.23 def result = "" switch ( x ) { case "foo": result = "found foo" // lets fall through case "bar": result += "bar" case [4, 5, 6, 'inList']: result = "list" break case 12..30: result = "range" break case Integer: result = "integer" break case Number: result = "number" break case ~/fo*/: // toString() representation of x matches the pattern? result = "foo regex" break case { it <0 }: // or { x <0 } result="negative" break default: result="default" } assert result =="number" ``` ### Structures de contrôle ```language-groovy def x = false def y = false if ( !x ) { x = true } assert x == true if ( x ) { x = false } else { y = true } assert x == y ``` ## Déclaration de méthodes ```language-groovy int add( int a, int b) { // Similar as in Java return a + b; } add( int a, int b) { // Omitted returned type return a + b; } add( int a, int b) { // Omitted returned type and return and semi-column a + b } def add( int a, int b) { // Using def keyword return a + b; } ``` ## Les structures de données ### Les structures de données disponibles en Groovy * Les structures classiques Java : * **classes** * **classes abstraites** * **interfaces** * **enums** * Les traits ### Déclaration de classes ``` class Person { String name Integer age private String gender; def increaseAge(Integer years) { this.age += years } } ``` ### Déclaration de classes * Les classes et les méthodes sans modificateur de visibilité sont automatiquement publics. * La visibilité "package private" nécessite une annotation spéciale. * Les attributs sans visibilité sont transformés en **propriétés** automatiquement. Une **propriété** comprend un attribut, son getter et son setter. ### Immutabilité ``` @Immutable class Coordinates { double latitude double longitude double getAt(int idx) { if (idx == 0) latitude else if (idx == 1) longitude else throw new Exception("Wrong coordinate index, use 0 or 1") } } ``` ### Interfaces ``` interface Marks { void DisplayMarks(); } class Student implements Marks { int StudentID int Marks1; void DisplayMarks() { println(Marks1); } } ``` ### Déstructuration d'objets ``` def coordinates = new Coordinates(latitude: 43.23, longitude: 3.67) def (la, lo) = coordinates assert la == 43.23 assert lo == 3.67 ``` ## Les traits ### Les traits Les Traits sont des structures de données du langage Groovy qui permettent : * La composition de comportements * L'implémentation à l'exécution d'interface * Surcharger le comportement par défaut de méthodes * La compatibilité avec le typage statique et la compilation native ### Les traits sont assez proches de la notion d'interface et du comportement via le mot clé **default** en Java 8. ### Exemple 1 ```language-groovy trait VolCapacité { String vol() { "Je vole" } } ``` ### Utilisation du trait ```language-groovy class Oiseau implements VolCapacité {} def o = new Oiseau() assert o.vol() == "Je vole" ``` ### Définition de propriétés ```language-groovy trait Named { String name } class Person implements Named {} def p = new Person(name: 'Bob') assert p.name == 'Bob' assert p.getName() == 'Bob' ``` ### Composition de traits ```language-groovy trait VolCapacité { String vol() { "Je vole" } } trait ParoleCapacité { String parle() { "Je parle" } } class Canard implements VolCapacité, ParoleCapacité {} def d = new Canard() assert d.vol() == "Je vole" assert d.parle() == "Je parle" ``` ### Surcharge d'opérateurs (1/2) | Opérateur | Méthode | |--------------|---------------| | `a + b` | a.plus(b) | | `a - b` | a.minus(b) | | `a * b` | a.multiply(b) | | `a / b` | a.div(b) | | `a % b` | a.mod(b) | | `a++ or ++a` | a.next() | | `a-- or --a` | a.previous() | | `a**b` | a.power(b) | | `a ¦ b` | a.or(b) | | `a & b` | a.and(b) | | `a ^ b` | a.xor(b) | | `~a` | a.negate() | | `a[b]` | a.getAt(b) | | `a[b] = c` | a.putAt(b,c) | ### Surcharge d'opérateurs (2/2) | Opérateur | Méthode | |-------------------------|-------------------------| | `a << b` | a.leftShift(b) | | `a >> b` | a.rightShift(b) | | `a >>> b` | a.rightShiftUnsigned(b) | | `switch(a) { case b: }` | b.isCase(a) | | `a == b` | a.equals(b) | | `a != b` | !a.equals(b) | | `a <=> b` | a.compareTo(b) | | `a > b` | a.compareTo(b) > 0 | | `a >= b` | a.compareTo(b) >= 0 | | `a < b` | a.compareTo(b) < 0 | | `a <= b` | a.compareTo(b) <= 0 | # Fin de la leçon Slideshow Aperçu Leçon précédente Chapitre suivant Please enable JavaScript to view the comments powered by Disqus.
