Scala Tutorial
Basics
Control Statements
OOP Concepts
Parameterized - Type
Exceptions
Scala Annotation
Methods
String
Scala Packages
Scala Trait
Collections
Scala Options
Miscellaneous Topics
In Scala, when you create an instance of a subclass, the constructor of its superclass is called before the subclass's constructor. If the superclass has multiple constructors, by default the primary (no-argument) constructor is invoked. But what if you want to call a specific superclass constructor with arguments? You can do that by placing the arguments right after the extends keyword.
Here's how you can call a superclass constructor in Scala:
Basic Example:
class Parent(val name: String) {
println(s"Parent constructor with name $name")
}
class Child(name: String, val age: Int) extends Parent(name) {
println(s"Child constructor with name $name and age $age")
}
val child = new Child("John", 10)
// Output:
// Parent constructor with name John
// Child constructor with name John and age 10
In the above example, the Child class's constructor takes two parameters. It passes one of them (name) to the Parent class's constructor using extends Parent(name).
Chained and Auxiliary Constructors:
If you have auxiliary constructors (secondary constructors) in your Scala classes, the first statement in every auxiliary constructor must either call the primary constructor (of the same class) or another auxiliary constructor.
Similarly, the superclass constructor is still only directly called from the primary constructor. If you're invoking the superclass constructor with specific arguments, ensure those arguments are available when the primary constructor is executed.
class Parent(val name: String) {
def this() = {
this("Unknown")
println("Parent auxiliary constructor")
}
println(s"Parent primary constructor with name $name")
}
class Child(name: String, val age: Int) extends Parent(name) {
def this(age: Int) = {
this("Unknown Child", age)
println("Child auxiliary constructor")
}
println(s"Child primary constructor with name $name and age $age")
}
val child = new Child(15)
// Output:
// Parent primary constructor with name Unknown Child
// Child primary constructor with name Unknown Child and age 15
// Child auxiliary constructor
In conclusion, when you're subclassing in Scala, you can easily pass arguments to the superclass's constructor by placing them right after the extends keyword. Ensure you understand the order of constructor execution, especially when auxiliary constructors are involved.
Using super keyword to call a constructor in Scala:
super keyword is used to call a constructor from the superclass when creating an instance of a subclass.class Animal(name: String) {
println(s"Creating animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name) {
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Scala super() constructor invocation:
super() constructor invocation is implicit and is called automatically when creating an instance of a subclass.class Animal(name: String) {
println(s"Creating animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name) {
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Invoking parent class constructor in Scala:
super keyword is used to invoke the constructor of the parent class during the creation of a subclass instance.class Animal(name: String) {
println(s"Creating animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name) {
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Scala constructor chaining with super:
super keyword.class Animal(name: String, category: String) {
def this(name: String) = this(name, "Generic")
}
class Dog(name: String, breed: String) extends Animal(name) {
def this(name: String) = this(name, "Unknown")
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Overriding and calling superclass constructors in Scala:
super is used to invoke the parent class constructor.class Animal(name: String) {
println(s"Creating animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name) {
override def toString: String = s"${super.toString}, Breed: $breed"
}
val myDog = new Dog("Buddy", "Labrador")
Calling base class constructor in Scala:
super when creating an instance of a subclass.class Animal(name: String) {
println(s"Creating animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name) {
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Scala auxiliary constructor and super:
super to invoke another constructor within the same class.class Animal(name: String, category: String) {
def this(name: String) = this(name, "Generic")
}
class Dog(name: String, breed: String) extends Animal(name) {
def this(name: String) = {
this(name, "Unknown")
println(s"Creating $breed dog named $name")
}
}
val myDog = new Dog("Buddy", "Labrador")
Using super in constructor parameters in Scala:
super can be used in constructor parameters to pass arguments to the superclass constructor.class Animal(name: String, category: String) {
println(s"Creating $category animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name, "Canine") {
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Mixins and calling constructors from supertraits in Scala:
super is used to call constructors from supertraits.trait Animal {
println("Creating Animal")
}
trait Pet extends Animal {
println("Creating Pet")
}
class Dog extends Pet {
println("Creating Dog")
}
val myDog = new Dog
Accessing protected constructors in Scala:
protected to limit access. super is used to invoke a protected constructor in a subclass.class Animal protected (name: String) {
println(s"Creating animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name) {
println(s"Creating $breed dog named $name")
}
val myDog = new Dog("Buddy", "Labrador")
Chaining constructors with super in Scala:
super, allowing for flexible initialization.class Animal(name: String, category: String) {
println(s"Creating $category animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name, "Canine") {
def this(name: String) = {
this(name, "Unknown")
println(s"Creating unnamed dog named $name")
}
}
val myDog = new Dog("Buddy", "Labrador")
Constructor delegation in Scala:
class Animal(name: String, category: String) {
println(s"Creating $category animal named $name")
}
class Dog(name: String, breed: String) extends Animal(name, "Canine") {
def this(name: String) = {
this(name, "Unknown")
println(s"Creating unnamed dog named $name")
}
}
val myDog = new Dog("Buddy", "Labrador")
Scala primary and auxiliary constructor usage with super:
super to delegate to another constructor within the same class.class Animal(name: String, category: String) {
println(s"Creating $category animal named $name")
def this(name: String) = {
this(name, "Generic")
println(s"Creating unnamed animal named $name")
}
}
val myAnimal = new Animal("Fido")