Groovy & Gradle: JVM Automation and Build Engineering · Pelajaran

Sintaks & Tipe Dasar Groovy

Pahami sintaks Groovy yang lebih ringkas, pengetikan dinamis, tipe data umum, dan operator.

Sintaks & Tipe Dasar Groovy adalah pelajaran Groovy & Gradle: JVM Automation and Build Engineering gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Groovy & Gradle: JVM Automation and Build Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Sintaks & Tipe Dasar Groovy” gratis?

Ya — teks lengkap “Sintaks & Tipe Dasar Groovy” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Groovy & Gradle: JVM Automation and Build Engineering, upgrade ke CoddyKit PRO. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Sintaks & Tipe Dasar Groovy”?

Pahami sintaks Groovy yang lebih ringkas, pengetikan dinamis, tipe data umum, dan operator. Kamu berlatih Groovy & Gradle: JVM Automation and Build Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Groovy & Gradle: JVM Automation and Build Engineering?

Tidak diperlukan pengalaman sebelumnya. Groovy & Gradle: JVM Automation and Build Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Sintaks & Tipe Dasar Groovy” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Groovy & Gradle: JVM Automation and Build Engineering ini?

Ya. Setiap pelajaran Groovy & Gradle: JVM Automation and Build Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Groovy & Gradle: JVM Automation and Build Engineering