C# - What is OOP and Classes?

What is OOP and Classes in C#?

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of "objects" — entities that combine data and behavior. C# is a modern, object-oriented programming language that fully supports OOP principles and makes extensive use of classes as blueprints for creating objects.

1. Introduction to Object-Oriented Programming (OOP)

OOP organizes software design around data, or objects, rather than functions and logic. An object is an instance of a class and encapsulates state (attributes) and behavior (methods). The main goal of OOP is to model real-world entities and relationships in code, making programs easier to understand, maintain, and extend.

1.1 Key Principles of OOP

The four fundamental principles of OOP are:

• Encapsulation: Bundling data (fields) and methods that operate on data into a single unit called a class, and restricting access to some of the object's components. This helps hide the internal state and protects it from unauthorized changes.
• Abstraction: Simplifying complex reality by modeling classes appropriate to the problem, focusing on essential characteristics while hiding irrelevant details.
• Inheritance: Creating new classes from existing ones, enabling reusability and establishing a hierarchy. Derived classes inherit fields and methods from base classes, allowing code sharing and extension.
• Polymorphism: The ability of different classes to be treated through a common interface, usually via method overriding or overloading, allowing for flexible and dynamic behavior.

1.2 Why Use OOP?

• Modularity: Code is organized into self-contained classes which can be developed and tested independently.
• Reusability: Classes and objects can be reused across programs.
• Maintainability: Changes in one part of the system can be isolated, reducing bugs and improving maintainability.
• Scalability: OOP designs can easily accommodate growth or changes in requirements.

2. Understanding Classes in C#

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

2.1 Class Declaration Syntax

public class Car
{
    // Fields (attributes)
    public string Make;
    public string Model;
    public int Year;

    // Constructor
    public Car(string make, string model, int year)
    {
        Make = make;
        Model = model;
        Year = year;
    }

    // Method (behavior)
    public void Drive()
    {
        Console.WriteLine($"{Make} {Model} is driving.");
    }
}

2.2 Creating Objects from Classes

An object is an instance of a class created using the new keyword.

Car myCar = new Car("Toyota", "Camry", 2020);
myCar.Drive();  // Output: Toyota Camry is driving.

2.3 Components of a Class

• Fields: Variables that hold data for the object.
• Properties: Encapsulated accessors to fields, providing get/set methods.
• Methods: Functions that define object behavior.
• Constructors: Special methods invoked when an object is created.
• Destructors: Cleanup methods called when an object is garbage collected (rarely used explicitly in C#).

3. Encapsulation and Access Modifiers

Encapsulation hides internal object details and exposes only what is necessary via access modifiers:

3.1 Properties as Encapsulation Mechanism

Instead of exposing fields directly, properties are used to control access:

public class Person
{
    private string name;  // Private field

    // Public property with getter and setter
    public string Name
    {
        get { return name; }
        set
        {
            if (!string.IsNullOrEmpty(value))
                name = value;
        }
    }
}

3.2 Auto-Implemented Properties

C# allows simplified property declaration:

public class Person
{
    public string Name { get; set; }
}

4. Constructors and Object Initialization

Constructors initialize new objects. They have the same name as the class and no return type.

4.1 Parameterized Constructors

public class Book
{
    public string Title;
    public string Author;

    public Book(string title, string author)
    {
        Title = title;
        Author = author;
    }
}

4.2 Default Constructor

If no constructor is declared, the compiler creates a parameterless default constructor.

4.3 Constructor Overloading

You can define multiple constructors with different parameters:

public class Rectangle
{
    public int Width;
    public int Height;

    public Rectangle()
    {
        Width = 0;
        Height = 0;
    }

    public Rectangle(int width, int height)
    {
        Width = width;
        Height = height;
    }
}

5. Inheritance — Building on Classes

Inheritance allows a class to acquire properties and methods from a base class. It supports reusability and polymorphism.

5.1 Syntax

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

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

5.2 Usage

Car car = new Car();
car.Start();  // Inherited method
car.Drive();  // Own method

5.3 Base Keyword

Used to call members of the base class explicitly.

public class BaseClass
{
    public void Show() { Console.WriteLine("Base Show"); }
}

public class DerivedClass : BaseClass
{
    public void Show()
    {
        base.Show();  // Call base class Show
        Console.WriteLine("Derived Show");
    }
}

6. Polymorphism in C#

Polymorphism allows objects of different types to be treated as objects of a common base type, typically via method overriding.

6.1 Virtual and Override Keywords

Virtual methods can be overridden by derived classes.

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

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

6.2 Runtime Polymorphism

Method calls are resolved at runtime:

Animal myAnimal = new Dog();
myAnimal.Speak();  // Output: Dog barks

7. Abstraction with Classes and Interfaces

Abstraction focuses on exposing only relevant information. In C#, it is supported by abstract classes and interfaces.

7.1 Abstract Classes

Cannot be instantiated and may contain abstract methods that derived classes must implement.

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

public class Circle : Shape
{
    public double Radius;

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

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

7.2 Interfaces

Interfaces define a contract without implementation.

public interface IFlyable
{
    void Fly();
}

public class Bird : IFlyable
{
    public void Fly()
    {
        Console.WriteLine("Bird is flying.");
    }
}

8. Practical Example: Modeling a Library System

Let’s create classes to model books, library members, and borrowing behavior.

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public bool IsBorrowed { get; private set; }

    public Book(string title, string author)
    {
        Title = title;
        Author = author;
        IsBorrowed = false;
    }

    public void Borrow()
    {
        if (!IsBorrowed)
            IsBorrowed = true;
        else
            Console.WriteLine("Book already borrowed.");
    }

    public void Return()
    {
        IsBorrowed = false;
    }
}

public class Member
{
    public string Name { get; set; }
    private List borrowedBooks = new List();

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

    public void BorrowBook(Book book)
    {
        if (!book.IsBorrowed)
        {
            book.Borrow();
            borrowedBooks.Add(book);
            Console.WriteLine($"{Name} borrowed {book.Title}");
        }
        else
        {
            Console.WriteLine($"{book.Title} is already borrowed.");
        }
    }

    public void ReturnBook(Book book)
    {
        if (borrowedBooks.Contains(book))
        {
            book.Return();
            borrowedBooks.Remove(book);
            Console.WriteLine($"{Name} returned {book.Title}");
        }
    }
}

In summary, Object-Oriented Programming in C# revolves around the concept of classes and objects. Classes define the blueprint, encapsulating data and behavior, while objects are instances of these classes.

Understanding OOP principles — encapsulation, abstraction, inheritance, and polymorphism — enables developers to write code that is modular, reusable, and easier to maintain. Classes provide a powerful mechanism to model real-world entities and behaviors.

With C#’s robust support for OOP features such as access modifiers, constructors, inheritance, interfaces, and abstract classes, developers can build scalable and flexible applications that are easy to evolve and extend.

Mastering these concepts lays the foundation for effective C# programming and software design.