Many of you might have different perspectives of traits in Scala. They can be viewed not only as interfaces in other languages, but also as classes with only parameter-less constructors.

In the following few sections, we will see the traits from different points of view and try to give you some ideas about how they can be used.

Scala allows developers to extend many traits in a single class. This adds the possibility of achieving multiple inheritance and saves a lot of effort in code writing, which has to be performed in languages where extending many classes is not allowed. In this subtopic, we will show how traits can be mixed in a specific class or used to create anonymous classes with some specific functionality while writing our code.

First of all, let's modify the code from the previous example. It is a really simple change and it will also show exactly how traits can be mixed in:

object MixinRunner extends Ping with Pong {
  def main(args: Array[String]): Unit = {
    ping()
    pong()
  }
}

As can be seen...

We inevitably had to mention multiple inheritance in the previous sections due to the fact that we can mix multiple traits and they can all have their own implementations of the methods. Multiple inheritance is not only a powerful technique, but also a dangerous one, and some languages such as Java have decided to not even allow it. As we already saw, Scala allows this, but with some limitations. In this subsection, we will present the problems of multiple inheritance and show how Scala deals with them.

Multiple inheritance suffers from the diamond problem.

Let's have a look at the following diagram:

Here, both B and C extend A, and then D extends B and C. Some ambiguities might...

As we already saw, traits offer a form of multiple inheritance. In such cases, the hierarchy is not necessarily linear, but forms an acyclic graph that needs to be flattened upon compilation. What linearization does is this—it specifies a single linear order for all of the ancestors of a class, including both the regular superclass chain and the parent chains of all of the traits.

We will not have to deal with linearization in traits that contain no code. However, if we use mixins, we will have to consider it. The following will be affected by linearization:

• Method definitions
• Variables (both mutable—var and immutable—val)

We already saw a simple example of linearization previously. Things, however, can get much more complicated and unexpected if the rules of linearization are not clear.

Testing is a really important part of software development. It ensures that changes to a certain piece of code do not end up producing errors either in the methods that were changed, or somewhere else.

There are different testing frameworks that one can use, and it really is a matter of personal preference. In this book, we have used ScalaTest (http://www.scalatest.org), as this is the one I use in my projects; it is understandable, readable, and easy to use.

In some cases, if a trait is mixed into a class, we could end up testing the class. However, we might want to test only a specific trait. It does not make much sense to test a trait that doesn't have all its methods implemented, so here we will look into the ones that have their code written (mixins). Also, the unit tests that we will show here are quite simple, but they are just for illustration purposes...

Traits could be similar, but also very different to classes. It could be hard for a developer to choose which one to use in various cases, but here we will try to provide some general guidelines that should help.

Use classes:

• When a behavior is not going to be reused at all or in multiple places
• When you plan to use your Scala code from another language, for example, if you are building a library that could be used in Java

Use traits:

• When a behavior is going to be reused in multiple unrelated classes.
• When you want to define interfaces and want to use them outside Scala, for example, Java. The reason is that the traits that do not have any implementations are compiled similar to interfaces.

In this chapter, we went through traits and mixin compositions in Scala. By now, you should have a good understanding of what these are and what can be achieved by using them. We also went through the examples of the different uses of traits and what to watch out for when using them. We presented the limitations of using traits for multiple inheritance. Traits are an extremely powerful concept, but they have their pitfalls as we saw with multiple inheritance, so you should use them carefully. Linearization was covered in depth and you should be familiar with what to expect when using traits for multiple inheritance and why things work exactly the way they currently do.

Testing is an essential part of every good software project, and we also presented how it should be done for traits. Last, but not least, we prepared a few guidelines that should help developers choose between...