What are public, private, and protected modifiers?

In object-oriented programming, access modifiers play a crucial role in defining the visibility and accessibility of class members (attributes and methods). Understanding public, private, and protected modifiers is essential for maintaining encapsulation and ensuring that the code is organized and secure. Below is an overview of these modifiers, their practical applications, best practices, and common mistakes.

Public Modifier

The public modifier allows class members to be accessible from any other code in the same program. This means that any object of the class can access its public attributes and methods.

Example of Public Modifier

class User {
    public name;
    
    constructor(name) {
        this.name = name;
    }
    
    public greet() {
        return `Hello, ${this.name}!`;
    }
}

const user = new User('Alice');
console.log(user.greet()); // Output: Hello, Alice!

Best Practices

• Use public modifiers for methods and properties that need to be accessed from outside the class.
• Keep public interfaces minimal to reduce complexity and improve maintainability.

Common Mistakes

• Overusing public access, which can lead to tightly coupled code and make it harder to change implementations later.
• Exposing sensitive data through public properties without validation or control.

Private Modifier

The private modifier restricts access to class members, allowing them to be accessed only within the class itself. This encapsulation helps protect the internal state of the object.

Example of Private Modifier

class BankAccount {
    private balance;

    constructor(initialBalance) {
        this.balance = initialBalance;
    }

    public deposit(amount) {
        this.balance += amount;
    }

    public getBalance() {
        return this.balance;
    }
}

const account = new BankAccount(100);
account.deposit(50);
console.log(account.getBalance()); // Output: 150
// console.log(account.balance); // Error: balance is private

Best Practices

• Use private modifiers to encapsulate the internal state and prevent external code from modifying it directly.
• Provide public methods to interact with private data, ensuring validation and control over changes.

Common Mistakes

• Failing to use private modifiers when necessary, which can expose the internal state and lead to unintended side effects.
• Using private members inappropriately, which can lead to complex and hard-to-maintain code.

Protected Modifier

The protected modifier allows class members to be accessed within the class itself and by subclasses. This is particularly useful in inheritance scenarios where derived classes need to access or modify the base class members.

Example of Protected Modifier

class Animal {
    protected species;

    constructor(species) {
        this.species = species;
    }
}

class Dog extends Animal {
    public bark() {
        return `Woof! I am a ${this.species}.`;
    }
}

const dog = new Dog('Dog');
console.log(dog.bark()); // Output: Woof! I am a Dog.
// console.log(dog.species); // Error: species is protected

Best Practices

• Use protected modifiers when you want to allow subclasses to access certain members while keeping them hidden from other parts of the program.
• Document protected members clearly to indicate their intended use in subclasses.

Common Mistakes

• Using protected members excessively, which can lead to fragile base class problems where changes in the base class affect derived classes unexpectedly.
• Not considering the implications of exposing protected members, which can lead to tight coupling between classes.