Ted Neward had recently started an article series on IBM's developerWorks site devoted to introducing Java developers to the Scala language. The most recent article in the series, Class Action, compares Java and Scala classes.

Neward notes that:

Scala's functional programming features are compelling, but they're not the only reason Java developers should be interested in the language. In fact, Scala blends functional concepts and object orientation. In order to let the Java-cum-Scala programmer feel more at home, it makes sense to look at Scala's object features and see how they map over to Java linguistically. Bear in mind that there isn't a direct mapping for some of these features, or in some cases, the "mapping" is more of an analog than a direct parallel.

Among other examples, Neward presents a simple POJO or, rather, a plain, old Scala object, that illustrates the conciseness of the Scala language:

class Person(firstName:String, lastName:String, age:Int) {
    def getFirstName = firstName
    def getLastName = lastName
    def getAge = age

    override def toString =
        "[Person firstName:" + firstName + " lastName:" + lastName +
            " age:" + age + " ]"
}

Neward points out, for example, Scala's ability to pass parameters to a default constructor:

Scala's preference for a single constructor makes a certain kind of sense—most classes end up having a single constructor or a collection of constructors that all "chain" through a single constructor as a convenience... Scala's constructor chain does the usual Java-constructor-chaining thing by calling into the preferred constructor...

Another feature Neward points to is the override keyword and the way a method returns values in Scala:

The override keyword in the front of the definition is required so that Scala can check to make sure that a corresponding definition exists in the base class. This can help prevent subtle bugs created by accidental keyboard slips...

Notice, as well, that the return type is not specified—it's obvious from the definition of the method body—and that the returned value isn't explicitly denoted using the return keyword, which Java would require. Instead, the last value in the function is considered the return value implicitly..

In the article, Neward also describes properties in a Scala class, function definitions, and the meaning of the var keyword.

What do you think of the manner in which Scala allows you to simplify class definitions?