Welcome to our next lesson! Today, we are focusing on Encapsulation, a crucial pillar of Object-Oriented Programming (OOP). We'll demystify the concept and master its implementation in Scala.

Just like a safe for valuables, encapsulation ensures that our data in code is accessed and utilized appropriately.

This guide covers an overview of encapsulation, its implementation in Scala, specifically using private properties, and a detailed rundown on Scala's unique approach to Accessors (getters and setters). Onward, let's dive in!

Encapsulation wraps data (properties) and the methods manipulating that data into one coherent unit — a class in Scala. Central to encapsulation is the confinement of data, which restricts outside access.

When you use your smartphone, you interact with apps and functions without directly accessing the internal storage or battery management system, ensuring the internal state is protected and managed through controlled interfaces.

Encapsulation offers valuable advantages: it safeguards data from unwanted alteration, enhances usability by revealing only pertinent aspects, and bolsters modularity, making your code more maintainable and adaptable.

In Scala, encapsulation is implemented primarily by controlling access to class properties using the private keyword. A private property can only be accessed within either the class they're defined in or the package they belong to, protecting your data from unauthorized access or modification.

To achieve exclusive intra-class access, Scala uses private[this]. Let's illustrate with a BankAccount class example:

Scala
Copy to clipboard
1class BankAccount:
2  private[this] var balance: Double = 0.0 
3
4  // Public method to deposit money, ensuring only valid amounts are added
5  def deposit(amount: Double): Unit =
6    if amount > 0 then
7      balance += amount
8      printBalance()
9  
10  // Public method to withdraw money, ensuring only valid amounts are subtracted
11  def withdraw(amount: Double): Unit =
12    if amount > 0 && balance >= amount then
13      balance -= amount
14      printBalance()
15  
16  // Private method to print the current balance
17  private def printBalance(): Unit =
18    println(s"Current balance: $balance")
19
20@main def run: Unit =
21  val account = new BankAccount()
22  account.deposit(1000.0) // Prints "Current balance: 1000.0"
23  account.withdraw(500.0) // Prints "Current balance: 500.0"
24  // Uncommenting the below lines would cause a compile error
25  // account.balance 
26  // account.printBalance() 
27  println("Transaction completed.")

The BankAccount class's balance property is private[this], allowing it to be only accessed within the class. It ensures balance can only be manipulated through the deposit and withdraw methods, preserving data integrity. Additionally, the printBalance method, also private, demonstrates methods encapsulation within a class, further controlling access.

In Scala, public members defined with var or val automatically provide getters (for both var and val) and setters (for var only). However, there are cases where you may need custom behavior when getting or setting a property. Custom getters and setters in Scala can be defined by using specific naming conventions: append _= for the setter method.

Here's an example with a User class to illustrate:

Scala
Copy to clipboard
1class User(private var _age: Int):
2  // Custom getter for age
3  def age: Int =
4    println("Accessing the age")
5    _age
6
7  // Custom setter for age
8  def age_= (value: Int): Unit =
9    println(s"Setting age to $value")
10    if (value > 0) _age = value else println("Age must be positive")
11
12  private var _name: String = "Unknown"
13
14  // Custom getter for name
15  def name: String =
16    println("Accessing the name")
17    _name
18
19  // Custom setter for name
20  def name_= (value: String): Unit =
21    println(s"Setting name to $value")
22    if value.nonEmpty then _name = value else println("Name cannot be empty")
23
24  def birthday(): Unit =
25    age += 1
26    println(s"Happy birthday, you are now $age years old!")
27
28@main def run: Unit =
29  val user = new User(30)
30  println(s"User's current age: ${user.age}") // Prints "Accessing the age" and "User's current age: 30"
31  user.age = 31  // Prints "Setting age to 31"
32  user.birthday()  // Increments age and prints a birthday message
33  println(s"User's current name: ${user.name}") // Prints "Accessing the name" and "User's current name: Unknown"
34  user.name = "John" // Prints "Setting name to John"
35  println(s"User's new name: ${user.name}") // Prints "Accessing the name" and "User's new name: John"

In this example, age and name have custom getters and setters. The getter methods simply return the corresponding private fields, while the setter methods include additional logic to validate the values before setting them. Using the proper naming convention (i.e., def property for the getter and def property_= for the setter), Scala's internal mechanisms appropriately handle property access and mutation.

Congratulations! You've successfully navigated through the nuances of encapsulation and understood the role of private properties and accessors in Scala.

Encapsulation in the context of real-world applications works much like the internal workings of a smartphone — hidden, providing only what's needed while safeguarding the rest.

Next, get ready for hands-on exercises to consolidate your understanding. Well done, and continue your coding journey!