The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Encapsulation

Next ►
►

Encapsulation is one of the fundamental principles of Object-Oriented Programming (OOP). It refers to the bundling of data (variables) and methods (functions) that operate on the data into a single unit, or class. Encapsulation also involves restricting direct access to some of an object's components, which is a means of preventing unintended interference and misuse of the data.

Key Concepts of Encapsulation

  1. Data Hiding: Encapsulation allows the internal state of an object to be hidden from the outside. Only the object's methods can interact with its internal state.
  2. Access Modifiers: C# provides access modifiers to control the visibility of class members. The most common access modifiers are:
    • public: The member is accessible from any other code.
    • private: The member is accessible only within the class.
    • protected: The member is accessible within the class and by derived class instances.
    • internal: The member is accessible only within its own assembly.
    • protected internal: The member is accessible within its own assembly or by derived class instances.

Practical Example

Let's create a simple class to demonstrate encapsulation in C#.

Step-by-Step Example

  1. Define a Class with Private Fields: Create a class Person with private fields for name and age.
public class Person
{
    private string name;
    private int age;

    // Constructor
    public Person(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // Public method to get the name
    public string GetName()
    {
        return name;
    }

    // Public method to set the name
    public void SetName(string name)
    {
        this.name = name;
    }

    // Public method to get the age
    public int GetAge()
    {
        return age;
    }

    // Public method to set the age
    public void SetAge(int age)
    {
        if (age > 0)
        {
            this.age = age;
        }
    }
}
  1. Using the Class: Create an instance of the Person class and interact with its properties using the public methods.
public class Program
{
    public static void Main()
    {
        // Create a new Person object
        Person person = new Person("John Doe", 30);

        // Access and modify the person's name and age using public methods
        Console.WriteLine("Name: " + person.GetName());
        Console.WriteLine("Age: " + person.GetAge());

        // Modify the person's name and age
        person.SetName("Jane Doe");
        person.SetAge(25);

        // Display the updated information
        Console.WriteLine("Updated Name: " + person.GetName());
        Console.WriteLine("Updated Age: " + person.GetAge());
    }
}

Explanation

  • Private Fields: The name and age fields are private, meaning they cannot be accessed directly from outside the Person class.
  • Public Methods: The GetName, SetName, GetAge, and SetAge methods are public, providing controlled access to the private fields.
  • Validation: The SetAge method includes a validation check to ensure the age is positive, demonstrating how encapsulation can enforce rules and constraints.

Practical Exercises

Exercise 1: Create a BankAccount Class

  1. Objective: Create a BankAccount class with private fields for accountNumber and balance. Provide public methods to deposit and withdraw money, and to check the balance.

  2. Solution:

public class BankAccount
{
    private string accountNumber;
    private decimal balance;

    // Constructor
    public BankAccount(string accountNumber, decimal initialBalance)
    {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Method to deposit money
    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }

    // Method to withdraw money
    public void Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
        }
    }

    // Method to check the balance
    public decimal GetBalance()
    {
        return balance;
    }
}

Exercise 2: Test the BankAccount Class

  1. Objective: Create an instance of the BankAccount class and perform some transactions.

  2. Solution:

public class Program
{
    public static void Main()
    {
        // Create a new BankAccount object
        BankAccount account = new BankAccount("123456789", 1000m);

        // Deposit money
        account.Deposit(500m);
        Console.WriteLine("Balance after deposit: " + account.GetBalance());

        // Withdraw money
        account.Withdraw(200m);
        Console.WriteLine("Balance after withdrawal: " + account.GetBalance());

        // Attempt to withdraw more money than the balance
        account.Withdraw(1500m);
        Console.WriteLine("Balance after attempting to overdraw: " + account.GetBalance());
    }
}

Common Mistakes and Tips

  • Direct Access: Avoid making fields public. Always use private fields with public methods to control access.
  • Validation: Always validate input in setter methods to ensure the object's state remains consistent.
  • Encapsulation vs. Abstraction: Remember that encapsulation is about bundling data and methods, while abstraction is about hiding complexity. Both are important OOP principles.

Conclusion

Encapsulation is a powerful concept in C# that helps in maintaining the integrity of an object's data by restricting direct access to its fields. By using access modifiers and providing public methods to interact with the data, you can ensure that the object's state remains consistent and protected from unintended interference. This principle not only enhances code maintainability but also improves security and robustness.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved