Control structures in Groovy

To control program flow in Groovy we can use all control structures available in Java, but with additional power.

In Java, branching statements like 'if', and 'while' accept an expression which evaluates to a boolean value. We cannot use an object where a boolean is required. Groovy, on the other hand has the concept of Groovy truth, which coerces non boolean values into boolean values. Thus statement like these are perfectly valid in Groovy.

List list = ['apples']
if(list) {
 println 'This list is not empty'
}

Here the list object evaluates to a boolean value. Any non empty list will evaluate to true. This article explains coercion rules for the Groovy truth.

Groovy truth allows us to use non booleans inside conditionals. It evaluates objects to their (truth) boolean values. With Groovy truth we can use booleans, Strings, GStrings, List, Map, Numbers, and any arbitrary object where a boolean is expected.

Groovy also gives greater power to switch statements. In Java we can only use integers, characters, and Enum constants in switch statements. However, Groovy allows the use of expressions that evaluate to arbitrary objects in switch as well as case statements.

printGameType('Soccer')
printGameType('Cricket')
printGameType('Tag')

def printGameType(name) {
    def boardGames = ['Chess', 'Carrom', 'Monopoly']
    def ballGames = ['Soccer', 'Football', 'Basketball']
    def ballAndBatGame = ['Baseball', 'Cricket']
    switch(name) {
        case boardGames:
            println """${name} is a board game"""
            break
        case ballGames:
            println """${name} is a ball game"""
            break
        case ballAndBatGame:
            println """${name} is a ball and bat game"""
        default:
            println """Could not determine game type of ${name}"""
    }
}

The output from running the above program is:

Soccer is a ball game
Cricket is a ball and bat game
Could not determine game type of Cricket
Could not determine game type of Tag

In Groovy, whenever a case expression is evaluated, the isCase() method of the object (which the case expression evaluates to) is invoked with the object provided in the switch statement as a parameter. In the above example, the isCase() method of each of the List objects is invoked with the String provided in the switch statement. If an object does not have an isCase() method then it's equals() method is invoked.

These new features makes Groovy a very expressive language to represent control logic.