📝 Lesson 4.2: Introduction to Object-Oriented Programming

What Is OOP?

Object-Oriented Programming (OOP) is a way of organizing code around objects — self-contained units that bundle together related data and the behavior that acts on it.

Think about a real-world car. It has data (color, current speed, fuel level) and behavior (accelerate, brake, honk). OOP lets you model that in code: a single Car object holds its own data and knows how to act on it.

So far your data (variables) and behavior (methods) have been separate. OOP brings them together into tidy, reusable units — which is how nearly all real C# programs are structured.

Classes vs. Objects

This is the single most important idea in the lesson, so let's make it concrete.

You define a class once, then create as many objects (also called instances) from it as you need — each with its own data.

Your First Class

Let's model a person. A class is declared with the class keyword and, by convention, a PascalCase name:

class Person
{
    // Properties (data each person has)
    public string Name;
    public int Age;
}

Now create objects from that blueprint using the new keyword, and access their data with a dot .:

Person alice = new Person();
alice.Name = "Alice";
alice.Age = 30;

Person bob = new Person();
bob.Name = "Bob";
bob.Age = 25;

Console.WriteLine($"{alice.Name} is {alice.Age}.");   // Alice is 30.
Console.WriteLine($"{bob.Name} is {bob.Age}.");       // Bob is 25.

alice and bob are two separate objects from the same Person class. Changing alice.Age has no effect on bob — each object holds its own state.

Properties: An Object's Data

The Name and Age above are simple fields. In real C#, we usually expose data through properties, which look like fields but can control how values are read and written. The short form uses { get; set; }:

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

You use them exactly like fields — alice.Name = "Alice"; — but properties give you a place to add rules later without changing how callers use them. For example, a property can reject invalid values:

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

    private int _age;                 // backing field (private)
    public int Age
    {
        get { return _age; }
        set
        {
            if (value >= 0)           // 'value' is what the caller assigned
            {
                _age = value;
            }
        }
    }
}

Methods: An Object's Behavior

Data is only half of an object. Methods inside a class define what the object can do — and they can freely use the object's own properties:

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

    // A method: behavior that uses this object's own data
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {Name} and I'm {Age} years old.");
    }

    public bool IsAdult()
    {
        return Age >= 18;
    }
}

Person alice = new Person();
alice.Name = "Alice";
alice.Age = 30;

alice.Introduce();                       // Hi, I'm Alice and I'm 30 years old.
Console.WriteLine(alice.IsAdult());      // True

Notice Introduce uses Name and Age directly — because it belongs to the class, it automatically works with that particular object's data. Call alice.Introduce() and it uses Alice's values; a bob.Introduce() would use Bob's.

Constructors

Setting each property one line at a time is tedious. A constructor is a special method that runs when you create an object with new, letting you set up the object in one step. It has the same name as the class and no return type:

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

    // Constructor — runs when you write 'new Person(...)'
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {Name} and I'm {Age} years old.");
    }
}

Now creating a fully-formed object is a single line:

Person alice = new Person("Alice", 30);
Person bob = new Person("Bob", 25);

alice.Introduce();   // Hi, I'm Alice and I'm 30 years old.
bob.Introduce();     // Hi, I'm Bob and I'm 25 years old.

public Person(string name, int age)
{
    this.Name = name;   // this.Name = the object's property; name = the parameter
    this.Age = age;
}

Exercise & Quiz

BankAccount account = new BankAccount("Ada", 100m);
account.Deposit(50m);
account.Withdraw(30m);
account.Withdraw(1000m);   // should be refused
account.PrintStatement();

class BankAccount
{
    // TODO: properties Owner and Balance
    // TODO: constructor(owner, startingBalance)
    // TODO: Deposit, Withdraw, PrintStatement methods
}

BankAccount account = new BankAccount("Ada", 100m);
account.Deposit(50m);
account.Withdraw(30m);
account.Withdraw(1000m);   // refused
account.PrintStatement();

class BankAccount
{
    public string Owner { get; set; }
    public decimal Balance { get; set; }

    public BankAccount(string owner, decimal startingBalance)
    {
        Owner = owner;
        Balance = startingBalance;
    }

    public void Deposit(decimal amount)
    {
        Balance += amount;
        Console.WriteLine($"Deposited {amount:C}. Balance: {Balance:C}");
    }

    public void Withdraw(decimal amount)
    {
        if (amount <= Balance)
        {
            Balance -= amount;
            Console.WriteLine($"Withdrew {amount:C}. Balance: {Balance:C}");
        }
        else
        {
            Console.WriteLine($"Insufficient funds to withdraw {amount:C}.");
        }
    }

    public void PrintStatement()
    {
        Console.WriteLine($"--- Statement for {Owner} ---");
        Console.WriteLine($"Current balance: {Balance:C}");
    }
}

Deposited $50.00. Balance: $150.00
Withdrew $30.00. Balance: $120.00
Insufficient funds to withdraw $1,000.00.
--- Statement for Ada ---
Current balance: $120.00

Summary

📚 Additional Resources

• Object-oriented programming — Microsoft Docs
• Classes — C# Programming Guide
• Properties — Microsoft Docs

🚀 What's Next?

You've now met every core building block of C#! In the final lesson, Lesson 4.3: Putting It All Together, you'll combine variables, control flow, methods, collections, and classes into one complete program — a capstone that ties the whole course together.