Hoofdstuk 3: Programmeertalen en Java

Programmeren kan een complexe taak zijn; het vereist plannen, oefening en soms wat gespecialiseerde hulpmiddelen. Als je denkt dat dit zoals een taak is die gebouwd construeert, heb je gelijk; het maken van een software programma is zoals het bouwen van een kantoorgebouw of shopping center. Je moet het eerst bestuderen, plannen, werknemers inhuren, gespecialiseerde hulpmiddelen kopen, en dan het gebouw construeren. Maar het werk eindigt niet daar, je moet constant je constructie (gebouw of software) veranderen naar de veranderende noden van de klant.

Evolutie van programmeertalen

De bedoeling van programmeren is om instructies te schrijven zodat een computer deze kan uitvoeren. Het vervelende is dat de computer enkel programmeerbaar is in 1'en en 0'en. Op deze manier een computer programmeren is onbegonnen werk.

Zoals je gezien hebt in het vorige hoofdstuk, is programmeren een manier om een verzameling van instructies te maken voor een computer. Om deze instructies te maken, maakt de programmeur gebruik van een programmeertaal om broncode te schrijven. Deze broncode wordt dan vertaald naar machinecode.

Machince code bestaat uit 1'en en 0'en, iets wat een CPU heel goed kan begrijpen. Helaas verstaan wij dat niet goed en is het voor ons heel complex om programma's te schrijven in 0'en en 1'en. Hierdoor is de mens programma's gaan ontwerpen die programma's maken. De programmeur schrijft een programma in voor de mens verstaanbare stappen, het programma vertaalt dan de stappen in machinecode.

Programmeurs kunnen vandaag de dag kiezen uit een ganse reeks van programmeertalen, met elk zijn eigen capaciteiten, flexibiliteit en gebruikersgemak. Ondanks deze verschillen zijn programmeertalen gelijk in 1 eigenschap: elke programmeertaal bevat zeer strikte regels die de programmeur moet toepassen. Bijvoorbeeld, programmeertalen vereisen dat de programmeur:

• informatie geeft in een welbepaalde volgorde of structuur
• speciale symbolen gebruikt
• leestekens gebruikt

Deze regels noemen we de syntax van de programmeertaal en varieert zeer sterk van programmeertaal tot programmeertaal. Syntaxfouten zijn dus fouten op die strikte regels van de programmeertaal. Je kan syntaxfouten vergelijken met spellingsfouten binnen onze taal.

Gebaseerd op de evolutie kan je programmeertalen indelen in 2 kategorie\"en: machinetalen of assemblertalen en hoger-niveautalen. Programmeertalen worden meestal uitgedrukt in generaties.

Eerste generatie programmeertalen

Deze vorm omvat de instructies te schrijven volgens 0'en en 1'en. Fabricanten van chips (e.g. Intel of ARM) leveren gigantische handleidingen met alle instructies die de CPU kan uitvoeren. Vroeger waren deze handleidingen heel kort, aangezien een CPU maar uit een handvol instructies kon uitvoeren en werd een computer op een dergelijke manier geprogrammeerd. Tegenwoordig zijn de capaciteiten van CPU's zo uitgebreid dat op dezee manier programmeren ondoenbaar is geworden.

In de beginjaren van de computer was dit de enige manier om een computer te programmeren. Programma's werden gemaakt in ponskaarten. Doorprikken van een gaatje was een 1 en het niet doorprikken een 0. Op deze manier werden machinecode gemaakt die dan het gewenste algoritme uitvoerde.

Tweede generatie programmeertalen

Deze vorm omvat dat de instructies in de vorm van 0'en en 1'en voorgesteld zijn door korte Engelstalige afkortingen. Bijvoorbeeld om 2 waarden die in een register zijn opgelagen op te tellen voldoet: $add R1, R2, R1$

Men noemt deze taal ook wel Assembler. Dit maakt het programmeren leesbaarder, maar voldoet niet om complexe bewerkingen uit te voeren (e.g. zoeken naar woorden in een stuk tekst). Een speciaal vertaalprogramma of compiler is nodig om de assembler te vertalen naar machinecode (0'en en 1'en).

