Lecture Outline
5.1 Introduction
5.2 Essentials of Counter-Controlled Repetition
5.3 for Repetition Statement
5.4 Examples Using the for Statement
5.5 do…while Repetition Statement
5.6 switch Multiple-Selection Statement
5.7 break and continue Statements
5.8 Labeled break and continue Statements
5.9 Logical Operators
5.1 Introduction
• Continue structured-programming discussion
– Introduce Java’s remaining control structures
5.2 Essentials of Counter-Controlled Repetition
• Counter-controlled repetition requires:
– Control variable (loop counter)
– Initial value of the control variable
– Increment/decrement of control variable through each loop
– Condition that tests for the final value of the control variable
1 // Fig. 5.1: WhileCounter.java
2 // Counter-controlled repetition.
3 import java.awt.Graphics;
4
5 import javax.swing.JApplet;
6
7 public class WhileCounter extends JApplet {
8
9 // draw lines on applet’s background
10 public void paint( Graphics g )
11 {
12 super.paint( g ); // call paint method inherited from JApplet
13
14 int counter = 1; // initialization
15
16 while ( counter <= 10 ) { // repetition condition
17 g.drawLine( 10, 10, 250, counter * 10 );
18 ++counter; // increment
19
20 } // end while
21
22 } // end method paint
23
24 } // end class WhileCounter
for Repetition Statement
• Handles counter-controlled-repetition details
1 // Fig. 5.2: ForCounter.java
2 // Counter-controlled repetition with the for statement.
3 import java.awt.Graphics;
4
5 import javax.swing.JApplet;
6
7 public class ForCounter extends JApplet {
8
9 // draw lines on applet’s background
10 public void paint( Graphics g )
11 {
12 super.paint( g ); // call paint method inherited from JApplet
13
14 // for statement header includes initialization,
15 // repetition condition and increment
16 for ( int counter = 1; counter <= 10; counter++ )
17 g.drawLine( 10, 10, 250, counter * 10 );
18
19 } // end method paint
20
21 } // end class ForCounter
for statement header components.
for ( initialization; loopContinuationCondition; increment )
statement;can usually be rewritten as:
initialization;
while ( loopContinuationCondition ) {
statement;
increment;
}
Examples Using the for Statement
• Varying control variable in for statement
– Vary control variable from 1 to 100 in increments of 1
• for ( int i = 1; i <= 100; i++ )
– Vary control variable from 100 to 1 in increments of –1
• for ( int i = 100; i >= 1; i-- )
– Vary control variable from 7 to 77 in increments of 7
• for ( int i = 7; i <= 77; i += 7 )
1 // Fig. 5.5: Sum.java
2 // Summing integers with the for statement.
3 import javax.swing.JOptionPane;
4
5 public class Sum {
6
7 public static void main( String args[] )
8 {
9 int total = 0; // initialize sum
10
11 // total even integers from 2 through 100
12 for ( int number = 2; number <= 100; number += 2 )
13 total += number;
14
15 // display results
16 JOptionPane.showMessageDialog( null, "The sum is " + total,
17 "Total Even Integers from 2 to 100", JOptionPane.INFORMATION_MESSAGE );
18
19
20 System.exit( 0 ); // terminate application
21
22 } // end main
23
24 } // end class Sum
1 // Fig. 5.6: Interest.java
2 // Calculating compound interest.
3 import java.text.NumberFormat; // class for numeric formatting
4 import java.util.Locale; // class for country-specific information
5
6 import javax.swing.JOptionPane;
7 import javax.swing.JTextArea;
8
9 public class Interest {
10
11 public static void main( String args[] )
12 {
13 double amount; // amount on deposit at end of each year
14 double principal = 1000.0; // initial amount before interest
15 double rate = 0.05; // interest rate
16
17 // create NumberFormat for currency in US dollar format
18 NumberFormat moneyFormat =
19 NumberFormat.getCurrencyInstance( Locale.US );
20
21 // create JTextArea to display output
22 JTextArea outputTextArea = new JTextArea();
23
24 // set first line of text in outputTextArea
25 outputTextArea.setText( "Year\tAmount on deposit\n" );
26
27 // calculate amount on deposit for each of ten years
28 for ( int year = 1; year <= 10; year++ ) {
29
30 // calculate new amount for specified year
31 amount = principal * Math.pow( 1.0 + rate, year );
32
33 // append one line of text to outputTextArea
34 outputTextArea.append( year + "\t" + moneyFormat.format( amount ) + "\n" );
35
36 } // end for
37
38
39 // display results
40 JOptionPane.showMessageDialog( null, outputTextArea,
41 "Compound Interest", JOptionPane.INFORMATION_MESSAGE );
42
43 System.exit( 0 ); // terminate the application
44
45 } // end main
46
47 } // end class Interest
do…while Repetition Statement
• do…while structure
– Similar to while structure
– Tests loop-continuation after performing body of loop
• i.e., loop body always executes at least once
1 // Fig. 5.7: DoWhileTest.java
2 // Using the do...while statement.
3 import java.awt.Graphics;
4
5 import javax.swing.JApplet;
6
7 public class DoWhileTest extends JApplet {
8
9 // draw lines on applet
10 public void paint( Graphics g )
11 {
12 super.paint( g ); // call paint method inherited from JApplet
13
14 int counter = 1; // initialize counter
15
16 do {
17 g.drawOval( 110 - counter * 10, 110 - counter * 10, counter * 20, counter * 20 );
18 ++counter;
19 } while ( counter <= 10 ); // end do...while
20
21
22 } // end method paint
23
24 } // end class DoWhileTest
switch Multiple-Selection Statement
• switch statement
– Used for multiple selections
1 // Fig. 5.9: SwitchTest.java
2 // Drawing lines, rectangles or ovals based on user input.
3 import java.awt.Graphics;
4
5 import javax.swing.*;
6
7 public class SwitchTest extends JApplet {
8 int choice; // user's choice of which shape to draw
9
10 // initialize applet by obtaining user's choice
11 public void init()
12 {
13 String input; // user's input
14
15 // obtain user's choice
16 input = JOptionPane.showInputDialog("Enter 1 to draw lines\n" +
17 "Enter 2 to draw rectangles\n" + "Enter 3 to draw ovals\n" );
18
19
20
21 choice = Integer.parseInt( input ); // convert input to int
22
23 } // end method init
24
25 // draw shapes on applet's background
26 public void paint( Graphics g )
27 {
28 super.paint( g ); // call paint method inherited from JApplet
29
30 for ( int i = 0; i < 10; i++ ) { // loop 10 times (0-9)
31
32 switch ( choice ) { // determine shape to draw
33
34 case 1: // draw a line
35 g.drawLine( 10, 10, 250, 10 + i * 10 );
36 break; // done processing case
37
38 case 2: // draw a rectangle
39 g.drawRect( 10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
40 break; // done processing case
41
42
43 case 3: // draw an oval
44 g.drawOval( 10 + i * 10, 10 + i * 10, 50 + i * 10, 50 + i * 10 );
45 break; // done processing case
46
47
48 default: // draw string indicating invalid value entered
49 g.drawString( "Invalid value entered", 10, 20 + i * 15 );
50
51
52 } // end switch
53
54 } // end for
55
56 } // end method paint
57
58 } // end class SwitchTest
break and continue Statements
• break/continue
– Alter flow of control
• break statement
– Causes immediate exit from control structure
• Used in while, for, do…while or switch statements
• continue statement
– Skips remaining statements in loop body
– Proceeds to next iteration
• Used in while, for or do…while statements
1 // Fig. 5.11: BreakTest.java
2 // Terminating a loop with break.
3 import javax.swing.JOptionPane;
4
5 public class BreakTest {
6
7 public static void main( String args[] )
8 {
9 String output = "";
10 int count;
11
12 for ( count = 1; count <= 10; count++ ) { // loop 10 times
13
14 if ( count == 5 ) // if count is 5,
15 break; // terminate loop
16
17 output += count + " ";
18
19 } // end for
20
21 output += "\nBroke out of loop at count = " + count;
22 JOptionPane.showMessageDialog( null, output );
23
24 System.exit( 0 ); // terminate application
25
26 } // end main
27
28 } // end class BreakTest
1 // Fig. 5.12: ContinueTest.java
2 // Continuing with the next iteration of a loop.
3 import javax.swing.JOptionPane;
4
5 public class ContinueTest {
6
7 public static void main( String args[ ] )
8 {
9 String output = "";
10
11 for ( int count = 1; count <= 10; count++ ) { // loop 10 times
12
13 if ( count == 5 ) // if count is 5,
14 continue; // skip remaining code in loop
15
16 output += count + " ";
17
18 } // end for
19
20 output += "\nUsed continue to skip printing 5";
21 JOptionPane.showMessageDialog( null, output );
22
23 System.exit( 0 ); // terminate application
24
25 } // end main
26
27 } // end class ContinueTest
Labeled break and continue Statements
• Labeled block
– Set of statements enclosed by {}
– Preceded by a label
• Labeled break statement
– Exit from nested control structures
– Proceeds to end of specified labeled block
• Labeled continue statement
– Skips remaining statements in nested-loop body
– Proceeds to beginning of specified labeled block
1 // Fig. 5.13: BreakLabelTest.java
2 // Labeled break statement.
3 import javax.swing.JOptionPane;
4
5 public class BreakLabelTest {
6
7 public static void main( String args[] )
8 {
9 String output = "";
10
11 stop: { // labeled block
12
13 // count 10 rows
14 for ( int row = 1; row <= 10; row++ ) {
15
16 // count 5 columns
17 for ( int column = 1; column <= 5 ; column++ ) {
18
19 if ( row == 5 ) // if row is 5,
20 break stop; // jump to end of stop block
21
22 output += "* ";
23
24 } // end inner for
25
26 output += "\n";
27
28 } // end outer for
29
30 // following line is skipped
31 output += "\nLoops terminated normally";
32
33 } // end labeled block
34
35 JOptionPane.showMessageDialog( null, output, "Testing break with a label",
36 JOptionPane.INFORMATION_MESSAGE );
37
38
39 System.exit( 0 ); // terminate application
40
41 } // end main
42
43 } // end class BreakLabelTest
1 // Fig. 5.14: ContinueLabelTest.java
2 // Labeled continue statement.
3 import javax.swing.JOptionPane;
4
5 public class ContinueLabelTest {
6
7 public static void main( String args[] )
8 {
9 String output = "";
10
11 nextRow: // target label of continue statement
12
13 // count 5 rows
14 for ( int row = 1; row <= 5; row++ ) {
15 output += "\n";
16
17 // count 10 columns per row
18 for ( int column = 1; column <= 10; column++ ) {
19
20 // if column greater than row, start next row
21 if ( column > row )
22 continue nextRow; // next iteration of labeled loop
23
24 output += "* ";
25
26 } // end inner for
27
28 } // end outer for
29
30 JOptionPane.showMessageDialog( null, output, "Testing continue with a label",
31 JOptionPane.INFORMATION_MESSAGE );
32
33
34 System.exit( 0 ); // terminate application
35
36 } // end main
37
38 } // end class ContinueLabelTest
Logical Operators
• Logical operators
– Allows for forming more complex conditions
– Combines simple conditions
• Java logical operators
– && (conditional AND)
– & (boolean logical AND)
– || (conditional OR)
– | (boolean logical inclusive OR)
– ^ (boolean logical exclusive OR)
– ! (logical NOT)
1 // Fig. 5.19: LogicalOperators.java
2 // Logical operators.
3 import javax.swing.*;
4
5 public class LogicalOperators
6
7 public static void main( String args[ ] )
8 {
9 // create JTextArea to display results
10 JTextArea outputArea = new JTextArea( 17, 20 );
11
12 // attach JTextArea to a JScrollPane so user can scroll results
13 JScrollPane scroller = new JScrollPane( outputArea );
14
15 // create truth table for && (conditional AND) operator
16 String output = "Logical AND (&&)" + "\nfalse && false: " + ( false && false ) +
17 "\nfalse && true: " + ( false && true ) + "\ntrue && false: " + ( true && false ) +
18 "\ntrue && true: " + ( true && true );
19
20
21
22 // create truth table for || (conditional OR) operator
23 output += "\n\nLogical OR (||)" + "\nfalse || false: " + ( false || false ) +
24 "\nfalse || true: " + ( false || true ) + "\ntrue || false: " + ( true || false ) +
25 "\ntrue || true: " + ( true || true );
26
27
28
29 // create truth table for & (boolean logical AND) operator
30 output += "\n\nBoolean logical AND (&)" + "\nfalse & false: " + ( false & false ) +
31 "\nfalse & true: " + ( false & true ) + "\ntrue & false: " + ( true & false ) +
32 "\ntrue & true: " + ( true & true );
33
34
35
36 // create truth table for | (boolean logical inclusive OR) operator
37 output += "\n\nBoolean logical inclusive OR (|)" + "\nfalse | false: " + ( false | false ) +
38 "\nfalse | true: " + ( false | true ) + "\ntrue | false: " + ( true | false ) +
39 "\ntrue | true: " + ( true | true );
40
41
42
43 // create truth table for ^ (boolean logical exclusive OR) operator
44 output += "\n\nBoolean logical exclusive OR (^)" + "\nfalse ^ false: " + ( false ^ false ) +
45 "\nfalse ^ true: " + ( false ^ true ) + "\ntrue ^ false: " + ( true ^ false ) +
46 "\ntrue ^ true: " + ( true ^ true );
47
48
49
50 // create truth table for ! (logical negation) operator
51 output += "\n\nLogical NOT (!)" + "\n!false: " + ( !false ) +
52 "\n!true: " + ( !true );
53
54
55 outputArea.setText( output ); // place results in JTextArea
56
57 JOptionPane.showMessageDialog( null, scroller,
58 "Truth Tables", JOptionPane.INFORMATION_MESSAGE );
59
60 System.exit( 0 ); // terminate application
61
62 } // end main
63
64 } // end class LogicalOperators
