One of my favorite features in Scala are case classes. Below is an example of the declaration of a case class:
case class Student(name:String, age:Int)
The declaration looks pretty simple, isn’t it?
Now let’s do it the java way:
public class Student { private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return this.name; } public String setName(String name) { this.name = name; } public int getAge() { return this.age; } public void setAge(int age) { this.age = age; } public boolean equals(Object obj) { ... } public int hashCode() { ... } public String toString() { ... }
Which method do you prefer.
Scala case classes are extremely powerful and their main use is not limited to writing abbreviated java beans.
By declaring a case class we get for free the equals, toString and hashCode methods. Nice, can it get any better? Yes….
You can easily create instances of a case class without having to declare a constructor and no need to use the new keyword:
val students = List(Student("John", 20), Student("David", 21))
Case classes are used for pattern matching. Pattern matching is similar to Java switch statements however it is many times more powerful. The example below shows a typical use for case classes with pattern matching:
abstract class Expression case class Sum(a1:Int, a2:Int) extends Expression case class Diff(a1:Int, a2:Int) extends Expression case class Mult(a1:Int, a2:Int) extends Expression def doOperation(expr:Expression):Int = expr matches { case Sum(a1, a2) => a1 + a2 case Diff(a1, a2) => a1 - a2 case Mult(a1, a2) => a1 * a2 }