Samenvatting programmeren I aan UGent

Samenvatting programmeren I
Inhoud
Inhoud
Basis
Types
Wiskundige Expressies
Begin van een Java-klasse
Mutatormethoden (void) en accessormethoden (get)
Interessante tekens
Parameters
Velden
Tekst dat Java niet mag lezen
Klasse String
Programma laten werken zonder BlueJ
pakketten
Functies van Java en BlueJ
Als-dan vergelijking
Printen
Lussen
Documentatie en interessante methoden
Random
Lijsten, tabellen en andere opslagmogelijkheden
Gooien en opvangen van fouten (Exceptions)
Programmeren met stijl (enkele tips)
Overerving
Basis
Dynamische en statsiche types
Abstracte klassen en interfaces

1
2
2
2
3
4
4
4
4
4
4
5
5
5
5
5
6
6
6
7
8
9
10
10
10
11
12
13

Bijlage 1: while-lus met dubbele conditie

Bijlage 2: while- of for-lus

Janos Braem

Samenvatting programmeren I aan UGent

Basis
Types
Alles is van het type Object. Als je bijvoorbeeld een tabel maakt van het type Object kan je daar alles
in steken.
Een geheel getal int
Een reel getal double
1 teken char
aanduiding q (niet q, dat is een string)
waar/niet waar boolean (true false in Java).
Een booleaanse waarde wordt vaak een vlag genoemd bij methoden waarbij een boolean
teruggegeven moet worden. Bv: bij de methode isRed kan je een vlag maken boolean isRed.
Tijdens je methode vul je die booleaanse waarde en deze kan dan op het einde teruggegeven
worden.
Deze 4 primitieve types horen bij de klassen: Double, Integer, Character, Boolean (je kan deze klassen
dan gebruiken bij een ArrayList en een HashMap).
Dit zijn twee interessante methoden die van een string een int of een double maken.
Double.parseDouble
Integer.parseInt
Verder zijn er nog enkele opmerking i.v.m. het type char. Al de waarden in het type char zijn
alfabetisch geordend. Zo kun je ook chars met elkaar vergelijken. Om bv te weten of een char een
hoofdletter is kan je het volgende doen: return ch >= A && ch <= Z;
Zo kan je ook twee getallen van elkaar aftrekken. Zo wordt D-A 3 en weet je dus dat deze twee
letters 3 plaatsen van elkaar afwijken. Verder kan je ook een getal omzetten in een hoofdletter:
if (ch >= a && ch <= z)
ch += A - a;
return ch;
Er treedt wel een probleem op wanneer je een int en een char met elkaar wil optellen. Je moet dan
een cast gebruiken.
if (ch >= a && ch <= z)
return (char)(ch + A - a);
else
return ch;

Wiskundige expressies
+ optellen
- aftrekken
i++ is hetzelfde als i= i+1
i-- is hetzelfde als i= i-1
i += m is hetzelfde als i = i+m
* - vermenigvuldigen
/ - delen (deling van twee gehele getallen is een geheel getal, analoog rationale getallen)
% - modulus of rest-na-delen
Rekenregels: modulus, vermenigvuldigen en delen eerder dan optellen en aftrekken
== - is gelijk aan (bij String gebruik de methode equals!)
!= - is niet gelijk aan
< - kleiner dan (analoog voor groter dan)
<= kleiner of gelijk aan (analoog voor groter of gelijk aan)
Absolute waarde Math.abs(x)
Correct wiskundig afronden (java rond steeds naar beneden af) Math.round(x)

Janos Braem

Samenvatting programmeren I aan UGent

