Sintassi e tipi di base di Groovy
Comprenda la sintassi semplificata di Groovy, il tipaggio dinamico, i tipi di dati comuni e gli operatori.
Sintassi e tipi di base di Groovy è una lezione Groovy & Gradle: JVM Automation and Build Engineering gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Groovy & Gradle: JVM Automation and Build Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Groovy & Gradle: JVM Automation and Build Engineering include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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.
Impara Groovy con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Sintassi e tipi di base di Groovy» è gratuita?
Sì — il testo completo di «Sintassi e tipi di base di Groovy» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Groovy & Gradle: JVM Automation and Build Engineering, passa a CoddyKit PRO. Il corso Groovy & Gradle: JVM Automation and Build Engineering include 4 lezioni in totale.
Cosa imparerò in «Sintassi e tipi di base di Groovy»?
Comprenda la sintassi semplificata di Groovy, il tipaggio dinamico, i tipi di dati comuni e gli operatori. Eserciti Groovy & Gradle: JVM Automation and Build Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Groovy & Gradle: JVM Automation and Build Engineering?
Non è richiesta alcuna esperienza precedente. Groovy & Gradle: JVM Automation and Build Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Sintassi e tipi di base di Groovy»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Groovy & Gradle: JVM Automation and Build Engineering?
Sì. Ogni lezione Groovy & Gradle: JVM Automation and Build Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Introduzione a Groovy e alla JVM
- Sintassi e tipi di base di Groovy
- Script Groovy e GShell
- Stringhe Groovy e GString