Encapsulation and Access Modifiers Explained

Key Concepts

Encapsulation and access modifiers are fundamental concepts in object-oriented programming (OOP) that help in controlling the visibility and accessibility of class members. Encapsulation ensures that the internal state of an object is protected from external interference, while access modifiers define the scope and visibility of class members.

1. Encapsulation

Encapsulation is the process of wrapping data and methods that operate on the data within one unit, or class. This prevents external code from directly accessing or modifying the internal state of an object. Encapsulation is achieved by using access modifiers to control the visibility of class members.

Example

class BankAccount
{
    private decimal balance;

    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }

    public void Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
        }
    }

    public decimal GetBalance()
    {
        return balance;
    }
}

In this example, the balance field is private, meaning it cannot be accessed directly from outside the class. The methods Deposit, Withdraw, and GetBalance provide controlled access to the balance, ensuring that it is modified only through valid operations.

2. Access Modifiers

Access modifiers are keywords that define the accessibility of class members. C# provides several access modifiers:

• public: Accessible from anywhere.
• private: Accessible only within the same class.
• protected: Accessible within the same class and derived classes.
• internal: Accessible within the same assembly.
• protected internal: Accessible within the same assembly or derived classes in other assemblies.

Example

public class Vehicle
{
    protected string Make;
    private string Model;

    public Vehicle(string make, string model)
    {
        Make = make;
        Model = model;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Make: {Make}, Model: {Model}");
    }
}

public class Car : Vehicle
{
    public Car(string make, string model) : base(make, model)
    {
    }

    public void ShowMake()
    {
        Console.WriteLine($"Car Make: {Make}");
    }
}

In this example, the Make field is protected, so it can be accessed by the Car class, which inherits from Vehicle. The Model field is private, so it cannot be accessed outside the Vehicle class. The DisplayInfo method is public, making it accessible from anywhere.

Conclusion

Encapsulation and access modifiers are crucial for creating robust and maintainable object-oriented programs. Encapsulation protects the internal state of objects, while access modifiers control the visibility and accessibility of class members. By mastering these concepts, you can write more secure and organized code.