Java I Lecture 5.pps

Java I--Copyright © 2000 Tom Hunter
Chapter 5
Control Structures: Part II

Counter-Controlled Repetition
• Used when you know in advance how many times you
want the loop to be executed.
4 Requirements:
1. Variable to count the number of repetitions
2. Starting value of counter
3. Amount in increment the counter each loop
4. The condition that decides when to stop looping.

• Can Use the while Loop
• Although the while is usually used when we don’t
know how many times we’re going to loop, it works just
fine.
• Still must supply the 4 Requirements.

// WhileCounter.java
import java.awt.Graphics;
import javax.swing.JApplet;
public class WhileCounter extends JApplet

{
public void paint( Graphics g )
{
int counter; // 1.) count variable
counter = 1; // 2.) starting value
while( counter <= 10 ) // 4.) condition, final value

{
g.drawLine( 10, 10, 250, counter * 10 );
++counter; // 3.) increment
}
}
}
•
• The for Loop
• A common structure called a for loop is specially
designed to manage counter-controlled looping.
for( int x = 1; x < 10; x++ )
1.) count variable,

2.) starting value
3.) Increment
4.) condition, final value

// ForCounter.java
import java.awt.Graphics;
import javax.swing.JApplet;
public class ForCounter extends JApplet

{
public void paint( Graphics g )
{ 1. 2. 4. 3.
for( int counter=1 ; counter <= 10 ; counter++ )
{
g.drawLine( 10, 10, 250, counter * 10 );
}
}
}
1.) count variable
2.) starting value
3.) increment
4.) condition, final value
• When appropriate, the for is quick and easy.

• The for loop is a do-while.
• It tests the condition before it

executes the loop for the first time.
( • Note: since the variable int counter was

declared within the for , it vanishes after the
for is finished. )

1. 2.
int counter = 1;
TRUE { body }
3. counter <= 10
?
FALSE counter++
4.

• All Three Sections are Optional
• Effects of Omitting Sections: condition
for(for(
int int
x = x1;= x1;;
< 10;
x++ x++
) )
• If you omit the condition, Java

assumes the statement is true, and
you have an infinite loop.

• Effects of Omitting Sections: initialization
int x = 1;
for( intx x< =10;
for(; 1; x++
x < )10; x++ )
• You can omit the initialization if

you have initialized the control
variable someplace else.

• Effects of Omitting Sections: increment
for(
for(int
intx x= =1;1;x x< <10;
10;)
x++ )
{
other stuff
x++;
}
• You can omit the increment of
the variable if you are doing so
within the body of the loop.
// Calculate Compound Interest
import javax.swing.JOptionPane;
import java.text.DecimalFormat;
import javax.swing.JTextArea;
public class Interest

{
Introducing two new class objects:

DecimalFormat
and the
JTextArea.
JTextArea is one of many GUI classes
that we use to put text onto a window
} // end of class Interest

import java.text.DecimalFormat; w

