Zie Scherp Scherper
OefeningenThe Corona filesHandboek backup
  • H0: Introductie
    • Introductie
    • Dit boek in papier?
    • Nuttige extras
  • H1: De eerste stappen
    • Introductie tot C#
    • Werken met Visual Studio
    • Je eerste programma
    • Input verwerken met ReadLine
    • Fouten in je code
    • Kleuren in Console
    • Meer weten
  • H2: De basisconcepten van C#
    • De essentie van C#
    • Datatypes
    • Variabelen
    • Expressies en operators
    • Const(ant)
    • Solutions en projecten
    • Meer weten
  • H3: Tekst gebruiken in code
    • Strings en chars
    • Escape characters
    • Strings samenvoegen
    • Unicode tonen
    • Environment bibliotheek
    • Meer weten
  • H4: Werken met data
    • Casting, conversie en parsing
    • Input verwerken en omzetten
    • Math-library en berekeningen
    • Over afronden
    • Random
    • Debuggen
    • Meer weten
  • H5: Beslissingen
    • Beslissingen intro
    • Booleanse logica en operators
    • If
    • Scope van variabelen
    • Switch
    • enum
    • Meer weten
  • H6: Herhalingen Herhalingen Herhalingen
    • Loops intro
    • While en Do While
    • For
    • Nesting
    • Meer weten
  • H7: Methoden
    • Methoden intro
    • Bibliotheken
    • Geavanceerde methodetechnieken
    • Meer weten
  • H8: Arrays
    • Array principes
    • Arrays en geheugen
    • System.Array
    • Algoritmes met arrays
    • Strings en arrays
    • Arrays en methoden
    • N-dimensionale arrays
    • Jagged arrays
    • Meer weten
  • H9: Object Oriented Programming
    • OOP Intro
    • Klassen en objecten in C#
    • Methoden en access modifiers
    • Full properties
    • Auto-properties
    • DateTime: leren werken met objecten
    • Meer weten
  • H10: Geheugenmanagement, uitzonderingen en namespaces
    • Stack en Heap
    • Objecten en methoden
    • Null en NullReferenceException
    • Namespaces en using
    • Exception handling
    • Waar exceptions plaatsen?
    • Meer weten
  • H11: Gevorderde klasseconcepten
    • Constructors en de default Constructors
    • Overloaded Constructors
    • Object Initializer Syntax
    • Static
    • Meer weten
  • H12: Arrays en klassen
    • Arrays van objecten
    • List
    • Foreach en var
    • Nuttige collection klassen
    • Meer weten
  • H13: Overerving
    • Overerving intro
    • Constructors bij overerving
    • Virtual en override
    • Base keyword
    • Meer weten
  • H14: Gevorderde overervingsconcepten
    • System.Object
    • Abstract
    • Eigen exceptions maken
    • Kennisclips
  • H15: Compositie en aggregatie
    • Compositie
    • this keyword
    • Meer weten
  • H16: Polymorfisme
    • Polymorfisme
    • Polymorfisme in de praktijk
    • Is en As keywords
    • Objecten vergelijken: alles komt samen
    • Meer weten
  • H17: Interfaces
    • Interface intro
    • Interfaces voorbeeld met president
    • Interfaces in de praktijk
    • Interfaces en polymorfisme
    • Meer weten
  • H18: Bestandsverwerking
    • Werken met bestanden
    • Schrijven en lezen
    • FileInfo klasse
    • Klassen serialiseren met json
    • Meer weten
  • Conclusie
    • Je hebt het gehaald
    • En nu?
  • Kennicslips
    • H1 - H8
    • H9 - H17
  • Appendix
    • Visual Studio snippets
    • VS Code for Mac installeren
    • Regions
    • String.Format
    • Out en Ref parameters
    • Operator overloading
    • Expression bodied members
    • Generics
    • struct en record
    • Een installer maken
  • Coding guidelines
    • Afspraken
    • Minpunten voor: Compileert niet
    • Minpunten voor: Klassen in 1 bestand
    • Minpunten voor: Redundante code
    • Minpunten voor: Bladspiegel
    • Minpunten voor: Naamgeving
    • Minpunten voor: goto, break en continue
    • Minpunten voor: Linq gebruiken
    • Minpunten voor: Methoden in methoden
    • Minpunten voor: Toplevel statements
Powered by GitBook
On this page
  • Constructors
  • Werking new operator
  • Soorten constructors
  • Default constructors

Was this helpful?

  1. H11: Gevorderde klasseconcepten

Constructors en de default Constructors

Nu we weten wat er allemaal achter de schermen gebeurt met onze objecten, wordt het tijd om wat meer geavanceerde concepten van klassen en objecten te bekijken.

We hebben al ontdekt dat een klasse kan bestaan uit:

  • Instantievariabelen: variabelen die de toestand van het individuele object bijhouden.

  • Methoden: om objecten voor ons te laten werken (gedrag).

  • Properties: om op een gecontroleerde manier toegang tot de interne staat van de objecten te verkrijgen.

