Programmeren in Java/Inleiding
Welkom in de cursus Programmeren in Java! In deze cursus kunt u leren hoe u eenvoudige programmaatjes schrijft in de programmeertaal Java. Deze basis is voldoende om verder te gaan naar de geavanceerdere delen van Java.
Voordat u met de cursus kan beginnen, moet u eerst de Java Development Kit installeren, ook wel kortweg JDK genoemd. Deze stelt u in staat uw programma's te bouwen. Zie ook het hoofdstuk Installatie voor meer informatie over het installeren van de JDK.
Deze inleiding geeft u wat meer informatie over het concept van objectgeoriënteerd programmeren, ook wel OO (Object Oriented) Programming genoemd, over de speciale kenmerken van de taal Java, en over het maken en uitvoeren van zelfgemaakte programma's in het algemeen.
Object-georiënteerd programmeren[bewerken]
Om een computer te programmeren, d.w.z. verschillende instructies achter elkaar zetten in een programma, moest men vroeger veel werk verrichten. Een computer werkt namelijk binair, d.w.z. met enen en nullen. Om een programma te schrijven moest men dus een heel lange serie van enen en nullen achter elkaar zetten. Dit is echter een zeer tijdrovende bezigheid, en het gevolg was dat er niet veel programma's waren en dat het schrijven van een nieuw programma zeer veel tijd in beslag nam. Daarom heeft men de programmeertaal uitgevonden, die programmeren een stuk eenvoudiger maakt.
Men probeert programmeertalen zo eenvoudig mogelijk te maken, en tegelijk ervoor te zorgen dat ze een zo groot mogelijk rendement hebben. Dit doet men door analogieën met de werkelijkheid in een programmeertaal te steken. Een programma moet namelijk niet alleen goed draaien, maar ook eenvoudig te begrijpen zijn. Daarom heeft men het Object-geörienteerd (OO) programmeren uitgevonden.
Het centrale concept bij OO is het Object. Om een voorbeeld te geven van een Object: kijk even rond u heen. Wat ziet u? Een pen, een bureau, een stuk papier, ... Dit zijn allemaal objecten. Op eenzelfde manier worden objecten in een OO-taal gebruikt.
Bovendien kunnen Objecten eigenschappen overerven. Om het principe van overerving te demonstreren, kijkt u even naar een fruitschaal. Wat ziet u? Appelen, peren, sinaasappelen, ... Al deze "objecten" kunnen onder de noemer "Fruit" vallen. Fruit zelf valt dan weer onder de noemer "Voedsel". Voedsel heeft één groot kenmerk: het kan gegeten worden. Fruit erft deze eigenschap over. Een Appel erft dan ook deze eigenschap over, en het gevolg is dat u de Appel kan eten. Een soortgelijk principe wordt toegepast in OO. Het moederobject, waarvan alle objecten overerven, heet dan toevallig of niet ook Object.
Objecten in OO kunnen vrij realistisch zijn, zoals in het voorbeeld met het fruit, maar ze kunnen ook abstracter worden, zoals bijvoorbeeld een lijstje, een stukje tekst, een bestand, een open netwerkverbinding, ... Wanneer u objecten maakt, probeer dan altijd de analogie met de werkelijkheid in het achterhoofd te houden.
Het is onmogelijk om objecten uit het niets te grijpen. Zo is dat ook in een OO-taal. Om objecten te maken, moet u eerst een soort blauwdruk schrijven voor dat object, een klasse. Dit is wat u doet in de programmeertaal, in dit geval Java. In deze klasse definieert u wat een bepaald object kan en doet, en dan kunnen er eindeloos veel objecten aangemaakt worden. Om terug te komen op het voorbeeld met het fruit: als u eenmaal weet hoe u een appel moet "maken", kan u er eindeloos veel "maken", met verschillende groottes, kleuren en zelfs andere smaken! Dit is de kracht van object-georiënteerd programmeren.
Compileren en de kracht van Java[bewerken]
Zoals eerder gezegd, een computer verstaat alleen enen en nullen. Dus hoe kan een computer ooit een programma uitvoeren in een programmeertaal met complexe dingen zoals objecten? Het antwoord is vrij simpel: voordat je iets met een programma kan doen, moet de code eerst worden omgezet naar enen en nullen. Dit proces heet compileren.
Bij een "klassieke" programmeertaal, bijvoorbeeld C++, wordt de programmacode omgezet naar code die direct door een computer te begrijpen is. Dat is uiteraard gemakkelijk, want er is geen extra programma nodig om de code uit te voeren. Maar dit betekent wel dat code die voor een systeem is geschreven (bv. Microsoft Windows) niet werkt op andere systemen (bv. Apple macOS of Linux). Er moeten dus aparte versies voor die systemen gecompileerd worden, en vaak dient de programmacode eerst worden aangepast omdat deze systemen anders werken.
Met Java is het de bedoeling om platformonafhankelijke programma's te maken. Dat wil zeggen dat een programma dat je thuis maakt in Java zal draaien op jouw besturingssysteem, maar ook op andere besturingssystemen, zonder aanpassing.
Java lost dit probleem op door gebruik te maken van een compiler die weliswaar een binair bestand aanmaakt, maar waarin de opdrachten nog steeds platformonafhankelijk zijn. In plaats van de broncode rechtstreeks om te zetten naar machinetaal, zoals bij C of C++ e.d. het geval is. Dit heeft tot gevolg dat de Java-compiler geen stand-alone uitvoerbaar bestand (een .exe onder Microsoft Windows) maakt. In de plaats daarvan compileert de Java-compiler een bestand in bytecode. Dit bestand wordt dan ingelezen door een interpreter (Java Virtual Machine, JVM) dat op elk platform waar java programma's op moeten draaien geïnstalleerd moet worden. De JVM leest de bytecode, interpreteert de opdrachten en voert dan het programma uit.
De JVM is wel degelijk afhankelijk van het platform, maar is beschikbaar voor veel verschillende systemen, is gratis en hoeft slechts eenmalig te worden geïnstalleerd.
Het uitvoeren van bytecode gaat weliswaar iets trager dan het doorsnee 'native' programma, oftewel een programma dat specifiek voor één systeem is geschreven (onder Microsoft Windows een .exe), maar dit is in het dagelijks gebruik nauwelijks merkbaar.