Case Classes | Pattern Matching

What are Case Classes?

Case classes in Scala are a special type of class that are optimized for working with immutable data. They provide a concise way to create classes that store data and come with built-in functionalities like equality checks, pattern matching, and easy-to-use constructors.

Defining a Case Class

To define a case class, you use the keyword case class followed by the class name and its parameters. Here’s a simple example:

case class Person(name: String, age: Int)

This defines a case class called Person with two parameters: name of type String and age of type Int.

Benefits of Case Classes

Immutable by Default: Case classes are immutable, meaning once they are created, their values cannot be changed.
Auto-generated Methods: Scala automatically generates useful methods such as toString, equals, and hashCode.
Pattern Matching: Case classes work seamlessly with pattern matching, making it easier to decompose and analyze data structures.
Copy Method: It provides a copy method that allows you to create a new instance with some modified fields.

Using Case Classes

Once you have defined a case class, you can create instances of it just like any other class:

val person1 = Person("Alice", 25)

val person2 = Person("Bob", 30)

Now, person1 and person2 are instances of the Person case class. You can access their fields directly:

println(person1.name) // Output: Alice

println(person2.age) // Output: 30

Pattern Matching with Case Classes

One of the most powerful features of case classes is their compatibility with pattern matching. Here’s how you can use it:

def greet(person: Person): String = person match {

case Person(name, age) if age < 30 => s"Hello, $name! You're young!"

case Person(name, age) => s"Hello, $name!"

}

In this example, we define a function greet that takes a Person and matches against its structure to return a greeting based on the age.

Copying Case Classes

The copy method allows you to create a new instance of a case class with some fields changed. Here’s an example:

val person3 = person1.copy(age = 26)

In this case, person3 is a new instance of Person with the same name as person1 but with an updated age.

Conclusion

Case classes in Scala are a powerful feature that simplifies working with immutable data and enhances code readability. They are especially useful when combined with pattern matching, making them a staple in Scala programming.

Case Classes in Scala