C# Object-Oriented Programming (OOP)

Welcome to The Coding College! In this tutorial, we’ll introduce you to Object-Oriented Programming (OOP) in C#, a programming paradigm designed to simplify complex software development through concepts like objects, classes, inheritance, polymorphism, and encapsulation.

What is OOP?

Object-Oriented Programming (OOP) is a programming paradigm that structures code around objects rather than functions or logic. Objects represent real-world entities and encapsulate data (properties) and behaviors (methods).

Core Principles of OOP

  1. Encapsulation: Bundling data and methods into a single unit (class).
  2. Inheritance: Sharing common functionality among classes.
  3. Polymorphism: Using a unified interface to interact with objects of different types.
  4. Abstraction: Hiding implementation details and exposing only essential features.

C# OOP: Key Concepts

1. Classes and Objects

A class is a blueprint for creating objects. An object is an instance of a class.

Example:

// Defining a class
public class Car
{
    public string Brand; // Field
    public int Speed;    // Field

    public void Drive()  // Method
    {
        Console.WriteLine($"{Brand} is driving at {Speed} km/h.");
    }
}

// Creating an object
public class Program
{
    public static void Main()
    {
        Car car = new Car();
        car.Brand = "Tesla";
        car.Speed = 100;
        car.Drive(); // Output: Tesla is driving at 100 km/h.
    }
}

2. Encapsulation

Encapsulation protects the internal state of an object and allows controlled access through properties or methods.

Example:

public class BankAccount
{
    private decimal balance; // Private field

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

    public decimal GetBalance()
    {
        return balance; // Controlled access
    }
}

public class Program
{
    public static void Main()
    {
        BankAccount account = new BankAccount();
        account.Deposit(500);
        Console.WriteLine($"Balance: {account.GetBalance()}"); // Output: Balance: 500
    }
}

3. Inheritance

Inheritance allows a class (child) to derive properties and methods from another class (parent).

Example:

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Barking...");
    }
}

public class Program
{
    public static void Main()
    {
        Dog dog = new Dog();
        dog.Eat(); // Output: Eating...
        dog.Bark(); // Output: Barking...
    }
}

4. Polymorphism

Polymorphism allows methods to have different implementations based on the object’s type.

Example:

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

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

public class Program
{
    public static void Main()
    {
        Shape shape = new Circle();
        shape.Draw(); // Output: Drawing a circle...
    }
}

5. Abstraction

Abstraction focuses on the essential features of an object and hides unnecessary details.

Example:

public abstract class Animal
{
    public abstract void Speak(); // Abstract method
}

public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Meow...");
    }
}

public class Program
{
    public static void Main()
    {
        Animal cat = new Cat();
        cat.Speak(); // Output: Meow...
    }
}

Benefits of OOP in C#

  1. Reusability: Code can be reused through inheritance and modular design.
  2. Scalability: Easy to extend functionality without affecting existing code.
  3. Maintainability: Organized code structure simplifies maintenance.
  4. Real-World Modeling: Closely resembles how objects interact in real life.

Real-World Use Cases

  1. Game Development: Representing game elements (e.g., players, enemies, items) as objects.
  2. Banking Applications: Modeling accounts, transactions, and customers using classes and objects.
  3. E-Commerce: Managing products, orders, and customers.

Conclusion

Object-Oriented Programming (OOP) is a cornerstone of modern programming, enabling developers to create efficient, scalable, and maintainable software. By mastering OOP in C#, you can write robust code that models real-world problems effectively.

Explore more tutorials and coding insights on The Coding College.

Leave a Comment