Many developers coming to Scala after years of Java programming find that Scala aims to solve many of the pain points of Java programming. One such pain point is the way Java facilitates reuse of common behavior across classes. Java does not permit multiple inheritance, and its single-inheritance rule does not make it easy to share common base behavior in subclasses that would otherwise not share a common base class.

In his most recent IBM developerWorks article on Scala, Of traits and behaviors, Ted Neward explains the concept of traits, and how Scala helps developers define a clean object model:

Consider the fact that the Java language was created close to 20 years ago, in the heyday of "object-orientation." It was designed to mimic C++, the dominant language of the day, in a naked attempt to woo that language's developers over to the Java platform. Certain decisions were made that seemed obvious and necessary at the time, but in retrospect, we know that some of them are not as beneficial as the creators then believed. For instance, 20 years ago, it made sense to the creators of the Java language to reject both C++-style private inheritance and multiple inheritance. Since that time, many Java developers have had cause to regret their decision...

Tossing out private and multiple inheritance has cost us dearly in terms of code reuse. Java developers may rejoice in being free of virtual multiple inheritance, but the trade-off is often painstaking — and error-prone — work done by the programmer.

In the article, Neward walks through a typical JavaBean implementation, where property change listeners register and receive notifications of changes in the bean's state. Implementing common bean behavior in Java tends to be verbose, and Neward demonstrates how traits in Scala can reduce boilerplate code:

Scala enables you to define a new construct that lies halfway between an interface and a class, called a trait. Traits are unusual in that a class can incorporate as many of them as desired, like interfaces, but they can also contain behavior, like classes. Also, like both classes and interfaces, traits can introduce new methods. But unlike either, the definition of that behavior isn't checked until the trait is actually incorporated as part of a class. Or, put differently, you can define methods that aren't checked for correctness until they're incorporated into a trait-using class definition.

Traits offer a powerful mechanism for categorization and definition in Scala, both to define an interface for clients to use, a la traditional Java interfaces, and as a mechanism for behavioral inheritance based on other behaviors defined within the trait. Perhaps what we need is a new inheritance phrase, IN-TERMS-OF, to describe the relationship between a trait and an implementing class.

What do you think of Scala's traits?

//This is Java      
public class Person
{
    private String lastName;
    private String firstName;
    private int age;
    
    public Person(String fn, String ln, int a)
    {
        lastName = ln; firstName = fn; age = a;
    }
    
    public String getFirstName() { return firstName; }
    public void setFirstName(String v) { firstName = v; }
    public String getLastName() { return lastName; }
    public void setLastName(String v) { lastName = v; }
    public int getAge() { return age; }
    public void setAge(int v) { age = v; }
}

class Person(
  var firstName: String,
  var lastName: String,  
  var age: Int
)

val bob = new Person("Bob", "Jones", 29)
bob.age = 31 // Be honest, Bob
println(bob.age)

import scala.reflect.BeanProperty

class Person(
 @BeanProperty var firstName: String,
 @BeanProperty var lastName: String,
 @BeanProperty var age: Int
)

if (bill.age > 50)
  startSendingAARPmaterials();

bill.age = 21;  // fake ID to allow Bill to buy beer

> if (bill.age > 50)
>   startSendingAARPmaterials();
> 

> bill.age = 21;  // fake ID to allow Bill to buy beer
> 

class Person(
  val firstName: String,
  val lastName: String,  
  val age: Int
)

import scala.reflect.BeanProperty

class Person(
  @BeanProperty val firstName: String,
  @BeanProperty val lastName: String,  
  @BeanProperty val age: Int
)