Derde generatie programmeertalen

Hoger-niveautalen maken het programmeren aanzienlijk gemakkelijker. Deze talen gebruiken een syntax dat meer gelijkaardig is aan een menselijke taal maar dat nog meer abstracter is. Mensen kunnen veel gemakkelijker dergelijke broncode lezen, schrijven en verstaan. De instructies in een hoger-niveautaal moeten nog wel vertaald worden in machinecode. 1 lijn van een hoger-niveautaal resulteert meestal in vele lijnen machinecode.

De belangrijkste talen van die soort waren BASIC en C. Hoewel de syntax vrij verschillend is, is het niet moeilijk om te achterhalen wat de programma's doen.

Hieronder vind je twee fragmenten die hetzelfde doen, maar in een andere taal.

Een fragment C code is als volgt:

if (d > 15)
{
    do
    {
        d--;
    } while (d>1)
}

Een fragment BASIC code is als volgt:

IF d& > 15 THEN
    DO WHILE D& > 1
         D& = D& - 1
    LOOP
END IF

Een ander belangrijk voordeel is dat men broncode kon uitwisselen. Indien je een compiler of interpreter had voor je machine, kon je een stuk broncode van iemand anders gebruiken. Je compileerde dan een uitvoerbaar bestand van die code dat je kon draaien op je eigen computer. Deze manier noemt men {\bf porting}.

Er bestaan veel derde-generatietalen. De belangrijkste zijn:

• C. Deze taal wordt beschouwd als de volbloed onder de programmeertalen. C code en de C compiler produceert programma's die heel snel en efficiënt zijn. Hierdoor maakt het de C een krachtige taal is. Maar C is heel moeilijk te onderhouden, gezien grote programma's al snel tienduizenden lijnen code kunnen halen.
• FORTRAN. Deze taal werd vroeger (en nu nog altijd) veel gebruikt om numerieke berekenening te doen (e.g. berekenen van luchtstromen, integralen,...)
• C++. C++ is de object-gerichte versie van C. Men gaat eerder objecten maken. Net zoals C, is C++ heel krachtig en heel efficiënt.
• Java. Java is een object-georienteerde programmeertaal die specifiek gemaakt is om programma's te maken die op verschillende soorten computers kunnen uitgevoerd worden. Java werd vroeger heel veel gebruikt voor internetapplicaties, Java-applets, gezien men op voorhand niet weet op welke computer het programma zal draaien.

Vierde generatie programmeertalen

Derde-generatie talen zijn op zich al een vooruitgang waarin een beginnende programmeur al kleine programma's kan schrijven. Het wordt echter moeilijk wanneer programma's heel groot worden (in de grootteorde van een Windows besturingssysteem). Vierde-generatie talen zijn gemakkelijker te gebruiken en zijn meer gericht naar het oplossen van problemen dan het ontwerpen van algoritmes. Ze gebruiken een tekstuele omgeving of een visuele omgeving om te programmeren. In een tekstuele omgevin gebruikt programmeur Engelstalige begrippen om te programmeren. Meer nog de programmeur kan zijn eigen taal omschrijven via objecten en methodes. Elk object heeft een naam, eigenschappen en heeft methodes. De methodes kunnen opgeroepen worden op het object.

Voorbeeld: deur.open of document.print, student.verlaatlokaal

Voorbeelden van dergelijke programma's zijn programma's die veel gebruikt worden voor personeelsbeleid (human resources management), verkoopbeheer (customer relatationship management) en supply chain management.

In een visuele omgeving kan de programmeur heel snel grafische interfaces bouwen, zoals knoppen, vensters, tekstvensters, enz... Wanneer de programmeur de grafische interface ontworpen heeft, kan hij deze elementen gebruiken in een zijn programma.

Meeste derde-generatietalen en vierde-generatietalen werken in een geïntegrerende ontwikkelingsomgeving (Eng. Integrated Development Environment of IDE). IDE's voorzien de programmeur met allerlei hulpmiddelen om snel en efficiënt programma's te bouwen. De belangrijkste IDE's zijn Microsoft's Visual Studio en Sun's Java Studio.

Java

