Courses/C#/Object-Oriented Programming

Object-Oriented Programming

Lesson 7 • Intermediate Track

What You'll Learn

Understand what OOP is and why C# is built around it
Create classes (blueprints) and objects (instances) with fields and methods
Write constructors to initialise objects with meaningful data
Apply encapsulation to protect data with private fields and public methods
Use properties (get/set) including auto-properties, validation, and computed properties
Distinguish between static and instance members and know when to use each

💡 Real-World Analogy

A class is like an architectural blueprint for a house. It defines what rooms exist, where doors go, and how plumbing works — but it's not a house you can live in. An object is an actual house built from that blueprint. You can build hundreds of houses from one blueprint, each with different paint colours (field values), but they all share the same structure (methods and properties). Encapsulation is like the walls — you can use the light switches (public methods) but you can't touch the electrical wiring directly (private fields).

Understanding OOP in C#

Object-Oriented Programming (OOP) is a programming paradigm that organises code around objects — units that bundle data (what something is) and behaviour (what something does). Instead of writing long procedural scripts, you model your program as interacting objects, just like the real world.

C# is fundamentally an OOP language — everything lives inside a class. The four pillars of OOP are:

🔒 Encapsulation — Hide internal data, expose controlled access (this lesson)
🧬 Inheritance — Create specialised classes from general ones (next lesson)
🎭 Polymorphism — Same method name, different behaviour depending on the object
🎨 Abstraction — Define "what" without specifying "how" (interfaces & abstract classes)

In this lesson, you'll master the first pillar — encapsulation — along with classes, objects, constructors, properties, and static members. These are the building blocks you'll use in every C# project from now on.

📊 Access Modifiers Quick Reference

Modifier	Access Level	Use When
public	Accessible from anywhere	Methods and properties that other code needs to call
private	Only inside the same class	Internal data and helper methods (default for fields)
protected	Same class + derived classes	Data that subclasses need but external code shouldn't touch
internal	Same assembly (project)	Classes/methods shared within a project but hidden from external consumers

1. Classes and Objects

A class defines the blueprint — what fields (data) and methods (behaviour) an object will have. An object is a specific instance created from that blueprint with its own unique data. You create objects with the new keyword.

Classes & Objects

Create a Car class with fields, constructor, and methods.

Try it Yourself »

using System;

// A class is a blueprint
class Car
{
    // Fields (data the object holds)
    public string Brand;
    public string Model;
    public int Year;

    // Constructor — runs when you create an object
    public Car(string brand, string model, int year)
    {
        Brand = brand;
        Model = model;
        Year = year;
    }

    // Method — something the object can do
    public void StartEngine()
    {
        Console.WriteLine($"{Brand} {Model} ({Year}) — engine started! �
...

2. Encapsulation — Protecting Data

Encapsulation means making fields private and providing public methods to interact with them. This prevents invalid data (like a negative bank balance) and lets you change the internal implementation without breaking code that uses the class.

Encapsulation

Build a BankAccount with private balance and public methods.

Try it Yourself »

using System;

class BankAccount
{
    // Private field — cannot be accessed from outside
    private double balance;
    public string Owner { get; }

    public BankAccount(string owner, double initialBalance)
    {
        Owner = owner;
        balance = initialBalance;
    }

    // Public methods control how the private data is modified
    public void Deposit(double amount)
    {
        if (amount <= 0)
        {
            Console.WriteLine("❌ Deposit must be positive.");
            r
...

3. Properties — The C# Way

Properties are C#'s elegant alternative to Java-style getters and setters. Auto-properties (public string Name { get; set; }) handle simple cases. For validation, use a full property with a backing field. Computed properties use => to calculate values on the fly.

Properties (get/set)

Auto-properties, validation setters, and computed properties.

Try it Yourself »

using System;

class Student
{
    // Auto-implemented property (most common)
    public string Name { get; set; }

    // Property with validation in the setter
    private int age;
    public int Age
    {
        get => age;
        set
        {
            if (value < 0 || value > 150)
                throw new ArgumentException("Age must be 0–150");
            age = value;
        }
    }

    // Read-only property (set only in constructor)
    public string StudentId { get; }

    // Com
...

4. Static vs Instance Members

Instance members belong to each object (every car has its own brand). Static members belong to the class itself and are shared across all objects (like counting how many cars exist). You access static members on the class name: Counter.GetTotalCount().

Static vs Instance

Compare static (shared) and instance (per-object) members.

Try it Yourself »

using System;

class Counter
{
    // Static field — shared by ALL instances
    private static int totalCount = 0;

    // Instance field — unique per object
    public string Label { get; }

    public Counter(string label)
    {
        Label = label;
        totalCount++;  // Incremented every time an object is created
    }

    // Static method — called on the CLASS, not on objects
    public static int GetTotalCount() => totalCount;

    // Instance method
    public void Display()
    {

...

Pro Tips

💡 Default to private fields, public properties: This is the standard C# convention. Never expose fields as public unless there's a strong reason.
💡 Use auto-properties for simple data: public string Name { get; set; } is cleaner than writing a full backing field when no validation is needed.
💡 Prefer init-only setters for immutable data: In C# 9+, public string Id { get; init; } allows setting only during construction.
💡 Use records for data-carrier classes: record Person(string Name, int Age); auto-generates equality, ToString, and deconstruction.

Common Mistakes

Making everything public — This defeats encapsulation. If external code can modify balance directly, your validation logic is useless.
Confusing class and object — Car is the class (blueprint). new Car("Toyota", "Camry", 2023) creates an object (instance). You can't call Car.StartEngine() unless it's static.
Forgetting constructors — Without a constructor, fields get default values (0, null, false). Objects end up in invalid states. Always initialise with constructors.
Using static when you mean instance — Static members are shared. If each player has their own score, score should be an instance field, not static.
Not using properties — Exposing raw public fields (public string name;) instead of properties means you can't add validation later without breaking all calling code.
Property naming conventions — Properties use PascalCase (FirstName), private fields use camelCase or underscore (_firstName or firstName).

🎉 Lesson Complete

✅ A class is a blueprint; an object is an instance created with new
✅ Constructors initialise objects with meaningful data when they're created
✅ Encapsulation = private fields + public methods/properties for controlled access
✅ Properties (get/set) are the C# way to expose data — use auto-properties for simple cases
✅ Static members belong to the class; instance members belong to each object
✅ Access modifiers: public, private, protected, internal
✅ Next lesson: Inheritance & Polymorphism — extending classes and overriding behaviour

Object-Oriented Programming

What You'll Learn

💡 Real-World Analogy

Understanding OOP in C#

📊 Access Modifiers Quick Reference

1. Classes and Objects

Classes & Objects

2. Encapsulation — Protecting Data

Encapsulation

3. Properties — The C# Way

Properties (get/set)

4. Static vs Instance Members

Static vs Instance

Pro Tips

Common Mistakes

🎉 Lesson Complete

Cookie & Privacy Settings