Case Classes in Scala

In this lesson, you will learn about case classes in Scala. Case classes are special classes designed to hold immutable data and work seamlessly with pattern matching.

They are heavily used in real-world Scala applications for modeling data.

What Is a Case Class?

A case class is a class with built-in support for:

• Immutable data storage
• Automatic equals and hashCode
• Readable toString
• Pattern matching

Scala generates these features automatically.

Creating a Case Class

Case classes are created using the case class keyword.

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

This single line defines:

• A constructor
• Immutable fields
• Utility methods

Creating Objects from Case Classes

Unlike regular classes, case classes do not require the new keyword.

val p1 = Person("Alice", 25)
val p2 = Person("Bob", 30)

This makes object creation concise and readable.

Accessing Case Class Fields

Fields in case classes are public by default.

println(p1.name)
println(p1.age)

No getters are required.

Immutability in Case Classes

By default, fields in case classes are immutable.

// This will cause a compilation error
// p1.age = 26

Immutability improves safety and predictability.

Copying Case Classes

Case classes provide a copy() method to create modified versions.

val updated = p1.copy(age = 26)
println(updated)

The original object remains unchanged.

Case Classes with Pattern Matching

Case classes work naturally with pattern matching.

p1 match {
  case Person(name, age) =>
    println(s"Name: $name, Age: $age")
}

This allows easy extraction of values.

Case Classes with Multiple Fields

Case classes can have multiple parameters.

case class Book(title: String, author: String, pages: Int)

val book = Book("Scala Guide", "John Doe", 350)

All fields are automatically handled.

Comparing Case Class Objects

Case classes compare values, not references.

val a = Person("Alice", 25)
val b = Person("Alice", 25)

println(a == b)

This prints true because values are equal.

Case Classes vs Regular Classes

Key differences include:

• No need for new
• Automatic immutability
• Built-in pattern matching support
• Value-based equality

Case classes are ideal for data modeling.

When to Use Case Classes

Use case classes when:

• Representing structured data
• Working with immutable objects
• Using pattern matching extensively

They are a fundamental building block in Scala.

📝 Practice Exercises

Exercise 1

Create a case class for a Student with name and grade.

Exercise 2

Create an object and access its fields.

Exercise 3

Use pattern matching on a case class.

✅ Practice Answers

Answer 1

case class Student(name: String, grade: Int)

Answer 2

val s = Student("Emma", 90)
println(s.name)
println(s.grade)

Answer 3

s match {
  case Student(name, grade) =>
    println(s"$name scored $grade")
}

What’s Next?

In the next lesson, you will learn about OOP Basics in Scala, including classes, objects, and inheritance concepts.