Klassen en objecten: de basis van OOP

Wat is een klasse?

Tot nu toe schreven we code in een rechte lijn: variabelen en methoden los van elkaar. Object-georiënteerd programmeren (OOP) is een manier om code te organiseren rond objecten — dingen met eigenschappen en gedrag.

Een klasse is het sjabloon (de mal) voor een object. Een object is een concreet exemplaar van die klasse.

Vergelijk het met AutoCAD: een blok is de klasse (het sjabloon), en elke keer dat je het blok plaatst, maak je een blokreferentie aan — dat is een object.

Een klasse definiëren

class Laag
{
    // Eigenschappen (properties)
    public string Naam;
    public string Kleur;
    public bool IsZichtbaar;

    // Methode
    public void ToonInfo()
    {
        Console.WriteLine($"Laag: {Naam} | Kleur: {Kleur} | Zichtbaar: {IsZichtbaar}");
    }
}

Een object aanmaken (instantiëren)

Laag muurLaag = new Laag();
muurLaag.Naam = "Muren";
muurLaag.Kleur = "Wit";
muurLaag.IsZichtbaar = true;

muurLaag.ToonInfo();
// Laag: Muren | Kleur: Wit | Zichtbaar: True

Meerdere objecten van dezelfde klasse

Laag deurLaag = new Laag();
deurLaag.Naam = "Deuren";
deurLaag.Kleur = "Rood";
deurLaag.IsZichtbaar = false;

Laag[] lagen = { muurLaag, deurLaag };
foreach (Laag laag in lagen)
{
    laag.ToonInfo();
}

Klassen zijn ook typen

Net zoals int of string een type is, is jouw eigen klasse ook een type. Je kunt een Laag-parameter in een methode zetten:

void PrintLaag(Laag laag)
{
    Console.WriteLine($"Verwerken: {laag.Naam}");
}

PrintLaag(muurLaag);

De drie pijlers van OOP

• Encapsulatie — verberg interne details, toon alleen wat nodig is
• Overerving — een klasse kan eigenschappen en methoden erven van een andere
• Polymorfisme — objecten van verschillende klassen kunnen op dezelfde manier aangesproken worden

We behandelen elk van deze in de komende posts. In de volgende post duiken we dieper in: constructors en properties.

What is a class?

Until now we wrote code in a straight line: variables and methods separate from each other. Object-oriented programming (OOP) is a way to organise code around objects — things with properties and behaviour.

A class is the template (the mould) for an object. An object is a concrete instance of that class.

Compare it to AutoCAD: a block is the class (the template), and every time you insert the block you create a block reference — that is an object.

Defining a class

class Layer
{
    public string Name;
    public string Color;
    public bool IsVisible;

    public void ShowInfo()
    {
        Console.WriteLine($"Layer: {Name} | Color: {Color} | Visible: {IsVisible}");
    }
}

Creating an object (instantiating)

Layer wallLayer = new Layer();
wallLayer.Name = "Walls";
wallLayer.Color = "White";
wallLayer.IsVisible = true;

wallLayer.ShowInfo();
// Layer: Walls | Color: White | Visible: True

Multiple objects from the same class

Layer doorLayer = new Layer();
doorLayer.Name = "Doors";
doorLayer.Color = "Red";
doorLayer.IsVisible = false;

Layer[] layers = { wallLayer, doorLayer };
foreach (Layer layer in layers)
    layer.ShowInfo();

Classes are also types

void PrintLayer(Layer layer)
{
    Console.WriteLine($"Processing: {layer.Name}");
}

PrintLayer(wallLayer);

The three pillars of OOP

• Encapsulation — hide internal details, expose only what is needed
• Inheritance — a class can inherit properties and methods from another
• Polymorphism — objects of different classes can be used in the same way

We cover each of these in the coming posts. In the next post we dive deeper: constructors and properties.