C# - What is OOP and Classes?

What is OOP and Classes? in C# 

Introduction to Object-Oriented Programming in C#

Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around data, or objects, rather than functions and logic. In modern software development, OOP plays a crucial role in building scalable, maintainable, and reusable applications. In C# programming, OOP is the core foundation upon which applications are built, whether it is desktop software, web applications, enterprise systems, or game development using .NET technologies.

This comprehensive guide explains What is OOP in C#, the concept of classes in C#, and how OOP principles such as encapsulation, abstraction, inheritance, and polymorphism help developers write clean and efficient code. If you are preparing for interviews, learning C# for beginners, or building real-world applications, understanding these concepts is essential.

What is Object-Oriented Programming (OOP)?

Object-Oriented Programming is a programming model that uses objects and classes to structure software. An object represents a real-world entity, and a class acts as a blueprint for creating objects.

In simple terms:

• Class → Blueprint or template
• Object → Instance of a class
• Properties → Data of an object
• Methods → Behavior of an object

OOP in C# helps in organizing code into reusable structures, improving readability, and enhancing maintainability. It is widely used in .NET development, ASP.NET applications, Windows applications, and enterprise-level software systems.

Why OOP is Important in C# Programming

Understanding OOP concepts in C# is essential because:

• It promotes code reusability.
• It ensures data security using encapsulation.
• It supports modular programming.
• It improves software maintainability.
• It simplifies large application development.

Most real-world C# applications rely heavily on OOP principles. Whether you are building a banking system, hospital management software, or e-commerce platform, OOP helps manage complexity efficiently.

Core Principles of OOP in C#

1. Encapsulation

Encapsulation in C# means binding data and methods together into a single unit (class) and restricting direct access to some components. This helps protect data from unauthorized access.

Encapsulation is implemented using access modifiers like:

• public
• private
• protected
• internal

using System;

class Person
{
    private string name;

    public void SetName(string personName)
    {
        name = personName;
    }

    public string GetName()
    {
        return name;
    }
}

class Program
{
    static void Main()
    {
        Person p = new Person();
        p.SetName("John");
        Console.WriteLine(p.GetName());
    }
}

In this example, the variable name is private and cannot be accessed directly. This ensures data protection and controlled access.

2. Abstraction

Abstraction in C# means hiding internal implementation details and showing only essential features. This is achieved using abstract classes and interfaces.

using System;

abstract class Animal
{
    public abstract void MakeSound();
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }
}

class Program
{
    static void Main()
    {
        Animal myDog = new Dog();
        myDog.MakeSound();
    }
}

Here, the abstract class defines behavior but does not provide full implementation. The derived class provides the specific behavior.

3. Inheritance

Inheritance in C# allows one class to acquire properties and methods of another class. It promotes code reuse and hierarchical classification.

using System;

class Vehicle
{
    public void Start()
    {
        Console.WriteLine("Vehicle started");
    }
}

class Car : Vehicle
{
    public void Drive()
    {
        Console.WriteLine("Car is driving");
    }
}

class Program
{
    static void Main()
    {
        Car c = new Car();
        c.Start();
        c.Drive();
    }
}

The Car class inherits from Vehicle class and can use its methods.

4. Polymorphism

Polymorphism in C# allows objects to behave differently based on context. It is achieved using method overloading and method overriding.

using System;

class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }
}

class Program
{
    static void Main()
    {
        Calculator calc = new Calculator();
        Console.WriteLine(calc.Add(5, 3));
        Console.WriteLine(calc.Add(5.5, 3.2));
    }
}

Here, the Add method behaves differently based on parameters.

What is a Class in C#?

A class in C# is a user-defined data type that contains fields (variables), properties, methods, constructors, and events. It acts as a blueprint for creating objects.

Syntax of a Class:

class ClassName
{
    // Fields
    // Properties
    // Methods
}

Components of a Class in C#

1. Fields

Variables declared inside a class.

2. Properties

Used to access private fields in a controlled manner.

class Student
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

3. Methods

Functions defined inside a class.

4. Constructors

Special methods used to initialize objects.

class Student
{
    public string Name;

    public Student(string name)
    {
        Name = name;
    }
}

Creating Objects in C#

An object is created using the new keyword.

Student s1 = new Student("Meena");

Here, s1 is an object of the Student class.

Real-World Example of OOP in C#

using System;

class BankAccount
{
    private double balance;

    public BankAccount(double initialBalance)
    {
        balance = initialBalance;
    }

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

    public void Withdraw(double amount)
    {
        if (amount <= balance)
        {
            balance -= amount;
        }
    }

    public double GetBalance()
    {
        return balance;
    }
}

class Program
{
    static void Main()
    {
        BankAccount account = new BankAccount(1000);
        account.Deposit(500);
        account.Withdraw(200);
        Console.WriteLine(account.GetBalance());
    }
}

This example demonstrates encapsulation, object creation, and real-world modeling using C# OOP concepts.

Advantages of OOP in C#

• Improved code reusability
• Better data security
• Easier maintenance
• Scalability
• Modular structure

Difference Between Class and Object in C#

• Class → Blueprint
• Object → Instance of class
• Class does not occupy memory until object is created
• Object occupies memory

Understanding What is OOP in C# and What is a Class in C# is fundamental for any C# developer. Object-Oriented Programming provides structure, scalability, and maintainability to applications. By mastering encapsulation, abstraction, inheritance, and polymorphism, developers can build robust and efficient applications using C# programming and the .NET framework.

Whether you are a beginner learning C# basics or an experienced developer preparing for interviews, strong knowledge of OOP concepts will significantly improve your programming skills and software design capabilities.