Traits and Mixin Class Composition cover the ways in which Scala models interfaces and abstract classes, allowing for multiple inheritance.
Scala doesn’t have interfaces in the way that Java does; rather it uses Mixins (like Ruby), referred to as Traits.
A Trait is somewhat more similar to an abstract class in Java, except that in Scala, you can extend any number of traits that you wish.
Suppose our Circle class is getting refactored and enhanced. We wish to make the
area method part of an interface that other shape classes might use. Further, we wish to be able to compare circles based on their size. In Java, we would implement the
Comparable interface and a new interface called something like
Now, further suppose that we want our comparison interface to be a bit richer than a simple
compareTo method that returns an int; we want to clearly test for “less than”. In Java, we would need to extend the
Comparable interface as so:
The problem is that the three new methods would have the exact same implementation in every case — they’d use the
compareTo method. If our class already extends another class, we’re SOL. Traits let us combine the concepts:
There is a lot more that can be done with traits (and several no-doubt better implementations of the “super comparable” concept), but this should demonstrate what Traits can do and why they are useful.
My Thoughts on this Feature
I love mixins in Ruby and I love this feature. It does, however, make the scaladoc very hard to follow at times, and I just can’t for the life of me understand why you always
extends the first trait. It would be so much nicer to only
extend proper classes and instead
with Traits; this would make reading code a lot easier.