Encapsulation and Abstraction in C#

# CHAPTER 17

Encapsulation and Abstraction #

1. Introduction #

2. Learning Objectives #

• Implement Encapsulation using private fields and public Properties.

• Understand the concept of Data Hiding.

• Implement Abstraction using abstract classes and methods.

3. Encapsulation: Data Hiding #

Encapsulation dictates that internal data should be private (hidden). The only way to interact with that data is through controlled, public methods or Properties that contain validation logic.

using System;

class BankAccount
{
    // 1. HIDDEN DATA (Private Field)
    private decimal _balance = 0;

    // 2. CONTROLLED ACCESS (Public Property)
    public decimal Balance
    {
        get { return _balance; } // Read-only access
    }

    // 3. CONTROLLED MODIFICATION (Public Method with Validation)
    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            _balance += amount;
            Console.WriteLine($"Deposited: ${amount}");
        }
        else
        {
            Console.WriteLine("Invalid deposit amount.");
        }
    }
}

4. Abstraction: Hiding Complexity #

In C#, we achieve this using the abstract keyword.

5. Abstract Classes and Methods #

An Abstract Method is a method that has no body. It *forces* the child class to provide the implementation.

// Abstract Class (Cannot instantiate 'new Shape()')
abstract class Shape
{
    // Abstract Method (No body, forces child to implement)
    public abstract double CalculateArea();

    // Regular Method (Inherited normally)
    public void Display()
    {
        Console.WriteLine("Displaying shape...");
    }
}

// Child class MUST implement CalculateArea()
class Circle : Shape
{
    private double _radius;

    public Circle(double radius)
    {
        _radius = radius;
    }

    // Using the 'override' keyword is mandatory
    public override double CalculateArea()
    {
        return 3.14159 * _radius * _radius;
    }
}

class Program
{
    static void Main()
    {
        // Shape s = new Shape(); // ERROR! Cannot instantiate abstract class.
        
        Shape myCircle = new Circle(5);
        myCircle.Display();
        Console.WriteLine($"Area: {myCircle.CalculateArea()}");
    }
}

6. Why use Abstraction? #

7. Common Mistakes #

• Writing logic in an abstract method: Abstract methods cannot have curly braces {}. They just end in a semicolon. Example: public abstract void DoWork();

• Forgetting override: When a derived class implements an abstract method, it must use the override keyword.

8. Best Practices #

• Default to making all class fields private and exposing them only via Properties.

• Use Abstract classes when you have some shared logic (like the Display method above) but want to force child classes to implement specific missing pieces.

9. Exercises #

1. 1. Create a User class with a private _password field. Create a public method SetPassword(string pwd) that only updates the password if it is longer than 6 characters.

1. 2. Create an abstract class Vehicle with an abstract method HonkHorn(). Create a Truck class that implements it.

10. MCQs with Answers #

11. Interview Questions #

• Q: Explain the difference between Abstraction and Encapsulation.

• Q: Can an abstract class have a constructor in C#? (Answer: Yes, it can have a constructor to initialize its own fields, which is called when the derived class is instantiated).

12. Summary #

13. Next Chapter Recommendation #