{
public static void main( String args[] )
{
double amount, principle = 1000.0, rate = 0.05;
DecimalFormat twoDig =
This is the common style of creating objects.

ObjectType instanceName.
After this statement executes, twoDig is a
complete example, or instance, of the
DecimalFormat class.
Actually, since it hasn’t been initialized,
System.exit( 0 );
} // end of main() twoDig is still only a reference.
import javax.swing.JOptionPane; w

{
{
DecimalFormat twoDig = new DecimalFormat( “0.00” );
Every class has a default method—a Constructor—whose only

purpose is to initialize a fresh instantiation of the class.
The new keyword fires the default “Constructor” method.
The Constructor always has the exact same name as the class.
( Chapter 6 covers this in greater detail.)
System.exit( 0 );
} // end of main()

{
{
JTextArea output = new JTextArea( 11, 20 );
Once again, we have the same pattern. The name of a

class—JTextArea—followed by the name of an
instantiation of that class—output.
Next, we fire off the default Constructor using the
new keyword. In this case, we are making a JTextArea
System.exit( 0 );
}
11//columns
end of main()
wide by 20 columns tall.
JTextArea—a brief sidebar
• A JTextArea is a multi-line area that displays plain text.
• This is the actual
documentation for the
JTextArea. You
must become
comfortable
looking up and
interpreting this
information.
Here, you should
notice that there are several Constructors.
The top one—which you notice takes no arguments—is
the “default” Constructor.

{
{
output.append( “Year\tAmount on deposit\n” );
Since output is an object of type JTextArea, it possesses all the

methods of that object. Method append says to add the String data to
the JTextArea in the order that we wish it to appear within the
JTextArea.
System.exit( 0 );
Notice,
} // end can
we either pass it a String object (a variable that contains a
of main()
} // end of String object), or we can just pass it a String.
class Interest

{
{
for( int year = 1; year <= 10; year++ )

{
} // end of for
System.exit( 0 );
} // end of main()
Since Java has no exponentiation operator, we
calling on the Math library’s method (pow for
public class Interest power).

{
Notice,
public static void main( it expects
String args[] ) as arguments two
{
doubles. These will be used in this way: ab
= (1.0
DecimalFormat twoDig or + rate)year
new DecimalFormat( “0.00” );
The return value is a double.

{
amount = principle * Math.pow( 1.0 + rate, year );
output.append( year + “\t” + twoDig.format(amount) + “\n”);
} // end of for
System.exit( 0 );
} // end of main()

{
{

{
} // end of for
JOptionPane.showMessageDialog( null, output,

“Compound Interest”, JOptionPane.INFORMATION_MESSAGE);
System.exit( 0 );
} // end of main()

{
{

{
} // end of for
JOptionPane.showMessageDialog( null, output,

“Compound Interest”, JOptionPane.INFORMATION_MESSAGE);
System.exit( 0 );
} // end of main()

Multiple-Selection Structure
• Once you start nesting many ‘if’s, it becomes a nuisance.
• Java—like C and C++ before it—provides the switch
structure, which provides multiple selections.
• Unfortunately—in contrast to Visual Basic’s Select
Case and even COBOL’s Evaluate—you cannot use
any of type of argument in the switch statement other
than an integer.

int x = 0;
switch( x ) • The integer expression x is
{
case 1:
evaluated. If x contains a 1,
do stuff; then the case 1 branch is
break;
case 2: performed. Notice the
do stuff; ‘break;’ statement.
break;
case 55: This is required. Without it,
do stuff; every line after the match
break;
case 102: will be executed until it
case 299:
do stuff okay for both;
reaches a break;
break;
default:
if nothing else do this stuff;
break;
} w
• The expression within the switch( expression )
section must evaluate to an integer.
• Actually, the expression can evaluate to any of these
types (all numeric but long):
byte
short
int
char
but they will be reduced to an integer and that value

w
will be used in the comparison.
• The expression after each case statement can only be a
constant integral expression
—or any combination of character constants and integer

constants that evaluate to a constant integer value.
w
• The default: is optional.
• If you omit the default choice, then it is possible
for none of your choices to find a match and that
nothing will be executed.
• If you omit the break; then the code for every

choice after that—except the default!—will be
executed.
w
• Question: if only integer values can appear in the
switch( x ) statement, then how is it possible for
a char to be the expression?

Statements
break; and continue;
• Both of these statements alter the flow of control.
• The break statement can be executed in a:
while
do/while
for
switch
• break causes the immediate exit from the structure

Statements break; and continue;
• After a break exits the “structure”—whatever that
is—execution resumes with the first statement
following the structure.
• If you have nested structures—be they a while,

do/while/ for or switch—the break will only exit the
innermost nesting.
• break will not exit you out of all nests. To do that,

you need another break*
* There is a variant of the break called a labeled

break—but this is similar to a goto and is frowned
upon.
• The continue statement, when used in a while or
do/while or a for, skips the remaining code in the
structure and returns up to the condition.
• If the condition permits it, the next iteration of the

loop is permitted to continue.
• So, the continue is a “temporary break.”
• The continue is only used in iterative structures,

such as the while, do/while and for.

• The “Labeled” continue and break statements send
execution to the label to continue execution.
• Note: using the labeled break and continue is bad code.
Avoid using them!
stop:
for(row = 1; row <= 10; row++)

{
for(col=1; col <=5; col++)
{
if( row == 5)
{
break stop; // jump to stop block
}
output += “* “;
}
output += “\n”;
}
JScrollPane—a brief sidebar
• We are all familiar with the scrollable pane—it means

the amount of text available is larger than the screen.
• Java provides the JScrollPane, which is an API that is

capable of scrolling text in this manner.

• Bizarre construction, because it uses composition—
where several smaller tools are combined to form a larger
tool.
• A String object feeds into a JTextArea, which feeds into

a JScrollPane object.

String
JTextArea( )
JScrollPane( )
JOptionPane( )
JOptionPane( null, JScrollPane( JTextArea( String) ) )

// ExploreJScrollPane.java
import javax.swing.*;
public class ExploreJScrollPane

{
{
String output = "Test\nTest\nTest\n";
System.exit( 0 );
}
}


{
{
JTextArea outputArea = new JTextArea( 10, 10 );
outputArea.setText( output );
System.exit( 0 );
}
}


{
{
JScrollPane scroller = new JScrollPane( outputArea );
System.exit( 0 );
}
}


{
{
JScrollPane scroller = new JScrollPane( outputArea );
JOptionPane.showMessageDialog( null, scroller,

"Test JScrollPane",
JOptionPane.INFORMATION_MESSAGE );
System.exit( 0 );
}
}


Logical Operators
• So far, all of the conditions we have tested were simple.
• It is possible to construct complex conditions using the
Java Logical Operators, which—again—were inherited
form C/C++.
&& Logical AND
|| Logical OR
! Logical NOT

Logical Operators
• Logical AND—two ampersands together.
&&
if( gender == ‘F’ && age >= 65 )
• Condition is true only if both halves are true.

• Java will short-circuit the process—skipping the 2nd
half of the expression—if the first half is false.
Logical Operators
• Logical OR—two “pipes” together. (Shift of key
underneath backspace.)
|| (no space between)
if( gender == ‘F’ || age >= 65 )
• Entire condition is true if either half is true.

Logical Operators
• Logical NOT—single exclamation mark.
if( !(age <= 65) )
• Negates the expression—not many opportunities to

use.

Logical Operators
• Logical Boolean AND—one ampersand.
&
if( gender == ‘F’ & ++age >= 65 )
• A Logical Boolean AND [ & ] works exactly like

a Logical AND [ && ] with one exception.
• A Logical Boolean AND [ & ] will always check

both halves of the equation, even if the first is false.
Logical Operators
• Logical inclusive Boolean OR—one pipe.
|
if( gender == ‘F’ | age >= 65 )
• Again, this works just like the Logical OR, but you
are guaranteed that both sides of the expression will
always be executed.
• If either half is true, the entire ‘if’ is true.
Logical Operators
• Logical exclusive Boolean OR.
^ ( shift 6 )
if( gender == ‘F’ ^ age >= 65 )
• This Logical exclusive Boolean OR is true only if

one side is true and the other false.
• If both sides are true, the entire expression is false.

Java I Lecture 5.pps

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java I Lecture 5.pps

Uploaded by

Copyright:

Available Formats

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

public class WhileCounter extends JApplet

while( counter <= 10 ) // 4.) condition, final value

for( int x = 1; x < 10; x++ )

1.) count variable,

Java I--Copyright © 2000 Tom Hunter

public class ForCounter extends JApplet

• When appropriate, the for is quick and easy.

• The for loop is a do-while.

• It tests the condition before it

( • Note: since the variable int counter was

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

• If you omit the condition, Java

Java I--Copyright © 2000 Tom Hunter

• You can omit the initialization if

Java I--Copyright © 2000 Tom Hunter

public class Interest

Introducing two new class objects:

} // end of class Interest

public class Interest

This is the common style of creating objects.

public class Interest

Every class has a default method—a Constructor—whose only

public class Interest

Once again, we have the same pattern. The name of a

public class Interest

output.append( “Year\tAmount on deposit\n” );

Since output is an object of type JTextArea, it possesses all the

public class Interest

output.append( “Year\tAmount on deposit\n” );

for( int year = 1; year <= 10; year++ )

public class Interest power).

for( int year = 1; year <= 10; year++ )

public class Interest

output.append( “Year\tAmount on deposit\n” );

for( int year = 1; year <= 10; year++ )

JOptionPane.showMessageDialog( null, output,

public class Interest

output.append( “Year\tAmount on deposit\n” );

for( int year = 1; year <= 10; year++ )

JOptionPane.showMessageDialog( null, output,

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

but they will be reduced to an integer and that value

• The expression after each case statement can only be a

constant integral expression

—or any combination of character constants and integer

• If you omit the break; then the code for every

Java I--Copyright © 2000 Tom Hunter

• The break statement can be executed in a:

• break causes the immediate exit from the structure

• If you have nested structures—be they a while,

• break will not exit you out of all nests. To do that,

* There is a variant of the break called a labeled

• If the condition permits it, the next iteration of the

• So, the continue is a “temporary break.”

• The continue is only used in iterative structures,

Java I--Copyright © 2000 Tom Hunter

for(row = 1; row <= 10; row++)