Java werd ontwikkeld door Sun Microsystems (nu Oracle) en was bedoeld om programma's te maken in ingebedde elektronica in elektrische toestellen. Het werkt herontwikkeld voor het maken van Web toepassingen.

Java is enorm populair. Zijn snelle groei en brede acceptatie komt uit het feit dat je een programma kan schrijven en het ergens anders kan uitvoeren. De ontwikkelaar beschrijft Java als volgt:

Java is a simple, object oriented, distributed, interpreted, robust, secure, architecture neutral, portable, high performance, multithreaded and dynamic programming language.

Java wordt niet enkel gebruikt om Web toepassingen, maar ook voor robuste tijdskritische toepassingen. De communicatie en de controle met de Mars Rover werd in Java geprogrammeerd.

Java is nu heel populair voor toepassingen met Web servers. Deze toepassingen verwerken gegevens, voeren berekeningen uit en genereren dynamische webpagina's. Veel commerciële websites zijn ontwikkeld gebruik makende van Java.

Java is een heel versatiel programmeertaal. Je kan het gebruiken voor het ontwikkelen van toepassingen voor computers, servers en smartphones. Het Android besturingssysteem in smartphones is ontwikkeld met behulp van Java.

De Java Taal Specificatie, API, JDK en IDE

• Computertalen hebben een strikte set van regels. Als je deze regels niet volgt, dan kan de computer je programma niet begrijpen.
• De Java Taal Specificatie is een technische definitie van de syntax en de semantiek van de taal. Je kan de complete specificatie vinden op http://docs.oracle.com/javase/specs/.
• De application program interface of API bevat voorgedefiniëerde klassen en functies om Java programma's te ontwikkelen.
• Java is een complete en krachtige programmeertaal dat op vele manieren kan gebruikt worden. Het is beschikbaar in 3 edities:
  • Java Standard Edition (Java SE) om toepassingen te ontwikkelen. De toepassingen kunnen op zichzelf uitgevoerd worden (standalone)
  • Java Enterprise Edition (Java EE) om servertoepassingen te maken zoals Java Servlets, Java Server Pages (JSP)
  • Java Micro edition (Java ME) om applicaties te maken op mobiele apparaten zoals smartphones.

Een eenvoudig java programma

• Een eenvoudig java programma kan bijvoorbeeld op "Welkom bij Java!" op het scherm tonen.

Codefragment 1.1

• De eerste lijn definieert een klasse. Hoewel we hier niet dieper op in gaan, heeft elk Java programma een klasse. Elke klasse heeft een naam en er is een conventie dat elke klasse begint met een hoofdletter. In dit voorbeeld is de naam van de klasse Welkom.
• De tweede lijn definieert een functie, die we methode zullen noemen met de naam main. De main methode is het startpunt van het programma - daar begint het programma.
• Een methode is een constructie die een verzameling van statements bevat. Hier bevat de main methode het statement System.out.println. Dit statement zal de tekst Welkom bij Java! op het scherm tonen.
• In Java wordt een stukje tekst ook wel in het Engels String genoemd. Vanaf hier wordt een stuk tekst ook wel string genoemd.
• Een string wordt tussen dubbele aanhalingstekens geplaatst.
• Elk statement in Java eindigt met een ;. Dit analoog aan een taal, waarbij na elke zin een punt zetten.
• Gereserveerde woorden of sleutelwoorden zijn woorden die een speciale betekenis hebben voor de compiler en mogen niet voor andere doeleinden gebruikt worden in een programma. Bijvoorbeeld is class een sleutelwoord dat het begin van dat stukje code aanduidt. De compiler weet dat na dit sleutel woord het programma komt. Ander sleutelwoorden die je ook ziet zijn public, static, void.
• De derde lijn is een commentaar: dit documenteert de code en voorziet ze van informatie. De compiler zal commentaar volledig negeren aangezien ze geen code zijn. Ze zijn bedoeld om de code te voorzien van documentatie zodat de auteur notities kan maken en deze leesbaar zijn voor andere gebruikers.
• In Java kan commentaar voorafgaan door twee slashes //, dat is een commentaar op één lijn. Block commentaar wordt geschreven tussen /* en */. Enkele voorbeelden van commentaar zijn

