Traits

Traits are halfway between Java interfaces and abstract classes.

·       Like abstract classes, traits may contain concrete members, but may not be instantiated.

·       As with interfaces, a class can inherit the members of multiple traits.

·       Classes can extend traits

class C extends Trait1 { ... }

·       Traits can extend classes and other traits

trait T1 extends Class1 { ... }
trait T2 extends Trait1 { ... }

·       Classes, objects, and traits can mix in traits

class C extends Trait1 with Trait2 with Trait3 { ... }
val obj = new Class1() with Trait1 with Trait2 with Trait3 { ... }

Example: Acorn

 

Like most programming languages, Acorn distinguishes between expressions (things that can be executed) and values (results of executing expressions). Jawa formalizes this distinction by defining two traits:

trait Value { }

trait Expression {
  def execute: Value
}

Numbers and Booles are both, expressions and values, When executed they return themselves! In future versions of Acorn there may be additional expression-value hybrids such as strings and characters. Acorn calls all such hybrids literals:

trait Literal extends Value with Expression {
   def execute = this
}

class Number (val value: Double) extends Literal { }

class Boole (val value: Boolean) extends Literal { }

By contrast, a sum is an expression but not a value:

class Sum(operand1: Expression, operand2: Expression) extends Expression {
   def execute =  {
     val arg1 = operand1.execute
     val arg2 = operand2.execute
     if (!arg1.isInstanceOf[Number] || !arg2.isInstanceOf[Number]) {
       throw new Exception("sum inputs must be numbers")
     }
     val num1 = arg1.asInstanceOf[Number]
     val num2 = arg2.asInstanceOf[Number]
     new Number(num1.value + num2.value)
   }
}

In UML we must introduce a special stereotype to represent traits:

Example: Delegation Chains

Delegation chains are useful when we want to add behavior to an object.

Assume Delegate is a trait with a concrete do-nothing method:

trait Delegate {
  def delegate() {}
}

An Entity class inherites the do-nothing delegate method, which it calls:

class Entity extends Delegate {
  def doSomething() {
    println("calling Entity.doSomething")
    delegate()
  }
}

Next we define three sub-traits. Each prints a unique message, then calls super.delegate:

trait Delegate1 extends Delegate {
  override def delegate() {
    println("calling Delegate1.delegate")
    super.delegate()
  }
}

//Delegte2, Delegate3, etc.

Scala allows objects to inherit from traits, too:

val test1 = new Entity() with Delegate1 with Delegate2 with Delegate3
test1.doSomething()
val test2 = new Entity() with Delegate3 with Delegate1 with Delegate2
test2.doSomething()

Here's the output. Note the delegation order:

calling Entity.doSomething
calling Delegate3.delegate
calling Delegate2.delegate
calling Delegate1.delegate
calling Entity.doSomething
calling Delegate2.delegate
calling Delegate1.delegate
calling Delegate3.delegate