Encapsulation with TypeScript (OOP)

Encapsulation is a fundamental principle of object-oriented programming that involves bundling the data (properties) and methods that operate on the data within a class, and controlling the access to these members. Access modifiers (public, private, and protected) are used to specify the visibility of class members, determining whether they can be accessed from outside the class.

By marking certain properties or methods as private, a class encapsulates its internal implementation details, hiding them from external code and promoting a more secure and controlled interaction with the object. Encapsulation enhances code organization, reduces the risk of unintended interference, and enables the implementation to evolve without affecting the external code that uses the class, developing modular and maintainable software development.

The Fundamentals

Imagine a BankAccount class responsible for managing financial transactions. It would contain sensitive data like balance and transaction history.

Encapsulation in TypeScript helps protect this data by:

  1. Hiding sensitive data: Declaring members (variables and methods) as private.
  2. Exposing controlled operations: Creating public methods to perform operations on the data (e.g., deposit, withdraw) with validation and security checks.
Example: Bank Account
class BankAccount { private balance: number; // Private data, only accessible within the class constructor(initialBalance: number) { this.balance = initialBalance; } public deposit(amount: number): void { if (amount <= 0) { throw new Error("Cannot deposit negative amount!"); } this.balance += amount; } public withdraw(amount: number): boolean { if (amount > this.balance) { return false; // Insufficient funds } this.balance -= amount; return true; } public getBalance(): number { // Expose readable balance return this.balance; } } const account = new BankAccount(100); account.deposit(50); console.log(account.getBalance()); // Outputs 150 // Direct access to balance not allowed: account.balance = 200; // Error: `balance` is private

This example demonstrates how encapsulation works. The balance is hidden, while functions like deposit and withdraw provide controlled access with validation and security measures.

Benefits of Encapsulation

  1. Data protection: Sensitive data is shielded from unauthorized access, enhancing security and preventing accidental modification.
  2. Improved code maintainability: Class internals are contained and organized, making the code easier to understand and modify.
  3. Reduced coupling: External code relies on exposed methods, minimizing dependencies and making the code more modular.
  4. Increased reliability: Controlled access through methods allows for validation and error handling, leading to more robust code.

Encapsulation with Accessors

TypeScript provides property accessors (get and set) that allow additional logic to be executed when getting or setting a property, providing another layer of encapsulation.

class Temperature { private _celsius: number; constructor(celsius: number) { this._celsius = celsius; } get celsius(): number { return this._celsius; } set celsius(value: number) { if (value < -273.15) { console.log("Invalid temperature"); return; } this._celsius = value; } get fahrenheit(): number { return (this._celsius * 9) / 5 + 32; } } const temperature = new Temperature(25); console.log(temperature.celsius); // Accessing 'celsius' through a getter temperature.celsius = 30; // Accessing 'celsius' through a setter console.log(temperature.fahrenheit); // Calculating and accessing 'fahrenheit'

Here, the celsius property is encapsulated with a getter and setter, allowing controlled access and additional logic.

Beyond Simple Access Control

  1. Encapsulation also involves using other features like constructors and access modifiers (public, private, protected) to control how objects are created and interact with each other.
  2. Advanced techniques like abstract classes and interfaces help further enforce encapsulation by defining contracts for data and functionality.

Conclusion

Encapsulation in TypeScript promotes information hiding, data protection, and the creation of well-defined interfaces for interacting with objects, contributing to more maintainable and scalable code.






Related Topics
  1. TypeScript Classes
  2. TypeScript Object Types
  3. TypeScript Inheritance
  4. TypeScript Access Modifiers
  1. Polymorphism With TypeScript (OOP)
  2. Using interfaces in TypeScript
  3. TypeScript Namespaces
  4. TypeScript Module
  5. Typescript Function Overloading
  6. TypeScript Abstract Class
  7. Typescript Static Members