En aquest tema, explorarem els diferents tipus d'operadors disponibles en Groovy. Els operadors són símbols que indiquen a l'intèrpret que realitzi operacions específiques sobre un o més operands. Groovy, com altres llenguatges de programació, ofereix una varietat d'operadors que es poden classificar en diverses categories.
Tipus d'Operadors
- Operadors Aritmètics
- Operadors de Comparació
- Operadors Lògics
- Operadors de Bit a Bit
- Operadors d'Assignació
- Operadors Especials
- Operadors Aritmètics
Els operadors aritmètics s'utilitzen per realitzar operacions matemàtiques bàsiques com la suma, resta, multiplicació, divisió, etc.
| Operador | Descripció | Exemple |
|---|---|---|
+ |
Suma | a + b |
- |
Resta | a - b |
* |
Multiplicació | a * b |
/ |
Divisió | a / b |
% |
Mòdul (residu) | a % b |
** |
Exponenciació | a ** b |
Exemple:
def a = 10
def b = 3
println "Suma: ${a + b}" // Suma: 13
println "Resta: ${a - b}" // Resta: 7
println "Multiplicació: ${a * b}" // Multiplicació: 30
println "Divisió: ${a / b}" // Divisió: 3.3333333333333335
println "Mòdul: ${a % b}" // Mòdul: 1
println "Exponenciació: ${a ** b}" // Exponenciació: 1000
- Operadors de Comparació
Els operadors de comparació s'utilitzen per comparar dos valors. El resultat d'una operació de comparació és un valor booleà (true o false).
| Operador | Descripció | Exemple |
|---|---|---|
== |
Igual a | a == b |
!= |
Diferent de | a != b |
> |
Major que | a > b |
< |
Menor que | a < b |
>= |
Major o igual que | a >= b |
<= |
Menor o igual que | a <= b |
Exemple:
def a = 10
def b = 3
println "Igual a: ${a == b}" // Igual a: false
println "Diferent de: ${a != b}" // Diferent de: true
println "Major que: ${a > b}" // Major que: true
println "Menor que: ${a < b}" // Menor que: false
println "Major o igual que: ${a >= b}" // Major o igual que: true
println "Menor o igual que: ${a <= b}" // Menor o igual que: false
- Operadors Lògics
Els operadors lògics s'utilitzen per combinar expressions booleanes.
| Operador | Descripció | Exemple |
|---|---|---|
&& |
I lògic | a && b |
| ` | ` | |
! |
Negació lògica | !a |
Exemple:
def a = true
def b = false
println "I lògic: ${a && b}" // I lògic: false
println "O lògic: ${a || b}" // O lògic: true
println "Negació lògica: ${!a}" // Negació lògica: false
- Operadors de Bit a Bit
Els operadors de bit a bit s'utilitzen per realitzar operacions a nivell de bit.
| Operador | Descripció | Exemple |
|---|---|---|
& |
I de bit a bit | a & b |
| ` | ` | O de bit a bit |
^ |
XOR de bit a bit | a ^ b |
~ |
Complement de bit | ~a |
<< |
Desplaçament a l'esquerra | a << b |
>> |
Desplaçament a la dreta | a >> b |
>>> |
Desplaçament a la dreta sense signe | a >>> b |
Exemple:
def a = 5 // 0101 en binari
def b = 3 // 0011 en binari
println "I de bit a bit: ${a & b}" // I de bit a bit: 1 (0001 en binari)
println "O de bit a bit: ${a | b}" // O de bit a bit: 7 (0111 en binari)
println "XOR de bit a bit: ${a ^ b}" // XOR de bit a bit: 6 (0110 en binari)
println "Complement de bit: ${~a}" // Complement de bit: -6 (en binari: 1010)
println "Desplaçament a l'esquerra: ${a << 1}" // Desplaçament a l'esquerra: 10 (1010 en binari)
println "Desplaçament a la dreta: ${a >> 1}" // Desplaçament a la dreta: 2 (0010 en binari)
println "Desplaçament a la dreta sense signe: ${a >>> 1}" // Desplaçament a la dreta sense signe: 2 (0010 en binari)
- Operadors d'Assignació
Els operadors d'assignació s'utilitzen per assignar valors a les variables.
| Operador | Descripció | Exemple |
|---|---|---|
= |
Assignació | a = b |
+= |
Assignació amb suma | a += b |
-= |
Assignació amb resta | a -= b |
*= |
Assignació amb multiplicació | a *= b |
/= |
Assignació amb divisió | a /= b |
%= |
Assignació amb mòdul | a %= b |
**= |
Assignació amb exponenciació | a **= b |
Exemple:
def a = 10
def b = 3
a += b
println "Assignació amb suma: ${a}" // Assignació amb suma: 13
a -= b
println "Assignació amb resta: ${a}" // Assignació amb resta: 10
a *= b
println "Assignació amb multiplicació: ${a}" // Assignació amb multiplicació: 30
a /= b
println "Assignació amb divisió: ${a}" // Assignació amb divisió: 10.0
a %= b
println "Assignació amb mòdul: ${a}" // Assignació amb mòdul: 1.0
a **= b
println "Assignació amb exponenciació: ${a}" // Assignació amb exponenciació: 1.0
- Operadors Especials
Groovy també té alguns operadors especials que no es troben en tots els llenguatges de programació.
| Operador | Descripció | Exemple |
|---|---|---|
?. |
Operador de navegació segura | a?.b |
*. |
Operador de propagació | a*.b |
?.[] |
Operador d'indexació segura | a?.[index] |
?: |
Operador Elvis | a ?: b |
as |
Operador de conversió | a as Type |
in |
Operador de pertinença | a in b |
Exemple:
def a = null
def b = "Hello"
println "Navegació segura: ${a?.length}" // Navegació segura: null
println "Operador Elvis: ${a ?: b}" // Operador Elvis: Hello
def list = [1, 2, 3]
println "Pertinença: ${2 in list}" // Pertinença: trueExercicis Pràctics
- Escriu un script en Groovy que calculi la suma, resta, multiplicació, divisió i mòdul de dos nombres donats.
- Escriu un script en Groovy que compari dos nombres i imprimeixi si són iguals, diferents, si un és major que l'altre, etc.
- Escriu un script en Groovy que utilitzi operadors lògics per combinar diverses expressions booleanes.
- Escriu un script en Groovy que utilitzi operadors de bit a bit per realitzar operacions sobre dos nombres.
- Escriu un script en Groovy que utilitzi operadors d'assignació per modificar el valor d'una variable.
Solucions
Exercici 1:
def a = 15
def b = 4
println "Suma: ${a + b}"
println "Resta: ${a - b}"
println "Multiplicació: ${a * b}"
println "Divisió: ${a / b}"
println "Mòdul: ${a % b}"Exercici 2:
def a = 10
def b = 20
println "Igual a: ${a == b}"
println "Diferent de: ${a != b}"
println "Major que: ${a > b}"
println "Menor que: ${a < b}"
println "Major o igual que: ${a >= b}"
println "Menor o igual que: ${a <= b}"Exercici 3:
def a = true
def b = false
def c = true
println "I lògic: ${a && b}"
println "O lògic: ${a || b}"
println "Negació lògica: ${!a}"
println "Combinació: ${(a && b) || c}"Exercici 4:
def a = 5 // 0101 en binari
def b = 3 // 0011 en binari
println "I de bit a bit: ${a & b}"
println "O de bit a bit: ${a | b}"
println "XOR de bit a bit: ${a ^ b}"
println "Complement de bit: ${~a}"
println "Desplaçament a l'esquerra: ${a << 1}"
println "Desplaçament a la dreta: ${a >> 1}"
println "Desplaçament a la dreta sense signe: ${a >>> 1}"Exercici 5:
def a = 10
def b = 3
a += b
println "Assignació amb suma: ${a}"
a -= b
println "Assignació amb resta: ${a}"
a *= b
println "Assignació amb multiplicació: ${a}"
a /= b
println "Assignació amb divisió: ${a}"
a %= b
println "Assignació amb mòdul: ${a}"
a **= b
println "Assignació amb exponenciació: ${a}"Conclusió
En aquesta secció, hem explorat els diferents tipus d'operadors disponibles en Groovy, incloent-hi operadors aritmètics, de comparació, lògics, de bit a bit, d'assignació i especials. Hem vist exemples pràctics de com utilitzar aquests operadors i hem proporcionat exercicis per reforçar els conceptes apresos. Amb aquesta base, estàs preparat per avançar a la següent secció sobre estructures de control en Groovy.
Curs de Programació Groovy
Mòdul 1: Introducció a Groovy
Mòdul 2: Sintaxi i Característiques del Llenguatge Groovy
Mòdul 3: Programació Orientada a Objectes en Groovy
Mòdul 4: Característiques Avançades de Groovy
Mòdul 5: Groovy en la Pràctica
- Entrada/Sortida de Fitxers
- Treballant amb XML i JSON
- Accés a Bases de Dades
- Desenvolupament Web amb Groovy
Mòdul 6: Proves i Depuració
Mòdul 7: Ecosistema i Eines de Groovy
- Eina de Construcció Gradle
- Framework de Proves Spock
- Framework Grails
- Altres Llibreries i Eines de Groovy
Mòdul 8: Millors Pràctiques i Temes Avançats
- Estil de Codi i Convencions
- Optimització del Rendiment
- Consideracions de Seguretat
- Concurrència en Groovy