This post originated from an RSS feed registered with Java Buzz by Lalit Pant. Original Post: Playing with Traits in Scala Feed Title: All Things Runnable / Java Feed URL: http://feeds.feedburner.com/lalitpant/java Feed Description: Java related posts on Lalit Pant's Blog Latest Java Buzz Posts Latest Java Buzz Posts by Lalit Pant Latest Posts From All Things Runnable / Java

• Define a type by specifying the signature of supported methods. This is similar to how interfaces work in Java.
  
• Provide partial/full implementations that can be mixed-in to classes that use the trait. Why is this different from what abstract classes give you? The big difference is that abstract classes cannot be multiply extended from, while traits can.
  

• An interface called X with all the methods in the trait.
• A class called X$class with static versions of all the non-abstract methods in the trait. These methods take one additional parameter (relative to the methods in the trait) of type X . Any code within a non-abstract method in the trait goes into the corresponding static method in X$class. Any calls to other trait methods from within this code get translated to calls on the extra parameter of type X.
  

• Implementing the interface X.
• Delegating all the non-abstract methods of X to the static methods of X$class, passing itself (this) as a parameter.
  

class Employee {
// etc
}

class Manager extends Employee {
List<Employee> directReports = new ArrayList<Employee>();

// etc
}

interface Observer<T> {
void onChange(Observable<T> source, T notificationData);
}

interface Observable<T> {
void addObserver(Observer<T> observer);
void removeObserver(Observer<T> observer);
void notifyObservers(T notificationData);
}

class ObservableImpl<T> implements Observable<T> {
// manages sequence of observers and notifications to these observers
}

class Manager extends Employee, ObservableImpl<Employee> {

List<Employee> directReports = new ArrayList<Employee>();

public void addReport(Employee e) {
directReports.add(e);
notifyObservers(e);
}

// etc
}

class Manager extends Employee implements Observable<Employee> {

List<Employee> directReports = new ArrayList<Employee>();

Observable<Employee> observable = new ObservableImpl<Employee>();

public void addReport(Employee e) {
   directReports.add(e);
   notifyObservers(e);
}

// etc

// implement Observable methods by delegating to observable

public void notifyObservers(Employee notificationData) {
   observable.notifyObservers(notificationData);
}

public void addObserver(Observer<Employee> observer) {
   observable.addObserver(observer);
}

public void removeObserver(Observer<Employee> observer) {
   observable.removeObserver(observer);
}
}

trait Observer[T] {
def onChange(source: Observable[T], notificationData: T) : Unit
}

trait Observable[T] {
def addObserver(observer: Observer[T]) = {/*do the right thing*/}
def removeObserver(observer: Observer[T]) = {/*do the right thing*/}
def notifyObservers(notificationData: T) = {/*do the right thing*/}
}

class Employee {}

class Manager extends Employee with Observable[Employee] {

var directReports : List[Employee] = Nil

def addEmployee(employee: Employee) = {
   directReports = employee :: directReports
   notifyObservers(employee)
}
}

class Manager extends Employee with Observable[Employee]