• De accolades in de code geven een block of blok aan. Een blok groepeert componenten in een programma. Elk blok start met een open accolade ({) en eindigt me sluit accolade (}).

  • Tip Een open accolade moet gematched zijn met een sluit accolade. Je doet er dus goed aan wanneer je een open accolade typt, direct ook een sluit accolade te typen.

  • Opgelet Java is hoofdletter gevoelig. Het zou verkeerd zijn om de methode main te vervangen door Main.

• Er veel speciale tekens die voorkomen in een programma (e.g. { },//,;). Deze worden in elk programma gebruikt.

• Zoals elke (programmeer-) taal heeft Java regels om juist schrijven. We noemen deze ook syntax regels. Als je programma niet voldoet aan één of meerdere regels dan zal de Java compiler de syntax fouten bevatten.
• Je kan bijvoorbeeld het programma herschrijven om 3 keer iets op het scherm te tonen.

• Je kan ook wiskundige berekeningen uit voern en het resultaat op het scherm tonen. Het volgend stukje code zal de volgende uitdrukking evalueren: $\frac{10.5 +2 \times 3}{45-3.5}$:

Creëren, compileren en uitvoeren van een Java programma

• Je kan een Java-programma maken in een eenvoudige teksteditor zoals notepad, maar je gebruikt beter een geavanceerde teksteditor zoals (Notepad++, Atom,...). Bij geavanceerde teksteditors kan de code duidelijk gemaakt worden aan de hand van kleuren: syntax highlighting.
• Eens je het programma het opgeslaan met een extensie .java kan je het uitvoeren. Let wel, de naam van het bestand moet exact de naam hebben als de naam van de klasse. Bij het bovenstaande codefragment 1.1 moet dit Welkom.java zijn aangezien de naam van de klasse gelijk is aan Welkom.
• Java is een hogere programmeertaal. Een programma geschreven in Java moet vertaald worden naar machinecode zodat de CPU dit kan begrijpen. We hadden dit al gezien als compileren.
• Java gebruikt een compiler die het java-bestand omzet naar een class-bestand. Hiervoor dien je de Java Development Kit te installeren: Java JDK 8. De compiler genereert bytecode, dit is een tussentaal. Een Java virtuele machine zal de tussentaal omzetten naar machinecode. Deze laatste omzetten gebeurt real-time wanneer het programma wordt uitgevoerd.
• Dit heeft als voordeel dat een class-bestand kan uitgewisseld worden over verschillende computers en uitgevoerd kan worden als de juiste Java Virtuele Machine (JVM) geinstalleerd is. Zo biedt Oracle (de huidige eigenaar van Java) verschillende JVM's aan voor verschillende computers en besturingssystemen (Windows, Mac OSX, Linux,...).

• Het compileren van een java programma via de command line (Opdrachtprompt in Windows, terminal in Mac OSx) gaat als volgt: javac Welkom.java

• Dit genereert een .class-bestand waarin de bytecode beschreven is. Deze bytecode kan uitgevoerd worden door de Java Virtual Machine: java Welkom

Figure of compiling (Fig 1.9:DL)

• Opgelet
  • Gebruik niet de extensie .class bij het uitvoeren. Gebruik java NaamKlasse!
  • Als een klasse niet bestaat, dan zal je de volgende foutmelding krijgen NoClassDefFoundError. Dit zal voorkomen bij java Welkome of java welkom. Als er geen main-methode is of je hebt een typfout gemaakt in main (bv. Main) dan zal er een NoSuchMethodError melding komen.

Compileeromgevingen

• Compileren via de zogenaamde Opdrachprompt (Engels: Command Prompt) is heel tijdrovend en onoverzichtelijk
• Voor het maken van programma's worden bijna altijd programmeeromgevingen gebruikt. In het Engels noemen we deze Integrated Development Environment of IDE. Ze bieden heel wat functionaliteit en bieden een overzicht wanneer het programma uit meerdere klassen bestaat.
• Voorbeelden van omgevingen zijn NetBeans, Eclipse, BlueJ. Eclipse is veruit de meest gebruikte omgeving maar is wel complex in zijn gebruik. We zullen BlueJ gebruiken gezien dit een specifiek gemaakt is voor didaktische doeleinden.

Programmeerstijl en documentatie

• Programmeerstijl refereert naar stijl van je code en de manier hoe je de code vormgeeft naar analogie van de layout van een tekstdocument. Dit heeft op geen manier effect op het compilatieproces of de uitvoering, maar verhoogt de leesbaarheid van je code.
• Documentatie is het geheel van tekst dat je bij je code schrijft om deze te verduidelijken voor andere gebruikers.
• Er zijn 2 manieren om commentaar aan te duiden
  • // : lijn van commentaar
  • /* ... */ : blok van commentaar

Inspringen en spaties

• Een consistente gebruik van inspringen en spaties maakt de code leesbaar en makkelijker om te corrigeren voor fouten.
• Inspringen wordt gebruikt om structurele relaties te tonen binnen de onderdelen van een programma.

Slecht gebruik

Goed gebruik

• Spaties kunnen gebruikt worden voor lange statements

Slecht gebruik

System.out.println(3+4*4);

Slecht gebruik

System.out.println(3 + 4 * 4);

Blokstijlen

• Een blok is een groep van statements omgeven door accolades. Er zijn twee veel gebruikte stijlen, next-line en end-of-line.

next-line stijl

public class Test
{
  public static void main(String[] args)
  {
    System.out.println("next-line stijl");
  }
}

end-of-line stijl

public class Test{
  public static void main(String[] args){
    System.out.println("next-line stijl");
  }
}

• Hoewel de next-line stijl duidelijker is en overzichtelijker om blokken te definiëren, maakt het de code heel uitgerekt. We zullen in deze cursus de end-of-line stijl hanteren.
• Opnieuw, het gebruik van een andere stijl is een persoonlijke voorkeur. Het zal het compilatie en de uitvoering van een programma niet beïnvloeden.

Fouten tijdens het programmeren

Syntaxfouten

• Fouten die gedetecteerd worden door de compiler worden syntaxfouten of compileerfouten genoemd. Dit zijn fouten in de constructie van de code of fouten tegen de taal (e.g. mistypen van een woord, vergeten van ; of verkeerd gebruik van { }).

TODO figuur 1.10 LIANG

Runtimefouten

• Runtime fouten zijn fouten dat het uitvoeren van het programma zal foutief afsluiten. Ze komen voor wanneer het programma aan het uitvoeren is wanneer de JVM een instructie krijgt die hij onmogelijk kan uitvoeren.
• Veel voorkomende fouten hebben te maken met invoer, wanneer het programma een invoer krijgt dat hij niet verwacht. (bv. het programma verwacht een geheel getal, maar er wordt een stuk tekst meegegeven)
• Een vaak voorkomende fout bij wiskundige berekeningen in Java is het delen door nul. Hoewel het programma zal compileren (er is geen fout gemaakt tegen de taal), het programma niet kunnen uitgevoerd worden.

Logische fouten

• Dit zijn fouten die voorkomen als het programma een uitvoer geeft die je niet verwacht. In dit geval compileert de code en wordt de code zonder fouten uitgevoerd, maar de uitvoer beantwoordt niet aan wat je zou verwachten.
• In onderstaand voorbeeld wordt een waarde in graden Celcuis omgezet naar graden Fahrenheit

• Het programma zal 67 op het scherm vertonen, maar in werkelijkheid moet dit 95.0 zijn. Het is namelijk zo dat 35 graden Celcius gelijk is aan 95 graden Fahrenheit.
• In Java is het zo wanneer er gedeeld wordt door twee gehele getallen dan wordt de gehele deling uitgevoerd: 9 / 5 wordt 1. Terwijl volgens de fysica de reële deling dient gebruikt te worden. De makkelijkste manier om dit te doen is om dit te gebruiken 9.0 / 5. Het resultaat van die deling wordt 1.8.

Vaak voorkomende fouten

• Ontbrekende accolades. Accolades ({ }) duiden het einde en begin aan van een blok code. Als er een einde accolade gemist wordt, dan verwacht de compiler dat er nog code volgt.
  • Typ daarom altijd de sluit-accolade direct na je ook een open-accolade schrijft.
  • Sommige IDEs zullen onmiddelijk dit gaan doen.
• Ontbrekende punt-komma's (;). Elk statement moet eindigen met een ;. Een beginnende programmeer vergeet vaak een ; als het statement de laatste is een blok code.
  • public static void main(String[] args){ System.out.println("Programmeren is leuk!"); System.out.println("Eerst de basics!"); System.out.println("Probleem gestuurd") //vergeten ; }
    
• Ontbrekende dubbele aanhalingstekens (""). Een stuk tekst of string moet omgegeven zijn door dubbele aanhalingstekens ("").
  System.out.println("Hallo Java); //ontbrekende "
  
• Foutief gespelde namen. Sleutelwoorden en variabelenamen moeten correct gespeld worden. Bovendien is Java hoofdlettergevoelig. De methode Main is een andere methode dan die van main, die nodig is voor het begin van een programma.

Ontwikkeling van programma's in BlueJ

BlueJ is een programmeeromgeving die ons toelaat om op een grafische manier en gebruiksvriendelijke manier klassen en programma's te schrijven. Hier zullen we kort beschrijven hoe we een project en een java programma aanmaken.

Creatie van een Java project

Alvorens een Java programma te maken, moet je eerst een project maken. Een project is zoals een map in windows verkenner (op een PC) of finder (op Mac) waarin de borncode zich bevindt. Wanneer je BlueJ voor het eerst opstart krijg je het volgend scherm:

Op een project te starten:

1. Klik je op Project, Nieuw Project
2. Je geeft het project een naam en je kan het project ergens opslaan op je computers

Creatie van een Java klasse

Wanneer je een project hebt aangemaakt, kan je java-programma's schrijven. Idealiter maak je voor elke aparte oefening of probleem een project. Eens je een project hebt gemaakt, kan je klasses beginnen maken. Elk Java-programma heeft een klasse. We zullen in het tweede semester zien hoe we die klasses kunnen gebruiken om grote problemen op te lossen. Voorlopig gaan we slechts voor elke oefening één klasse maken. Dus in een project komt, op enkele uitzonderingen na, slechts een klasse. De klasse is in feite, voorlopig toch nog, "ons programma".

Op een klasse te maken:

1. klik op de knop "Nieuwe klasse"
2. Kies de soort klasse, die staat altijd standaard op Class
3. Je geeft de klasse een naam (bv. "MijnProgramma"). Je kan kiezen welke naam je het programma (of klasse) geeft. Zorg dat de naam een zinvolle naam is.

Je zal zien dat er een oranje hokje verschijnt. Dit geeft aan dat de klasse is aangemaakt. In verkenner zal je zien dat er een extra bestand is gemaakt, met de extensie .java (bv. MijnProgramma.java). Dit bestand kunnen we bewerken en kunnen we openen in een editor.

Schrijven van een code in de klasse

Eens de klasse gemaakt is, kan je de code van die klasse aanpassen om ons programma te maken. Dit doe je door rechts te klikken en dan op "Editor opstarten" of (in het Engels "Open editor") te klikken.

Je kan dan in het geopende venster code aangeven. Het is zo dat BlueJ bij het maken van een klasse reeds wat voorbeeld code aanmaakt. Deze kan je direct verwijderen en je kan de code aanmaken bv. als volgt:

Dit resulteert dan in:

Compilatie

Wanneer je de code hebt geschreven, kan je de code compileren. Dit process vertaalt de code naar machinecode zodat de computer die kan uitvoeren. Compileren doe je op de knop compileren te drukken. In het editorvenster, krijg je onderaan een melding dat de klasse gecompileerd is of dat er nog fouten in het programma aanwezig zijn.

Uitvoering

Om het programma dan uit te voeren, moeten we rechtsklikken op het oranje blokje van onze klasse waarin we ons programma hebben geschreven. Dan kan je het programma laten uitvoeren door te klikken op void main(String[] args). Op deze manier wordt het main programma uitgevoerd.