0Pricing
Groovy & Gradle: JVM Automation and Build Engineering · Lesson

Groovy Syntax & Basic Types

Understand Groovy's relaxed syntax, dynamic typing, common data types, and operators.

Groovy Syntax & Basic Types is a free Groovy & Gradle: JVM Automation and Build Engineering lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Groovy & Gradle: JVM Automation and Build Engineering learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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.

Frequently asked questions

Is the “Groovy Syntax & Basic Types” lesson free?

Yes — the full text of “Groovy Syntax & Basic Types” is free to read here on the web, and the Groovy & Gradle: JVM Automation and Build Engineering course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Groovy & Gradle: JVM Automation and Build Engineering course, upgrade to CoddyKit PRO.

What will I learn in “Groovy Syntax & Basic Types”?

Understand Groovy's relaxed syntax, dynamic typing, common data types, and operators. You practise Groovy & Gradle: JVM Automation and Build Engineering with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Groovy & Gradle: JVM Automation and Build Engineering?

No prior experience is required. Groovy & Gradle: JVM Automation and Build Engineering on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Groovy Syntax & Basic Types” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Groovy & Gradle: JVM Automation and Build Engineering lesson?

Yes. Every Groovy & Gradle: JVM Automation and Build Engineering lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Introduction to Groovy & JVM
  2. Groovy Syntax & Basic Types
  3. Groovy Scripts & GShell
  4. Groovy Strings & GStrings
← Back to Groovy & Gradle: JVM Automation and Build Engineering