Setters and Getters in Scala Trait?

Question

In Java I would sometimes define an interface for ensuring that classes have "setters" and "getters".

For example, if I have a node in a tree I might define interface such as:

public interface Node { 

    Node getLeft();

    void setLeft(Node node);

    Node getRight();   

    void setRight(Node node);

    int getValue();
}

and then my nodes would implement this interface:

 public Node2D implements Node{
     //implements all of Node's methods along with getters
     // and setters
 }

Would I do the same in Scala, or is it done in a different way?

Answer 1

Getters and setters are not common in Scala. In fact a var is internally realized with two getter/setter-like methods. If you want the mutable solution (which is usually avoided in Scala if possible), you could simply write

trait Node {
  var left:Node
  var right:Node
  var value:Int
}

class Node2D(var left:Node, var right:Node, var value:Int) extends Node

The Node interface provides little additional value here, and I don't like the idea of vars in it, so I'd probably get rid of the interface alltogether, or would end up with an read-only interface and a mutable class:

trait Node {
  def left:Node
  def right:Node
  def value:Int
}

class Node2D(var left:Node, var right:Node, var value:Int) extends Node

Note that pattern matching makes it much easier in Scala to get back a more specific type (like Node2D from a Node), so don't worry about cases where you would need instanceof in Java.

Answer 2

In Scala, getters and setters are syntactically identical to vars. So you could declare the variable as a var in your trait:

trait A {
  var x: Int
}

Then you could implement it just as a var, or with getters and setters if you wanted:

class B extends A {
  var _x: Int = 0

  def x: Int = _x

  def x_=(value: Int) {
    println("Setting x to "+value)
    _x = value
  }
}

class C extends A {
  var x = 1
}

Finally, here's how it would look like to use the getters and setters:

val b = new B
b.x // is 0
b.x = 10
b.x // is 10

val c = new C
c.x // is 1
c.x = 20
c.x // is 20

It's worth noting that the preferred design in Scala is to use immutable objects and stick to the functional programming paradigm. See also http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-2.