Minimum van x en y Math.min(x,y) (analoog voor maximum)
Cosinus in x, met x in radialen Math.cos(x) (analoog voor sin(x), acos(x), asin(x), atan(x)
E^x Math.exp(x)
Ln(x) Math.log(x)
Vierkantwortel x Math.sqrt(x)
Vierkantswortel van x + y - Math.hypot (x,y)
Math.PI
e Math.E
AFRONDEN:
Java rond int-waarden steeds naar beneden af. Hou daar rekening mee. Verder kan de compiler soms
zeggen: possible loss of precision. Dit kan komen doordat je een int-waarde berekent met behulp van
double waarden. Je kan dit oplossen door int-waarden te gebruiken (java zal afronden als hij double
uitkomt) of door Math.round te gebruiken.
Opmerking! In java zijn de volgende twee bewerking niet hetzelfde:
(1) a = a* b/c
en (2) a*= b/c.
Want dan wordt de uitkomst bij (1) a wordt (ab)/c en bij (2) a wordt a(b/c) .
Deze twee waarden zijn niet gelijk want java rondt af!
Als je dit doet: x*(1/2) zal dit niet het gewenste effect bereiken want
Java rondt steeds naar beneden af! Dus dat wordt dan 0. Dit moet je doen: x/2.

Begin van een java-klasse

1. Druk op new class
2. public class Naam{ (maak een nieuwe klasse aan met naam als naam) (voor public zie
opmerking)
3. Noem alle velden die er moeten zijn en waarvan de klasse moet gebruik maken, dit moet je
zo doen: private Type naam (maakt een nieuw priv-veld aan van Type met naam. Het is
belangrijk dat velden altijd private zijn. Een klasse moet zo weinig mogelijk van zijn geheimen
aan de buitenwereld prijsgeven.)
4. Zeg hoe een nieuw object moet noemen: public Naam() met binnenin de parameter,
initialiseer daarna binnenin alle velden en parameters, altijd initialiseren, desnoods met 0 of
null, of het eerste element van een tabel of lijst.
Opmerkingen:
1. Gebruik static, na private of public, om van de methode een klassenmethode te maken. Dit wil
zeggen dat deze methode een onderdeel is van een klasse en niet afhangt van een object. Je
moet dus geen object hebben om de methode te kunnen toepassen. Dit is handig voor
mensen die niets van BlueJ of Java kennen en toch het programma vlot willen gebruiken. Als
je dan de geschreven methode wilt toepassen gebruik je: Class.methode(). Deze methode
heeft twee beperkingen:
a. Een klassenmethode mag geen gebruik maken van instantiemethoden, enkel van
andere klassenmethode.
b. Een klassenmethode mag geen gebruik maken van velden die gedeclareerd worden in
een instantiemethode, enkel variabelen van de klasse zelf.
2. Gebruik final om een constante te definiren. Het veld dan gecreerd wordt is dan
onveranderbaar. Hierbij moet de naam van de constante wel in hoofdletters worden
geschreven.
3. Public gebruik je als het zichtbaar mag zijn voor heel java. Private is alleen beschikbaar voor
de klasse. Protected is voor de klasse en subklassen zichtbaar. En als je niets zet is het voor
alle klassen van hetzelfde pakket zichtbaar.

Janos Braem

Samenvatting programmeren I aan UGent

Mutatormethoden (void) en accessormethoden (get)

1. public void naam() maakt een nieuwe methode die iets moet uitvoeren, gelijk wat, er
kunnen eventueel parameters ingesteld worden om dan enkel binnen deze methode te
gebruiken. Hier kan je niet het statement return gebruiken.
2. Type getIets() je kan hierna een methode schrijven maar op het einde moet je een return
waarde geven dat iets teruggeeft van het type dat in het begin gezegd werd.

Interessante tekens
= steekt hetgeen dat na dit teken staat in het geen dat ervoor staat
. voert de methode die erna staat uit op hetgeen ervoor staat
Merk op! Als de methode in de klasse zelf voorkomt moet je ze niet op een object toepassen met . .
return geeft iets terug
; moet na elke zin die je typt in java, behalve voorwaarden bij lussen of een als-dan vergelijking en
ook niet na het declareren van een nieuwe methode, klasse of object.
this.iets met this kan je vanuit de ene constructor een andere constructor van dezelfde klasse
oproepen, this verwijst ook naar het object zelf
! dit maakt van hetgeen erachter staat het omgekeerde (bv. true wordt dus false)
(Type) Dit is een cast. Dit moet je voor iets zeggen en dan zeg je aan de compiler dat hetgeen dat
hierna staat van het type tussen de haakjes is.

Parameters
De parameters moeten steeds tussen haakjes staan en later nog gebruikt worden. Je maakt een
parameter door eerst het type te schrijven en daarna de naam van de desbetreffende parameter.

Velden
Er worden telkens nieuwe velden gedeclareerd in het begin. Het programma moet vooraf weten wat
hij allemaal zal moeten gebruiken, maar hij moet het maar gebruiken (en initialiseren) in de methode
zelf. Stel dat je in het begin hebt geschreven: private Schaakbord schaakbord. Dan moet je de eerste
keer dat je dit schaakbord nodig hebt nog schrijven: schaakbord = new Schaakbord (dit kan je ook al
doen als je een object van de klasse aanmaakt).

Tekst dat java niet mag lezen

Je kan bovenaan een methode, klasse of constructor schrijven: /** en dan op enter drukken. Je tekst
mag geschreven na elk enkel sterretje.
Je kan ook // schrijven en dan kan je tekst schrijven voor de rest van de regel. Java zal dat niet lezen.
In je algemene omschrijving kan je ook bepaalde tags aan je java-klasse of programma verbinden.
Hieronder volgt een lijst van vaak gebruikte tags:
@auteur
De naam of namen van de auteurs.
@param
De naam van de parameter(s), of een omschrijving ervan.
@return
De omschrijving van de te retourneren waarde.
@versie
Een versie-omschrijving (Bv. 1.5.6 of de datum van de laatste aanpassing.)

Klasse String
Deze klasse is geen primitieve klasse, maar toch moet je de klasse niet bovenaan het programma
importeren. Strings worden voorgesteld als q (niet q, anders heb je een char). Enkele belangrijke
dingen over Strings:
1. Als je wilt weten of twee strings gelijk zijn moet je de methode .equals() gebruiken en niet
==. Bv. Stel je wilt weten of String s1 gelijk is aan String s2 dan doe je het volgende:
s1.equals(s2).
2. Als je de lengte van een string wil weten, gebruik je de methode: .length()
3. Als je een String wilt splitsen gebruik je de volgende methode: .substring(beginpositie,
eindpositie), waarbij je de eindpositie niet per s hoeft te zeggen.

Janos Braem

Samenvatting programmeren I aan UGent

4. Om een char in een String te zoeken: .indexOf(char t, int vanafIndex) Deze methode geeft de
plaats weer van de eerste keer dat het teken t in de string voorkomt. De methode begint te
zoeken vanaf de int die als parameter ingevuld wordt (vanafIndex). Ook hier moet dit laatste
niet per s ingevuld te worden.
5. s1.contains(char): deze methode controleert of s1 de char bevat die als parameter
opgegeven werd.
6. s1.isEmpty(): deze methode geeft aan of de string leeg is of niet.
7. String.replace (char c1, char c2): Vervangt alle tekens van c1 in een string door c2.
8. String.trim () doet begin- en eindspaties weg.
9. String.toLowerCase() zet alles om in kleine letters.
10. String.startsWith() Zegt met welk karakter een string begint.

Programma laten werken zonder BlueJ

Daarvoor moet je de hoofding van je methode aanpassen:
public static void main (String[] args). Je methode noemt dus main en is public (uiteraard!). Verder
heb je als parameter een tabel van Stringwaarden, dit is altijd zo! Deze hoofding gebruik je best zoals
hij hier beschreven staat. Je kan je programma dan zo openen: c:\> java MijnKlasse een twee drie. De
een twee drie zijn drie Strings die in de tabel zullen opgeslagen worden. De lengte van je tabel args
hangt dus af van het aantal waarden dat je na c:\> java MijnKlasse schrijft.
Om het te proberen kan je de opdrachtprompt gebruiken. Je kan je mappen veranderen door cd te
schrijven en daarachter de nieuwe map.
Compileren doe je als volgt: javac Naam.java.

Pakketten
Dit is een mechanisme die gelijkaardige klassen in een groep schikt. Alle klassen en pakketten zijn
gebundeld in het pakket java. Elke subpakket heeft zo een aparte naam. Stel dat we onder java een
klasse K hebben uit het pakket p dan wordt de officile naam van die klasse: java.p.K. Bij Random is
dat bijvoorbeeld: java.util.Random. Dus in principe moet je altijd de officile naam gebruiken. Maar
om het schrijven te versimpelen zijn er enkele regels ingevoerd:
Je kan een klasse importen. Die doe je bovenaan door te schrijven import java.p.K. Vanaf nu
moet je dus in de rest van je klasse nooit meer de officile naam van K gebruiken maar kan je
gewoon K gebruiken.
Klassen uit hetzelfde pakket waar je in bezig bent moet je niet meer importen en officiel
benoemen.
Om een bestand in het package te plaatsen moet je het enerzijds in de juiste map zetten maar ook
bovenaan schrijven: package java.p bijvoorbeeld.

Functies van Java en BlueJ

Als-dan vergelijking
if(voorwaarde) {doe iets; doe iets; doe iets;} als aan de voorwaarde voldaan is zal hij iets doen
else{doe iets anders;} als niet aan de voorwaarde voldaan is, doet hij iets anders
Merk op! Vaak worden de accolades binnen een als-dan vergelijking weggelaten als er slechts
1 opdracht tussen de haakjes bevindt.
Als je moet teruggeven of iets true of false is, kan je best direct return k<1 doen bv. In plaats
van if(k<1){return true;)else{return false;}
Als je wil controleren of een object van een gegeven type is, kan je het volgende na je if in de
ronde haakjes schrijven: Object instanceof type.

Printen
Printen op een nieuwe regel System.out.println( te printen tekst )
Printen ernaast System.out.print( te printen tekst )

Janos Braem

Samenvatting programmeren I aan UGent

Strings worden aan elkaar gekoppeld door +
Strings worden met andere waarden gekoppeld door +
Als je gewoon een nieuwe lijn wilt zonder al direct iets af te drukken typ je System.out.println()
(zonder parameters)
Als je een blok tekst wil schrijven en je wilt middenin je regel een nieuwe regel schrijven gebruik je
best de code \n
De code System.out.print is niets nieuws: System is een klasse, out is een veld en print is een
methode van die klasse.
Belangrijk!
Het is soms beter om de methode String toString() te gebruiken. Deze methode zet een char, int of
double om in een string. Als je dat van een object wil doen, kan je dat zelf schrijven door middel van
een nieuwe methode die toString() noemt en die dan via setters en getters een omschrijving geeft
van het object. En nu komt het interessante. Als je System.out.println gebruikt en daarin iets zet dat
geen string is, gebruikt hij automatisch de methode toString van dat Object. Als je dat zelf reeds
geschreven hebt, zal hij dat dus gebruiken. Als je dat niet doet gebruikt java een eigen code waar je
als buitenstaander niet veel van kan maken. De toString-methode is dus zeer handig. Want zo kan je
de toString niet alleen op een scherm gebruiken, maar ook in andere toepassingen.

Lussen
While-lus
while (voorwaarde) {doe iets; doe iets; doe iets;} zolang aan de voorwaarde voldaan is, doet hij iets
Merk op! Als je in je voorwaarde bij de while lus een dubbele conditie plaats, moet je eens
zeer goed bijlage 1 lezen.
for-each-lus
for (Type naam: collectie) {doe iets;} voor elk element (=naam) van het Type uit de collectie, doe
iets
Merk op! Bij een for-each-lus, mag je NOOIT je lijst veranderen waarmee je aan het werken
bent.
Merk op! Als je dit schrijft, zal je niet elk element in de tabel in 5 veranderen:
double [] tab = new double [20];
for (double d : tab) {d=5}.
Java gaat 5 in de variabele d steken, maar niet in de tabel zelf.
Het geen je hierboven schrijft is eigenlijk dit:
For (int i = 0; i<tabel.length ; i++){double d = tab[i]; d=5;} (dit klopt dus niet!)
for-lus
for(initialiseren; voorwaarde; eindhandeling){doe iets} je initialiseert een waarde, als daarna aan
de voorwaarde voldoen is doe hij hetgeen binnen de accolades. Daarna controleert java terug de
voorwaarde. Vanaf het moment dat er niet aan de voorwaarde voldaan is wordt de eindhandeling
uitgevoerd.

Documentatie en interessante methoden

Java bevat zeer veel klassen. Om ze allemaal van buiten te kennen zou je veel moeten blokken.
Daarom staat er op de volgende link een overzicht. Zie API: http://twizz.ugent.be/java/docs6.0/api/index.html .
De belangrijkste methodes zijn deze van Math (zie wiskundige expressies pagina 1 en 2), Random
(zie Random hieronder) en de methodes van een String (ga naar String).

Random
Random is een bepaalde klasse die een bepaald willekeurig getal kan weergeven. Om de methode te
gebruiken schrijf je helemaal bovenaan je programma: import java.util.random. Een nieuw object van
de klasse random wordt op de volgende manier aangemaakt: private Random

Janos Braem

Samenvatting programmeren I aan UGent

naamRandomMachine. En om te initialiseren: naamRandomMachine = new Random() . Interessante
methodes die random bevat zijn:
1. naamRandomMachine.nextBoolean(): geeft willekeurig true of false terug.
2. naamRandomMachine.nextInt(): geeft een willekeurig getal terug.
3. naamRandomMachine.nextInt(int n): geeft een willekeurig getal van 0 tot n (dus n niet
meegerekend) terug.
4. naamRandomMachine.nextDouble(): geeft een willekeurig reel getal terug.

Lijsten, tabellen en andere opslagmogelijkheden

Er zijn een aantal mogelijkheden om elementen ergens in een lijst of een tabel in op te slaan, met elk
hun eigen voor- en nadelen.
1. Tabel. Bij een tabel maak je eigenlijk een fictief boek en je steekt daar vooraf allemaal
blaadjes in. Het interessante aan een tabel is dat je vooraf moet beslissen hoeveel blaadjes je
er in wilt steken. Bij een boek is dat net hetzelfde, eenmaal een boek ingebonden is, kan je
het aantal bladeren niet meer veranderen. Elk blad heeft een nummer (beginnend van 0 en
eindigend met het aantal paginas -1. Een tabel heet in Java Array. Op elk blad kan je dan iets
invullen. Hoe je ermee moet werken zie je hieronder.
a. Je moet een tabel niet importeren in Java.
b. Om je tabel zogezegd aan te maken schrijf je: Type [] naamTabel. Hierbij kan je
meerdere elementen in de tabel steken op de volgende manier: int[] rij3 = { 3, 4, 5, 6
};. Dit kan je ook met een ander Type doen.
c. Om de tabel de definiren schrijf je: naamTabel = new Type [lengteTabel]. Hier kan je
de tabel niet met meerdere elementen vullen zoals bij punt b!
d. Om iets in de tabel te steken gebruik je naamTabel[positie] = vulling.
e. Om een bepaald element te weten: naamTabel[positie]
f. Om de lengte te weten: naamTabel.length
g. Opmerking! Je kan een tabel ook twee dimensies geven. Zo kan je een tabel met i
rijen en j kolommen aanmaken bijvoorbeeld. Dit doe je zo
i. Aanmaken tabel: int[][] tabel = new int [3][5];
ii. Je kan de tabel als volgt vullen:
iii.
for (int i = 0; i < 3; i++)
for (int j = 0; j < 5; j++)
tabel[i][j] = 10 * (i + 1) + j + 1;
Dan ziet je tabel er als volgt uit:
11 12 13 14 15
21 22 23 24 25
31 32 33 34 35
iv. Om van een tweedimensionale tabel de lengte weten kan je het aantal rijen
als volgt weten: tabel.length, het aantal kolommen weet je als volgt:
tabel[0].length
v. Het effect van het volgende java-fragment is dat je in elk kolomnummer
dezelfde rij steekt:
double [] [] mat = new double [5] [];
double [] rij = new double [5];
for (int i = 0; i < 5; i++){
mat [i] = rij;}
vi. Verder nog dit, vaak zul je te maken hebben met een situatie waarbij je een
getal moet invoegen, en de andere getallen telkens met eentje moet
opschuiven, de meest handige techniek is dan om van achter naar voor te
werken, tot de plaats waar het element ingevoegd moet worden.

Janos Braem

Samenvatting programmeren I aan UGent

2. Lijst. Een lijst is anders dan een tabel omdat je hier de lijst het best met een ringmap kan
vergelijken. Je kan er heel wat blaadjes insteken en je kan ze ten allen tijde eruit halen of erin
steken. Een groot nadeel van een ArrayList is dat er enkel objecten kunnen in opgeslagen
worden en geen primitieve klasses zoals int. Je kan je lijst wel van het type Integer maken,
dan lukt het wel. Om een lijst te maken en te gebruiken doe je het volgende
a. Een lijst wordt gemporteerd met: import java.util.ArrayList;
b. Om je lijst aan te maken schrijf je: private (of public) ArrayList<Type> naamLijst
c. Om de lijst te initialiseren: naamLijst = new ArrayList<Type>().
d. Om iets toe te voegen: naamLijst.add(hetToeTeVoegenElement) merk op dat je hier
geen positie moet invoeren, het element wordt op de laatste plaats in de lijst
geplaatst.
e. Om de lengte te weten: naamLijst.size()
f. Om een bepaald element te weten: naamLijst.get(element)
g. Om een element te verwijderen: naamLijst.remove(positieInLijst)
i. Merk op! Als je een element verwijdert, verandert de nummering!
3. Hashmap. Een hashmap kan je het best vergelijken met een telefoonboek. Elke waarde uit
een Hashmap is gekoppeld aan een andere waarde. We hebben telkens een soort sleutel
nodig die dan iets anders vrijgeeft. In een Hashmap kunnen enkel objecten opgeslagen
worden en geen primitieve types. Om een object uit de hashmap op te roepen moet je als
het ware de naam ingeven en dan krijg je het telefoonnummer, je moet dus een object
ingeven en dan zoekt hij waar in de hashmap hij dat object terugvindt en geeft dan het
object dat ermee gekoppeld is terug. Een hashmap gebruik je als volgt (voor het gemak
wordt de sleutel hier voornaam genoemd en het object dat aan de sleutel gekoppeld is wordt
hier telnummer genoemd):
a. Importeren: import java.util.HashMap
b. Hashmap aanmaken: HashMap<TypeVoornaam, TypeTelnummer> naamHashMap
c. Initialiseren: naamHashMap = new HashMap<TypeVoornaam, TypeTelnummer> ()
d. Er iets in steken: naamHashMap.put(Voornaam, Telnummer)
e. Om een element te weten: naamHashMap.get(Voornaam)

Gooien en opvangen van fouten (exceptions)

Soms komen er bij het uitvoeren van programmas fouten tevoorschijn. Die fouten zijn eigenlijk
objecten die allemaal van n klasse zijn. Al de klassen die een fout als object hebben zijn subklassen
van Exception. Als er iets fout gaat wordt het volgende gedaan:
throws new Exception (boodschap);
Die Exception kan ook even goed IllegalArgumentException zijn, dat een subklasse van Exception is.
Bovenstaande opdracht kan je zelf ook in je methode implementeren, maar dan moet er na de
hoofding van je methode throws TypeException staan.
Zon fouten kunnen opgevangen worden. Dat kan door een stuk code in een try te plaatsen:
try { implementatie waar er mogelijk een fout kan gegooid worden}
catch (TypeException f) {als hij een fout heeft opgevangen van het type dat in de haakjes staat zal hij
hetgeen doen dat hier in de accolades staat, je kan hierbij gebruik maken van f, dat is de boodschap
die aan de fout verbonden is.}
catch (TypeException f) { je kan dus meerdere types van fouten opvangen}
finally { de code die hierin staat voert hij sowieso uit, of hij een fout opvangt of niet}.
Er zijn twee soorten exceptions. We hebben de checked exceptions en de unchecked exceptions. Met
de unchecked exceptions hebben wij meestal te maken. Als API bij het gebruik van een methode zegt
dat er een checked exception gegenereerd kan worden dan moeten we de implementatie ervan in
een try-catch vorm zetten.

Janos Braem

Samenvatting programmeren I aan UGent

Gecontroleerde (checked) fouten zijn fouten waar wij een probleem kunnen verwachten,
bijvoorbeeld iemand die het verkeerde getal ingeeft als parameter. In deze situaties kan de gebruiker
het probleem oplossen.
Ongecontroleerde (unchecked) fouten zijn fouten die onverwacht komen en zijn vaak een oorzaak
van slecht programmeren. (Alle subklassen van RunTimeException).

Programmeren met stijl

Enkele tips om te programmeren met stijl, lees deze even door, het is niet de bedoeling dat je dit van
buiten leert. Maar probreer er tijdens het programmeren rekening mee te houden.
1. Gebruik zinnige namen. Ook voor mutator- en accessormethoden: gebruik bv setIets() en
getIets(). Wanneer een boolean geretourneerd moet worden, gebruik isIets(). Is je naam al
zo goed en je moet een nieuwe verzinnen? Je kan ook this. Gebruiken.
2. Namen van klassen beginnen met een hoofdletter.
3. Namen van klassen zijn enkelvoudige zelfstandige naamwoorden (vb. dobbelsteen, oval, )
4. Namen van methodes en variabelen beginnen met een kleine letter. Als er meerdere
woorden in een naam voorkomen, zet je het tweede woord met een hoofdeltter.
5. Een constante wordt altijd in hoofdletters geschreven, om verschillende woorden hier te
onderscheiden kan je gebruik maken van underscores.
6. Een niveau inspringen betekent vier spaties.
7. Alle statements binnen een blok worden een niveau ingesprongen
8. Accolades voor klassen en methodes staan op een eigen regel met dezelfde inspringing. Bij
accolade-gebruik voor alle andere blokken moet de eerste accolade aan het eind van de regel
geschreven worden.
9. Als je weet dat je in een bepaalde situatie de accolades kan weglaten, doe het dan. Ben je het
niet zeker, laat ze dan staan (op het examen word je hiervoor niet afgestraft)
10. Plaats een lege regel tussen methodes en constructors.
11. Accolades bij een als dan vergelijking (zie paragraaf over als dan vergelijking)
12. Controleren van de conditite bij een while-lus (zie bijlage 1).
13. Wanneer een for-lus en wanneer een while-lus gebruiken (zie bijlage 2).
14. De klasse iterator wordt in programmeren 1 niet gebruikt, for each lus vervangt deze functie.
15. Om een programma met stijl te schrijven moet je er voor zorgen dat het programma door
iemand anders makkelijk aan te passen valt:
a. Hou samenhorende begrippen samen per klasse en gebruik zo weinig mogelijk
klassen.
b. Zorg voor een goede flexibiliteit: schrijf bij een tabel die 10 tekens telt in een for lus
dus beter i<tab.length in plaats van i<10.
c. Probeer code niet te dupliceren, dit wil zeggen dat er twee of meerdere keren in je
programma een stuk code voorkomt met dezelfde structuur. Je kan er ofwel een
methode van maken, ofwel de verschillende opdrachten samenvoegen door enkele
constanten aan te passen naar variabelen.
16. Het is vaak zeer handig om, nadat je programma getest is, je code te herlezen en te
refactoren: dit wil zeggen dat je de broncode nog eens bekijkt en bedenkt of er dingen
anders (beter) geschreven kunnen worden.
17. Je moet een klasse inkapselen, ervoor zorgen dat enkel aan de buitenwereld wordt
blootgegeven wat blootgegeven moet worden. Maak velden bijvoorbeeld steeds private.
Want zij verraden hoe je bepaalde methodes gebruikt, en dat hoeft niet. Waarom is dit zo?
Als je dit doet, dan gaan andere klassen gebruik maken van je velden en andere functies die
je te veel hebt blootgegeven, en dat zorgt voor een grotere afhankelijkheid (de klassen zijn
afhankelijker van elkaar). Dit is heel complex, onduidelijk en moeilijker aan te passen voor
een buitenstaander.

Janos Braem

Samenvatting programmeren I aan UGent

18. Als je een functie wilt toevoegen aan een programma en je weet niet in welke klasse je ze
best schrijft kan je best het volgende trucje gebruiken: een klasse die verantwoordelijk is
voor het opslaan van gegevens is ook verantwoordelijk voor het bewerken ervan.
19. Denk vooruit, denk goed na op welke manier een klasse in het vervolg nog kan aangepast kan
worden. Stel dat je bijvoorbeeld iets afdrukt met system.out, maar dat dit in het vervolg via
return handiger zou zijn, pas het dan nu al aan.
20. Probeer methoden zo kort mogelijk te houden en te beperken tot 1 taak. Waardoor een
andere programmeur je code makkelijker kan lezen en begrijpen.
21. Soms moeten methoden en klassen gesplitst worden omdat ze (doordat er zodanig veel
dingen worden bijgeschreven) te lang worden. Dit gebeurt in twee stappen: eerst splitsten
(en controleren of de functionaliteit van je programma hetzelfde is) en dan pas je
programma verbeteren (door nieuwe functies toe te voegen).

Overerving
Basis
Als je van verschillende klassen enkele methoden en velden gemeenschappelijk hebt is de basis voor
overerving gelegd. Overerving zorgt namelijk voor een betere structuur in je programma. Het
programma wordt dan ook veel gebruiksvriendelijker en overzichterlijker. Hoe ga je te werk?
De superklasse is de gemeenschappelijke klasse die verschillende subklassen heeft. Die superklasse
heeft een aantal methoden en velden, alle subklassen hebben die dan ook. Alleen kan je aan elke
subklasse bijkomende individuele eigenschappen geven. Stel dat je bijvoorbeeld een klasse slangen
hebt, dan kan je instellen dat die geen poten en schubben hebben, verder kan je dan met
verschillende subklassen verschillende soorten slangen gaan definiren met elk hun eigen
eigenschappen.
Een subklasse begint met: public class subklasseNaam extends superklasseNaam.
Bij de initialisatie ga je dan alle parameters die je nodig hebt om een object van de superklasse aan te
maken naast elkaar zitten onder de vorm: super(para1, para2). Verder verloopt alles hetzelfde.
Enkele regels:
1. Een subklasse heeft alle methoden van de superklasse (deze moet je dus niet opnieuw
schrijven).
2. Als je een object nodig hebt van de structuur in een methode buiten de structuur gebruik je
steeds de naam van de superklasse. Als je een tabel wilt maken van slang gebruik je als type
best Slang en niet Ratelslang bijvoorbeeld, zo kunnen alle slangen toegevoegd worden en
niet alleen ratelslangen.
3. In sommige situaties kan je die super niet toepassen. Dan kan je de velden die je nodig hebt
veranderen in protected (enkel zichtbaar voor de klasse zelf en subklassen ervan). Maar het
is misschien beter om met getters en setters te werken.
4. Een object van de superklasse en een object van een subklasse hebben in principe hetzelfde
type. Als het bijvoorbeeld toch niet werkt, kan je het volgende gebruiken: c = (Type) d. Maar
dan moet d wel degelijk van het type zijn dat binnen de haakjes aangegeven staat. Dit laatste
liever niet gebruiken.
5. Elk type heeft een superklasse, namelijk de klasse Object. Vb.: public class naamKlasse is
eigenlijk public class naamKlasse extends Object. (extends Object mag weggelaten worden.)
6. Als we een methode van een superklasse willen gebruiken moeten we het volgende
toepassen: super.naamMethode (parameters).
Opmerking: als een subklasse een lege constructor heeft mag die volledig weggelaten worden.

Dynamische en statische types

Er zijn twee soorten types:
1. Dynamische types zijn de types van het object dat op dit moment is opgeslagen in de
variabele. Dit zijn types die gebruikt worden bij het uitvoeren van het programma. Java zal
10

Janos Braem

Samenvatting programmeren I aan UGent

dan namelijk naar je subklasse kijken en minder naar je superklasse. Soms worden
dynamische types ook gewoon klassen genoemd.
2. Statische types zijn de gedeclareerde types. Dit zijn types die enkel belangrijk zijn bij het
compileren, waar de superklasse ook belangrijk is. Soms worden statische types ook gewoon
type genoemd.
De compiler zal altijd kijken naar het statische type, maar bij de uitvoering zal naar het dynamisch
type worden gekeken. Als je een methode in een subklasse hebt, dan moet je die in principe ook in
de superklasse steken, want anders zal de compiler dat niet begrijpen.
Vb. Klasse heeft twee subklassen: klasse 1 en klasse 2. Stel dat klasse en klasse 1 beiden een methode
print() hebben en klasse 2 niet. Dan zal bij het uitvoeren van die methode op een object van klasse 1,
de methode van klasse 1 zelf gebruikt worden. Als dit bij klasse 2 gebeurt, dan hij de overgerfde
methode van klasse gebruiken.
Waarom is dit zo? We hernemen bovenstaand voorbeeld. Als je nu buiten de sub- en superklassen
ergens de methode print toepast op een object van klasse, dan kan het zijn dat jij weet dat daar
enkel objecten van klasse 1 zullen gebruik van maken (omdat jij dat zo programmeert). De compiler
weet dat echter niet. Dus moet er (stel dat de methode toch op een object van klasse 2 wordt
toegepast) een methode in klasse staan zodat de subklassen daar zogezegd gebruik van kunnen
maken.

Abstracte klassen en interfaces

Een abstracte methode is een methode die eigenlijk wel nodig is maar enkel omdat de compiler dan
tevreden zou zijn. Het zijn methoden die bestaan, maar die eigenlijk niet gebruikt worden omdat
steeds de methodes van de subklassen worden geschreven.
Dit doe je als volgt: public abstract class KlasseNaam. Die moet je steeds doen vanaf er minstens n
abstracte methode in zit. Een abstracte methode wordt als volgt geschreven: abstract public void
add();. Hierbij moet je geen accolades en ook geen implementatie geven.
Er kunnen nooit objecten van een abstracte klasse worden aangemaakt. Dat wordt volledig met hun
subklassen geregeld. Toch moet er vaak een constructor zijn omdat de subklassen die met de super
methode nodig hebben.
Een interface is een klasse die volledig abstract is. Dit wil zeggen dat er geen enkele niet-abstracte
methode in voorkomt. Een interface heeft dus ook geen constructor of implementatie. Er kunnen
geen objecten aangemaakt worden van een interface.
Je maakt een interface als volgt: public interface Naam. De verschillende methoden in die erin
voorkomen worden dan als volgt gegeven: public void doeIets (String s); (merk op dat er een punt
komma staat en dat er geen implementatie is). Het is ook niet verplicht om de waarde public te
gebruiken.
Die interface kan door een andere klasse gebruikt worden. Als een andere klasse een interface
implementeert, moeten alle methoden van de interface in die klasse voorkomen en wordt dat bij de
hoofding als volgt aangeduid: public class Naam implements Pipi.
Het is als student van programmeren I nog niet altijd duidelijk wat precies het nut van een interface
is. Het zorgt voor een betere structuur en het maakt ook meervoudige overerving mogelijk (een
klasse heeft meer dan 1 superklasse). Uiteindelijk moet je niet echt zelf kunnen bepalen wanneer een
interface echt nodig is. Meestal is het uit de context van een opgave af te lezen of het gebruik van
een interface al dan niet aangewezen is. Maar dit is dan ook enkel bij programmeren I.

11

Janos Braem

Samenvatting programmeren I aan UGent

Bijlage 1: while-lus met dubbele conditie

Als je bij een while-lus een dubbele conditie plaatst, moet je het resultaat per conditie retourneren
(bv met een als dan vergelijking). Een voorbeeld vind je bij public int IndexOf uit AutolijstTest uit
hoofdstuk 6.
Dan komt vaak de vraag, wat moet er bij de if-lus in de voorwaarde?
Wel je past het volgende trucje toe:
/
Voorwaarde 2 OK
Voorwaarde 2 niet OK

Voorwaarde 1 OK

Voorwaarde 1 niet OK

Dan vul je de tabel in en kijk je wat er in de vakjes moet. Dan kan je makkelijker zien welke
voorwaarde je moet gebruiken.
Hier is er ook nog een opmerking te maken ivm programmeren met stijl:
public boolean isPriem (int getal) {
int deler = 2;
while (deler * deler <= getal && getal % deler != 0)
deler ++;
return deler*deler > getal;
}
Is veel beter geprogrammeerd dan:
public boolean isPriem (int getal) {
int deler = 2;
while (deler * deler <= getal && getal % deler != 0)
deler ++;
if (deler*deler > getal)
return true;
else
return false;
}

12

Janos Braem

Samenvatting programmeren I aan UGent

Bijlage 2: while of for-lus?

Alles wat je in Java met een for-lus kan doen, kan je ook met een while noteren, en omgekeerd.
Wanneer je welk type lus gebruikt is dus in vele gevallen een kwestie van persoonlijke smaak. Toch
kan je hier best een aantal bestaande conventies volgen.
1. In principe: enkel for-lus als je vooraf al weet hoeveel hij moet gedaan worden. Vb: bepaal de
som van alle gehele getallen van 50 tot en met 100.
2. Als er een dubbele conditie is gebruik je beter een while. (vergeet niet bij het overlopen van
een tabel ook als voorwaarde in te stellen dat hij niet verder mag gaan dan de tabel lang is!)
3. Als je de tellervariabele (vaak i) nog nodig hebt na de lus gebruik je ook beter een while-lus.
4. Als de eindwaarde van de teller afhangt van iets wat niet met de teller te maken heeft
gebruik je best ook een while-lus (bv: stop met tellen bij de eerste positie van de tabel waar
zich een negatief getal bevindt.)
5. Wanneer je in de for-lus een nieuwe waarde aan de teller toewijst, gebruik je best een while
met dubbele conditie.

13

Janos Braem