Calling A Super Class Constructor in Scala - GeeksforGeeks

28 Feb, 2022
Prerequisite – Scala ConstructorsIn Scala, Constructors are used to initialize an object’s state and are executed at the time of object creation. There is a single primary constructor and all the other constructors must ultimately chain into it. When we define a subclass in Scala, we control the superclass constructor that is called by its primary constructor when we define the extends portion of the subclass declaration.  
With one constructor: An example of calling a super class constructor Example:  
Scala
// Scala program to illustrate// calling a super class constructor // Primary constructorclass GFG (var message: String){    println(message)}  // Calling the super class constructorclass Subclass (message: String) extends GFG (message){    def display()    {        println("Subclass constructor called")    }} // Creating objectobject Main{    // Main method    def main(args: Array[String])    {                 // Creating object of Subclass        var obj = new Subclass("Geeksforgeeks");        obj.display();    }}
 
Geeksforgeeks
Subclass constructor called
 
In the above example, the subclass is defined to call the primary constructor of the GFG class, which is a single argument constructor that takes message as its parameter. When defining a subclass in Scala, one controls the Superclass constructor that’s called by the Subclass’s primary constructor when defining the extends segment of the Subclass declaration.
With multiple constructors : In a case with the Superclass having multiple constructors, any of those constructors can be called using the primary constructor of the Subclass. For Example, in the following code, the double argument constructor of the Superclass is called by the primary constructor of the Subclass using the extends clause by defining the specific constructor.Example:  
Scala
// Scala program to illustrate// calling a specific super class constructor // Primary constructor (1)class GFG (var message: String, var num: Int){         println(message+num)         // Auxiliary constructor (2)    def this (message: String)    {        this(message, 0)             }     } // Calling the super class constructor with 2 argumentsclass Subclass (message: String) extends GFG (message, 3000){    def display()    {        println("Subclass constructor called")    }} // Creating objectobject GFG{    // Main method    def main(args: Array[String])    {                 // Creating object of Subclass        var obj = new Subclass("Article count ");        obj.display();    }}
 
Article count 3000
Subclass constructor called
 
 
We can call the single argument constructor here, By default another argument value will be 0. Example:  
Scala
// Scala program to illustrate// calling a specific super class constructor // Primary constructor (1)class GFG (var message: String, var num: Int){         println(message + num)         // Auxiliary constructor (2)    def this (message: String)    {        this(message, 0)             }     }  // Calling the superclass constructor with 1 argumentsclass Subclass (message: String) extends GFG (message){    def display()    {        println("Subclass constructor called")    }} // Creating objectobject GFG{    // Main method    def main(args: Array[String])    {                 // Creating object of Subclass        var obj = new Subclass("Article Count ");        obj.display();    }}
 
Article Count 0
Subclass constructor called
 
 
BinuKumar
Picked
Scala
Scala-Constructor
Scala
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Inheritance in Scala
Hello World in Scala
Scala | Option
Scala ListBuffer
Scala | Traits
Method Overriding in Scala
Scala Sequence
Comments In Scala
Scala List exists() method with example
Scala List map() method with example