hoorcollege1a_object_orientatie - Tagged.pdf

# Inleiding tot objectgeoriënteerd programmeren Dit onderwerp introduceert de fundamentele principes van objectgeoriënteerd programmeren (OOP), waarbij de nadruk ligt op het gebruik van objecten en klassen als de primaire bouwstenen voor softwareontwikkeling, in tegenstelling tot functionele programmeerparadigma's. ### 1.1 Basisconcepten van objectgeoriënteerd programmeren Objectgeoriënteerd programmeren (OOP) beschouwt software niet als een verzameling functies, maar als een interactie tussen objecten. Deze objecten zijn geïnspireerd op entiteiten uit de "echte" wereld en combineren zowel gegevens als bijbehorende acties. Het algemene type of blauwdruk voor een object wordt een klasse genoemd. In OOP wordt de software ontworpen door klassen te definiëren, waarna objecten van deze klassen efficiënt kunnen worden gecreëerd [2](#page=2). ### 1.2 Vergelijking met functioneel programmeren Functionele programmeertalen, zoals Python of BES in hun basisvorm, presenteren software primair als een verzameling functies die objecten gebruiken voor specifieke taken, zoals reeksen, lijsten of plots. Hoewel deze aanpak nuttig kan zijn om problemen op te delen en functies herbruikbaar te maken, leidt het bij grotere projecten vaak tot een overweldigend aantal functies, wat het overzicht bemoeilijkt en niet altijd overeenkomt met de manier waarop de werkelijkheid wordt ervaren [7](#page=7). ### 1.3 De wereld als een hiërarchie van objecten De "echte" wereld bestaat uit objecten die natuurlijkerwijs in hiërarchieën kunnen worden ingedeeld, wat een hoger niveau van abstractie biedt dan een indeling puur op basis van functies. Denk bijvoorbeeld aan een auto: deze is niet slechts een verzameling functies zoals 'rijden' of 'remmen', maar een complex systeem van objecten zoals een motor, airbags, een audiosysteem en een carrosserie. Een ander voorbeeld is de administratie van een universiteit, die kan worden ingedeeld in objecten zoals professoren, studenten, vakken en lokalen, in plaats van een losse verzameling functies voor inschrijven, punten invoeren, enzovoort. Het hoofddoel van OOP is om de wereld te classificeren in zulke objecten [8](#page=8). ### 1.4 Voordelen van objectgeoriënteerde softwareontwikkeling Objectgeoriënteerde softwareontwikkeling resulteert in software die een hiërarchie van objecten vertegenwoordigt. Dit leidt tot duurzamere software, omdat objecten veel minder snel veranderen dan losse functies. Functies gerelateerd aan universitaire administratie, zoals delibereren of inschrijven voor vakken, zijn door de eeuwen heen sterk veranderd. Daarentegen is de fundamentele indeling in professoren, vakken en studenten grotendeels constant gebleven. Nieuwe software wordt dan een combinatie van bestaande en nieuw of aangepaste objecten, vergelijkbaar met de ontwikkeling van een nieuw automodel [9](#page=9). #### 1.4.1 Duurzaamheid en aanpasbaarheid Een belangrijk voordeel van OOP is de duurzaamheid van de software. Objecten veranderen veel minder snel dan functies. Bij aanpassingen aan de software, zoals het toevoegen van extra functionaliteit of het aanpassen van bestaande, hoeft vaak slechts de betreffende klasse te worden aangepast, in plaats van het gehele programma. Het uitbreiden van een programma komt neer op het toevoegen van nieuwe klassen [13](#page=13) [9](#page=9). #### 1.4.2 Beheersing van complexiteit en samenwerking OOP helpt bij het beheersen van complexiteit. Het opdelen van software in klassen maakt het mogelijk om werk te verdelen over verschillende teams. Communicatie met belanghebbenden wordt effectiever omdat de discussie kan plaatsvinden op het niveau van herkenbare en begrijpelijke objecten, zonder te verzanden in implementatiedetails [13](#page=13). ### 1.5 Van objecten naar klassen Sommige objectgeoriënteerde talen werken rechtstreeks met objecten, wat intuïtief kan aanvoelen omdat het de directe manipulatie van entiteiten mogelijk maakt, vergelijkbaar met het creëren van voorwerpen uit klei, met ad-hoc relaties tussen objecten. De meeste objectgeoriënteerde talen maken echter gebruik van klassen. Dit voegt een extra abstractielaag toe, maar maakt het creëren van grote aantallen objecten veel gemakkelijker, vergelijkbaar met de auto-industrie. Het creëren van een klasse kan complex zijn, maar het maken van objecten van die klasse is daarentegen zeer eenvoudig [11](#page=11). ### 1.6 Objectoriëntatie als verbetering van softwareontwikkeling Objectoriëntatie wordt gezien als een methode voor betere softwareontwikkeling. Het stelt ontwikkelaars in staat om de complexiteit van software te beheersen door deze op te delen in klassen, wat efficiënte taakverdeling tussen teams bevordert. De communicatie met management en stakeholders wordt effectiever doordat de discussie kan plaatsvinden aan de hand van herkenbare concepten. OOP leidt tot duurzamere software, omdat aanpassingen aan de software vaak beperkt blijven tot specifieke klassen. Bovendien maakt OOP geavanceerde concepten mogelijk die bijdragen aan de ontwikkeling van complexere en flexibelere systemen [13](#page=13). > **Tip:** Denk bij het modelleren van een probleem in termen van objecten na over de "dingen" die een rol spelen en wat die "dingen" kunnen doen. Vraag jezelf af: welke eigenschappen (gegevens) hebben deze dingen, en welke acties (methoden) kunnen ze uitvoeren [2](#page=2)? > > **Tip:** Het concept van klassen als blauwdrukken is cruciaal voor het efficiënt creëren van meerdere, vergelijkbare objecten. Dit bespaart veel tijd en voorkomt redundantie in de code [11](#page=11). > > **Voorbeeld:** Een 'Student'-klasse kan eigenschappen hebben zoals `naam`, `studentnummer` en `opleiding`, en methoden zoals `schrijfInVoorVak(vak)` of `toonCijfers()`. Van deze klasse kunnen vervolgens talloze individuele studentobjecten worden gemaakt, elk met hun eigen specifieke gegevens [9](#page=9). --- # Sterke typering en datatypen in Java Dit gedeelte introduceert het concept van sterke typering in Java, waarbij elke variabele een specifiek datatype heeft, wat de programmeerveiligheid verhoogt, en geeft een overzicht van veelvoorkomende datatypen. ### 2.1 Sterke typering in Java Sterke typering houdt in dat elke variabele in een programma verplicht een specifiek type moet hebben. Bij de eerste aanroep van een variabele moet het type worden gespecificeerd. Vanaf dat moment kan die variabele alleen gegevens van dat specifieke type bevatten. Dit mechanisme biedt aanzienlijke voordelen op het gebied van veiligheid, omdat de compiler in staat is om potentiële fouten al in een vroeg stadium van de ontwikkeling te identificeren [4](#page=4). In tegenstelling tot impliciete of dynamische typering, die soms onvoorspelbaar kan zijn, biedt sterke typering, zoals in Java, een voorspelbaar gedrag. Dit betekent dat de code altijd op een consistente manier reageert, wat de betrouwbaarheid van het programma ten goede komt [5](#page=5). > **Tip:** Sterke typering verkleint de kans op runtime-fouten die veroorzaakt worden door incompatibele gegevenstypen, doordat typecontroles al tijdens het compileren plaatsvinden. ### 2.2 Veelvoorkomende datatypen in Java Java biedt een reeks ingebouwde datatypen die kunnen worden gebruikt om verschillende soorten informatie op te slaan: * **Gehele getallen (`int`):** Dit datatype wordt gebruikt voor het opslaan van gehele getallen, zonder decimalen [6](#page=6). * **Reële getallen (`double`):** Dit datatype is bedoeld voor het opslaan van getallen met een decimale component [6](#page=6). * **Boolse waarden (`boolean`):** Dit type kan slechts twee waarden aannemen: `true` of `false` [6](#page=6). * **Teksten (`String`):** Wordt gebruikt om reeksen tekens, oftewel tekst, op te slaan [6](#page=6). * **Exclusieve opsomming (`enum`):** Maakt het mogelijk een vaste set aan vooraf gedefinieerde constanten te creëren [6](#page=6). * **Objecten:** Een programmeur kan zelf een nieuw datatype definiëren door een eigen klasse te creëren [6](#page=6). * **Lijsten:** Java biedt ook de mogelijkheid om lijsten van bovenstaande datatypen te maken, wat flexibiliteit biedt voor het opslaan van verzamelingen van gegevens [6](#page=6). > **Example:** Een variabele gedeclareerd als `int leeftijd;` kan alleen gehele getallen opslaan, zoals `leeftijd = 25;`. Als men probeert een tekst toe te kennen, bijvoorbeeld `leeftijd = "twintig";`, zal de compiler een fout geven. --- # Kernconcepten van objectoriëntatie: abstractie, encapsulatie en de relatie tussen klasse en object Dit onderwerp introduceert de fundamentele principes van objectoriëntatie, waarbij de nadruk ligt op abstractie, encapsulatie en de essentiële relatie tussen klassen en objecten. ### 3.1 De relatie tussen klasse en object Een **klasse** fungeert als een algemene blauwdruk of beschrijving. Het definieert de structuur en het gedrag dat objecten van deze klasse zullen hebben. De inhoud van een klasse bestaat uit data members, ook wel eigenschappen of attributen genoemd, en methodes, die de acties beschrijven die objecten kunnen uitvoeren [12](#page=12). Elk **object** is daarentegen een concrete instantie van een specifieke klasse. Objecten delen dezelfde data members en methodes als gedefinieerd in hun klasse, maar ze kunnen verschillende waarden hebben voor hun data members. Dit onderscheid in inhoud zorgt voor individualiteit tussen objecten, zelfs als ze tot dezelfde klasse behoren [12](#page=12). > **Voorbeeld:** Stel een klasse `Auto` voor. Deze klasse kan data members hebben zoals `kleur` en `gewicht`, en methodes zoals `starten()` en `rijden()`. Twee objecten van de klasse `Auto`, genaamd `rodeAuto` en `zwarteAuto`, zouden bijvoorbeeld verschillende waarden kunnen hebben voor de `kleur` data member (respectievelijk "rood" en "zwart"), terwijl ze beide de `starten()` methode kunnen uitvoeren. Een ander voorbeeld is een `Teller` klasse, waarbij objecten verschillende tellerstanden kunnen hebben, zoals 4/5 of 7/12 [12](#page=12). ### 3.2 Abstractie Abstractie is het proces van het vereenvoudigen van complexiteit door alleen de essentiële kenmerken van een entiteit weer te geven en de irrelevante details weg te laten. Binnen objectoriëntatie betekent abstractie het indelen van concepten in klassen met hun bijbehorende methodes [15](#page=15). De kern van abstractie ligt in het verbergen van implementatiedetails. Hierbij focust men op: * De naam van de klasse en een korte beschrijving [15](#page=15). * De namen en effecten van methodes, oftewel wat men met de klasse kan doen [15](#page=15). Dit leidt tot een beter zichtbare hoog-niveau-structuur van het programma [15](#page=15). > **Tip:** Abstractie helpt bij het beheersen van de complexiteit van software door gebruikers alleen bloot te stellen aan wat ze nodig hebben, zonder de details van hoe het intern werkt. ### 3.3 Encapsulatie Encapsulatie is het principe waarbij de data members (eigenschappen) en de methodes (acties) die op die data werken, worden gebundeld binnen één eenheid: de klasse. Het primaire doel van encapsulatie is het verbergen van implementatiedetails en het beschermen van de interne toestand van objecten [19](#page=19). Dit houdt in dat informatie die alleen intern relevant is, zoals de concrete variabelen binnen een klasse, wordt verborgen. Ook de concrete code van methodes, en zelfs eventuele hulpmethodes die intern gebruikt worden, worden verhuld. Dit zorgt ervoor dat de interne werking van een object niet zomaar gewijzigd kan worden door externe partijen, wat de stabiliteit en voorspelbaarheid van het systeem bevordert [19](#page=19). #### 3.3.1 De "zwarte doos" analogie Conceptueel kan een object worden beschouwd als een **zwarte doos**. Dit betekent dat men niet noodzakelijk weet wat er binnenin de doos gebeurt of hoe de interne processen verlopen. Wel weet men dat er knopjes aan de buitenkant zijn om mee te interageren en uitgangen om waarden uit te lezen [17](#page=17). Deze analogie illustreert het verschil tussen hoe je programmeert en hoe je iets gebruikt. De **gebruiker** van een klasse ziet en gebruikt alleen de buitenkant – de "zwarte doos met knoppen". De **programmeur of ontwerper** daarentegen, ontwerpt de buitenkant, implementeert de binnenkant (inclusief de gegevens en methodes), en bepaalt hoe de interactie met het object verloopt. Encapsulatie zorgt ervoor dat deze interne implementatie kan veranderen zonder dat dit invloed heeft op hoe de gebruiker het object aanroept, zolang de buitenkant (interface) hetzelfde blijft [18](#page=18). --- # Praktische aspecten van softwareontwerp en data members/methoden Dit gedeelte behandelt de praktische implementatie van objectgeoriënteerd ontwerp door middel van data members en methoden, geïllustreerd met een voorbeeld van een AutoRadio. ### 4.1 Data members Data members, ook wel eigenschappen genoemd, representeren de permanente gegevens die bij elk object van een klasse worden bijgehouden. Ze zijn bedoeld voor informatie die essentieel is voor het object en niet slechts tijdelijk nodig is tijdens een berekening (zoals tellers) [23](#page=23). Kenmerken van data members: * **Zinvolle naamgeving:** Data members moeten een duidelijke en beschrijvende naam hebben, bij voorkeur in camelCase [23](#page=23). * **Type:** Elk data member moet een specifiek datatype hebben, zoals `int`, `double`, `boolean`, `String`, een opsomming, een object, of een lijst van objecten [23](#page=23). ### 4.2 Methoden Methoden, ook wel gedrag genoemd, definiëren de acties die een object kan uitvoeren of de informatie die het kan verschaffen. Er is een sterke samenhang tussen data members en methoden. Methoden kunnen worden onderverdeeld in getters en setters [23](#page=23): * **Getters (Informatie opvragen):** * Deze methoden worden gebruikt om de waarde van data members op te vragen [23](#page=23). * Ze nemen meestal geen parameters [23](#page=23). * Ze retourneren altijd een waarde die de status of informatie van het object weerspiegelt [23](#page=23). * **Setters (Informatie veranderen):** * Deze methoden worden gebruikt om de waarden van data members te wijzigen [23](#page=23). * Ze nemen meestal parameters die de nieuwe waarden bevatten [23](#page=23). * Soms retourneren ze een waarde, bijvoorbeeld om de succesvolle wijziging aan te geven, maar dit is niet altijd het geval [23](#page=23). > **Tip:** De concepten van data members en methoden zijn fundamenteel voor het creëren van goed gestructureerde en onderhoudbare objectgeoriënteerde code. ### 4.3 Voorbeeld: Eenvoudige AutoRadio Een vereenvoudigd voorbeeld van een `AutoRadio` klasse kan de toepassing van data members en methoden illustreren. Hoewel de specifieke implementatie van de `AutoRadio` niet gedetailleerd wordt beschreven op de opgegeven pagina's, wordt het wel genoemd als een concreet voorbeeld om de concepten te demonstreren [24](#page=24). Reflectie op een mogelijke (eerdere) oplossing van de `AutoRadio` suggereert dat het bijhouden van informatie zoals frequentie en band (AM/FM) voor meerdere zenders onoverzichtelijk kan worden. Dit probleem wordt in latere delen van het materiaal opgelost met compositie [27](#page=27). --- ## Veelgemaakte fouten om te vermijden - Bestudeer alle onderwerpen grondig voor examens - Let op formules en belangrijke definities - Oefen met de voorbeelden in elke sectie - Memoriseer niet zonder de onderliggende concepten te begrijpen

