By the end of this session, you will be able to:

• Define classes with constructors, fields, and properties
• Apply access modifiers to enforce encapsulation
• Use static members for shared class-level state and behaviour
• Build class hierarchies using inheritance
• Override methods in derived classes correctly

public class Person
{
    public string Name;
    public int Age;
    public string Email;

    // Delegates to the three-parameter constructor
    public Person(string name, int age) : this(name, age, "")
    {
    }

    public Person(string name, int age, string email)
    {
        Name  = name;
        Age   = age;
        Email = email;
    }
}

this(...) calls another constructor in the same class — avoids duplicating initialisation logic across overloads.

public class Product
{
    private decimal _price;

    public decimal Price
    {
        get => _price;
        set
        {
            if (value < 0)
                throw new ArgumentException(
                    "Price cannot be negative.");
            _price = value;
        }
    }
}

Use a backing field when you need validation, computed transformations, or side effects inside get or set.

public class User
{
    private static int _totalCreated = 0;   // one copy — shared by all instances

    public string Name { get; set; }

    public User(string name)
    {
        Name = name;
        _totalCreated++;                     // every constructor call increments it
    }

    public static int TotalCreated => _totalCreated;
}

var u1 = new User("Alice");
var u2 = new User("Bob");

Console.WriteLine(User.TotalCreated);  // 2

Static fields are shared — every instance reads and writes the same memory location.

• Methods are non-virtual by default — a derived class cannot replace them
• virtual on a base-class method signals "derived classes may supply their own implementation"
• override in the derived class supplies that implementation — the compiler requires the keyword explicitly, preventing accidental hiding
• At runtime the most-derived override is always called, even when the variable type is the base class
• This is runtime polymorphism — the same call produces different behaviour depending on the actual object type

public class Shape
{
    public virtual double Area() => 0;
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public Circle(double r) => Radius = r;
    public override double Area()
        => Math.PI * Radius * Radius;
}

public class Rectangle : Shape
{
    public double Width  { get; set; }
    public double Height { get; set; }
    public Rectangle(double w, double h)
    { Width = w; Height = h; }
    public override double Area() => Width * Height;
}

Shape[] shapes =
{
    new Circle(5),
    new Rectangle(4, 6)
};

foreach (Shape s in shapes)
{
    Console.WriteLine($"Area: {s.Area():F2}");
}

// Output:
// Area: 78.54   (Circle)
// Area: 24.00   (Rectangle)

The variable type is Shape, but the object's actual type decides which Area() runs.

1. Create a base class WorkItem with properties Id (int), Title (string), CreatedAt (DateTime), and a virtual string Summarize() method
2. Derive TaskItem : WorkItem — add IsCompleted (bool) and DueDate (DateTime?). Override Summarize() to include the completion status
3. Derive BugReport : WorkItem — add Severity (string). Override Summarize() to include the severity level
4. Instantiate both types, store them in a WorkItem[], and loop over the array printing each summary

• A class is a blueprint — each instance gets its own data; constructors guarantee a valid starting state
• Fields should be private; expose them through properties so callers are shielded from internal changes
• Auto-implemented properties are concise; use a full property with a backing field when you need validation or side effects
• Static members belong to the class — one shared copy, accessed through the class name, not an instance
• A derived class inherits all non-private members; base(args) delegates to the parent constructor
• Mark methods virtual to allow overriding — at runtime the most-derived override always wins (polymorphism)

Next session: Session 06 — OOP II: Polymorphism, Abstraction & Interfaces

• Abstract classes and abstract methods
• Interfaces and multiple-interface implementation
• Casting with is and as
• Polymorphism patterns used throughout the .NET standard library

Build a BankAccount class hierarchy that exercises encapsulation, properties, inheritance, and method overriding.

• Create BankAccount with a private decimal _balance field, a read-only Balance property, an Owner string, and Deposit / Withdraw methods that validate their arguments
• Add a virtual string GetAccountType() method that returns "Standard"
• Derive SavingsAccount : BankAccount — add InterestRate (decimal) and ApplyInterest(); override GetAccountType() to return "Savings"
• Store a BankAccount and a SavingsAccount in a BankAccount[] and print GetAccountType() and Balance for each
• Attempting to set Balance directly from outside the class should not compile — demonstrate this in a comment