Object-Oriented Programming (OOP) in C#

OOP revolves around four key principles: encapsulation, inheritance, polymorphism, and abstraction. These principles enable the creation of modular, extensible, and flexible codebases. Let’s briefly explore each concept:

Classes are blueprint templates that define the properties and behaviors of objects. An object, on the other hand, is an instance of a class, representing a real-world entity or an abstract concept. Inheritance allows a class to inherit properties and methods from another class, establishing a hierarchical relationship. This ensures code reusability and promotes a logical class hierarchy.

Example:

class Animal
{
public string Name { get; set; }
public void MakeSound() { }
}

class Dog : Animal
{
public void Bark()
{
Console.WriteLine(“Woof!”);
}
}

Dog dog = new Dog();
dog.Name = “Buddy”;
dog.Bark(); // Output: “Woof!”

Polymorphism enables objects of different classes to be treated as instances of a common base class, allowing dynamic behavior based on the actual type at runtime. Method overriding is a crucial aspect of polymorphism, where a subclass provides a specific implementation for a method already defined in its base class.

Example:

class Shape
{
public virtual void Draw()
{
Console.WriteLine(“Drawing a shape”);
}
}

class Circle : Shape
{
public override void Draw()
{
Console.WriteLine(“Drawing a circle”);
}
}

Shape shape = new Circle();
shape.Draw(); // Output: “Drawing a circle”

Encapsulation shields the internal workings of a class, hiding implementation details and exposing only necessary functionalities. Access modifiers like public, private, protected, and internal control the accessibility of class members, ensuring proper data encapsulation and preventing unauthorized access.

Example:

class BankAccount
{
private decimal balance;

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

public decimal GetBalance()
{
return balance;
}
}

BankAccount account = new BankAccount();
account.Deposit(1000);
Console.WriteLine(account.GetBalance()); // Output: 1000

Abstract classes serve as base classes for other classes and cannot be instantiated directly. They contain abstract methods that must be implemented by derived classes. Interfaces, on the other hand, define a contract that classes must adhere to, ensuring a consistent behavior across unrelated classes.

Example:

abstract class Shape
{
public abstract double CalculateArea();
}

interface IDrawable
{
void Draw();
}

class Circle : Shape, IDrawable
{
public double Radius { get; set; }

public override double CalculateArea()
{
return Math.PI * Radius * Radius;
}

public void Draw()
{
Console.WriteLine(“Drawing a circle”);
}
}