Groovy - Data Types and Variables

4. Data Types and Variables

Data Types in Groovy

In Groovy, data types represent the kind of values a variable can hold. Groovy is dynamically typed, so you don't need to explicitly declare a variable's data type; it is determined at runtime based on the assigned value. Here are the common data types in Groovy:

1. Numbers:

Groovy supports two main types of numbers:

• Integers: Whole numbers without a fractional part.
• Floating-Point Numbers: Numbers with a decimal point.

def age = 30 // Integer
def temperature = 98.6 // Floating-point number

2. Strings:

Strings are used to represent textual data. They can be enclosed in single or double quotes. Groovy supports string interpolation, allowing you to embed variables and expressions within strings.

def singleQuoted = 'This is a single-quoted string.'
def doubleQuoted = "This is a double-quoted string with interpolation. My name is ${name}."

3. Booleans:

Booleans represent two values: 'true' or 'false'. They are commonly used for conditional statements and logical operations.

def isGroovyFun = true
def isJavaCool = false

4. Lists:

Lists are ordered collections of elements. You can store multiple values in a list and access them by their position (index).

def colors = ['red', 'green', 'blue']
def numbers = [1, 2, 3, 4, 5]

// Accessing elements
def firstColor = colors[0] // 'red'

5. Maps:

Maps are collections of key-value pairs. Keys are unique, and they are used to access values. Maps are useful for representing structured data.

def person = [name: 'John', age: 25]

// Accessing values
def personName = person.name // 'John'

6. Closures:

Closures are blocks of code that can be assigned to variables. They can capture and manipulate their surrounding context. Closures are commonly used for functional programming and as callback functions.

def add = { a, b -> a + b }
def result = add(3, 4) // 7

7. Type Conversion:

You can convert data from one type to another using conversion functions provided by Groovy, such as 'toInteger()', 'toString()', and 'toDouble()'.

def numString = "42"
def num = numString.toInteger() // Converts the string to an integer

8. Default Values:

Uninitialized variables in Groovy have a default value of  'null'. This means they don't hold any specific value until you assign one.

def uninitializedVar
println(uninitializedVar) // Outputs: null

These are the primary data types in Groovy. Understanding these data types and how to work with them is essential for effective Groovy programming. Groovy's dynamic typing allows for flexibility and ease of use when dealing with various data types.

Variables in Groovy

Variables are used to store and manage data in Groovy. Groovy is a dynamically typed language, which means you don't need to declare a variable's data type explicitly; it's determined at runtime based on the assigned value. Here are the types of variables in Groovy:

1. Local Variables:

Local variables are declared within a specific scope, such as a method or block, and are only accessible within that scope.

def greet(name) {
    def message = "Hello, ${name}!" // Local variable
    println(message)
}
greet("Alice")

In this example, the 'message' variable is a local variable within the 'greet'method.

2. Instance Variables:

Instance variables are associated with objects (instances) of a class. They hold state information for the object and are accessible across methods within the object.

class Person {
    def name // Instance variable
    
    def introduce() {
        println("My name is ${name}.")
    }
}

def person = new Person()
person.name = "John"
person.introduce()

In this example, 'name' is an instance variable of the 'Person' class.

3. Class Variables (Static Variables):

Class variables belong to a class rather than instances of the class. They are shared among all instances of the class and can be accessed without creating an object.

class MathOperations {
    static def pi = 3.14159 // Class variable
    
    static def calculateArea(radius) {
        return pi * radius * radius
    }
}

println(MathOperations.pi) // Accessing class variable
def area = MathOperations.calculateArea(5)
println("Area: ${area}")

In this example, 'pi' is a class variable of the 'MathOperations' class.

4. Global Variables:

Groovy allows you to declare global variables that are accessible throughout the script. However, it's considered good practice to minimize the use of global variables.

globalVar = 42 // Global variable

def printGlobal() {
    println(globalVar)
}

printGlobal()

In this example, 'globalVar' is a global variable accessible within the script.

5. Closure Variables (Closure Scope):

Closures are blocks of code that can capture variables from their surrounding context. These captured variables are called closure variables.

def outer = 10

def closure = {
    def inner = 5 // Closure variable
    return outer + inner
}

def result = closure()
println(result)

In this example, 'inner'is a closure variable captured by the 'closure' block.

6. Final Variables (Constants):

Final variables are declared using the 'final'keyword and cannot be modified once assigned a value. They are often used for constants.

final MAX_VALUE = 100
println("The maximum value is ${MAX_VALUE}")