Sintaxe e tipos básicos de Groovy
Compreenda a sintaxe flexível do Groovy, a tipagem dinâmica, os tipos de dados comuns e os operadores.
Sintaxe e tipos básicos de Groovy é uma aula grátis de Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Groovy & Gradle: JVM Automation and Build Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Groovy's Relaxed Style
Groovy's syntax is deliberately relaxed — you can skip a lot of what Java forces on you and write the same logic in far fewer lines.
Optional Semicolons & Parens
Two big relaxations: semicolons are optional, and parentheses around method arguments often are too. The code below shows both.
public class Main {
// Define a simple static method for demonstration
static void printMessage(String msg) {
System.out.println(msg)
}
public static void main(String[] args) {
// Semicolons are optional at the end of a line
System.out.println("Hello from Groovy")
System.out.println("CoddyKit makes learning fun") // Semicolon also optional
// Parentheses for method calls with arguments can be omitted
printMessage "Less typing, more coding!" // Calling without parentheses
printMessage("It's concise!") // Calling with parentheses
}
}Dynamic `def` for Variables
Use def to declare a variable without naming its type — Groovy figures it out at runtime, and it can even hold different types.
public class Main {
public static void main(String[] args) {
def myVariable = "A string value"
System.out.println("Value: " + myVariable + ", Type: " + myVariable.getClass().getName())
myVariable = 12345
System.out.println("Value: " + myVariable + ", Type: " + myVariable.getClass().getName())
myVariable = true
System.out.println("Value: " + myVariable + ", Type: " + myVariable.getClass().getName())
}
}Groovy's Smart Type Inference
Even without def, Groovy uses type inference — it reads the assigned value and picks the right type for you behind the scenes.
public class Main {
public static void main(String[] args) {
// Groovy infers 'productName' as a String
productName = "Groovy Course"
System.out.println("Product: " + productName + ", Type: " + productName.getClass().getName())
// Groovy infers 'version' as an Integer
version = 4
System.out.println("Version: " + version + ", Type: " + version.getClass().getName())
// Groovy infers 'price' as a Double
price = 29.99
System.out.println("Price: " + price + ", Type: " + price.getClass().getName())
}
}Numbers: Integers & Decimals
Groovy handles numbers naturally: Integer/Long for whole values, Double for decimals, plus BigInteger and BigDecimal for exact math.
public class Main {
public static void main(String[] args) {
def quantity = 150 // Inferred as Integer
def temperature = -4.5 // Inferred as Double
def largeId = 987654321098765L // Explicit Long using 'L' suffix
def exactPi = 3.1415926535G // Explicit BigDecimal using 'G' suffix
System.out.println("Quantity: " + quantity + " (Type: " + quantity.getClass().getName() + ")")
System.out.println("Temperature: " + temperature + " (Type: " + temperature.getClass().getName() + ")")
System.out.println("Large ID: " + largeId + " (Type: " + largeId.getClass().getName() + ")")
System.out.println("Exact Pi: " + exactPi + " (Type: " + exactPi.getClass().getName() + ")")
}
}Strings: Text in Groovy
Single quotes give a plain String; double quotes give a GString that interpolates variables and expressions with $x or ${...}.
public class Main {
public static void main(String[] args) {
def user = "Alice"
def itemPrice = 25
// Single-quoted string: no interpolation
def message1 = 'Hello, $user! Your item costs $itemPrice.'
System.out.println("Literal string: " + message1)
// Double-quoted string (GString): allows interpolation
def message2 = "Hello, $user! Your item costs $itemPrice."
System.out.println("Interpolated string: " + message2)
// Interpolating an expression
def total = itemPrice * 2
def message3 = "Two items for $user cost ${itemPrice * 2} (or $total).
System.out.println("Expression interpolation: " + message3)
}
}Basic Arithmetic Operators
All the usual arithmetic operators work. One twist: Groovy's / does decimal division by default, even on two integers.
public class Main {
public static void main(String[] args) {
def num1 = 20
def num2 = 6
System.out.println("Addition: " + (num1 + num2)) // 26
System.out.println("Subtraction: " + (num1 - num2)) // 14
System.out.println("Multiplication: " + (num1 * num2)) // 120
System.out.println("Division: " + (num1 / num2)) // 3.3333333333333335 (decimal division)
System.out.println("Modulo: " + (num1 % num2)) // 2 (remainder)
}
}Comparison & Logical Operators
Compare values with ==, !=, <, > and combine the booleans with the logical operators &&, ||, and !.
public class Main {
public static void main(String[] args) {
def val1 = 10
def val2 = 20
def val3 = 10
System.out.println("val1 == val3: " + (val1 == val3)) // true
System.out.println("val1 != val2: " + (val1 != val2)) // true
System.out.println("val1 < val2: " + (val1 < val2)) // true
def condition1 = (val1 < val2) // true
def condition2 = (val1 == val3) // true
System.out.println("condition1 && condition2: " + (condition1 && condition2)) // true
System.out.println("condition1 || (val1 > val2): " + (condition1 || (val1 > val2))) // true
System.out.println("!condition1: " + (!condition1)) // false
}
}Groovy Syntax & Types Check
Choose the TRUE statements about Groovy syntax and basic types:
Lesson Recap: Groovy Basics
You covered relaxed syntax, def and type inference, numbers and GStrings, plus the operators. The Groovy building blocks are yours now.
Perguntas Frequentes
A aula “Sintaxe e tipos básicos de Groovy” é grátis?
Sim — o texto completo de “Sintaxe e tipos básicos de Groovy” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Groovy & Gradle: JVM Automation and Build Engineering, atualize para CoddyKit PRO. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.
O que vou aprender em “Sintaxe e tipos básicos de Groovy”?
Compreenda a sintaxe flexível do Groovy, a tipagem dinâmica, os tipos de dados comuns e os operadores. Você pratica Groovy & Gradle: JVM Automation and Build Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Groovy & Gradle: JVM Automation and Build Engineering?
Nenhuma experiência prévia é necessária. Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Sintaxe e tipos básicos de Groovy”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Groovy & Gradle: JVM Automation and Build Engineering?
Sim. Cada aula de Groovy & Gradle: JVM Automation and Build Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Introdução a Groovy e à JVM
- Sintaxe e tipos básicos de Groovy
- Scripts Groovy e GShell
- Cadeias de Texto Groovy e GStrings