Skip to main content
TopMiniSite

Back to all posts

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

Published on
4 min read
How to Declare A Constructor Or Extends A Class Of A Groovy Script? image

Best Groovy Script Extensions and Constructors to Buy in October 2025

1 Groovy in Action: Covers Groovy 2.4

Groovy in Action: Covers Groovy 2.4

BUY & SAVE
$28.80 $59.99
Save 52%
Groovy in Action: Covers Groovy 2.4
2 Groovy Programming: An Introduction for Java Developers

Groovy Programming: An Introduction for Java Developers

BUY & SAVE
$58.56 $65.95
Save 11%
Groovy Programming: An Introduction for Java Developers
3 Modern Programming Made Easy: Using Java, Scala, Groovy, and JavaScript

Modern Programming Made Easy: Using Java, Scala, Groovy, and JavaScript

BUY & SAVE
$30.95 $37.99
Save 19%
Modern Programming Made Easy: Using Java, Scala, Groovy, and JavaScript
4 Making Java Groovy

Making Java Groovy

  • AFFORDABLE OPTION FOR AVID READERS ON A BUDGET.
  • QUALITY CHECKED FOR SATISFACTION-YOU'LL LOVE YOUR PURCHASE!
  • ECO-FRIENDLY CHOICE: PROMOTE RECYCLING AND REDUCE WASTE!
BUY & SAVE
$40.14 $44.99
Save 11%
Making Java Groovy
5 The C Programming Language

The C Programming Language

BUY & SAVE
$107.44
The C Programming Language
6 The Definitive Guide to Grails (Expert's Voice in Web Development)

The Definitive Guide to Grails (Expert's Voice in Web Development)

  • AFFORDABLE PRICE FOR QUALITY READS WITHOUT THE RETAIL MARKUP.
  • ECO-FRIENDLY OPTION; REDUCES WASTE BY REUSING PRE-LOVED BOOKS.
  • RELIABLE CONDITION ENSURES YOUR READING EXPERIENCE WON’T DISAPPOINT.
BUY & SAVE
$11.00 $46.99
Save 77%
The Definitive Guide to Grails (Expert's Voice in Web Development)
+
ONE MORE?

To declare a constructor in a Groovy script, you can use the "def" keyword followed by the class name, and then include the constructor parameters in parentheses. For example, if you have a class named "Person" with a constructor that takes two parameters (name and age), you would declare it like this:

class Person { def Person(String name, int age) { // constructor logic here } }

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, if you have a class named "Employee" that extends the "Person" class, you would declare it like this:

class Employee extends Person { // class logic here }

By using these syntax rules, you can easily declare constructors and extend classes in your Groovy scripts.

How to access superclass methods in a subclass in Groovy?

In Groovy, you can access superclass methods in a subclass using the 'super' keyword. You can use 'super' to call a superclass method with the same signature as the subclass method. Here's an example:

class Animal { void makeSound() { println "Some sound" } }

class Dog extends Animal { void makeSound() { super.makeSound() // calling superclass method println "Woof" } }

def dog = new Dog() dog.makeSound()

In the above example, the 'makeSound' method of the superclass 'Animal' is called using the 'super' keyword in the 'makeSound' method of the subclass 'Dog'. This allows you to access and override superclass methods in the subclass.

What is the difference between constructor overloading and constructor overriding in Groovy?

In Groovy, constructor overloading refers to the ability to define multiple constructors for a class, each with a different parameter list. This allows the class to be instantiated in different ways, depending on the arguments provided.

Constructor overriding, on the other hand, refers to the ability to redefine or extend an existing constructor in a subclass. This allows the subclass to customize the behavior of the constructor, while still maintaining the original functionality of the superclass constructor.

In summary, constructor overloading is about defining multiple constructors in the same class with different parameters, while constructor overriding is about redefining or extending a constructor in a subclass.

How to create a subclass in Groovy?

In Groovy, you can create a subclass by using the extends keyword. Here's an example of how to create a subclass in Groovy:

class Vehicle { def make def model

Vehicle(make, model) {
    this.make = make
    this.model = model
}

def display() {
    println "Make: $make"
    println "Model: $model"
}

}

class Car extends Vehicle { def color

Car(make, model, color) {
    super(make, model)
    this.color = color
}

def display() {
    super.display()
    println "Color: $color"
}

}

def myCar = new Car("Toyota", "Camry", "Blue") myCar.display()

In this example, we have a superclass Vehicle with properties make and model, and a method display to print out the make and model of the vehicle. We then create a subclass Car that extends Vehicle, with an additional property color. The Car class calls the superclass constructor using super, and overrides the display method to also print out the color of the car.

When we create an instance of the Car class and call the display method, it will print out the make, model, and color of the car.

How to pass parameters to a constructor in Groovy?

In Groovy, you can pass parameters to a constructor by defining a parameterized constructor in your class. Here is an example:

class Person { String name int age

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

}

def person = new Person("John", 30) println(person.name) // Output: John println(person.age) // Output: 30

In this example, we have defined a Person class with a parameterized constructor that takes two parameters (name and age). When creating a new Person object, we pass the values for these parameters in the constructor (e.g., new Person("John", 30)). The constructor sets the values of the object's properties based on the passed parameters.

What is the constructor signature in Groovy?

In Groovy, the constructor signature is simply the class name followed by parentheses. For example:

class Person { Person() { // constructor code } }

In this example, the constructor signature for the Person class is Person() which indicates that it is a default constructor with no parameters.