diff --git a/_images/blueprint1.png b/_images/blueprint1.png
new file mode 100644
index 00000000..4791d9b1
Binary files /dev/null and b/_images/blueprint1.png differ
diff --git a/_images/dutch_bike_symbol.png b/_images/dutch_bike_symbol.png
new file mode 100644
index 00000000..6fd9c2ee
Binary files /dev/null and b/_images/dutch_bike_symbol.png differ
diff --git a/_images/word_cloud.png b/_images/word_cloud.png
new file mode 100644
index 00000000..9decf6f9
Binary files /dev/null and b/_images/word_cloud.png differ
diff --git a/_sources/course/ex_5.md b/_sources/course/ex_5.md
new file mode 100644
index 00000000..5e5668e7
--- /dev/null
+++ b/_sources/course/ex_5.md
@@ -0,0 +1,4 @@
+# Opgaven week 5
+
+- Opgave 1 [Voertuigen](../problems/verhuur/index.md)
+- Opgave 2 [Codingbat Arrays](../exercises/codingbat_arrays.md)
diff --git a/_sources/course/week_5.md b/_sources/course/week_5.md
new file mode 100644
index 00000000..6025d215
--- /dev/null
+++ b/_sources/course/week_5.md
@@ -0,0 +1,13 @@
+# Week 5
+
+## Boek
+
+- Hoofdstuk 12: [Arrays of Objects](https://books.trinket.io/thinkjava2/chapter12.html)
+- Hoofdstuk 13: [Objects of Arrays](https://books.trinket.io/thinkjava2/chapter13.html)
+- Hoofdstuk 14: [Extending Classes](https://books.trinket.io/thinkjava2/chapter14.html)
+
+## Optioneel
+
+Java for Python Programmers:
+
+- [Defining Classes in Java](https://runestone.academy/runestone/books/published/java4python/Java4Python/definingclasses.html)
diff --git a/_sources/exercises/codingbat_arrays.md b/_sources/exercises/codingbat_arrays.md
new file mode 100644
index 00000000..0a2e51eb
--- /dev/null
+++ b/_sources/exercises/codingbat_arrays.md
@@ -0,0 +1,18 @@
+# CodingBat
+
+[CodingBat](https://codingbat.com/java) is een handige site waar je kan oefenen met onder andere arrays en strings. Het is aan te raden om een account aan te maken zodat jouw opgaven bewaard blijven voor een volgende keer dat je de site bezoekt.
+
+## Arrays
+
+- [Arrays 1](https://codingbat.com/java/Array-1)
+
+ Basic array problems
+
+- [Arrays 2](https://codingbat.com/java/Array-2)
+
+ Medium array problems (1 loop)
+
+- [Arrays 3](https://codingbat.com/java/Array-3)
+
+ Harder array problems (2 loops, more complex logic)
+
diff --git a/_sources/exercises/hypotheek.md b/_sources/exercises/hypotheek.md
new file mode 100644
index 00000000..ccc5c22c
--- /dev/null
+++ b/_sources/exercises/hypotheek.md
@@ -0,0 +1,528 @@
+# Overervering
+
+## Inleiding
+
+Dit practicum is een inleiding in overerving. Overerving wil zeggen dat een klasse eigenschappen overneem van zijn ouder-klasse (*parent class*).
+
+## Hypotheek
+
+Een lening voor de financiering van een huis wordt in de volksmond ook wel een hypotheek genoemd.
+
+Een hypotheek bestaat uit één of meerdere leningdelen.
+
+Elk leningdeel heeft een bedrag, een rentepercentage en looptijd.
+
+De looptijd wordt uitgedrukt in maanden en is standaard 360 maanden (30 jaar).
+
+Het rentepercentage kan in werkelijkheid veranderen. Om het eenvoudig te houden, is het in deze opgave gedurende de looptijd een vast percentage.
+
+Het bedrag kan gedurende de looptijd lager worden doordat er wordt afgelost. De verplichte maandelijkse aflossing is afhankelijk van het soort leningdeel. Daarnaast is het altijd mogelijk om extra af te lossen.
+
+Hoewel er verschillende soorten leningdelen zijn, hebben ze altijd bovenstaande eigenschappen. De verschillen tussen soorten leningdelen heeft vooral te maken met hoe wordt bepaald welk bedrag maandelijks wordt afgelost. De meest eenvoudige soort is aflossingsvrij, waarbij er geen verplichte maandelijkse aflossing is.
+
+Financieel adviseurs gebruiken software om inzichtelijk te maken wat de maandlasten van een hypotheek zijn. Met klassen voor een hypotheek en voor verschillende leningdelen kunnen veel verschillende hypotheken worden ondersteund.
+
+## De klasse `Aflossingsvrij`
+
+Onderstaande code bevat een klasse voor een aflossingsvrij leningdeel. Bestudeer de code om een goed beeld te krijgen van hoe deze werkt. De klasse is lang, maar de methodes zijn kort en eenvoudig.
+
+```{code-block} java
+public class Aflossingsvrij {
+
+ private double bedrag; // oorspronkelijke bedrag
+ private double resterendBedrag; // resterend bedrag
+ private double rentePercentage; // Jaarlijks rentepercentage
+ private int looptijd; // oorspronkelijke looptijd
+ private int resterendeLooptijd; // resterende looptijd
+
+ /**
+ * Constructor
+ * @param bedrag Bedrag van het leningdeel
+ * @param rentePercentage Rentepercentage
+ * @param looptijd Looptijd uitgedrukt in maanden
+ */
+ public Aflossingsvrij(double bedrag, double rentePercentage, int looptijd) {
+ this.rentePercentage = rentePercentage;
+ this.bedrag = bedrag;
+ this.resterendBedrag = bedrag;
+ this.looptijd = looptijd;
+ this.resterendeLooptijd = looptijd;
+ }
+
+ /**
+ * Constructor met standaard looptijd van 30 jaar
+ * @param bedrag Bedrag van het leningdeel
+ * @param rentePercentage Rentepercentage
+ */
+ public Aflossingsvrij(double bedrag, double rentePercentage) {
+ this(bedrag, rentePercentage, 360); // standaard looptijd is 30 jaar
+ }
+
+ public double getRentePercentage() {
+ return rentePercentage;
+ }
+
+ public double getBedrag() {
+ return bedrag;
+ }
+
+ public double getResterendBedrag() {
+ return resterendBedrag;
+ }
+
+ public int getLooptijd() {
+ return looptijd;
+ }
+
+ public int getResterendeLooptijd() {
+ return resterendeLooptijd;
+ }
+
+ /**
+ * Af te lossen bedrag deze maand
+ * @return bedrag aan aflossing deze maand
+ */
+ public double berekenMaandlastAflossing() {
+ return 0; // geen standaard aflossing
+ }
+
+ /**
+ * De te betalen rente deze maand
+ * @return bedrag aan rente in de huidige termijn
+ */
+ public double berekenMaandlastRente() {
+ return ( resterendBedrag / 100 * rentePercentage ) / 12;
+ }
+
+ /**
+ * De totale maandlast bestaat uit maandelijkse rente en vaste maandelijkse aflossing
+ * @return totale maandlast
+ */
+ public double berekenMaandlast() {
+ return berekenMaandlastRente() + berekenMaandlastAflossing();
+ }
+
+ /**
+ * Bedrag aflossen
+ * Deze methode wordt gebruikt voor de verplichte maandelijkse aflossing
+ * maar kan ook worden gebruikt voor extra aflossingen.
+ * @param aflossing bedrag aan aflossing
+ */
+ public void aflossen(double aflossing) {
+ resterendBedrag = resterendBedrag - aflossing;
+ if (resterendBedrag < 0) {
+ resterendBedrag = 0;
+ }
+ }
+
+ /**
+ * Naar volgende maand gaan
+ */
+ public void volgendeMaand() {
+ if (resterendeLooptijd > 0) {
+ // Aflossing verwerken
+ aflossen( berekenMaandlastAflossing() );
+ // Resterende looptijd verlagen
+ resterendeLooptijd--;
+ }
+ }
+
+ /**
+ * Naar volgend jaar gaan
+ * door middel van 12 keer naar volgende maand gaan
+ */
+ public void volgendJaar() {
+ for(int t = 0; t < 12; t++) {
+ volgendeMaand();
+ }
+ }
+
+ /**
+ * Retourneert true als hypotheek nog een resterende looptijd heeft (actief is).
+ * @return true als hypotheek nog actief is
+ */
+ public boolean isActief() {
+ return resterendeLooptijd > 0;
+ }
+
+}
+```
+
+Neem de klasse `Aflossingsvrij` over in je IntelliJ.
+
+Maak een klasse `Main` met een main-methode met de volgende code om het leningdeel te testen:
+
+```{code-block} java
+Aflossingsvrij leningdeel = new Aflossingsvrij(150000, 4.5); // Leningdeel 150.000 euro 4,5%
+while( leningdeel.isActief() ) {
+ System.out.printf("%d maanden € %.2f [maandbedrag rente + aflossing : € %.2f + € %.2f = € %.2f]\n",
+ leningdeel.getResterendeLooptijd(), leningdeel.getResterendBedrag(),
+ leningdeel.berekenMaandlastRente(), leningdeel.berekenMaandlastAflossing(),
+ leningdeel.berekenMaandlast()
+ );
+ leningdeel.volgendJaar();
+}
+System.out.printf("Einde looptijd: € %.2f\n", leningdeel.getResterendBedrag());
+
+```
+
+Verwachte uitvoer:
+
+```{code-block}shell
+360 maanden € 150000,00 [maandbedrag rente + aflossing : € 562,50 + € 0,00 = € 562,50]
+348 maanden € 150000,00 [maandbedrag rente + aflossing : € 562,50 + € 0,00 = € 562,50]
+...
+24 maanden € 150000,00 [maandbedrag rente + aflossing : € 562,50 + € 0,00 = € 562,50]
+12 maanden € 150000,00 [maandbedrag rente + aflossing : € 562,50 + € 0,00 = € 562,50]
+Einde looptijd: € 150000,00
+```
+
+## De klasse `Lineair`
+
+Lineair aflossen wil zeggen dat elke maand hetzelfde bedrag wordt afgelost, zodat aan het einde van de looptijd het leningdeel volledig is afgellost. Kenmerkt van linair aflossen is dat de maandelijkse lasten steeds iets lager worden, omdat de te betalen rente afneemt. Het af te lossen bedrag wordt berekend door het resterende bedrag te delen door de resterende looptijd.
+
+Maak de klasse `Lineair` door een kopie te maken van klasse `Aflossingsvrij`. Alleen de methode `berekenMaandlastAflossing` moet aangepast worden, op basis van de bovenstaande beschrijving.Test de klasse met behulp van de main-methode.
+
+Verwachte uitvoer:
+
+```{code-block}shell
+360 maanden € 150000,00 [maandbedrag rente + aflossing : € 562,50 + € 416,67 = € 979,17]
+348 maanden € 145000,00 [maandbedrag rente + aflossing : € 543,75 + € 416,67 = € 960,42]
+...
+24 maanden € 10000,00 [maandbedrag rente + aflossing : € 37,50 + € 416,67 = € 454,17]
+12 maanden € 5000,00 [maandbedrag rente + aflossing : € 18,75 + € 416,67 = € 435,42]
+Einde looptijd: € 0,00
+```
+
+## Problemen van twee soortgelijke klassen
+
+De klassen `Aflossingsvrij` en `Lineair` zijn soortgelijke klassen. Beide representeren een leningdeel. De code komt grotendeels overeen, wat resulteert in duplicate code. Als de opzet van de ene klasse verandert, dient dit waarschijnlijk ook in de andere klasse te gebeuren. Dit probleem wordt groter naarmate er meerdere soorten leningdelen bijkomen.
+
+Een ander probleem is gebruik van het datatype: Bij het wijzigen van `Aflossingsvrij` naar `Lineair` in `main` moesten zowel het *datatype* van de declaratie als het *object* bij keyword `new` aangepast worden. Dit maakt het gebruik van arrays of collecties voor het opslaan van een lijst verschillende leningdelen moeilijk. Het is wenselijk om een datatype te kunnen gebruiken voor een leningdeel, ongeacht het specifieke soort leningdeel (aflossingsvrij of lineair).
+
+De oplossing voor dit probleem is overerving. Overervaring wordt gerealiseerd met het keyword `extends`:
+
+```{code-block} java
+public class Lineair extends Aflossingsvrij {
+ ...
+}
+```
+
+In dit geval overerft de klasse `Lineair` de klasse `Aflossingsvrij`. De klasse `Lineair` is de *parent class*. De klasse `Aflossingsvrij` is hier de *child class*. In plaats van *parent class* en *child class* worden ook wel de begrippen *superklasse* en *subklasse* gebruikt.
+
+Pas de klasse-definitie `Lineair` aan zodat deze `Aflossingsvrij` overerft. verwijder alle code in de klasse uit klasse `Lineair`.
+
+Om het correct werkend te krijgen moeten twee aanpassingen worden gedaan:
+
+1. De klasse `Lineair` heeft constructors nodig
+2. De methode `berekenMaandlastAflossing` moet geïmplementeerd worden, zodat er daadwerkelijk sprake is van lineaire aflossing.
+
+De constructors van `Lineair` zijn als volgt:
+
+```{code-block} java
+public Lineair(double bedrag, double rentePercentage, int looptijd) {
+ super(bedrag, rentePercentage, looptijd);
+}
+
+public Lineair(double bedrag, double rentePercentage) {
+ super(bedrag, rentePercentage);
+}
+```
+
+Het enige wat deze constructors doen is de constructor van de parent class (of superklasse) aanroepen. Dit voorkomt dubbele code.
+
+Alle publieke reguliere methodes van de *parent class* zijn ook beschikbaar in de *child class*.
+
+De implementatie van `berekenMaandlastAflossing` is als volgt:
+
+```{code-block} java
+
+ /**
+ * Af te lossen bedrag deze maand
+ * @return bedrag aan aflossing deze maand
+ */
+@Override
+public double berekenMaandlastAflossing() {
+ return getResterendBedrag() / getResterendeLooptijd();
+}
+
+Mogelijk heb je in de vorige versie van `Lineair` de properties `resterendBedrag` en `resterendeLooptijd` rechtstreeks gebruikt. Dit is nu niet meer mogelijk, omdat deze properties `private` zijn.
+
+Er zijn twee mogelijke oplossingen voor dit probleem. De hierboven gebruikte oplossing is het gebruik van beschikbare *getters*. Een alternatief is gebruik van access-modifier *protected*.
+
+Test de nieuwe versie van `Lineair`.
+
+## Problemen van incorrecte overerving
+
+Ondanks dat het probleem van duplicate code is opgelost, is deze overerving niet geheel correct. Hoewel het technisch werkt, is het ontwerp slecht.
+
+Overervaring creëert een "is-a"-relatie. Als klasse `Lineair` de klasse `Aflossingsvrij` overerft, dan is `Lineair` impliciet `Aflossingsvrij`.
+
+Daardoor is de volgende code mogelijk:
+```{code-block} java
+Aflossingsvrij leningdeel = new Lineair(150000, 4.5);
+```
+
+Dit voorbeeld maakt zichtbaar dat het niet correct is. Immers, lineair aflossen is niet aflossingsvrij.
+
+De relatie ligt anders: lineair en aflossingsvrij zijn beide een soort leningdeel. Om dit te implementeren moeten beide klassen de klasse *Leningdeel* overervaren.
+
+Realiseer met door de volgende stappen:
+1. Hernoem *Aflossingsvrij* naar *Leningdeel*
+2. Maak een nieuwe klasse *Aflossingsvrij* die *Leningdeel* overerft. Voorzie deze klasse van de benodigde constructors.
+3. Mogelijk overerft de klasse *Lineair* al *Leningdeel* doordat de editor dit automatisch voor je doet. Indien dit nog niet het geval is, voer deze wijziging dan zelf door.
+
+Test de nieuwe klassen in main, waarbij de variabele *leningdeel* gedeclareerd kan worden met *Leningdeel*:
+Daardoor is de volgende code mogelijk:
+```{code-block} java
+Leningdeel leningdeel = new Lineair(150000, 4.5);
+```
+
+## Ongewenste instantiëring
+
+Soms is het niet wenselijk dat van een bepaalde klasse objecten worden gemaakt (ook instantiëring genoemd). Dit is vaak het geval bij een overkoepelende superklasse en is ook hier het geval.
+
+Van *Leningdeel* kan een object worden gemaakt:
+```{code-block} java
+Leningdeel leningdeel = new Leningdeel(150000, 4.5);
+```
+
+Deze zal zich gedragen als aflossingsvrij, maar het schept verwarring. De klasse *Leningdeel* is bedoeld om gebruikt te worden als superklasse, niet als klasse om objecten van te maken.
+
+Dit kan voorkomen worden met het keyword *abstract*:
+```{code-block} java
+public abstract class Leningdeel
+```
+
+In dat geval zal het instantiëren van *Leningdeel* niet meer mogelijk zijn, waardoor expliciet gekozen moet worden voor *Aflossingsvrij* of *Lineair*.
+
+Een abstract klasse is een klasse die wel overerft kan worden, maar niet kan worden geïnstantiëerd.
+
+## Abstracte methodes
+
+Binnen een abstracte klasse, kunnen methoden *abstract* worden gemaakt met het keyword `abstract`. Daarmee wordt een methode gedefiniëerd maar niet geïmplementeerd.
+
+Een methode waarbij dit wenselijk is, is de methode *berekenMaandlastAflossing*. Het meest onderscheidende kenmerk tussen verschillende soorten leningdelen is het bedrag wat maandelijks wordt afgelost en hoe dit bedrag tot stand komt. Daarom is het vreemd dat *Leningdeel* al een standaard implementatie bevat.
+
+Het ligt meer voor de hand om implementaties uitsluitend in de subklassen te doen.
+
+Controleer of de variabele *leningdeel* is gedeclareerd als type *Leningdeel*. Verwijder de methode *berekenMaandlastAflossing* uit de klasse *Leningdeel*. Wat gebeurt er?
+
+De klasse *Leningdeel* moet een methode *berekenMaandlastAflossing* bevatten. Daarom geeft het verwijderen van de methode *berekenMaandlastAflossing* problemen. Maar implementatie van deze methode is niet wenselijk. Oplossing is het abstract maken van deze methode met keyword *abstract*:
+```{code-block} java
+abstract public double berekenMaandlastAflossing();
+```
+
+Voer deze wijziging door. Het is noodzakelijk om ook in de klasse *Aflossingsvrij* een implementatie te maken van *berekenMaandlastAflossing*.
+
+## Annuïteiten
+
+Annuïtair aflossen wil zeggen dat elke maand hetzelfde bedrag wordt betaald, zodanig aan het einde van de looptijd het leningdeel volledig is afgelost. Kenmerkt van linair aflossen is dat de (bruto) lasten maandelijks gelijk blijven. Elke maand wordt minder rente betaald en meer aflossing, maar het totaalbedrag is steeds hetzelfde.
+
+Deze klasse is aanzienlijk lastiger dan de andere twee soorten leningdelen, omdat er een ingewikkelde formule is voor het berekenen van het te betalen bedrag.
+
+Bij aflossingsvrij en lineair is het gemakkelijk om de maandelijkse aflossing te berekenen in de methode `berekenMaandlastAflossing`. Bij annuïtair is dit het vaste maandbedrag met aftrek van de die maand te betalen rente.
+
+Dit wordt als volgt geïmplementeerd:
+```{code-block} java
+@Override
+public double berekenMaandlastAflossing() {
+ return berekenMaandlast() - berekenMaandlastRente();
+}
+```
+
+Vervolgens dient in de methode *berekenMaandlast* het vaste maandelijkse bedrag worden berekend, door deze methode te `overriden` in *Annuitair*.
+
+De formule voor een vast maandbedrag bij een annuïtaire lening is als volgt:
+
+vast bedrag = ( r / ( 1 - ( (1 + r) ^ -aantaltermijnen ) ) ) x bedrag
+
+r is fractie van het rentepercentage, percentage / 100. Om een vast maandbedrag te berekenen dient de rente gedeeld te worden door 12. Kortom, *r = (getRentePercentage() / 100) / 12*
+
+Let op het negatieve exponent in de formule! Hint: Math.pow
+
+Maak de klasse `Annuitair`.
+
+Test klasse met behulp van de main-methode.
+
+Verwachte uitvoer (obv. EUR 150.000 en 4,5%):
+360 maanden € 150000,00 [maandbedrag rente + aflossing : € 562,50 + € 197,53 = € 760,03]
+348 maanden € 147580,16 [maandbedrag rente + aflossing : € 553,43 + € 206,60 = € 760,03]
+...
+24 maanden € 17412,74 [maandbedrag rente + aflossing : € 65,30 + € 694,73 = € 760,03]
+12 maanden € 8901,86 [maandbedrag rente + aflossing : € 33,38 + € 726,65 = € 760,03]
+0 maanden € 0,00
+
+## Volledige hypotheek
+
+Doordat er verschillende soorten leningdelen beschikbaar zijn, kunnen hypotheken samengesteld worden. Een hypotheek bestaat uit 1 of meer leningdelen
+
+Dit zou kunnen met een array of ArrayList, maar het is wenselijk om methoden beschikbaar te hebben om bijvoorbeeld het (totaal) resterende bedrag op te vragen of de totale maandlast. Dat kan eenvoudig gerealiseerd worden met een klasse *Hypotheek*
+
+Voor een klasse Hypotheek zijn twee opties:
+
+
+Optie 1:
+```{code-block} java
+public class Hypotheek1 extends ArrayList {
+
+ // de rest
+
+}
+```
+
+Optie 2:
+```{code-block} java
+public class Hypotheek {
+
+ private ArrayList leningdelen;
+
+ // de rest
+}
+```
+Welke van de twee heeft de voorkeur? Probeer een onderbouwing te vinden waarom...
+
+Optie 1 heeft betrekking op een *is-a*-relatie. Dat is problematisch, want een hypotheek is geen arraylist. Daarnaast is een ongewenst neveneffect dat *alle* publieke methodes die via ArrayList beschikbaar zijn ook beschikbaar worden via Hypotheek.
+
+In optie 2 vindt geen overerving plaats (behalve van `Object`) maar is de lijst leningdelen een property van hypotheek. Dit wordt *compositie* genoemd en definieert een *has-a*-relatie. Dat is in dit geval passend.
+
+Per situatie moet overwogen worden of er gebruik wordt gemaakt van *overerving* of *compositie*.
+
+Dit is een eerste opzet van klasse `Hypotheek`:
+
+```{code-block} java
+public class Hypotheek {
+
+ private ArrayList leningdelen;
+
+ /**
+ * Voegt leningdeel toe aan hypotheek
+ * @param leningdeel Toe te voegen leningdeel
+ */
+ public void voegLeningdeelToe(Leningdeel leningdeel) {
+ // Nog maken...
+ }
+
+ /**
+ * Berekent het totaalbedrag van alle leningdelen
+ * @return totaalbedrag van alle leningdelen
+ */
+ public double getBedrag() {
+ double bedrag = 0;
+ for(Leningdeel leningdeel : leningdelen) {
+ bedrag = bedrag + leningdeel.getBedrag();
+ }
+ return bedrag;
+ }
+
+ /**
+ * Berekent het totaal resterende bedrag van alle leningdelen
+ * @return totaal resterende bedrag van alle leningdelen
+ */
+ public double getResterendBedrag() {
+ return -1; // Nog maken...
+ }
+
+ /**
+ * Berekent het totaal af te lossen bedrag deze maand van alle leningdelen
+ * @return totaal af te lossen bedrag deze maand van alle leningdelen
+ */
+ public double berekenMaandlastAflossing() {
+ return -1; // Nog maken...
+ }
+
+ /**
+ * Berekent de totaal te betalen rente deze maand van alle leningdelen
+ * @return totaal te betalen rente deze maand van alle leningdelen
+ */
+ public double berekenMaandlastRente() {
+ return -1; // Nog maken...
+ }
+
+ /**
+ * De totale maandlast bestaat uit maandelijkse rente en vaste maandelijkse aflossing
+ * @return totale maandlast
+ */
+ public double berekenMaandlast() {
+ return berekenMaandlastRente() + berekenMaandlastAflossing();
+ }
+
+ /**
+ * Naar volgende maand gaan (dit doen voor alle leningdelen)
+ */
+ public void volgendeMaand() {
+ // Nog maken
+ }
+
+ /**
+ * Naar volgend jaar gaan
+ * door middel van 12 keer naar volgende maand gaan
+ */
+ public void volgendJaar() {
+ for(int t=0; t < 12; t++) {
+ volgendeMaand();
+ }
+ }
+
+ /**
+ * Retourneert true als tenminste één leningdeel nog een resterende looptijd heeft (actief is).
+ * @return true als hypotheek nog actief is
+ */
+ public boolean isActief() {
+ // Let op! Hypotheken met leningdelen met verschillende looptijden zijn mogelijk.
+ // Daaruit volgt dat er lopende hypotheken bestaan met leningdelen die niet meer actief zijn.
+ // Retourneer true als tenminste één leningdeel actief is
+ return false; // Nog maken
+ }
+
+}
+```
+
+Maak de klasse `Hypotheek` af.
+
+Test deze met de onderstaande code in main, waar op de plaats van ... nog wat ingevuld moet worden..
+
+```{code-block} java
+/*
+Hypotheek van EUR 291.000, looptijd 30 jaar, bestaande uit twee leningdelen
+- Lineair EUR 224.000 5,2% rente
+- Aflossingsvrij EUR 67.000 5.5% rente
+*/
+Leningdeel leningdeel1 = ...
+Leningdeel leningdeel2 = ...
+System.out.println(leningdeel1.getResterendBedrag());
+System.out.println(leningdeel2.getResterendBedrag());
+
+Hypotheek hypotheek = new Hypotheek();
+System.out.println(hypotheek.getResterendBedrag());
+
+hypotheek.voegLeningdeelToe(leningdeel1);
+hypotheek.voegLeningdeelToe(leningdeel2);
+
+int jaar=1;
+while(hypotheek.isActief()) {
+ System.out.printf("%de jaar: € %.2f [maandbedrag rente + aflossing : € %.2f + € %.2f = € %.2f]\n",
+ jaar, hypotheek.getResterendBedrag(),
+ hypotheek.berekenMaandlastRente(), hypotheek.berekenMaandlastAflossing(),
+ hypotheek.berekenMaandlast()
+ );
+ hypotheek.volgendJaar();
+ jaar++;
+}
+System.out.printf("Einde looptijd: %.2f\n", hypotheek.getResterendBedrag());
+
+```
+
+Het verwachte resultaat is:
+
+```{code-block}shell
+1e jaar: € 291000,00 [maandbedrag rente + aflossing : € 1277,75 + € 622,22 = € 1899,97]
+2e jaar: € 283533,33 [maandbedrag rente + aflossing : € 1245,39 + € 622,22 = € 1867,62]
+...
+29e jaar: € 81933,33 [maandbedrag rente + aflossing : € 371,79 + € 622,22 = € 994,02]
+30e jaar: € 74466,67 [maandbedrag rente + aflossing : € 339,44 + € 622,22 = € 961,66]
+Einde looptijd: € 67000,00
+```
+
+
+
diff --git a/_sources/problems/recursive_graphics/index.md b/_sources/problems/recursive_graphics/index.md
index e20408bf..930f469c 100644
--- a/_sources/problems/recursive_graphics/index.md
+++ b/_sources/problems/recursive_graphics/index.md
@@ -7,7 +7,6 @@
* Een programma ontwerpen en ontwikkelen dat een recursief patroon van eigen ontwerp in beeld brengt (optioneel).
\ No newline at end of file
diff --git a/_sources/topics/6a_collections.ipynb b/_sources/topics/6a_collections.ipynb
new file mode 100644
index 00000000..b0f3b199
--- /dev/null
+++ b/_sources/topics/6a_collections.ipynb
@@ -0,0 +1,397 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "8f6163fb-f9a9-4b02-94f6-e1c5e8ac89d7",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Arrays\n",
+ "\n",
+ "Net als constanten zijn arrays ook \"final\". Als de grootte eenmaal is bepaald, dan kan deze niet meer worden gewijzigd: de array kan niet meer worden uitgebreid. De elementen in de array kunnen nog wel worden gewijzigd."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "ee4035d9-0c6f-4ad4-86c2-073dbf80de25",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "class Lingo {\n",
+ " private char[] letters;\n",
+ " \n",
+ " public Lingo(String word) {\n",
+ " letters = new char[word.length()];\n",
+ " \n",
+ " for (int i = 0; i < letters.length; i++) {\n",
+ " letters[i] = word.charAt(i);\n",
+ " }\n",
+ " }\n",
+ " \n",
+ " public boolean guessLetter(int position, char letter) {\n",
+ " if (letters[position] == letter) {\n",
+ " return true;\n",
+ " }\n",
+ " return false;\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "99031470-12ac-4c47-859d-e08d8157a561",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "Lingo game = new Lingo(\"opzet\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "b1d47bff-c6a7-4948-878b-267d2cedac25",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "false"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "game.guessLetter(0, 'z')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "15aa11a6-a57d-4c80-94f5-9994bbf9e356",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Collecties\n",
+ "\n",
+ "Arrays zijn eenvoudige types voor het beheren van een collectie elementen. Collecties zijn typen die veel flexibeler zijn, bijvoorbeeld ze groeien en weer krimpen (in tegenstelling tot arrays waar de lengte vast is)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "d88cb315-adc3-4b86-9059-b7a717c43bbd",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import java.util.ArrayList;"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "4b4d0d97-a35d-4ecf-b444-5ffc3819effe",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "ArrayList gameWords = new ArrayList();"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "cdfda69b-68b9-4c35-964a-add57c9fdc45",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "true"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gameWords.add(\"opzet\");"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "41e4c85e-d3d7-4ca3-8605-cfe017ad37e3",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "true"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gameWords.add(\"pannekoek\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "id": "31ef308a-1632-48a6-86db-205ac27725a3",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gameWords.size()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "id": "fdc79fb3-de1e-4e7d-b89f-140cd02b69a6",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "pannekoek"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gameWords.remove(1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "id": "477f3fdf-efe0-4b0b-a22e-666f02fbb7b3",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "true"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gameWords.add(\"pannenkoek\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "id": "da40534a-86d7-4d0f-9be2-a93ff6ac3bab",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[opzet, pannenkoek]"
+ ]
+ }
+ ],
+ "source": [
+ "System.out.print(gameWords)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "id": "8ef47095-15bb-48e1-99a7-fffcd2403e71",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "opzet\n",
+ "pannenkoek\n"
+ ]
+ }
+ ],
+ "source": [
+ "for (String woord: gameWords) {\n",
+ " System.out.println(woord);\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "349bb7d9-05cb-481f-8562-c3c8a2220465",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": []
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b3542829-4801-42f8-bb47-736245af1b8d",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "In hoofdstuk [12](https://books.trinket.io/thinkjava2/chapter12.html) tot en met [13](https://books.trinket.io/thinkjava2/chapter13.html) worden kaartspellen uitgewerkt, in opgave [simulatie](/problems/simulation/index) ga je dit voor het spel oorlogje (\"War\") uitwerken en het spel simuleren."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Java",
+ "language": "java",
+ "name": "java"
+ },
+ "language_info": {
+ "codemirror_mode": "java",
+ "file_extension": ".jshell",
+ "mimetype": "text/x-java-source",
+ "name": "Java",
+ "pygments_lexer": "java",
+ "version": "11.0.11+9-Ubuntu-0ubuntu2"
+ },
+ "toc-autonumbering": true,
+ "toc-showcode": true
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/_sources/topics/6a_static_klassen.ipynb b/_sources/topics/6a_static_klassen.ipynb
new file mode 100644
index 00000000..1aa04631
--- /dev/null
+++ b/_sources/topics/6a_static_klassen.ipynb
@@ -0,0 +1,821 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e320476a-5748-4521-bca4-50fbccef7052",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "# Context\n",
+ "\n",
+ "Deze les gaat over klassen en over objecten: *instanties* van klassen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b8f7eb70-85ab-4d93-8d7c-806078583b12",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": []
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2778f400-c98a-4e83-a1b7-51f65f49039d",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "Eerder is een klasse beschreven als een *blauwdruk*, het is de bouwtekening die vertelt wat nieuwe objecten moeten zijn. Denk aan de bouwtekening van een huis: op basis van die tekening kan één huis worden gebouwd, maar ook 100 of meer."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c44577b1-1eb8-4b1d-ac33-5165613e0006",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "## De *object* context"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "d7a721a7-0bfa-44f1-8eb1-8588ab1ee38d",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "public class House {\n",
+ " private int number;\n",
+ " private String colour;\n",
+ " \n",
+ " public House(int number) {\n",
+ " this.number = number;\n",
+ " colour = \"red\";\n",
+ " }\n",
+ " \n",
+ " public House(int number, String colour) {\n",
+ " this.number = number;\n",
+ " this.colour = colour;\n",
+ " }\n",
+ " \n",
+ " public String toString() {\n",
+ " return String.format(\"House number %d with colour %s\", number, colour);\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6988c2f1-4124-481b-bedd-d89823e717eb",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "De klasse `House` heeft twee constructors: één met alleen het huisnummer en een andere met zowel een huisnummer als een kleur. Dit geeft aan dat bij het maken van een huis in ieder geval een huisnummer meegegeven moet worden (maar niet welke), maar dat een kleur optioneel is. Pas bij een aanmaken van een huis (object) worden deze waarden concreet."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "65f782a5-d432-4cd0-868a-5e7559fffe15",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "House myHouse = new House(149);\n",
+ "House yourHouse = new House(150, \"blue\");"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "6d1459ba-46f6-4335-a4a0-81ab808b1b4b",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "House number 149 with colour red"
+ ]
+ }
+ ],
+ "source": [
+ "System.out.print(myHouse)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "d13b08f0-83ef-40f9-9411-b8b0841c7fab",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "House number 150 with colour blue"
+ ]
+ }
+ ],
+ "source": [
+ "System.out.print(yourHouse)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b2699618-57da-4571-b323-54f627fcfd69",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "## De *statische* context"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "22616cc2-49d5-4ffe-89f6-ca9c54105269",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "public class Account {\n",
+ " private String name;\n",
+ " private static double balance;\n",
+ "\n",
+ " public Account(String name) {\n",
+ " this.name = name;\n",
+ " balance = 0.0;\n",
+ " }\n",
+ "\n",
+ " public void deposit(int amount) {\n",
+ " balance += amount;\n",
+ " }\n",
+ "\n",
+ " public double getBalance() {\n",
+ " return balance;\n",
+ " }\n",
+ " \n",
+ " public String toString() {\n",
+ " return String.format(\"%s's balance: %.02f\", name, balance);\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "51506683-2aeb-4dde-9e09-2da5c6143209",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "Hierboven zie je een andere klasse, een spaarrekening waar geld op kan worden gestort. Let op, tot nu toe heb je methoden gezien die *statisch* gedefinieerd waren met het *keyword* `static` (denk aan `main`), maar *velden* kunnen ook statisch zijn. Hier is het veld `balance` statisch gedefinieerd. Let nu op wat er in de onderstaande code-voorbeelden gebeurt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "32dc06a5-4d22-4b0a-8af9-819069e1f09b",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "Account misja = new Account(\"Misja\");\n",
+ "Account simon = new Account(\"Simon\");"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "f6a09c03-fc1f-4cee-ac5f-29e5c8db9ca9",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "misja.deposit(1500);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ab34ef49-105c-47f7-afd4-96717078ba85",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Misja's balance: 1500,00"
+ ]
+ }
+ ],
+ "source": [
+ "System.out.print(misja);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "53420e61-1d16-40c9-a011-c08183caa3cf",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "simon.deposit(2500);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "35d47633-a21d-414f-b099-e473f4e2be60",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Simon's balance: 4000,00\n"
+ ]
+ }
+ ],
+ "source": [
+ "System.out.println(simon);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "79c48277-99bf-4ce3-8445-6b0ed854c3fa",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Misja's balance: 4000,00\n"
+ ]
+ }
+ ],
+ "source": [
+ "System.out.println(misja);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aaa536f5-9ae4-4d31-a5dc-c5d9bed37ce1",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "Dat is makkelijk rijk worden 😎. Maar wat gebeurt hier 🤔?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4bfcf71d-82b7-4a10-aeae-aea4ea2b3f2e",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "### `static`\n",
+ "\n",
+ "Een klasse is niet alleen maar een definitie, hij *kan* ook waarden hebben. Dit zijn zogenaamde *statische waarden*, die gedefinieerd zijn voor de klasse en daardoor hetzelfde zijn voor *alle* objecten die van die klasse gemaakt worden."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "468d0d6b-a1c3-48ac-96e7-f82664b48750",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "public class Hello {\n",
+ " public static void main(String[] args) {\n",
+ " System.out.println(\"Hello, \" + args[0] + \"!\");\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb97529f-c7df-4a41-80aa-372620f1359f",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "Met waarden bedoelen we hier niet alleen variabelen (data) maar ook methoden, bijvoorbeeld de welbekende methode `main`. Als een waarde eigen is aan de klasse dan betekent dit dat *geen* instantie van deze klasse nodig is om de methode aan te roepen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c861e75d-db31-4734-b15d-5941321999ef",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": []
+ },
+ "source": [
+ "```console\n",
+ "> java HelloWorld.java Misja\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9df96b64-5883-4217-a2ff-c3d61698341b",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "De argumenten die via de commandline zouden worden gegeven en verzameld worden in een array van `String`'s."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "e59cae47-3879-42fb-9bdc-fdc8de517030",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hello, Misja!\n"
+ ]
+ }
+ ],
+ "source": [
+ "String[] args = {\"Misja\"};\n",
+ "Hello.main(args);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86d8f655-4b9c-4064-a7d2-089c565ccd29",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "De aanroep van de methode `main` via de klasse, en niet een via een *instantie* van de klasse."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0adb0ed5-ef08-4ef3-84b7-e2cff2442c75",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Combineren\n",
+ "\n",
+ "Context mixen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "3d0ac723-d109-41c7-8d61-4dcca04847a3",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "public class Person {\n",
+ " private String name;\n",
+ " \n",
+ " public Person(String name) {\n",
+ " this.name = name;\n",
+ " }\n",
+ " \n",
+ " public String toString() {\n",
+ " return name;\n",
+ " }\n",
+ " \n",
+ " public static void main(String[] args) {\n",
+ " Person a = new Person(\"Ariel\");\n",
+ " Person b = new Person(\"Bo\");\n",
+ " \n",
+ " System.out.println(\"Hi \" + a + \" and \" + b + \"!\");\n",
+ " }\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb9c8482-c23e-4567-9e3c-6f82f6c33cf4",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "De klasse als \"client\" van zichzelf."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "499c09ed-042c-46f5-bd70-8a1c1bbba574",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": []
+ },
+ "source": [
+ "```console\n",
+ "> java Person.java\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "e1d7f8fe-1a13-4185-84cd-7bc471ade97c",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Hi Ariel and Bo!\n"
+ ]
+ }
+ ],
+ "source": [
+ "Person.main(args)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bced0a2a-bcda-4255-896d-9c1ece145700",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": []
+ },
+ "source": [
+ "| | `static`
(voor de hele klasse) | *niet* `static`
(per instantie) |\n",
+ "|----------------|---------------------------------------|---------------------------------------|\n",
+ "| methode | `Math.sqrt()`
`Integer.parseInt()` | `name.length()`
`text.charAt()` |\n",
+ "| veld/variabele | `Math.PI` | `args.length`
`name.toUpperCase()` |"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d38b9a23-ec99-425b-b331-5451aa1ea54f",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "Je hebt inmiddels zowel methoden als klassen in een objectcontext én in een statische context gebruikt; je zal hier een aantal aanroepen wellicht herkennen. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "712192f6-27a0-4aa0-b47e-5cc8d0bba33d",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "slide"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Onverandelijkheid\n",
+ "\n",
+ "Door gebruik te maken van `final` zorg je ervoor dat een eenmaal aangemaakte variabele niet meer van waarde kan veranderen. Deze is nu `final`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "354ef4ef-a15c-4545-b6e5-73563c0e241f",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "public class Square {\n",
+ " public static final int MAX_WIDTH = 100;\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "25a1621a-9eb8-42b7-a39f-4cb157fe214e",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Square.MAX_WIDTH;"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "675d29d4-2e2f-40f7-a779-0b4821734da4",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "CompilationException",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1m\u001b[30m| \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mSquare.MAX_WIDTH\u001b[0m\u001b[1m\u001b[30m = 101;\u001b[0m",
+ "\u001b[1m\u001b[31mcannot assign a value to final variable MAX_WIDTH\u001b[0m",
+ ""
+ ]
+ }
+ ],
+ "source": [
+ "Square.MAX_WIDTH = 101;"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "31a8e335-cc09-4b7d-8bbe-b896d66613d5",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "subslide"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3.141592653589793"
+ ]
+ },
+ "execution_count": 20,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Math.PI"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "9f6b835e-cce4-4e65-8b02-a7569ad9df82",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "fragment"
+ },
+ "tags": [],
+ "vscode": {
+ "languageId": "java"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "CompilationException",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1m\u001b[30m| \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mMath.PI\u001b[0m\u001b[1m\u001b[30m = 2 * Math.PI\u001b[0m",
+ "\u001b[1m\u001b[31mcannot assign a value to final variable PI\u001b[0m",
+ ""
+ ]
+ }
+ ],
+ "source": [
+ "Math.PI = 2 * Math.PI"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c28b3a6f-50e4-4ab3-a838-283014b927a6",
+ "metadata": {
+ "slideshow": {
+ "slide_type": "notes"
+ },
+ "tags": []
+ },
+ "source": [
+ "De conventie is dat `final` velden met hoofdletters worden geschreven. Het geeft aan dat het *constanten* zijn, onveranderlijke waarden."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Java",
+ "language": "java",
+ "name": "java"
+ },
+ "language_info": {
+ "codemirror_mode": "java",
+ "file_extension": ".jshell",
+ "mimetype": "text/x-java-source",
+ "name": "Java",
+ "pygments_lexer": "java",
+ "version": "11.0.11+9-Ubuntu-0ubuntu2"
+ },
+ "toc-autonumbering": true,
+ "toc-showcode": true
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/about/literatuur.html b/about/literatuur.html
index 4e0c9441..81046fcc 100644
--- a/about/literatuur.html
+++ b/about/literatuur.html
@@ -411,6 +411,62 @@ Objectgeoriënteerd Programmeren
+
+
+ Week 5
+
+
+
diff --git a/about/syllabus.html b/about/syllabus.html
index 4e293d46..7cea503a 100644
--- a/about/syllabus.html
+++ b/about/syllabus.html
@@ -410,6 +410,62 @@ Objectgeoriënteerd Programmeren
+
+
+ Week 5
+
+
+
@@ -566,6 +622,8 @@ Welkom
+
+
+