Uiteraard is dit niet alles. In dit hoofdstuk bekijken we:

  • Constructors: een gecontroleerde manier om de beginstaat van een object in te stellen.

  • static: die je de mogelijkheid geeft een (deel van je) klasse te laten werken als een object.

  • Object initializer syntax: een recente C# aanvulling die het aanmaken van nieuwe objecten vereenvoudigd.

Constructors

Werking new operator

Objecten die je aanmaakt komen niet zomaar tot leven. Nieuwe objecten maken we aan met behulp van de new operator zoals we al gezien hebben:

Student frankVermeulen = new Student();

De new operator doet 3 dingen:

  • Het maakt een object aan in het heap geheugen.

  • Het roept de constructor van het object aan voor eventuele extra initialisatie.

  • Het geeft een referentie naar het object in het heap geheugen terug.

Via de constructor van een klasse kunnen we extra code meegeven die moet uitgevoerd worden telkens een nieuw object van dit type wordt aangemaakt.

De constructor is een unieke methode die wordt aangeroepen bij het aanmaken van een object. Daarom dat we dus ronde haakjes zetten bij new Student().

Momenteel hebben we in de klasse Student de constructor nog niet expliciet beschreven. Maar zoals je aan bovenstaande code ziet bestaat deze constructor al wel degelijk.Hij doet echter niets extra. Zo krijgen de instantievariabelen gewoon hun default waarde toegekend, afhankelijk van hun datatype.

De naam "constructor" zegt duidelijk waarvoor het concept dient: het construeren van objecten. Constructors mogen maar op 1 moment in het leven van een object aangeroepen worden: tijdens hun geboorte m.b.v. new. Je mag een constructor op geen enkel ander moment gebruiken!

Soorten constructors

Als programmeur van eigen klassen zijn er 3 opties voor je:

  • Je gebruikt geen zelfgeschreven constructors: het leven gaat voort zoals het is. Je kunt objecten aanmaken zoals eerder getoond. Een onzichtbare default constructor wordt voor je uitgevoerd.

  • Je hebt enkel een default constructor nodig: je kan nog steeds objecten met new Student() aanmaken. Maar je gaat zelf beschrijven wat er moet gebeuren in de default constructor. De default constructor herken je aan het feit dat je geen parameters meegeeft aan de constructor tijdens de new aanroep.

  • Je gebruikt één of meerdere overloaded constructors: hierbij zal je dan actuele parameters kunnen meegeven bij de creatie van een object. Denk maar aan new Student(24, "Jos").

Constructors zijn soms gratis, soms niet. Een lege default constructor voor je klasse krijg je standaard wanneer je een nieuwe klasse aanmaakt. Je ziet deze niet en kan deze niet aanpassen. Je kan echter daarom altijd objecten met new Student() aanmaken.Van zodra je echter beslist om zelf één of meerdere constructors te schrijven zal C# zeggen: "Ok, jij je zin, nu doe je alles zelf". De default constructor die je gratis kreeg zal ook niet meer bestaan. Heb je die nodig dan zal je die dus zelf moeten schrijven!

Een nadeel van C# is dat het soms dingen voor ons achter de schermen doet, en soms niet. Het is mijn taak je dan ook duidelijk te maken wanneer dat wél en wanneer dat net niét gebeurt. Ik vergelijk het altijd met het werken met aannemers: soms ruimen ze hun eigen rommel op nadien, maar soms ook niet. Alles hangt er van af hoe ik die aannemer heb opgetrommeld.

Default constructors

De default constructor is een constructor die geen extra parameters aanvaardt. Een default constructor bestaat ALTIJD uit volgende vorm:

  • Iedere constructor is altijd public .

  • Heeft geen returntype, ook niet void.

  • Heeft als naam de naam van de klasse zelf.

  • Heeft geen extra formele parameters.

Stel dat we een klasse Student hebben:

internal class Student
{
    public int UurVanInschrijven {private set; get;}
}

We willen telkens een Student-object wordt aangemaakt bijhouden op welk uur van de dag dit plaatsvond. Eerst schrijven de default constructor, deze ziet er als volgt uit:

internal class Student
{
    public Student()
    {
        // zet hier de code die bij initialisatie moet gebeuren
    }
    public int UurVanInschrijven {private set; get;}
}

Zoals verteld moet de constructor de naam van de klasse hebben, public zijn en geen returntype definiëren.

Vervolgens voegen we de code toe die we nodig hebben:

internal class Student
{
    public Student()
    {
        UurVanInschrijven = DateTime.Now.Hour;
    }

    public int UurVanInschrijven {private set; get;}
}

Telkens we nu een object zouden aanmaken met new Student() zal de waarde in UurVanInschrijven afhangen van het moment waarop we de code uitvoeren. Beeld je in dat we dit programma uitvoeren om half twaalf 's morgens:

Student eenStudent = new Student();

Dan zal de property UurVanInschrijven van eenStudent op 11 worden ingesteld.

Constructors zijn soms nogal zwaarwichtig indien je enkel een eenvoudige auto-property een startwaarde wenst te geven. Wanneer dat het geval is mag je dit ook als volgt doen:

internal class Student
{
    public int UurVanInschrijven {private set; get;} = 2;
}
PreviousMeer wetenNextOverloaded Constructors

Last updated 8 months ago

Was this helpful?