# Methoden en access modifiers

## Een eenvoudige klasse

We zullen nu enkele basisconcepten van klassen en objecten toelichten aan de hand van praktische voorbeelden.

### Object methoden

Stel dat we een klasse willen maken die ons toelaat om objecten te maken die verschillende mensen voorstellen. We willen aan iedere mens kunnen vragen waar deze woont en die zal dat dan op het scherm tonen.

We maken een nieuwe klasse `Mens` en maken een methode `Praat` die iets op het scherm zet:

```csharp
class Mens
{
    public void Praat()
    {
        Console.WriteLine("Ik ben een mens!");
    }
}
```

We zien twee nieuwe aspecten:

* Het keyword **`static`** komt bij een klasse niet aan te pas (of toch minder zoals we [later zullen zien](/cursus-pro-oo/experimentalmerge5/semester-2-oop/h10-geavanceerde-klassen-en-objecten/5_static.md))
* Voor de methode plaatsen we `public` : dit leggen we zo meteen uit

Je kan nu elders objecten aanmaken en ieder object z'n methode `Praat` aanroepen:

```csharp
Mens joske = new Mens();
Mens alfons = new Mens();

joske.Praat();
alfons.Praat();
```

Er zal 2x `Ik ben een mens!` op het scherm verschijnen. Waarbij telkens ieder object (`joske` en `alfons`) zelf verantwoordelijk ervoor waren dat dit gebeurde.

### Public en private access modifiers

De **access modifier** geeft aan hoe zichtbaar een bepaald deel van de klasse is. Wanneer je niet wilt dat "van buitenuit" (bv objecten van je klasse in de Main) een bepaalde methode kan aangeroepen worden, dan dien je deze als `private` in te stellen. Wil je dit net wel dat moet je er expliciet `public` voor zetten.

Test in de voorgaande klasse eens wat gebeurt wanneer je `public` verwijderd voor de methode. Inderdaad, je zal de methode `Praat` niet meer op de objecten kunnen aanroepen.

De reden: **wanneer je voor een methode (of klasse) niet expliciet `public` zet, dan kan deze methode niet van uit alle andere klassen worden aangeroepen.**

Test volgende klasse eens, kan je de methode `VertelGeheim` vanuit de Main op `joske` aanroepen?

```csharp
class Mens
{
    public void Praat()
    {
        Console.WriteLine("Ik ben een mens!");
    }

    void VertelGeheim()
    {
        Console.WriteLine("Mijn geheim is dat ik leef!");
    }
}
```

Als je duidelijk wil maken dat bepaalde code niet van buitenaf aangeroepen kan worden, schrijf dan `private` in plaats van `public`. Als je geen van beide schrijft, zit je code ergens tussenin `public` en `private` (zie later). Als beginnende programmeur maak je er best een gewoonte van duidelijk te kiezen voor `public` of `private`.

#### Reden van private

Waarom zou je bepaalde zaken `private` maken?

Stel dat we in de klasse extra (hulp)methoden willen gebruiken die enkel intern nodig zijn, dan doen we dit. Volgende voorbeeld toont hoe we in de methode `Praat` de private methode `VertelGeheim` gebruiken:

```csharp
class Mens
{
    public void Praat()
    {
        Console.WriteLine("Ik ben een mens!");
        VertelGeheim();
    }

    void VertelGeheim()
    {
        Console.WriteLine("Mijn geheim is dat ik leef!");
    }
}
```

Als we nu elders een object laten praten als volgt:

```csharp
Mens rachid = new Mens();
rachid.Praat();
```

Dan zal de uitvoer worden:

```
Ik ben een mens!
Mijn geheim is dat ik leef!
```

## Instantievariabelen

We maken onze klasse wat groter, we willen dat een object een leeftijd heeft die we kunnen verhogen via een methode `VerjaardagVieren` (we hebben de methode `VertelGeheim` even weggelaten):

```csharp
class Mens
{
    private int leeftijd = 1;

    public void VerjaardagVieren()
    {
        Console.WriteLine("Hiphip hoera voor mezelf!");
        leeftijd++;
        Praat();
    }

    public void Praat()
    {
        Console.WriteLine("Ik ben een mens! ");
        Console.WriteLine($"Ik ben {leeftijd} jaar oud");
    }

}
```

Hier zien we een pak details die onze aandacht vereisen:

* Ook variabelen zoals `int leeftijd` mogen een access modifier krijgen in een klasse. Ook hier, als je niet expliciet `public` zet wordt deze als `private` beschouwd.
* Ook al is `leeftijd` `private` alle methoden in de klasse kunnen hier aan. Het is enkel langs buiten dat bijvoorbeeld volgende code niet zal werken `rachid.leeftijd = 34;`.
* We kunnen iedere variabele een beginwaarde geven.
* **Ieder object zal z'n eigen leeftijd hebben.**

Die laatste opmerking is een kernconcept van OOP: ieder object heeft z'n eigen interne staat die kan aangepast worden individueel van de andere objecten van hetzelfde type.

We zullen dit testen in volgende voorbeeld waarin we 2 objecten maken en enkel 1 ervan laten verjaren. Kijk wat er gebeurt:

```csharp
Mens Elvis = new Mens();
Mens Bono = new Mens();

Elvis.VerjaardagVieren();
Elvis.VerjaardagVieren();
Evlis.VerjaardagVieren();
Bono.VerjaardagVieren();
```

Als je deze code zou uitvoeren zal je zien dat de leeftijd van Elvis verhoogt en niet die van Bono wanneer we `VerjaardagVieren` aanroepen. Zoals het hoort!

### Initiële waarde van een instantievariabele

Bekijk opnieuw het voorbeeld:

```csharp
class Mens
{
    private int leeftijd = 1;

    public void VerjaardagVieren()
    {
        Console.WriteLine("Hiphip hoera voor mezelf!");
        leeftijd++;
        Praat();
    }

    public void Praat()
    {
        Console.WriteLine("Ik ben een mens! ");
        Console.WriteLine($"Ik ben {leeftijd} jaar oud");
    }

}
```

De eerste regel binnenin de klasse betekent dat een `Mens` wordt aangemaakt met een leeftijd van 1 jaar. WE noemen dit de initiële waarde van de instantievariabele `leeftijd`. Het is niet verplicht deze te voorzien. Als je niet aangeeft welke waarde een variabele krijgt (hier of in, zoals we iets verder zullen zien, de constructor), dan zal de instantievariabele een defaultwaarde krijgen die afhangt van zijn type.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://apwt.gitbook.io/cursus-pro-oo/experimentalmerge5/semester-2-oop/h8-klassen-en-objecten/0c_simpleobjects.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.