Trying to understand scala trait

Question

I am new to scala. I don't understand scala traits properly. I have read it is similar to java interfaces but the methods need not be abstract. But how can I declare a scala trait and instantiate it in the following code. BTW, the following code is working fine.

trait fooable {
    def foo: Unit = {
        println("This is foo")
    }
}

object Main {
    def main(args: Array[String]): Unit = {
        println("This is morking")
        val foo = new fooable{}
        foo.foo
    }
}

Output -

This is morking This is foo

Thanks in advance.

possible duplicate of [What is the advantage of using abstract classes instead of traits?](http://stackoverflow.com/questions/1991042/what-is-the-advantage-of-using-abstract-classes-instead-of-traits) — Johny T Koshy, Jul 27 '15 at 11:53
You can't instantiate a trait. What you are doing is creating an anonymous inner subclass of the trait, and instantiating *that*, *exactly* like in Java. BTW: traits are really not much like interfaces at all. They are more like mixins. In fact, Scala's traits are much more like mixins than they are like traits, so the term "trait" is a bit of a misnomer. — Jörg W Mittag, Jul 27 '15 at 11:57

score 4 · Accepted Answer · answered Jul 27 '15 at 13:17

Scala traits are more general than both Java interfaces and abstract classes.

You can use a trait as an interface, you can use it to store some implementation, you can use it simply to define a common super-type:

trait Message
case class Text(text: String) extends Message
case class Data(data: ByteString) extends Message

Multiple traits can be 'mixed in' a class:

class MyClass extends TraitA with TraitB with TraitC

where any conflict with identically named methods is resolved by the simple rule: the last trait takes precedence. This code:

trait TraitA { def print() { println("A") } }
trait TraitB { def print() { println("B") } }
trait TraitC { def print() { println("C") } }
new MyClass.print()

will print "C".

Scala traits can't be instantiated. You are creating an anonymous class in you example. If you add an abstract method to your trait it will not compile.

Unrelated note: It is a good practice to write braces "()" in methods with side effects. Your method foo has a side effect: it prints something. So you should write "foo()".

score 2 · Answer 2 · answered Jul 27 '15 at 13:10

When you instantiate a trait you create an instance of an anonymous class that extends that trait it works the same way as creating anonymous classes of interfaces in java. If you had any unimplemented methods in the trait fooable the compiler would've forced you to implement them on spot when you created your anonymous class.

Rashmit Rathod · Answer 3 · 2015-12-07T07:38:11.883

Indeed your code should work fine and output the same result you mentioned. However the important point to note here is TRAIT CAN NEVER EVER be instantiated. Its the same concept that Java interface can never ever be instantiated.

When scala compiler notice the code foo = new fooable{}, It internally creates an anonymous class which extends your fooable trait and thus it inherits foo() method due to inheritance. See following code snippet:

scala> val foo = new fooable{}
foo: fooable = $anon$1@277c0f21

Thus when you call foo.foo, At runtime it invokes a anonymous's class(i.e. $anon$1@277c0f21) inherited method foo().

The same understanding is true in case of Java as well, Following is perfectly legal java code:

 Runnable r = new Runnable() {
        public void run() {
            System.out.println(" Cat");
        }
    };

r.run()

Happy learning !

score 0 · Answer 4 · answered Nov 02 '17 at 10:50

An Scala Trait is abstract and can't be instantiated. In the code above its instantiated as

val foo = new fooable{}

and NOT as

val foo = new fooable()

The curly braces created some anonymous class which is not fooable but an empty one

What are Traits?

Traits are similar to interfaces in any other language. Scala allows traits to be instantiate during definition as well as during construction. For example if we have a trait and a abstract class

trait testTrait {
}

abstract class BaseClass {}

class Derive extends BaseClass with testTrait {

}

// ---------------------- OR----------------------

// Traits can be used during instantiation

class Derive extends BaseClass {

}

val classInst = new Derive with testTrait

Traits can also be chained using multiple with trait

Trying to understand scala trait

4 Answers4