What are the differences and similarties between Scala traits vs. Java 8 interfaces?

Question

I am new to Scala started learning the language for fun and I am still trying to get my head around it. My understanding of Scala traits is that they are like java interfaces except that some methods can have an implementation.

Java 8 is adding interfaces that can have default methods where an implementation can be provided.

What are the similarities and differences between Java 8 interfaces and Scala traits?

Answer 1

Motivations for Java 8' default methods and Scala traits differ.

The former was introduced to support safe API evolution and a limited form of multiple inheritance. With leveraging functional programming idioms in Project Lambda it's been beneficial to add, for example, a forEach(lambda) method to java.util.Collection interface without altering all possible implementers (which is actually impossible to do without breaking backward compatibility). As a side effect this also offered a form of mixin composition.

Scala traits were designed from scratch as building blocks for modular components composition. They are multiple inheritance friendly and don't have diamond problem by having strict rules on evaluation order of mix-ins due to linearization. They also support state, can reference the implementing class and place restrictions on which type can mix-in them. Look at Scala collections library where traits are used thoroughly.

Answer 2

Note that with scala 2.12.0 RC1 (Sept. 2016), Trait now compiles to an interface.
Scala 2.12 is all about making optimal use of Java 8’s new features

With Java 8 allowing concrete methods in interfaces, Scala 2.12 is able to compile a trait to a single interface.

Before, a trait was represented as a class that held the method implementations and an interface.
Note that the compiler still has quite a bit of magic to perform behind the scenes, so that care must be taken if a trait is meant to be implemented in Java.
(Briefly, if a trait does any of the following its subclasses require synthetic code: defining fields, calling super, initializer statements in the body, extending a class, relying on linearization to find implementations in the right super trait.)

See scala PR 5003 more the difference of implementation.