Encapsulation in TypeScript: Private Attributes and Methods

Lesson Overview

Hello! In this lesson, we're revisiting Encapsulation, Private Attributes, and Private Methods in Object-Oriented Programming (OOP). Imagine encapsulation as an invisible fence safeguarding a garden from outside interference, keeping data and methods safe within. Within this garden, certain plants (Private Attributes and Methods) are only for the gardener's eyes. These are crucial for making your classes more robust and secure!

Encapsulation Explained

Encapsulation in OOP wraps up data and methods into a class . This organizational approach tidies the code and reinforces security. If you were to code a multiplayer game, for example, you could create a Player class, encapsulating data (health, armor, stamina) and methods (receiveDamage, shieldHit, restoreHealth). TypeScript class Player {private health: number; private armor: number; private stamina: number; constructor(health: number, armor: number, stamina: number) {this.health = health; this.armor = armor; this.stamina = stamina;} receiveDamage(damage: number): void {this.health -= damage;} shieldHit(armor: number): void {this.armor -= armor;} restoreHealth(healthIncrease: number): void {this.health += healthIncrease;}} const player = new Player(100, 50, 77); Now, player is an instance of the Player class on which you can call methods. You may notice the private keyword in the Player class definition; we will discuss the private keyword in the next section.

Remark the Privacy

In TypeScript, private attributes and methods are designated using the private keyword. Note that the constructor itself cannot be private. TypeScript class PrivateExample {private privateAttribute: string; constructor() {this.publicAttribute = "Public"; this.privateAttribute = "Private";} publicAttribute: string; getPrivateAttribute(): string {return this.privateAttribute;}} const example = new PrivateExample(); console.log(example.publicAttribute); // Works: logs "Public" console.log(example.getPrivateAttribute()); // Works: logs "Private" // console.log(example.privateAttribute); // Error: can't access private attribute from outside Private attributes and methods are inaccessible directly from an instance. This arrangement helps maintain integrity.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Private Methods

Like private attributes, private methods are accessible only within their class. Here's an example:

TypeScript

class BankAccount {
    private balance: number;
    accountNumber: number;

    constructor(accountNumber: number, balance: number) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    private addInterest(interestRate: number): void {
        this.balance += this.balance * interestRate;
    }

    addYearlyInterest(): void {
        this.addInterest(0.02);  // Adds 2% interest
    }

    getBalance(): number {
        return this.balance;
    }
}

const bankAccount = new BankAccount(1234, 100);
bankAccount.addYearlyInterest();  // Works, calling a public method
console.log(bankAccount.getBalance());  // Logs the updated balance
// bankAccount.addInterest(0.1);  // Error: can't call a private method from outside

class BankAccount {
    private balance: number;
    accountNumber: number;

    constructor(accountNumber: number, balance: number) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    private addInterest(interestRate: number): void {
        this.balance += this.balance * interestRate;
    }

    addYearlyInterest(): void {
        this.addInterest(0.02);  // Adds 2% interest
    }

    getBalance(): number {
        return this.balance;
    }
}

const bankAccount = new BankAccount(1234, 100);
bankAccount.addYearlyInterest();  // Works, calling a public method
console.log(bankAccount.getBalance());  // Logs the updated balance
// bankAccount.addInterest(0.1);  // Error: can't call a private method from outside

Within the BankAccount class, the public method addYearlyInterest calls the private method addInterest. Although private methods like addInterest can't be called from outside the class, they can still be used internally by class methods. Such private methods are useful when you want to encapsulate functionalities that are not meant to be exposed externally but are utilized to support the class operations internally.

Setters

Setters allow modification of the value of a private attribute while providing a controlled interface. To create a setter method, you should use the set keyword followed by the method name. Here's an example demonstrating the use of a setter method:

TypeScript

class BankAccount {
    private balance: number;
    accountNumber: number;

    constructor(accountNumber: number, balance: number) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    get balanceValue(): number {
        return this.balance;
    }

    set balanceValue(amount: number) {
        if (amount >= 0) {
            this.balance = amount;
        } else {
            console.log("Balance cannot be negative.");
        }
    }

    deposit(amount: number): void {
        this.balance += amount;
    }
}

const bankAccount = new BankAccount(1234, 100);
bankAccount.balanceValue = 200;  // Works: sets balance to 200
console.log(bankAccount.balanceValue);  // Works: logs 200
bankAccount.balanceValue = -50;  // Logs: "Balance cannot be negative."

class BankAccount {
    private balance: number;
    accountNumber: number;

    constructor(accountNumber: number, balance: number) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    get balanceValue(): number {
        return this.balance;
    }

    set balanceValue(amount: number) {
        if (amount >= 0) {
            this.balance = amount;
        } else {
            console.log("Balance cannot be negative.");
        }
    }

    deposit(amount: number): void {
        this.balance += amount;
    }
}

const bankAccount = new BankAccount(1234, 100);
bankAccount.balanceValue = 200;  // Works: sets balance to 200
console.log(bankAccount.balanceValue);  // Works: logs 200
bankAccount.balanceValue = -50;  // Logs: "Balance cannot be negative."

In this example, the balanceValue setter method ensures that the balance is only set to non-negative values, adding a layer of validation.

Getters and setters provide a controlled way to access and modify private attributes. By using a getter, we offer read-only access to private attributes without exposing the attribute itself. A setter can enforce rules, like ensuring a balance attribute remains non-negative. This maintains encapsulation by letting external code interact with private data safely and predictably.

Lesson Overview

Encapsulation Explained

Remark the Privacy

Join the 1M+ learners on CodeSignal

Private Attributes

Private Methods

Getters and Setters

Getters

Setters

Lesson Summary and Practice