Understanding Scala Traits: Definition, Implementation, and Construction Order

Scala traits are comparable to Java interfaces but are more powerful because they can contain both abstract method declarations and concrete implementations, and they enable multiple inheritance.

The keyword trait is used to define a trait, for example:

trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

This trait defines two methods: isEqual (abstract) and isNotEqual (implemented), making a trait similar to a Java abstract class.

A complete example shows a trait, a class that extends it, and a test object:

trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
  var x: Int = xc
  var y: Int = yc
  def isEqual(obj: Any) =
    obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == x
}

object Test {
  def main(args: Array[String]) {
    val p1 = new Point(2, 3)
    val p2 = new Point(2, 4)
    val p3 = new Point(3, 3)
    println(p1.isNotEqual(p2))
    println(p1.isNotEqual(p3))
    println(p1.isNotEqual(2))
  }
}

Running the program produces the output:

$ scalac Test.scala
$ scala Test
false
true
true

Traits can also have constructors composed of field initializations and statements; these are executed for any object that mixes in the trait. The execution order is:

Call the superclass constructor.

Execute trait constructors after the superclass constructor but before the class constructor.

Traits are constructed from left to right.

Within each trait, parent traits are constructed first.

If multiple traits share a parent trait, that parent is constructed only once.

After all traits are constructed, the subclass constructor runs.

The constructor order follows the reverse of the class linearization, which describes the full hierarchy of supertypes.