| Term | Definition | |------|------------| | Object | Een entiteit die gegevens (data members of attributen) en acties (methodes) combineert. Objecten zijn concrete instanties van klassen. | | Klasse | Een blauwdruk of sjabloon dat de structuur en het gedrag definieert voor objecten. Het beschrijft de data members en methodes die objecten van die klasse zullen hebben. | | Variabele | Een benoemde opslaglocatie in het geheugen die een waarde kan bevatten. In sterk getypeerde talen heeft elke variabele een vooraf gedefinieerd datatype. | | Sterke typering | Een programmeerconcept waarbij elke variabele een verplicht type heeft. Dit type wordt bij de eerste gebruik van de variabele gespecificeerd en beperkt de soorten gegevens die erin kunnen worden opgeslagen. | | Methode | Een functie die geassocieerd is met een klasse of object. Methoden definiëren de acties die een object kan uitvoeren. | | Data member (Attribuut) | Een variabele die deel uitmaakt van een klasse en de eigenschappen of staat van een object representeert. | | AbstraHerie | Het proces van het vereenvoudigen van complexiteit door implementatiedetails te verbergen en te focussen op de essentiële kenmerken en functionaliteiten. | | Encapsulatie | Het bundelen van data members en methodes die op die data werken binnen één eenheid (de klasse). Dit principe helpt bij het verbergen van interne implementatiedetails en het beschermen van de interne staat van objecten. | | Instantiëren | Het proces van het creëren van een concreet object uit een klasse. Dit object is een "instantie" van die klasse. | | Impliciete typering | Een programmeerparadigma waarbij de compiler of interpreter het type van een variabele automatisch afleidt op basis van de toegewezen waarde, in plaats van dat het expliciet wordt gedeclareerd. | | Overerving | Een mechanisme in objectgeoriënteerd programmeren waarbij een nieuwe klasse (subklasse of afgeleide klasse) eigenschappen en gedrag van een bestaande klasse (superklasse of basisklasse) kan erven. | | PolymorDe | Het vermogen van objecten van verschillende klassen om te reageren op dezelfde methodeaanroep op een manier die specifiek is voor hun eigen type. |