hoorcollege2_2dec.pdf

# Codeerconventies en verzamelingen Dit gedeelte behandelt de basisprincipes van goede codeerpraktijken in Java, zoals naamgevingsconventies en indentatie, en introduceert het concept van verzamelingen met de `ArrayList`. ### 1.1 Codeerconventies: internationale afspraken Goede codeerconventies zijn essentiële afspraken die ervoor zorgen dat code leesbaar, onderhoudbaar en consistent is [3](#page=3). #### 1.1.1 Naamgeving De naamgeving van klassen, variabelen en methodes volgt specifieke patronen om de functionaliteit duidelijk te maken [3](#page=3). * **Algemeen:** Gebruik altijd CamelCase, waarbij woorden aan elkaar worden geschreven en elk nieuw woord begint met een hoofdletter [3](#page=3). * **Klassen en interfaces:** Gebruik *UpperCamelCase*, waarbij het eerste woord ook met een hoofdletter begint [3](#page=3). * **Variabelen en methodes:** Gebruik *lowerCamelCase*, waarbij het eerste woord met een kleine letter begint [3](#page=3). * **Seters:** Methoden die de waarde van een variabele instellen, beginnen met `set` gevolgd door de naam van de variabele (e.g., `setNaam()` ) [3](#page=3). * **Getters:** Methoden die de waarde van een variabele ophalen, beginnen met `get` gevolgd door de naam van de variabele (e.g., `getNaam()` ) [3](#page=3). * **Booleans:** Methoden die een booleaanse waarde teruggeven, kunnen beginnen met `is`, `can`, of `has` (e.g., `isActive()`, `canEdit()`, `hasPermission()` ) [3](#page=3). * **Tellers in for-lussen:** Gebruik gangbare korte namen zoals `i`, `j`, `k` voor tellers in for-lussen [3](#page=3). #### 1.1.2 Indentatie Indentatie, het inspringen van code, is cruciaal voor de leesbaarheid en structuur van de code [3](#page=3). * **Inspringen:** Na elke openende accolades `{` moet de code met 2 tot 4 spaties worden ingesprongen [3](#page=3). * **Openen van accolades:** Accolades mogen aan het einde van de regel worden geopend of op een nieuwe regel [5](#page=5). * **Sluiten van accolades:** Een sluitende accolade `}` wordt uitgelijnd met de eerste letter van het sleutelwoord dat de openende accolade heeft veroorzaakt (bijvoorbeeld de `i` van `if`, de `f` van `for`, of de `p` van `public`) [6](#page=6). > **Tip:** Een extensie (zoals die genoemd wordt in het document) kan helpen bij het controleren van indentatie en naamgevingsconventies. Het controleert op correct gebruik van CamelCase, de beginletters van klassen, interfaces, variabelen en methodes, en de conventies voor getters en seters [7](#page=7). ### 1.2 Verzamelingen met de ArrayList Wanneer een klasse meerdere objecten van hetzelfde type bevat, is een verzameling nodig. De `ArrayList` is een veelgebruikte implementatie hiervan in Java [10](#page=10) [11](#page=11). #### 1.2.1 Het concept van verzamelingen * **Situaties met één object:** Soms is er slechts één instantie van een bepaald kenmerk, zoals iemands haarkleur of natuurlijke moeder [10](#page=10). * **Situaties met veel objecten:** Vaak heeft een object meerdere instanties van een ander type. Voorbeelden zijn een radio met voorkeurzenders, een klas met studenten, een studentenvereniging met leden, een gemeente met inwoners, een inbox met SMS'jes, of een muziekplayer met nummers. In dergelijke gevallen is een verzameling noodzakelijk [10](#page=10). #### 1.2.2 De ArrayList De `ArrayList` is een dynamische array die een verzameling van objecten van het type `T` kan bevatten [11](#page=11). * **Generics:** De `` geeft aan dat de `ArrayList` type-veilig is en objecten van een specifiek type kan opslaan [11](#page=11). * **For-each lus:** `ArrayList`s bieden een handige *for-each* lus om eenvoudig door de elementen van de verzameling te itereren [12](#page=12). ```java for ( Object o : collection ) { o.doSomething(); } ``` * **Voorbeeld:** ```java double port; for (Poststuk x : stukken) { port = port + x.getPortKost(); } ``` ```java for (Hond dog : kennel) { dog.makeSomeNoise(); } ``` #### 1.2.3 Verantwoordelijkheden: Element versus Verzameling Het is cruciaal om het verschil tussen een enkel element en de verzameling ervan te onderscheiden en deze verantwoordelijkheden in aparte klassen te beheren [13](#page=13). * **Element klasse:** * Beheert alleen zichzelf [13](#page=13). * Bevat een constructor, data members, en getters/seters [13](#page=13). * Voorbeelden van elementen zijn Zender, Boek, Student, Wedstrijd, Meeting [13](#page=13). * **Verzamelklasse:** * Beheert voornamelijk de verzameling van elementen [13](#page=13). * Bevat een constructor voor een lege verzameling [13](#page=13). * Biedt methodes voor het toevoegen, verwijderen en opzoeken van elementen [13](#page=13). * Kan methodes 'delegeren' naar elementen, vaak met een extra zoekparameter [13](#page=13). * Voorbeelden van verzamelingen zijn Radio, Bibliotheek, Studentenvereniging, Competitie, Wetenschappelijk experiment [13](#page=13). > **Belangrijk:** Houd deze twee concepten strikt gescheiden. Een typische beginnersfout is het creëren van een "gemengde klasse" die functionaliteit van zowel elementen als verzamelingen bevat [14](#page=14). * **Niet doen in een Element-klasse:** * Een lijst bijhouden van andere elementen [14](#page=14). * Opzoekwerk doen binnen de verzameling [14](#page=14). * **Niet doen in een Verzamelklasse:** * Get/set-methodes zonder parameter die specifiek op één element gericht zijn, tenzij het een zoekfunctionaliteit betreft [14](#page=14). #### 1.2.4 Voorbeeld: Studentenvereniging Een studentenvereniging die leden beheert, illustreert het verschil tussen een element (een lid) en de verzameling (de ledenlijst van de vereniging) [15](#page=15). #### 1.2.5 Voorbeeld: Universiteit, Vakken en Inschrijvingen Een universiteit die vakken aanbiedt, waarbij studenten zich kunnen inschrijven en examens kunnen afleggen, toont een complexere relatie van compositie [16](#page=16). * **Vak klasse:** * Beheert alleen dat specifieke vak en de punten die op dat vak zijn behaald [16](#page=16). * Data members: `Vak vak`, `int punt` (dit lijkt een vereenvoudiging, waarschijnlijk bedoeld als een relatie binnen de inschrijving) [16](#page=16). * **Student klasse:** * Schrijft zich in voor *veel* vakken, inclusief evaluaties [16](#page=16). * Beheert zijn lijst van vakken waarin hij is ingeschreven [16](#page=16). * Kan de punten voor een specifiek vak opzoeken of veranderen [16](#page=16). * Data member: Een lijst van inschrijvingen (een verzameling van objecten die zowel het vak als de punten bevatten) [16](#page=16). Dit voorbeeld toont aan dat een student meerdere "inschrijvingen" heeft, en elke inschrijving gerelateerd is aan één vak. De student beheert de verzameling van deze inschrijvingen. [16](#page=16). --- # Erving in software-ontwerp Erving is een krachtig ontwerpmiddel dat software-uitbreiding en herbruikbaarheid verhoogt door speciale gevallen toe te voegen [19](#page=19). ### 2.1 De noodzaak van erving Software is in constante ontwikkeling en moet worden uitgebreid tegen minimale kosten en inspanning. Vaak betekent dit het toevoegen van "speciale gevallen". Zonder erving leidt dit tot problemen [19](#page=19) [20](#page=20): * Data members moeten worden uitgebreid [22](#page=22). * Methodes moeten worden herschreven, elke keer wanneer een nieuw type wordt toegevoegd [22](#page=22). Dit is een veelvoorkomend probleem, bijvoorbeeld bij het beheren van verschillende soorten tickets (normaal, VIP, super-VIP) of gebruikersrollen (gebruiker, admin, superadmin) [22](#page=22). ### 2.2 Wat is erving? Erving (inheritance) is een mechanisme dat het mogelijk maakt om "speciale soorten" van een klasse toe te voegen. Het documenteert gemeenschappelijke structuren tussen klassen, creëert een hiërarchie en verhoogt de herbruikbaarheid [23](#page=23) [25](#page=25). #### 2.2.1 De syntax van erving De basisvorm van erving in Java wordt gedefinieerd met het sleutelwoord `extends`: ```java class Y extends X { // ... } ``` Hierbij breidt klasse `Y` klasse `X` uit. Klasse `Y` erft alle functionaliteiten van `X` en kan deze uitbreiden of aanpassen. `Y` is een subtype van `X`, en `X` is een supertype van `Y` [26](#page=26). #### 2.2.2 Toepassing van erving Een typisch voorbeeld is de relatie tussen een algemene klasse `Hond` en een specifiekere klasse `Rashond`. Een `Rashond` is een speciaal geval van een `Hond` [27](#page=27). Wanneer een klasse een andere klasse uitbreidt: * **Extra gegevens:** Nieuwe data members kunnen worden gedefinieerd zoals in een gewone klasse [28](#page=28). * **Extra methodes:** Nieuwe methodes kunnen worden gedefinieerd zoals in een gewone klasse [28](#page=28). * **Aangepaste methodes:** * Een methode kan volledig worden herschreven als deze totaal niet voldoet. Dit kan door een nieuwe methode met dezelfde naam te maken, eventueel met de `@Override` annotatie [28](#page=28). * Een methode kan gedeeltelijk worden hergebruikt. Dit gebeurt door een methode te maken die verwijst naar de super-methode, bijvoorbeeld `super.doetIets()` [28](#page=28). #### 2.2.3 De constructor-keten Tijdens de initialisatie wordt altijd eerst een object van de superklasse gemaakt. Als eerste opdracht van de constructor van de subklasse moet de constructor van de superklasse worden aangeroepen met `super()` [28](#page=28). Wanneer een object van een subklasse wordt gemaakt, wordt altijd eerst een object van de superklasse gecreëerd. Standaard kiest Java de default constructor, tenzij expliciet `super()` wordt aangeroepen [31](#page=31). ##### Voorbeeld constructor-keten Stel de hiërarchie is `LevendWezen` -> `Hond` -> `Rashond`. * Bij het aanmaken van een `Hond` object wordt eerst een `LevendWezen` object aangemaakt en daarna de `Hond`-specifieke data members toegevoegd [31](#page=31). * Bij het aanmaken van een `Rashond` object wordt eerst een `Hond` object aangemaakt (wat op zijn beurt weer een `LevendWezen` aanmaakt), en daarna de `Rashond`-specifieke data members toegevoegd [31](#page=31). ### 2.3 Subtypes en het Liskov Substitutie Principe Erving introduceert het concept van subtypes. Een subtype is een gespecialiseerd deel van een algemener type [33](#page=33). * **Klasse versus type:** Een object kan verschillende types hebben. In Java erft elk object van de klasse `Object`, waardoor elk object ook het type `Object` heeft [33](#page=33). * **Toepassing in collecties:** Als `RasHond` een subtype is van `Hond`, mag een `RasHond` object worden opgeslagen in een `ArrayList`. Omgekeerd is dit niet toegestaan: `Honden` mogen niet zomaar in een `ArrayList` worden opgeslagen [34](#page=34) [36](#page=36). #### 2.3.1 Het Liskov Substitutie Principe (LSP) Het Liskov Substitutie Principe stelt dat, als klasse `Y` klasse `X` uitbreidt (`class Y extends X`), objecten van klasse `Y` objecten van klasse `X` moeten kunnen vervangen zonder dat dit de correctheid van het programma beïnvloedt. Dit principe moet altijd in gedachten worden gehouden bij het toepassen van erving [35](#page=35). * Als klasse `Y` objecten van klasse `X` gebruikt en een **speciaal geval** is van `X`, dan is erving correct. Dit is de "is een" relatie [35](#page=35). * Als klasse `Y` objecten van klasse `X` gebruikt, maar **geen speciaal geval** is van `X`, dan moet compositie worden gebruikt. Dit is de "heeft een" relatie [35](#page=35). #### 2.3.2 Toepassing in lijsten en methodes Wanneer methodes worden toegepast op elementen van een lijst (zoals een `ArrayList`), gebruikt Java de meest specifieke methode die beschikbaar is voor het object [36](#page=36). Een betere oplossing voor het poststukken-voorbeeld, dankzij erving en het Liskov principe, maakt het mogelijk om nieuwe poststukken toe te voegen zonder extra werk [37](#page=37). ### 2.4 Abstracte klassen Abstracte klassen voorkomen dat "valse" objecten worden aangemaakt, bijvoorbeeld objecten van een algemene klasse zoals `Poststuk` als dit conceptueel niet logisch is. Door een klasse abstract te maken, kunnen er geen instanties van worden gecreëerd [39](#page=39). ### 2.5 Gemengde lijsten en typecasting Lijsten kunnen zowel gewone als speciale elementen bevatten (bijvoorbeeld `ArrayList` kan ook `AfgerondeRechthoek` objecten bevatten). Als er acties moeten worden uitgevoerd die specifiek zijn voor de speciale elementen (bv. alleen afgeronde rechthoeken tekenen), is het noodzakelijk om deze speciale objecten te herkennen [40](#page=40). #### 2.5.1 De `instanceof` operator De `instanceof` operator wordt gebruikt om te controleren of een object tot een specifieke klasse of subklasse behoort. Het retourneert een boolean waarde [40](#page=40). > **Tip:** Gebruik `instanceof` om te controleren of een object een specifiek type heeft voordat je een typecast uitvoert. #### 2.5.2 Typecasten naar een hogere klasse (upcasting) Als een `ArrayList` objecten van klasse `Rashond` bevat, en je wilt de specifieke `getRas()` methode van `Rashond` aanroepen, kan dit standaard niet omdat `Hond` deze methode niet heeft. De oplossing is "upcasting", wat alleen mag als je zeker bent dat de hond een rashond is. Dit controleer je met `instanceof` [42](#page=42). ### 2.6 Compositie versus erving Het is cruciaal om onderscheid te maken tussen compositie en erving [45](#page=45). * **Compositie:** Staat voor "heeft een". Een `Rechthoek` heeft een `Punt` en breedte/hoogte. Een rechthoek *is geen* punt [35](#page=35) [45](#page=45). * **Erving:** Staat voor "is een". Een `AfgerondeRechthoek` *is een* `Rechthoek` [35](#page=35) [45](#page=45). Hoewel compositie soms technisch mogelijk is voor relaties die lijken op erving, is het conceptueel fout. Compositie is soms minder handig omdat het niet direct toegang geeft tot data members en methodes. Erving kan technisch wel, maar moet conceptueel correct zijn [45](#page=45). --- ## 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 | |------|------------| | Codeerconventies | Internationale afspraken die helpen om code leesbaar, consistent en onderhoudbaar te maken, zoals naamgevingsregels en indentatie. | | CamelCase | Een naamgevingsstijl waarbij woorden aan elkaar worden geschreven en elk nieuw woord met een hoofdletter begint. Wordt onderscheiden in UpperCamelCase voor klassen en lowerCamelCase voor variabelen en methodes. | | UpperCamelCase | Een variant van CamelCase waarbij de eerste letter van het eerste woord ook een hoofdletter is, typisch gebruikt voor klassen- en interfacenamen. | | lowerCamelCase | Een variant van CamelCase waarbij de eerste letter van het eerste woord een kleine letter is, typisch gebruikt voor variabelen-, methode- en constructor-namen. | | Indentatie | Het proces van het inspringen van code om de structuur en leesbaarheid te verbeteren, waarbij blokken code op een consistente manier worden aangegeven, vaak met 2 tot 4 spaties per niveau. | | ArrayList | Een dynamische verzameling in Java die elementen van een bepaald type (aangegeven door T) opslaat en biedt methoden voor het toevoegen, verwijderen en opzoeken van elementen. | | For-each lus | Een vereenvoudigde manier om door alle elementen van een collectie of array te itereren zonder expliciet een index te hoeven beheren. | | Element | Een enkel object binnen een verzameling dat een specifieke entiteit vertegenwoordigt, zoals een zender, een boek of een student. | | Verzameling | Een klasse die verantwoordelijk is voor het beheren van meerdere elementen, inclusief functionaliteit voor het toevoegen, verwijderen en opzoeken van deze elementen. | | Composi=e | Een ontwerpconcept waarbij een klasse een ander object bevat als data member, wat een "heeft een"-relatie vertegenwoordigt. | | Erving (Inheritance) | Een mechanisme in objectgeoriënteerd programmeren waarbij een nieuwe klasse (subklasse) eigenschappen en gedrag van een bestaande klasse (superklasse) kan overnemen, wat een "is een"-relatie creëert. | | Subtype | Een klasse die eigenschappen van een superklasse overerft, waardoor het een gespecialiseerde versie van de superklasse wordt en hiermee compatibel is. | | Supertype | Een klasse waarvan de eigenschappen en gedrag worden overgeërfd door subklassen, waardoor het een algemener concept vertegenwoordigt. | | Liskov Substitution Principle (LSP) | Een ontwerpprincipe dat stelt dat objecten van een subklasse de objecten van hun superklasse moeten kunnen vervangen zonder dat de correctheid van het programma wordt aangetast. | | Abstracte klasse | Een klasse die niet direct geïnstantieerd kan worden en bedoeld is om als basis te dienen voor subklassen. Kan abstracte methoden bevatten die door subklassen geïmplementeerd moeten worden. | | instanceof | Een operator in Java die wordt gebruikt om te controleren of een objectinstantie behoort tot een bepaald type klasse of interface. | | Typecasten (Type casting) | Het proces waarbij een waarde van het ene type wordt geconverteerd naar een ander type. In Java kan dit "upcasting" (naar een algemener type) of "downcasting" (naar een specifieker type) zijn. |