How to Declare A Constructor Or Extends A Class Of A Groovy Script?

To declare a constructor in a Groovy script, you can use the def keyword followed by the class name, parentheses with any parameters you want to pass to the constructor, and then curly braces with the constructor logic inside. For example:

1
2
3
4
5

class MyClass {
    def MyClass(String name) {
        println "Hello, $name!"
    }
}

To extend a class in a Groovy script, you can use the extends keyword followed by the name of the class you want to extend. For example:

1
2
3
4
5

class MySubClass extends MyClass {
    def MySubClass(String name) {
        super(name)
    }
}

In this example, MySubClass extends the MyClass class and calls the constructor of the superclass using the super keyword.

How to override a constructor in Groovy?

In Groovy, you can override a constructor by creating a new constructor with the same signature as the one you want to override. Here is an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class ParentClass {
    String name

    ParentClass(String name) {
        this.name = name
    }
}

class ChildClass extends ParentClass {
    String age

    ChildClass(String name, String age) {
        // Calling the super constructor to initialize the 'name' property
        super(name)
        
        this.age = age
    }
}

def child = new ChildClass("Alice", "25")
println(child.name) // Output: Alice
println(child.age) // Output: 25

In the example above, ChildClass extends ParentClass and provides a new constructor that takes two parameters (name and age). Inside the constructor, we call the super constructor using super(name) to initialize the name property inherited from the ParentClass.

How to declare a constructor in a Groovy script?

In Groovy, a constructor can be declared using the this keyword followed by the parameter list and the body of the constructor. Here is an example of declaring a constructor in a Groovy script:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Person {
    String name
    int age
    
    // Constructor
    Person(String name, int age) {
        this.name = name
        this.age = age
    }
}

// Create an instance of the Person class using the constructor
def person = new Person("Alice", 30)

println "Name: ${person.name}, Age: ${person.age}"

In this example, we declare a class Person with two properties name and age. We then declare a constructor for the Person class that takes in two parameters name and age and assigns them to the properties of the class using the this keyword. Finally, we create an instance of the Person class using the constructor and print out the values of the properties.

What is the purpose of declaring a constructor in Groovy?

The purpose of declaring a constructor in Groovy is to initialize an object in a specific state when it is created. This allows the object to be set up with any necessary values or configurations before it is used. Constructors can also be used to perform any additional setup tasks or validations that need to be done when an object is created.