Encapsulation in Scala: Protecting and Managing Data

Welcome back! We're diving deeper into the world of Object-Oriented Programming (OOP) with a focus on encapsulation. In particular, this lesson will explore how the principle of encapsulation brings order and security to your Scala code. Get ready to enhance your skills and write code that's both robust and elegant! 🦾

Encapsulation is a cornerstone of OOP that bundles data (variables) and behaviors (methods) within a single unit called a class. It hides an object's internal state and requires all interactions to be performed through the object's methods. This means the internal workings are concealed from the outside, providing a clear and controlled interface.

By restricting direct access to an object's fields, encapsulation prevents unintended interference and misuse of data. It ensures that an object's state can only be changed in predictable ways, maintaining the integrity of the data throughout the program's execution.

In Scala, encapsulation is achieved using access modifiers that control the visibility of class members:

• private: Members are accessible only within the class or object that contains them.
• protected: Members are accessible within the class and its subclasses.
• Default (no modifier): Members are public by default when no access modifier is specified, meaning they are accessible from anywhere. Note that there isn't a public keyword in Scala; the default access level is public.

These modifiers allow you to define what parts of your code are exposed publicly and what parts are hidden, giving you granular control over the access to your class's internal state.

Let's illustrate encapsulation with an example and delve deeper into accessors and mutators:

class Person(private var _name: String, private var _age: Int):
  def name: String = _name // Accessor method for 'name'
  def name_=(newName: String): Unit = _name = newName // Mutator method for 'name'

  def age: Int = _age // Accessor method for 'age'
  def age_=(newAge: Int): Unit = _age = newAge // Mutator method for 'age'
  
@main def main(): Unit =
  val person = Person("Alice", 30) // Create a Person object
  person.name = "Bob" // Set name via mutator
  person.age = 25 // Set age via mutator
  println(s"Name: ${person.name}, Age: ${person.age}")

In this example, the Person class encapsulates the properties _name and _age by declaring them as private. To manipulate this properties, we introduce two types of (public) methods:

• Accessors: Also known as "getter" methods, accessors are used to retrieve the current value of a private field. For example, the name method is an accessor that returns the value of _name.
• Mutators: Also known as "setter" methods, mutators are used to modify the value of a private field. In Scala, you create a mutator by defining a method with the property name followed by _=. This is a Scala-specific convention that allows you to mimic assignment syntax: for example, the name_= method allows external code to modify the _name field, while maintaining control over the assignment.

By using accessors and mutators, we maintain control over how external code interacts with the object's state, ensuring that changes to private fields are performed in a controlled and predictable manner.