PowerPoint-presentatie
advertisement
HOOFDSTUK 5
CONTROLESTRUCTUREN (DEEL 2)
5.1.
INTRODUCTIE
Vervolg discussie omtrent gestructureerd programmeren
Introductie van de overblijvende controlestructuren
1
5.2.
ESSENTIE VAN DE HERHALING
GECONTROLEERD DOOR EEN TELLER
Voor een herhaling met een teller zijn nodig:
• naam van een controlevariabele (de teller)
• initiële waarde van de controlevariabele
• increment/decrement van de controlevariabele
elke keer de lus doorlopen wordt
• conditie, die test op de eindwaarde van de controlevariabele
2
VOORBEELD
WhileCounter.java
• is een programma (applet), dat een waaier van 10
lijnen gaat tekenen
• gebruikt een while- herhalingsstructuur
• gebruikt een teller om de herhaling bij te houden
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Fig. 5.1: WhileCounter.java
// Herhaling gecontroleerd door een teller
// Java core packages
import java.awt.Graphics;
// Java extension packages
import javax.swing.JApplet;
public class WhileCounter extends JApplet
{
// trek lijnen op de achtergrond van de applet lines on applet
public void paint( Graphics g )
{
// roep de overgeërfde versie van de methode paint op
super.paint( g );
int counter = 1;
// initialisatie
while ( counter <= 10 ) // conditie van de herhaling
{
g.drawLine( 10, 10, 250, counter * 10 );
++counter; // increment
} // einde while structuur
}
}
// einde methode paint
// einde klasse WhileCounter
4
18
19
20
21
22
23
24
int counter = 1;
// initialisatie
while ( counter <= 10 ) // conditie van de herhaling
{
g.drawLine( 10, 10, 250, counter * 10 );
++counter; // increment
} // einde while structuur
Lijn 18
• Naam van de controlevariabele is counter.
• Initiële waarde van de controlevariabele is 1.
Lijn 20
• Conditionele test op de eindwaarde van counter.
Lijn 23
• Increment van de controlevariabele counter.
5
5.3.
DE “FOR” HERHALINGSSTRUCTUUR
for ( expressie1; expressie2; expressie3 )
statement
• hanteert alle details van de herhalingsstructuur met teller
6
VOORBEELD
ForCounter.java
• is een programma (applet), dat een waaier van 10 lijnen
gaat tekenen.
• gebruikt een for-herhalingsstructuur.
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Fig. 5.2: ForCounter.java
// Herhaling gecontroleerd door een teller via een for-structuur
// Java core packages
import java.awt.Graphics;
// Java extension packages
import javax.swing.JApplet;
public class ForCounter extends JApplet
{
// teken lijnen op de achtergrond van de applet
public void paint( Graphics g )
{
// roep de overgeërfde versie van de methode paint op
super.paint( g );
// Initialisatie, herhalingsconditie and incrementeren
// zijn allemaal inbegrepen in de hoofding van de for structuur.
for ( int counter = 1; counter <= 10; counter++ )
g.drawLine( 10, 10, 250, counter * 10 );
}
}
// einde methode paint
// einde klasse ForCounter
8
18 // Initialisatie, herhalingsconditie and incrementeren
19 // zijn allemaal inbegrepen in de hoofding van de for structuur.
20
for ( int counter = 1; counter <= 10; counter++ )
21
g.drawLine( 10, 10, 250, counter * 10 );
Lijn 20
int counter = 1
• Naam van de controlevariabele is counter.
• Initiële waarde van de controlevariabele is 1.
counter <= 10
• Conditionele test op de eindwaarde van counter.
counter++
• Increment van de controlevariabele counter.
9
REGEL 20 UIT FORCOUNTER.JAVA
for
sleutelwoord
Naam van de
controlevariabele
Eindwaarde van de
controlevariabele
for ( int counter = 1; counter <= 10; counter++ )
Beginwaarde
van de controlevariabele
Increment
van de controlevariabele
Conditie voor vervolg van de lus
Fig. 5.3
Componenten van een typische hoofding van een “for” structuur.
10
5.3.
DE “FOR” HERHALINGSSTRUCTUUR
(VERVOLG)
for ( expressie1; expressie2; expressie3 )
statement
kan herschreven worden als:
{ expressie1;
while ( expressie2 )
{
}
statement
expressie3;
}
11
FLOWCHART VAN EEN TYPISCHE
“FOR” HERHALINGSSTRUCTUUR
Fig. 5.4 Flowchart van een
typische “for” herhalingsstructuur.
Stel de
beginwaarde
counter <- 1
van de controle-
variabele vast
true
Bepaal of
counter <= 10
10, 10, 250,
counter * 10
de eindwaarde
);
van de controle-
variabele bereikt is.
g.drawLine(
false
“body” van de lus
counter<- counter
Incrementeer
de controlevariabele.
(dit kunnen meerdere
Statements zijn)
12
5.4.
VOORBEELDEN DIE GEBRUIK MAKEN
VAN DE “FOR” HERHALINGSSTRUCTUUR
Variërende controlevariabele in de for structuur
• De controlevariabele varieert van 1 tot 100,
toenemend in stappen van 1
for ( int i = 1; i <= 100; i++ )
• De controlevariabele varieert van 100 tot 1,
afnemend in stappen van –1
for ( int i = 100; i >= 1; i-- )
• De controlevariabele varieert van 7 tot 77 in stappen van 7
for ( int i = 7; i <= 77; i += 7 )
13
VOORBEELD 1
Sum.java
• de som van de even gehele getallen van 2 t.e.m. 100
wordt weergegeven op het scherm.
• gebruikt een for-herhalingsstructuur in stappen van 2.
14
1 // Fig. 5.5: Sum.java
2 // Herhaling gecontroleerd door een teller met de “for” structuur
3
4 // Java extension packages
5 import javax.swing.JOptionPane;
6
7 public class Sum
8 {
9
// de uitvoering van de Java applicatie begint bij de main method
10
public static void main( String args[] )
11
{
12
int total = 0;
13
14
// sommeer de even gehele getallen van 2 tot en met 100
15
for ( int number = 2; number <= 100; number += 2 )
16
total += number;
17
18
// toon het resultaat
19
JOptionPane.showMessageDialog( null, "The sum is " + total,
20
"Sum Even Integers from 2 to 100",
21
JOptionPane.INFORMATION_MESSAGE );
22
23
System.exit( 0 ); // beëindig de applicatie
24
25
} // einde methode main
26
27 } // einde klasse Sum
15
12
13
14
15
16
17
18
19
20
21
int total = 0;
// sommeer de even gehele getallen van 2 tot en met 100
for ( int number = 2; number <= 100; number += 2 )
total += number;
// toon het resultaat
JOptionPane.showMessageDialog( null, "The sum is " + total,
"Sum Even Integers from 2 to 100",
JOptionPane.INFORMATION_MESSAGE );
Lijn 15
number += 2
• incrementeer number met 2 bij elke iteratie
16
VOORBEELD 2
Interest.java
• is een programma dat de samengestelde intrest berekent
a = p(1 + r)n
p = kapitaal (in ons vb. $1000)
r = jaarlijkse intrest (in ons vb. 5%)
n = aantal jaren
a = kapitaal na n jaar
• Het kapitaal MET de samengestelde intrest wordt voor de
eerste 10 jaar weergegeven.
• gebruikt een for-herhalingsstructuur.
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Fig. 5.6: Interest.java
// Berekening van samengestelde interest
// Java core packages
import java.text.NumberFormat;
import java.util.Locale;
// Java extension packages
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
Interest.java
public class Interest
{
// de uitvoering van de Java applicatie begint bij de main methode
public static void main( String args[] )
{
double amount, principal = 1000.0, rate = 0.05;
// creëer NumberFormat om floating point getallen
// met twee cijfers rechts van de decimale punt te formatteren
NumberFormat moneyFormat =
NumberFormat.getCurrencyInstance ( Locale.US );
// creëer JtextArea om de uitvoer te laten zien
JTextArea outputTextArea = new JTextArea();
// plaats de eerste lijn tekst in outputTextArea
outputTextArea.setText( "Year\tAmount on deposit\n" );
// bereken het bedrag in deposito voor elk van de tien jaren
for ( int year = 1; year <= 10; year++ )
{
// bereken nieuw bedrag voor een specifiek jaar
amount = principal * Math. pow( 1.0 + rate, year );
18
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 }
// voeg één lijn tekst toe aan outputTextArea
outputTextArea.append( year + "\t" +
moneyFormat.format( amount ) + "\n" );
}
// einde for structuur
// toon het resultaat
JOptionPane.showMessageDialog( null, outputTextArea,
"Compound Interest", JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
// beëindig de applicatie
// einde methode main
// einde klasse Interest
Interest.java
vervolg code
+ uitvoer
19
12 public class Interest
13 {
14
// de uitvoering van de Java applicatie begint bij de main methode
15
public static void main( String args[] )
16
{
17
double amount, principal = 1000.0, rate = 0.05;
18
Lijn 17
• Java stockeert floating-point getallen in variabelen van het
type double (of float)
20
19
20
21
22
23
24
25
26
27
28
29
// creëer NumberFormat om floating point getallen
// met twee cijfers rechts van de decimale punt te formatteren
NumberFormat moneyFormat =
NumberFormat.getCurrencyInstance( Locale.US );
// creëer JtextArea om de uitvoer te laten zien
JTextArea outputTextArea = new JTextArea();
// plaats de eerste lijn tekst in outputTextArea
outputTextArea.setText( "Year\tAmount on deposit\n" );
Lijn 21
• NumberFormat kan numerieke waarden als een valuta
formatteren
Lijn 22: Locale.US
• Toont geldbedragen met een dollarteken ($)
21
30
31
32
33
34
35
36
37
38
39
40
// bereken het bedrag in deposito voor elk van de tien jaren
for ( int year = 1; year <= 10; year++ )
{
// bereken nieuw bedrag voor een specifiek jaar
amount = principal * Math.pow( 1.0 + rate, year );
// voeg één lijn tekst toe aan outputTextArea
outputTextArea.append( year + "\t" +
moneyFormat.format( amount ) + "\n" );
}
// einde for structuur
Lijn 31-40
• Bereken amount (kapitaal) met een for structuur
amount = a = p(1 + r)n
Lijn 34
• Math.pow(1.0 + rate, year)
(1.0 + rate)year
22
41
42
// toon het resultaat
43
JOptionPane.showMessageDialog( null, outputTextArea,
44
"Compound Interest", JOptionPane.INFORMATION_MESSAGE );
45
46
System.exit( 0 ); // beëindig de applicatie
47
48 } // einde methode main
49
50 } // einde klasse Interest
23
5.5.
DE “DO/WHILE” HERHALINGSSTRUCTUUR
do statement while (voorwaarde);
lijkt op de while structuur, MAAR test of de lus verder
doorlopen moet worden
NADAT de body van de loop uitgevoerd is
dit betekent dat de lus altijd
MINSTENS EENMAAL doorlopen wordt
Het statement wordt herhaald zolang de voorwaarde
WAAR blijft!
Zorg ervoor dat de voorwaarde beïnvloed wordt in het
statement, anders oneindige lus!
24
VOORBEELD
DoWhileControle.java
• Er wordt gevraagd om een positief geheel getal,
verschillend van nul in te voeren; de invoer wordt
vervolgens gecontroleerd; indien deze niet voldoet,
wordt een nieuwe waarde aan de gebruiker gevraagd.
Is de invoer in orde, dan wordt dit getal in een
dialoogvenster getoond.
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Dit voorbeeld staat niet in het boek!!!
// Using the do/while repetition structure.
// Java core packages
import java.awt.Graphics;
// Java extension packages
import javax.swing.*;
public class DoWhileControle
{
public static void main( String[] args )
{
int getal;
String input;
do
{
input = JOptionPane.showInputDialog(“Geef een positief
geheel getal,verschillend van nul in : “);
getal = Integer.parseInt(input);
}
while ( getal <= 0 ); // einde do/while structuur
JOptionPane.showMessageDialog(null,”Het ingevoerde getal
getal);
System.exit(0);
} // einde methode main
} // einde klasse DoWhileControle
= “ +
26
18
19
20
21
22
23
do
{
input = JOptionPane.showInputDialog(“Geef een positief
geheel getal,verschillend van nul in : “);
getal = Integer.parseInt(input);
}
while ( getal <= 0 ); // einde do/while structuur
Lijn 19-23
• Een getal wordt ingevoerd en vervolgens wordt er
getest op de waarde van getal.
• Voldoet de waarde van getal niet, dan krijgt de
gebruiker een tweede kans om een getal in te voeren.
• Enz..., tot het ingevoerde getal voldoet aan de
gestelde vraag.
Merk op: de lus wordt niet verlaten, zolang het
ingevoerde getal niet voldoet!
27
FLOWCHART VAN DE “DO/WHILE”
HERHALINGSSTRUCTUUR
actie(s)
true
conditie
false
Fig. 5.10 Flowchart van de do/while herhalingsstructuur.
28
5.6.
DE “SWITCH”
MEERVOUDIGE SELECTIESTRUCTUUR
switch structuur
wordt gebruikt voor meervoudige selecties:
switch (var)
{
case label1: statement1
break;
case label2: statement2
break;
default: statement3
[ break;]
}
29
VOORBEELD
SwitchTest.java (= applet)
• de gebruiker geeft een getal in
1 = een waaier van 10 lijnen tekenen
2 = 10 vierkanten tekenen
3 = 10 cirkels tekenen
1, 2 en 3 = de tekst "Invalid value entered“
wordt weergegeven.
30
1
2
3
4
5
6
7
8
9
10
// Fig. 5.7: SwitchTest.java
// Lijnen, rechthoeken of ovalen tekenen op basis van de input van de gebruiker.
// Java core packages
import java.awt.Graphics;
// Java extension packages
import javax.swing.*;
Verkrijg input van de
gebruiker
public class SwitchTest extends JApplet
11 {
private int choice; // keuze van de gebruiker
12
13
14
15
16
welke vorm getekend moet worden
// initialiseeer de applet door de keuze van de gebruiker
public void init()
{
String input; // input van de gebruiker
te verkrijgen
17
18
19
20
21
22
23
24
25
26
// verkrijg de keuze van de gebruiker
input = JOptionPane.showInputDialog(
"Enter 1 to draw lines\n" +
"Enter 2 to draw rectangles\n" +
"Enter 3 to draw ovals\n");
// converteer de input van de gebruiker naar een int
choice = Integer.parseInt( input );
}
31
28
// teken vormen op de achtergrond van de applet
29
public void paint( Graphics g )
30
{
31
// roep de overgeërfde versie van de methode paint op
32
super.paint( g );
33
34
// bepaal de te tekenen vorm op basis van de keuze van de gebruiker
35
36
switch ( choice )
37
{
38
case 1:
39
for ( int i = 0; i < 10; i++ ) g.drawLine( 10, 10, 250, 10 + i * 10 );
40
break; // gedaan met dit geval te verwerken
41
42
case 2:
43
for ( int i = 0; i < 10; i++ )
44
g.drawRect( 10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
45
break; // gedaan met dit geval te verwerken
46
47
case 3:
48
for ( int i = 0; i < 10; i++ )
49
g.drawOval( 10 + i * 10, 10 + i * 10,50 + i * 10, 50 + i * 10 );
50
break; // gedaan met dit geval te verwerken
51
52
default:
53
g.drawString( "Invalid value entered",
54
10, 20 + i * 15 );
55
56
} // einde switch structuur
57
58
} // einde for structuur
59
60
} // einde paint methode
61
62 } // einde klasse SwitchTest
32
SWITCHTEST.JAVA: OUTPUT
33
36
37
38
switch ( choice )
{
case 1:
39
40
41
for ( int i = 0; i < 10; i++ ) g.drawLine( 10, 10, 250, 10 + i * 10 );
42
case 2:
43
44
45
46
47
48
49
50
51
52
53
54
55
56
break;
input van de gebruiker (choice) is de
for ( int i = 0; i < 10; i++ )
controlerende expressie
g.drawRect( 10 + i * 10, 10 + i * 10,50 + i * 10, 50 + i * 10 );
break; // gedaan met dit geval te verwerken
case 3:
for ( int i = 0; i < 10; i++ )
g.drawOval( 10 + i * 10, 10 + i * 10,50 + i * 10, 50 + i * 10 );
break; // gedaan met dit geval te verwerken
default:
g.drawString( "Invalid value entered",
10, 20 + i * 15 );
default case voor
ongeldige ingaven
} // einde switch structuur
Lijn 36
• de switch structuur bepaalt welk case label uitgevoerd
moet worden, wat afhangt van de controlerende
expressie.
34
FLOWCHART VAN DE “SWITCH”
MEERVOUDIGE SELECTIESTRUCTUUR
true
case a
case a actie(s)
break
false
true
case b
case b actie(s)
break
false
true
case z
case z actie(s)
break
false
default actie(s)
Fig. 5.8 De switch meervoudige selectiestructuur.
35
Zet de volgende geneste if-structuren om in een
switch – case-structuur
1. int i, k;
// invoer van een waarde voor i
if (i == 1) k = 3;
else if (i == 2) k = 6;
else if ( i == 3 || i == 4) k = 10;
else k = 20;
}
2. int x, y = 0;
// invoer van een waarde voor x
if (x == 100 || x == 150 || x == 170 || x == 199) y++;
36
OPLOSSINGEN
1. int i, k;
// invoer van een waarde voor i
switch (i)
{ case 1 : k = 3; break;
case 2 : k = 6; break;
case 3 : case 4 : k = 10; break;
default : k = 20;
}
37
OPLOSSINGEN
2. int x, y = 0;
// invoer van een waarde voor x
switch (x)
{
case 100 : case 150 : case 170 :
case 199 : y++;
}
38
5.7.
STATEMENTS “BREAK” EN “CONTINUE”
break/continue
• veranderen de stroom van de controle
break statement
• veroorzaakt een onmiddellijke exit uit de
controlestructuur
• wordt gebruikt in while, for, do/while en switch
statements
continue statement
• slaat de resterende statements in de body van de lus
over
• gaat verder naar de volgende iteratie
• wordt gebruikt in while, for en do/while statements 39
Voorbeeld met break statement
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Fig. 5.11: BreakTest.java
// Gebruik van het break statement in een for structuur
// Java extension packages
import javax.swing.JOptionPane;
public class BreakTest
{
// de uitvoering van de Java applicatie begint bij de main methode
public static void main( String args[] )
{
String output = "";
int count;
BreakTest.java
// herhaal 10 keer
for ( count = 1; count <= 10; count++ )
{
// als count gelijk is aan 5, beëindig dan de lus
if ( count == 5 )
break; // onderbreek de lus enkel als count == 5
output += count + " ";
}
// einde for structuur
output += "\nBroke out of loop at count = " + count;
JOptionPane.showMessageDialog( null, output );
System.exit( 0 );
}
}
// beëindig de applicatie
// einde methode main
// einde klasse BreakTest
40
16
17
18
19
20
21
22
23
24
for ( count = 1; count <= 10; count++ )
{
// als count gelijk is aan 5, beëindig dan de lus
if ( count == 5 )
break; // onderbreek de lus enkel als count == 5
output += count + " ";
} // einde for structuur
Lijn 16
• Herhaal 10 keer
Lijn 20
• ga uit de for structuur (break) wanneer count gelijk
is aan 5
41
Voorbeeld met continue statement
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Fig. 5.12: ContinueTest .java
// Gebruik van het continue statement in een for structuur
// Java extension packages
import javax .swing. JOptionPane ;
public class ContinueTest
{
// de uitvoering van de Java applicatie begint bij de main methode
public static void main( String args [] )
{
String output = "";
ContinueTest
.java
// herhaal 10 keer
for ( int count = 1; count <= 10; count++ )
{
// als count 5 is, ga verder met de volgende iteratie van de lus
if ( count == 5 )
continue ; // sla de overblijvende code in de lus over
// enkel als count == 5
output += count +
}
" ";
// einde for structuur
output += "\nUsed continue to skip printing 5" ;
JOptionPane .showMessageDialog ( null , output );
System.exit( 0 );
// beëindig de applicatie
} // einde methode main
}
// einde klasse ContinueTest
42
15
16
17
18
19
20
21
22
23
24
for ( int count = 1; count <= 10; count++ )
{
// als count 5 is, ga verder met de volgende iteratie van de lus
if ( count == 5 )
continue; // sla de overblijvende code
// in de lus over enkel als count == 5
output += count + " ";
} // einde for structuur
Lijn 15
• Herhaal 10 keer
Lijn 19
• Sla lijn 22 over en ga verder naar lijn 15 als count 5 is
43
5.8.
LOGISCHE OPERATOREN
Logische operatoren
• zorgen ervoor dat complexere condities gevormd kunnen worden
• combineren eenvoudige condities
Logische operatoren in Java
• && (conditionele EN)
•&
(logische EN)
• || (conditionele OF)
•|
(logische inclusieve OF)
•^
(logische exclusieve OF)
•!
(logische NIET)
44
WAARHEIDSTABEL CONDITIONELE EN (&&)
expressie1
expressie2
expressie1 && expressie2
false
false
false
false
true
false
true
false
false
true
true
true
Fig. 5.15 Waarheidstabel voor de && operator.
45
WAARHEIDSTABEL CONDITIONELE OF (||)
expressie1
expressie2
expressie1 || expressie2
false
false
false
false
true
true
true
false
true
true
true
true
Fig. 5.15 Waarheidstabel voor || operator.
46
WAARHEIDSTABEL LOGISCHE EXCLUSIEVE OF (^)
expressie1
expressie2
expressie1 ^ expressie2
false
false
false
false
true
true
true
false
true
true
true
false
Fig. 5.15 Waarheidstabel voor de logische exclusieve OF (^)
operator.
47
WAARHEIDSTABEL LOGISCHE EXCLUSIEVE OF (^)
Deze operator heeft geen short-circuit evaluatie!
Beide operands worden steeds geëvalueerd!
Voorbeeld:
Als x negatief is moet y positief zijn of omgekeerd, als y
negatief is moet x positief zijn.
if (x < 0 ^ y < 0) // (x < 0 en y >= 0) of
// (y < 0 en x >= 0)
48
WAARHEIDSTABEL LOGISCHE NIET (!)
expressie
!expressie
false
true
true
false
Fig. 5.18 Waarheidstabel voor de operator ! (logische
negatie, of logische NIET).
49
Short-circuit-operatoren
• De logische AND (&) en de logische inclusieve OR (|)
werken op dezelfde manier als de conditionele AND (&&)
en de conditionele OF (||), mits één uitzondering: het zijn
GEEN short-circuit-operatoren
• de logische operatoren & en | evalueren steeds de
beide operands
Voorbeelden:
geslacht == 1 & leeftijd >= 65
verjaardag == true | ++ leeftijd >= 65
50
Short-circuit-operatoren (vervolg)
•
een expressie met een conditionele AND (&&) of een
conditionele OF (||) wordt geëvalueerd totdat
geweten is of de volledige expressie true of false
oplevert
Gevolgen:
1. Zet bij de operator && de conditie die meest kans
heeft om vals te zijn links van de operator, bij de
operator || de conditie die meest kans heeft om waar
te zijn.
2. Zet de conditie die eventueel niet mag geëvalueerd
worden rechts!
51
Short-circuit-operatoren (vervolg)
Voorbeelden:
n != 0 && q < 1.0 / n
Als n = 0 dan is n != 0 vals -> volledig vals en GEEN
deling door nul!
n == 0 || q > 1.0 / n
Als n = 0 dan is n == 0 true -> volledig true en GEEN
deling door nul!
verjaardag == true || ++ leeftijd >= 65
Als verjaardag = true dan is conditie1 true -> volledig
true, MAAR geen aanpassing van de leeftijd!!!
52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Fig. 5.19: LogicalOperators .java
// Demonstratie van de logische operatoren
// Java extension packages
import javax .swing.*;
public class LogicalOperators
{
// de uitvoering van de Java applicatie begint bij de main methode
public static void
main( String args [] )
{
// creëer een JTextArea om de resultaten te laten zien
JTextArea outputArea
= new JTextArea ( 17 , 20 );
Logical
Operators
.java
// hang de JTextArea aan een JScrollPane, zodat de gebruiker kan
// scrollen door de resultaten
JScrollPane scroller
= new JScrollPane ( outputArea );
String output;
waarheidstabel logische EN
// creëer de waarheidstabel voor de && operator
output = "Logical AND (&&)"
+
"\nfalse && false: " + ( false && false ) +
"\nfalse && true: " + ( false && true ) +
"\ntrue && false: " + ( true && false ) +
"\ntrue && true: " + ( true && true );
// creëer de waarheidstabel voor de || operator
output += "\n\nLogical OR (||)" +
"\nfalse || false: " + ( false || false ) +
"\nfalse || true: " + ( false || true ) +
"\ntrue || false: " + ( true || false ) +
"\ntrue || true: " + ( true || true );
waarheidstabel
logische OF
53
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// creëer de waarheidstabel voor de & operator
output += "\n\nBoolean logical AND (&)" +
"\nfalse & false: " + ( false & false ) +
"\nfalse & true: " + ( false & true ) +
"\ntrue & false: " + ( true & false ) +
waarheidstabel
"\ntrue & true: " + ( true & true );
voor de
booleaanse logische EN
// creëer de waarheidstabel voor de | operator
output += "\n\nBoolean logical inclusive OR (|)"
+
"\nfalse | false: " + ( false | false ) +
"\nfalse | true: " + ( false | true ) +
"\ntrue | false: " + ( true | false ) +
waarheidstabel
"\ntrue | true: " + ( true | true );
voor de
booleaanse logische OF
// creëer de waarheidstabel voor de ^ operator
output += "\n\nBoolean logical exclusive OR (^)"
"\nfalse ^ false: " + ( false ^ false ) +
"\nfalse ^ true: " + ( false ^ true ) +
"\ntrue ^ false: " + ( true ^ false ) +
"\ntrue ^ true: " + ( true ^ true );
// creëer de waarheidstabel voor de !
output += "\n\nLogical NOT (!)" +
"\n!false: " + ( ! false ) +
"\n!true: " + ( ! true );
outputArea .setText ( output );
//
0 );
vervolg
+
Waarheidstabel voor de
booleaanse logische
operator
exclusieve OF
Waarheidstabel voor de
NIETin JOptionPane
plaatslogische
resultaten
JOptionPane .showMessageDialog ( null , scroller ,
"Truth Tables" , JOptionPane .INFORMATION_MESSAGE
System.exit(
Logical
Operators
.java
);
// beëindig de applicatie
54
67
68
69
70 }
}
// einde methode main
// einde klasse LogicalOperators
LogicalOperators.java
vervolg
55
21
22
23
24
25
26
27
// creëer de waarheidstabel voor de && operator
output = "Logical AND (&&)" +
"\nfalse && false: " + ( false && false ) +
"\nfalse && true: " + ( false && true ) +
"\ntrue && false: " + ( true && false ) +
"\ntrue && true: " + ( true && true );
Lijn 22-26
• waarheidstabel logische EN
56
28
29
30
31
32
33
34
// creëer de waarheidstabel voor de || operator
output += "\n\nLogical OR (||)" +
"\nfalse || false: " + ( false || false ) +
"\nfalse || true: " + ( false || true ) +
"\ntrue || false: " + ( true || false ) +
"\ntrue || true: " + ( true || true );
Lijn 29-33
• waarheidstabel logische OF
57
35
36
37
38
39
40
41
// creëer de waarheidstabel voor de & operator
output += "\n\nBoolean logical AND (&)" +
"\nfalse & false: " + ( false & false ) +
"\nfalse & true: " + ( false & true ) +
"\ntrue & false: " + ( true & false ) +
"\ntrue & true: " + ( true & true );
Lijn 36-40
• waarheidstabel voor de booleaanse logische EN
58
42
43
44
45
46
47
48
// creëer de waarheidstabel voor de | operator
output += "\n\nBoolean logical inclusive OR (|)" +
"\nfalse | false: " + ( false | false ) +
"\nfalse | true: " + ( false | true ) +
"\ntrue | false: " + ( true | false ) +
"\ntrue | true: " + ( true | true );
Lijn 43-47
• waarheidstabel voor de booleaanse logische OF
59
49 // creëer de waarheidstabel voor de ^ operator
50 output += "\n\nBoolean logical exclusive OR (^)" +
51
"\nfalse ^ false: " + ( false ^ false ) +
52
"\nfalse ^ true: " + ( false ^ true ) +
53
"\ntrue ^ false: " + ( true ^ false ) +
54
"\ntrue ^ true: " + ( true ^ true );
55
Lijn 50-54
• Waarheidstabel voor de booleaanse logische exclusieve OF
60
56
57
58
59
60
// creëer de waarheidstabel voor de ! operator
output += "\n\nLogical NOT (!)" +
"\n!false: " + ( !false ) +
"\n!true: " + ( !true );
Lijn 57-59
• Waarheidstabel voor de logische NIET
61
PRECEDENTIE EN ASSOCIATIVITEIT
VAN DE OPERATOREN
Operators
Associativity
Type
()
++
++
*
+
<
==
&
^
van
van
van
van
van
van
van
van
van
haakjes
unair postfix
unair
multiplicerend
toevoegend
relationeel
gelijkheid
booleaanse logische EN
booleaanse logische
exclusieve OF
booleaanse logische
inclusieve OF
logische EN
logische OF
conditioneel
toekenning
--- + - ! (type)
/
%
<= >
>=
!=
links naar rechts
rechts naar links
rechts naar links
links naar rechts
links naar rechts
links naar rechts
links naar rechts
links naar rechts
links naar rechts
|
van links naar rechts
&&
||
?:
=
+= -= *= /= %=
van
van
van
van
links naar rechts
links naar rechts
rechts naar links
rechts naar links
Fig. 5.20 Precedentie en associativiteit van operatoren.
62
5.9.
SAMENVATTING
GESTRUCTUREERD PROGRAMMEREN
Sequentiestructuur
• “ingebouwd” in Java
Selectiestructuren
• if, if/else en switch
Herhalingsstructuren
• while, do/while en for
63
SAMENVATTING HERHALINGSSTRUCTUREN
Je gebruikt een ‘for’ of een ‘while’ indien je van tevoren weet
om hoeveel herhalingen het gaat.
Weet je niet van tevoren om hoeveel herhalingen het gaat,
dan dien je een ‘while’ of een ‘do-while’ te gebruiken.
• Je kiest voor een ‘while’ indien de body van de while
misschien nooit mag worden uitgevoerd. De ‘voorwaarde’
wordt eerst getest. De body van de while wordt uitgevoerd
zolang de ‘voorwaarde’ waar is.
• Je kiest voor een ‘do-while’ indien de body van de ‘dowhile’ tenminste één keer moet worden uitgevoerd. Eerst
wordt de body van de ‘do-while uitgevoerd, vervolgens
wordt de voorwaarde gecontroleerd. Zolang de expressie
64
waar is, wordt de body van de ‘do-while’ uitgevoerd.
SAMENVATTING HERHALINGSSTRUCTUREN
de body van de while wordt 0, 1 of meerdere keren
uitgevoerd.
de body van de do-while wordt minstens 1 keer
uitgevoerd.
65
OEFENINGEN
Hoofdstuk 5
66
Vind de fout(en) in volgende stukjes code:
1. Deze code zou moeten printen of een geheel getal value,
even of oneven is
switch ( value % 2 )
{
case 0:
System.out.println( “Even getal” );
case 1:
System.out.println( “Oneven getal” );
}
67
Vind de fout(en) in volgende stukjes code:
2. Deze code zou moeten de oneven gehele getallen van 19
tot en met 1 printen
for ( x = 19; x >= 1; x += 2 )
System.out.println( x );
68
Welke output geven volgende statements?
Stel: i = 1, j = 2, k = 3 en m = 2
a)
b)
c)
d)
e)
f)
g)
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
i == 1 );
j == 3 );
i >= 1 && j < 4 );
m <= 99 & k < m );
j >= i || k == m );
k + m < j | 3 – j >= k );
!( k > m ) );
69
Schrijf een applicatie die…
volgende patronen print, enkel gebruik makend van:
System.out.print(‘*’), System.out.println()
en voor (c) en (d) ook nog System.out.print(‘ ’)
(a)
(b)
(c)
(d)
*
**
***
****
*****
******
*******
********
*********
***********
**********
*********
********
*******
******
*****
****
***
**
*
**********
*********
********
*******
******
*****
****
***
**
*
*
**
***
****
*****
******
*******
********
*********
**********
70
OPLOSSINGEN
Hoofdstuk 5
71
Verbeterde code:
1. Deze code zal printen of een geheel getal value, even of
oneven is
switch ( value % 2 )
{
case 0:
System.out.println( “Even getal” );
break;
case 1:
System.out.println( “Oneven getal” );
break;
}
72
Verbeterde code:
2. Deze code zal de oneven gehele getallen van 19 tot en
met 1 printen
int x;
for ( x = 19; x >= 1; x -= 2 )
System.out.println( x );
73
Welke output geven volgende statements?
Stel: i = 1, j = 2, k = 3 en m = 2
a)
b)
c)
d)
e)
f)
g)
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
i == 1 );
j == 3 );
i >= 1 && j < 4 );
m <= 99 & k < m );
j >= i || k == m );
k + m < j | 3 – j >= k );
!( k > m ) );
true
false
true
false
true
false
false
74
Schrijf een applicatie die…
volgende patronen print, enkel gebruik makend van:
System.out.print(‘*’), System.out.println()
en voor (c) en (d) ook nog System.out.print(‘ ’)
(a)
(b)
(c)
(d)
*
**
***
****
*****
******
*******
********
*********
***********
**********
*********
********
*******
******
*****
****
***
**
*
**********
*********
********
*******
******
*****
****
***
**
*
*
**
***
****
*****
******
*******
********
*********
**********
75
Patroon a
public class PatroonA
{
public static void main (String args[])
{
for (int i=1; i<=10; i++) // 10 rijen
{
for (int j=1; j<=i; j++) // #kol = rij-index
System.out.print (‘*’);
System.out.println();
}
}
}
76
Patroon b
public class PatroonB
{
public static void main (String args[])
{
for (int i=1; i<=10; i++) // 10 rijen
{
for (int j1=1; j1<=i-1; j1++)// 0,1,..,9 sp
System.out.print (‘ ’);
for (int j2=11-i; j2>=1; j2--)//10,9,..,1 *
System.out.print (‘*’);
System.out.println();
}
}
77
}
Patroon c
public class PatroonC
{
public static void main (String args[])
{
for (int i=1; i<=10; i++) // 10 rijen
{
for (int j=11-i; j>=1; j--) // 10,9,8,..,1 kol
System.out.print (‘*’);
System.out.println();
}
}
}
78
Patroon d
public class PatroonD
{
public static void main (String args[])
{
for (int i=1; i<=10; i++)// 10 rijen
{
for (int j1=10-i; j1>=1; j1--)// 9,8,..,0 sp
System.out.print (‘ ’);
for (int j2=1; j2<=i; j2++)//1,2,3,..,10 *
System.out.print (‘*’);
System.out.println();
}
}
79
}
