Hoofdstuk 5: Selecties

Doel van dit Hoofdstuk

het type boolean declareren voor variabelen en Booleaanse uitdrukkingen maken en evalueren
Implementeren van if-uitdrukkingen
Implementeren van if-else-uitdrukkingen
Implementeren van geneste if-uitdrukkingen
Genereren van willekeurige getallen met Math.random()
Combineren van logische uitdrukkingen (!, ||, && en ^)
Gebruik van meerdere gevallen met switch-uitdrukkingen

Inleiding

In het vorige hoofdstuk hebben een programma gezien dat ons toeliet de straal van de cirkel in te voeren en waarbij de computer de oppervlakte berekende van die cirkel. Maar wat als we een negatief getal invoeren? Hoe kunnen we omgaan met die situatie.
We diennen dus een selectie uitdrukking te hebben waarbij we uitvoering van het programma willen laten afhangen van bepaalde waarden in een variabele.
In Java kan dit als volgt:

import java.util.Scanner; public class BerekenOppervlakte{ public static void main(String[] args){ // Declaratie van variabelen double straal = 0; double oppervlakte = 0; Scanner invoer = new Schanner(System.in); // 1. Vraag de staal van de cirkel System.out.println("Voer de waarde van de straal in:") straal = invoer.nextDouble(); // 2. Controleer indien straal negatief is if (straal < 0) { // 2a. indien waar, toon "verkeerde invoer" System.out.println("Verkeerde invoer"); } else { // 2b. indien niet waar, bereken de oppervlakte oppervlakte = straal * straal * 3.14159; // 3. Toon het resultaat? System.out.println("De oppervlakte is " + oppervlakte); } }

Het datatype `boolean`

Het datatype boolean declareert een variabele die twee waarden kan aannemen: true of false

Om waardes met elkaar te vergelijken biedt Java 6 relationele operatoren.

Java Operator	Wiskundige operator	Name	Voorbeeld (veronderstel straal = 5)	Resultaat
`<`	$<$	kleiner dan	`straal < 0`	`false`
`<=`	$\le$	kleiner of gelijk aan	`straal <= 0`	`false`
`>`	$>$	groter dan	`straal > 0`	`true`
`>=`	$\ge$	groter of gelijk dan	`straal >= 0`	`true`
`==`	$==$	gelijk aan	`straal == 0`	`false`
`!=`	$\ne$	niet gelijk dan	`straal != 0`	`true`

Het resultaat van een vergelijking is true of false. Een dergelijke waarde noemt men ook een Booleaanse waarde. Een variabele dat een Booleaanse waarde bevat is ook een Booleaanse variabele en wordt in Java gedeclareerd door het datatype boolean.
In Java kunnen we een variabele van het type boolean als volgt declareren en initiëren:

boolean lichtenAan = true;

`if`-uitdrukkingen

een if-uitdrukking is een constructie dat een programma toelaat om alternatieve uitvoeringen te volgen

Java ondersteunt verschillende types van selectie-uitdrukkingen: een-weg if-uitdrukkingen, twee-weg if-else-uitdrukkingen, geneste if-uitdrukkingen, meervoudige if-else-uitdrukkingen, switch-uitdrukkingen en conditionele uitdrukkingen.

Een een-weg if-uitdrukking als blok uitvoeren enkel en alleen de voorwaarde bij de if waar is:

if(booleeanse-uitdrukking){ blok-met-uitdrukkingen; }

Als de Booleaanse uitdrukking evalueert tot true (waar), dan wordt het blok met uitdrukkingen uitgevoerd, anders niet.
De Booleanse uitdrukkinge booleaanse-uitdrukking met tussen haakjes staan.

Verkeerd

if i < 0 { System.out.println(" i is positief"); }

Goed

if (i < 0) { System.out.println(" i is positief"); }

In het onderstaande voorbeeld moet de gebruiker een getal ingeven. Als het getal een veelvoud is van 5 dan toont het HiFive. Als het getal een veelvoud is van 2 dan toont het HiEven.

import java.util.Scanner; public class EenvoudigeIfDemo{ public static void main(String[] args){ Scanner input = new Scanner(System.in); System.out.print("Enter an integer:"); int number = input.nextInt(); if(number % 5 == 0){ System.out.println("HiFive"); } if(number % 2 == 0){ System.out.println("HiEven"); } } }

`if-else`-uitdrukkingen

Een if-else-uitdrukking beslist zal de uitvoering aanpassen indien de conditie waar of niet waar is.

Een if-else-structuur laat je toe om alternatieve instructies uit te voeren wanneer de conditie niet waar is.
De syntax voor een if-else-structuur is:

if(booleeanse-uitdrukking){ blok-met-uitdrukkingen-indien-true; } else{ blok-met-uitdrukkingen-indien-false; }

Een flowchart voor dergelijke uitdrukkingen is als volgt:
Als booleeanse-uitdrukking de waarde true geeft, dan worden de uitdrukkingen voor de geval true uitgevoerd, ander worden de uitdrukkingen voor het geval false uitgevoerd.
Bijvoorbeeld:

if (straal>0){ oppervlakte = straal * straal * PI; System.out.println("De oppervlakte van een cirkel met straat " + straal + " is " + oppervlakte); } else { System.out.println("Fout: Negatieve invoer voor straal"); }

Geneste `if` en `if-else` structuren

Een if-uitdrukking kan binnen een andere if-structuur gebruikt worden

Een uitdrukking in een if of if-else-structuur kan elke Java-structuur zijn, ook een andere if of if-else structuur.
De binnense if-structuur is zogezegde genest in een de buitenste if-structuur. In die binnenste if-structuur kan een andere if-structuur zitten. Er is geen grens in hoe diep de geneste if-structuren kunnen gaan.
Voorbeeld:

if (i > k) { if (j > k) { System.out.println("i en j zijn groter dan k"); } } else { System.out.println("i is kleiner of gelijk aan k"); }

Op deze manier kunnen we het volgende uitvoeren als we graden willen toekennen aan het eindresultaat van een examen.

if (eindcijfer >= 85) { System.out.println("Geslaagd met de grootste onderscheiding") } else { if (eindcijfer >= 77) { System.out.println("Geslaagd met grote onderscheiding"); } else { if (eindcijfer >= 68) { System.out.println("Geslaagd met onderscheiding"); } else { if (eindcijfer >= 50) { System.out.println("Geslaagd op voldoende wijze"); } else { System.out.println("Niet geslaagd"); } } } }

De bovenstaande code is wat onleesbaar vanwege de vele alternatieven. Een betere manier is de formattering wat aan te passen zodat het wat leesbaarder wordt:

if (eindcijfer >= 85) { System.out.println("Geslaagd met de grootste onderscheiding") } else if (eindcijfer >= 77) { System.out.println("Geslaagd met grote onderscheiding"); } else if (eindcijfer >= 68) { System.out.println("Geslaagd met onderscheiding"); } else if (eindcijfer >= 50) { System.out.println("Geslaagd op voldoende wijze"); } else { System.out.println("Niet geslaagd"); }

Generatie van willekeurige getallen

Je kan Math.random() om een willekeurig reëel getal (type double) te krijgen tussen 0.0 en 1.0, 1.0 niet inbegrepen

De klasse Math bevat veel methodes waarbij wiskundige functies kunnen uitgevoerd worden die we later zullen zien, maar één van die methodes het het genereren van een willekeurig getal d zodat $0.0 \le d < 1.0$ .
Dus, (int)(Math.random() * 10) zal een geheel getal geven tussen 0 en 9.

Logische opoeratoren

De logische operatoren !, &&, || en ^ kunnen gebruikt worden om samengestelde Booleaanse uitdrukkingen te maken.

Soms, is het nodig dat een conditie in een if of if-else structuur bestaat uit meerdere Booleaanse uitdrukkingen.
Bijvoorbeeld, als we iets willen uitvoeren wanneer een getal deelbaar is door 2 en deelbaar is door 3 wordt dit:

if ((getal % 2 == 0) && (getal % 3 == 0)) { //voer statements uit... }

Er zijn 4 logische operatoren in Java:

Operator	Naam	Beschrijving
`!`	niet	Logische negatie
`&&`	en	Logische conjunctie
`		`	of	Logische disjunctie
`^`	exclusieve of	Logische exclusie

De uitkomst van de logische operatoren wordt typisch in waarheidstabellen uitgezet.
Dit is de waarheidstabel voor de niet-operator (!).

`p`	`!p`	Voorbeeld ( `leeftijd = 24` en `gewicht = 140`)
`true`	`false`	`!(leeftijd > 18)` is `false`, want `(leeftijd > 18)` is `true`
`false`	`true`	`!(gewicht == 150)` is `true`, want `(gewicht == 150)` is `false`

De waarheidstabel voor de en-operator (&&).

`p1`	`p2`	`p1 && p2`	Voorbeeld ( `leeftijd = 24` en `gewicht = 140`)
`false`	`false`	`false`
`false`	`true`	`false`	`(leeftijd > 28) && (gewicht <= 140)` is `false`, want `leeftijd > 28` is `false`
`true`	`false`	`false`
`true`	`true`	`true`	`(leeftijd > 18) && (gewicht >= 140)` is `true`, want `leeftijd > 18` en `gewicht >= 140` zijn beide `true`

De waarheidstabel voor de of-operator (||).

`p1`	`p2`	`p1`\|\|`p2`	Voorbeeld ( `leeftijd = 24` en `gewicht = 140`)
`false`	`false`	`false`	`(leeftijd > 34)`\|\|`(gewicht >= 150)` is `false`, want `leeftijd > 34` en `gewicht >= 150` zijn beide `false`
`false`	`true`	`true`
`true`	`false`	`true`	`(leeftijd > 18)`\|\|`(gewicht < 140)` is `true`, want `leeftijd > 18` is `true`
`true`	`true`	`true`

De waarheidstabel voor de exclusieve of-operator (^).

`p1`	`p2`	`p1 ^ p2`	Voorbeeld ( `leeftijd = 24` en `gewicht = 140`)
`false`	`false`	`false`	`(leeftijd > 34) ^ (gewicht > 140)` is `false`, want `leeftijd > 34` en `gewicht > 140` zijn beide `false`
`false`	`true`	`true`	`(leeftijd > 34) ^ (gewicht >= 140)` is `true`, want `leeftijd > 34` is `false`, maar `gewicht >= 140` zijn beide `true`
`true`	`false`	`true`
`true`	`true`	`false`

Onderstaande programma toont een voorbeeld van alle logische operatoren.

import java.util.Scanner; public class BooleaanseOperatorenDemo{ public static void main(String[] args){ //Maak een Scanner object voor invoer Scanner input = new Scanner(System.in); //Krijg invoer van de gebruiker System.out.println("Voer een geheel getal in:"); int getal = input.nextInt(); if( getal % 2 == 0 && getal % 3 == 0){ System.out.println(getal + " is deelbaar door 2 EN door 3"); } if( getal % 2 == 0 || getal % 3 == 0){ System.out.println(getal + " is deelbaar door 2 OF door 3"); } if( getal % 2 == 0 ^ getal % 3 == 0){ System.out.println(getal + " is deelbaar door 2 OF door 3, maar niet door beide"); } } }

Opgelet In wiskund is het mogelijk om het volgende te zeggen 28 <= aantalDagenInEenMaand <= 31. In Java is dit fout, want van links naar rechts voeren we eerst 28 <= aantalDagenInEenMaand wordt geëvalueerd tot een boolean waarde, die niet kan vergeleken worden met 31. In Java moet men dus zeggen:

28 <= aantalDagenInEenMaand && aantalDagenInEenMaand <= 31

In Logische operatoren worden heel veel gebruikt in logica om programma's te verifiëren en mogelijks om programma's te schrijven die zelf code schrijven. Augustus De Morgan (1806 - 1871) was een Britse wiskundige die de wetten van De Morgan afleide namelijk:

!(conditie1 && conditie2) is equivalent met !conditie1 || !conditie2 !(conditie1 || conditie2) is equivalent met !conditie1 && !conditie2

Bijvoorbeeld

!(getal % 2 == 0 && getal % 3 == 0) is equivalent met getal % 2 != 0 || getal % 3 != 0

`switch`-uitdrukkingen

Een switch-uitdrukkingen voert instructies uit op basis van de waarde van een variabele of een uitdrukking

Bij geneste if-structuren kunnen we verschillende instructies laten uitvoeren op basis van andere condities, maar dit kan soms onleesbaar overkomen. Hierbij is het beter een switch-structuur te gebruiken zodat verschillende gevallen kunnen gedefinieerd worden en uitgevoerd worden op basis van de waarde van een variabele of uitdrukking.
De syntax van een switch-uitdrukking is

switch (switch-uitdrukking){ case waarde1: blok-met-uitdrukking(en)1; break; case waarde2: blok-met-uitdrukking(en)2; break; ... case waardeN: blok-met-uitdrukking(en)N; break; default: blok-met-uitdrukking(en)-voor-default; }

De switch-structuur gehoorzaamt aan volgende regels:
- De switch-uitdrukking met een waarde teruggeve van het type char, byte, short, int of String en moet altijd tussen haakjes staan.
- De waarde1,waarde2,... en waardeN moeten waardes zijn van hetzelfde type als de teruggegeven waarden van de switch-uitdrukking. Ze moeten constante uitdrukkingen zijn en er mogen geen variabelen in zitten (bv. 1 + x mag niet).
- Wanneer er een case uitdrukking de zelfde waarde heeft als de switch-uitdrukking dan worden het blok met Java-uitdrukkingen uitgevoerd startend vanaf die case tot een break-statement of het einde van de switch-structuur wordt tegengekomen.
- Het geval default is optioneel en wordt uitgevoerd als er geen enkel geval opgenomen is in de case-uitdrukkingen.
- Het sleutelwoord break is optioneel. Bij het uitvoeren van de break-uitdrukking zal de uitvoering de switch-structuur onmiddelijk verlaten.

Conditionele operatoren

Een conditionele operator evalueert een uitdrukking gebaseerd op een conditie

Soms wil je een waarde toekennen aan een variabele y onder een bepaalde voorwaarden. Het volgend stukje code zal de waarde 1 toekennen als een andere variabele x groter is dan 0 en -1 als x

if (x > 0){ y = 1; } else { y = 0; }

Dergelijke code komt in een programma veel voor en kan korter geschreven woorden door een conditionele uitdrukking als volgt:

y = (x > 0) ? 1 : -1;

De symbolen ? en : worden gezamelijk een conditionele operator genoemd. Dit wordt ook wel de ternaire operator genoemd om dat hij 3 operandi nodig geeft. In Java is dit ook de enige ternaire operator. De syntax is als volgt:

booleaanse-uitdrukking ? uitdrukking1 : uitdrukking2

uitdrukking1 wordt uitgevoerd als booleaanse-uitdrukking waar is, in het andere geval wordt uitdrukking2 uitgevoerd.

Hoofdstuk 5: Selecties

Hoofdstuk 5: Selecties

Doel van dit Hoofdstuk

Inleiding

Het datatype `boolean`

`if`-uitdrukkingen

`if-else`-uitdrukkingen

Geneste `if` en `if-else` structuren

Generatie van willekeurige getallen

Logische opoeratoren

`switch`-uitdrukkingen

Conditionele operatoren

results matching ""

No results matching ""

Hoofdstuk 5: Selecties

Doel van dit Hoofdstuk

Inleiding

Het datatype boolean

if-uitdrukkingen

if-else-uitdrukkingen

Geneste if en if-else structuren

Generatie van willekeurige getallen

Logische opoeratoren

switch-uitdrukkingen

Conditionele operatoren

results matching ""

No results matching ""

Het datatype `boolean`

`if`-uitdrukkingen

`if-else`-uitdrukkingen

Geneste `if` en `if-else` structuren

`switch`-uitdrukkingen