Java lab(s) needed.

I need u to do these labs: 9 and 10. here are files given. in the pdf, navigate to lab 9 and 10, directions are there at the bottom in specification. the panels and all that is given, i need you to fill in the blanks in them and make the program work.

//Name______________________________ Date_____________
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Panel09 extends JPanel
private JLabel label;
private double total;
public Panel09()
setLayout(new BorderLayout());
total = 0.0;

/* Create and add the subpanel */
/* */
/* */
/* Add the big label */
/* */
private void addButton(JPanel panel, String s, double x)
/* */
/* Your code goes here. */
/* */

private class Listener implements ActionListener
private double myX;
public Listener(double x)
myX = x;
public void actionPerformed(ActionEvent e)
/* */
/* Your code goes here. */
/* */

//Name______________________________ Date_____________
import javax.swing.*;
import java.awt.*;
public class Display10 extends JPanel
private JLabel label;
private int last, next;
public Display10()
setLayout(new GridLayout(1, 1));
next = 5;

label = new JLabel(“5”);
label.setFont(new Font(“Serif”, Font.BOLD, 100));
private void pickNext()

/* */
/* Your code goes here. */
/* */

public boolean guessHigh()
return next > last;
public boolean guessLow()
return next < last; } }

//Torbert, e-mail:, website:
//version 4.4.2003
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Panel10 extends JPanel
private Display10 display;
private Scoreboard10 scoreboard;
public Panel10()
setLayout(new BorderLayout());

scoreboard = new Scoreboard10();
add(scoreboard, BorderLayout.NORTH);

display = new Display10();
add(display, BorderLayout.CENTER);

JPanel panel = new JPanel();
panel.setLayout(new FlowLayout());
add(panel, BorderLayout.SOUTH);
JButton button1 = new JButton(“High”);
button1.addActionListener(new Listener1());
JButton button2 = new JButton(“Low”);
button2.addActionListener(new Listener2());
private class Listener1 implements ActionListener
public void actionPerformed(ActionEvent e)
private class Listener2 implements ActionListener
public void actionPerformed(ActionEvent e)

//Name______________________________ Date_____________
import javax.swing.*;
import java.awt.*;
public class Scoreboard10 extends JPanel
private JLabel label1, label2, label3;
private int total, max;
public Scoreboard10()
setLayout(new GridLayout(1, 5));
total = max = 0;

add(new JLabel(“Run: “, SwingConstants.RIGHT));
label1 = new JLabel(“0”);
label2 = new JLabel(“—“);
label2.setFont(new Font(“Serif”, Font.BOLD | Font.ITALIC, 20));
add(new JLabel(“Max: “, SwingConstants.RIGHT));
label3 = new JLabel(“0”);
public void update(boolean arg) //arg is true means player guessed correct

/* */
/* Your code goes here. */
/* */


Unit Three – User Interface

July 2011

Developed by Shane Torbert

edited by Marion Billington

under the direction of Gerry Berry

Thomas Jefferson High School for Science and Technology

Fairfax County Public Schools

Fairfax, Virginia







Contributing Authors

The author is grateful for additional contributions from Michael Auerbach, Marion Billington, Charles Brewer, Margie

Cross, Cathy Eagen, Anne Little, John Mitchell, John Myers, Steve Rose, Ankur Shah, John Totten, and Greg W.


The students’ supporting web site can be found at

The teacher’s (free) FCPS Computer Science CD is available from Stephen Rose (

License Information

This work is licensed under the Creative Commons Attribution-Noncommercial-No Derivative Works 2.5 License. To

view a copy of this license, visit or send a letter to Creative

Commons, 543 Howard Street, 5th Floor, San Francisco, California, 94105, USA.

You are free:

* to Share — to copy, distribute, display, and perform the work

Under the following conditions:

* Attribution. You must attribute the work in the manner specified by the author or licensor.

* Noncommercial. You may not use this work for commercial purposes.

* No Derivative Works. You may not alter, transform, or build upon this work.

* For any reuse or distribution, you must make clear to others the license terms of this work.

* Any of these conditions can be waived if you get permission from the copyright holder,

You are free to alter and distribute these materials within your educational institution provided that appropriate credit

is given and that the nature of your changes is clearly indicated. As stipulated above, you may not distribute altered

versions of these materials to any other institution. If you have any questions about this agreement please e-mail



Java Instruction Plan—Unit Three

Section One – Event Driven Programming Page

Lab00: Hello Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-3 to 5

Lab01: Hello Text Box . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-6 to 8

Lab02: Multiple Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-9 to 11

Lab03: Hailstone Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-12 to


Section Two – What’s Inside the Black Box?

Lab04: Odometer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-15 to


Lab05: Press Your Luck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-17 to 19

Lab06: Luck of the Roll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-20 to 21

Lab07: GCD and LCM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-22 to 24

Section Three – GUI Formatting

Lab08: Sum of a Series . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-25 to


Lab09: Subway Tokens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-27 to 29

Lab10: High – Low . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-29 to 30

Lab11: Last Stone Wins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-31

Section Four – I/O Window Output

Lab12: Asterisks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-32 to 34

Lab13: The Necklace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-35

Lab14: Bowling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


Section Five – Additional GUI Topics

Lab15: More GUI Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-37

Lab16: The jGrasp Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-39

Lab17: Mixing Graphics and GUIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Three-40



Panels, GUI Components, and Listeners

A Graphical User Interface (GUI) allows users to point and click on on-screen “buttons.” Almost all

computers today are operated through GUIs, but once upon a time people used keyboards, punchcards, or even

dials and toggle switches. A GUI is quite hard to program, unless you are in an object-oriented language, in

which case it is fairly easy. That’s because an object oriented language takes advantage of abstraction,

inheritance, and encapsulation. For example, each object in a GUI, such as the buttons, textfields, labels,

panels, and frame, “knows” its own attributes and methods—that is encapsulation. Like the Polkadot and Ball

classes in Unit 2, each GUI object even knows how to draw itself. Each object inherits some of its methods

from higher up the hierarchy, overrides some methods, and adds new methods. The hierarchy proceeds from

abstract to concrete, with the programmers assigning powers at the appropriate level. For example, abstractly

considered, all JComponent objects can be assigned ActionListeners. You, the programmer, work with the

concrete objects when you assign a specific button to a specific listener. (You did the same thing in Unit 2,

when you assigned a timer to a specific listener.) You also, as the last programmer in the chain, get to say

exactly what happens when each button is clicked.

The structure of the applications in

this unit is exactly the same as in Unit

2. The driver creates a frame, puts the

panel on the frame, and displays the

frame. The panel has the buttons,

labels, text boxes, and even other

panels. Visually, a GUI is not a whole

lot different from straight graphics.

However, in a GUI the program reacts

to something the user does. Unlike

programs in Units 1 and 2, our GUI

will wait patiently until a button is

clicked, then it springs forth and does

its thing. Best of all, we don’t have to

know the details of how all that

works. Someone else programmed

buttons and listeners for us.

Just for fun, here is the hierarchy, including interfaces, for a JButton:








All Implemented Interfaces:

Accessible, ImageObserver, ItemSelectable, MenuContainer, Serializable, SwingConstants





Hello Button


Understand frames, panels, and GUI components.


The drivers in Unit 3 are exactly the same as those in Unit 2. The panel

will have GUI components like this:


Filenames Unit3\Lab00\ and Unit3\Lab00\ Enter the source code for the driver.

Enter the source code for the resource class (the panel) as shown below, then compile and run the program.

Lines 4-6: import the swing,

awt, and event classes.

Line 9: The panel’s JLabel is

a private field. This is

essential if we want to access

the label in the


Lines 10-22: The constructor.

Line 12: set the panel‘s layout

Lines 14-17: Instantiate a

label, set its font and color,

then add it to the panel.

Lines 19-21: Instantiate a

button, register its listener,

then add it to the panel.

Line 23: Listener implements

the ActionListener interface,

meaning that actionPerformed

must have code.

Line 28: (” ” + x) converts a

number to a string, because

setText requires a string.

The scope of a variable is the region of the program in which it is valid to use that variable. The global

private JLabel label in Line 9 has a wider scope than the local JButton button on Line 19 and the

local double x in Line 27. The blue lines down the side in jGrasp show the scope of the different variables.

We need to declare the panel‘s private Jlabel label on Line 9 because we want the listener on Line

28 to use it. In contrast, the listener does not need to use the button. Therefore, we declared JButton

button on Line 19, restricting its scope entirely inside the constructor. Similarly, the double x in Line 27

has a scope that entirely inside the actionPerformed method, which is where we want to use it.

Test Data Go to



4 import javax.swing.*;

5 import java.awt.*;

6 import java.awt.event.*;

7 public class Panel00 extends




9 private JLabel label; //a private field

10 public Panel00()



12 setLayout(new FlowLayout());


14 label = new JLabel(“0.0000000000000000”);

15 label.setFont(new Font(“Serif”, Font.BOLD, 20));

16 label.setForeground(;

17 add(label);


19 JButton button = new JButton(“Random”); //local

20 button.addActionListener(new Listener());

21 add(button);



23 private class Listener implements ActionListener




public void actionPerformed(ActionEvent e)



27 double x = Math.random(); //local variable

28 label.setText(“” + x);





31 }




1) What three steps do you have to do to create buttons?

2) add(label) adds a label to the _______________.

3) There are at least four GUI components showing below. Label them all.

4) A fifth GUI component is hidden, but you know it is there. What is it?

5) What do you have to do to program the action of a button?

6) What interface does every button‘s listener implement? ____________________________

7) What method is in that interface? _________________________________

8) ―To implement an interface‖ means to write concrete methods for all the ___________________ methods
in the interface.

9) Give the range of values that the following will generate:

a. Math.random(); ____________________

b. Math.random() * 10; _____________________

c. Math.random() * 100; _______________________

d. Math.random() * 6; ______________________



GUI components, strings, numbers

The initial text that appears in any label, button, or text box can be specified through the object’s constructor.

private JLabel label;

private JTextField box;

public Panel01()


label = new JLabel(“0.0”);

JButton button = new JButton(“SQRT”);

box = new JTextField(“0.0”, 10);

In the last command, the text field named “box” will display 0.0, right justified, and it will be 10 characters in

total width. There is no way to set the font or color for all components with a single command. You must call

the set methods on each component individually. Look at the API for all the relevant formatting commands.

To a Java compiler, “6” is different from 6, which is different from 6.0. “6” is a string, 6 is an integer, and 6.0

is a double, and each representation of 6 is stored in a completely different way. We humans want to convert

each kind of 6 into the other kinds. In Lab01, we will want to retrieve a number from the text field. We use

the method getText, which returns a string. Then we turn that string (the ―6‖) into a double (the 6.0) using

the Double.parseDouble method.

double d = Double.parseDouble(box.getText());

After we do the arithmetic with d, often saving the result in a new double variable, then we need to


the result on the screen. In other words, we have to change the double into a string. We can do so with

label.setText(“” + d);

In Java, the quote-quote-plus returns the string representation of the double. Then setText accepts the

string and displays it on the label.

There is a difference between a declaration and an instantiation. In a declaration, such as,

private JLabel label;

you create a reference that eventually will point to an object. In a declaration you don‘t create the object itself.

A call to the class‘s constructor, using the keyword new, actually instantiates the object. Only then does the

JLabel reference point to the JLabel object.

label = new JLabel(“”);

label OBJECT

We declare and instantiate in separate steps whenever we need to access the private reference in several

methods, i.e. when the scope of the field must be global. We saw this in Lab00 at lines 9, 14, and 28.




Hello Text Box


Fields vs. local variables


Lines 9-10: These three

declarations create private

fields because the fields need

to be accessed later in the


Line 13: FlowLayout is the

simplest GUI layout. The first

component added to the panel

is placed at the center top.

Additional components are

placed to the right, or on the

next line. Be sure to drag the

corner of the frame and watch

how the flow works.

Line 15-31. Notice the

different components are

instantiated, formatted, and

added to the panel.

Components appear in the

order in which they are added.

Line 19: This button is

declared local because it does

not need to be accessed in the

listener, unlike the label and

the textField.


Filename Unit3\Lab01\ Create an appropriate driver. Make sure to add a panel object of type


Filename Unit3\Lab01\ Type in the resource class above. Implement the method

actionPerformed to find square roots. What happens if you type a negative number into the text box?


Edit your program to handle negative numbers correctly, i.e., returns 5i. You will need an if-


Warning! A common error is to write Line 15 as JTextField box = new JTextField(“0.0”, 10);

Write Line 15 with this mistake. Compile and run. Explain the error message.

Test Data

Go to


4 import javax.swing.*;

5 import java.awt.*;

6 import java.awt.event.*;

7 public class Panel01 extends JPanel

8 {

9 private JLabel label1; //field

10 private JTextField box; //field

11 public Panel01()

12 {

13 setLayout(new FlowLayout());


15 box = new JTextField(“0.0”, 10);

16 box.setHorizontalAlignment(SwingConstants.RIGHT);

17 add(box);


19 JButton button = new JButton(“SQRT”); //local

20 button.addActionListener(new Listener());

21 add(button);


23 label1 = new JLabel(“0.0”);

24 label1.setFont(new Font(“Serif”, Font.BOLD, 20));

25 label1.setForeground(;

26 add(label1);

27 }

28 private class Listener implements ActionListener

29 {


public void actionPerformed(ActionEvent e)



32 //get the number

33 //take the square root

34 //display it



36 }

37 }




1) There are at least five GUI components showing below. Label them all.

2) Describe a ―string‖ in Computer Science.

3) Describe a ―double‖ in Computer Science.

4) How do you get a string that is in a textField?

5) How do you change that string into a double?

6) How do you change a double into a string, as when you setText a numerical answer into a label?

7) Define and/or explain every underlined term.:
double d = Double.parseDouble( textField.getText() );

Complete this scavenger hunt using Sun’s on-line Java API.

8) What is the lowest common ancestor of JButton, JLabel, and JTextField? _______________________

9) How many methods does the ActionListener interface specify? _________________________

10) What package is ActionEvent in? _________________________

11) How many classes extend JButton? __________________

12) How many constructors does JButton define? _________________________

13) How many methods does JButton define? _________________________

14) JButton has a setText method. When would you ever want to use a button’s setText in the middle of

a program?

15) How many constructors does JTextField define? _________________________

16) Write the code to instantiate a JTextField with “Enter name” in the field, and the field is 20 spaces wide.




public class Panel02 extends JPanel


//fields–for objects that must be accessed later

public Panel02() //constructor


format the panel,

instantiate and format the GUI components,

register the listeners,

add the GUI components.


private class Listener1 implements ActionListener

public void actionPerformed(ActionEvent e)

. . .


//another listener

//another listener

Multiple Buttons

The event model we have seen thus far can be applied to any number of buttons and listeners.

listener1 listener2

component1 component2



Simply declare a separate listener class for each different action that has to be performed. Register listener

objects with buttons appropriately.

button1.addActionListener(new Listener1());

button2.addActionListener(new Listener2());

button3.addActionListener(new Listener3());

The code above will work, but the names are not informative. You should use informative names, such as:

randomNumber.addActionListener(new RandomListener());

reciprocalButton.addActionListener(new ReciprocalListener());

quitButton.addActionListener(new QuitListener());

As the code below says, each private listener class implements the ActionListener interface. That interface

specifies exactly one abstract method, actionPerformed. That means that each Listener code must define

its own actionPerformed method to specify what happens on each button-click.

Be careful! The placement of

braces is critical to ensure the

proper scope of the fields and

listeners. The listener classes

must be able to access the

fields. In other words, the

scope of the private fields must

include the listener classes.

Also, each of the listener classes

must be visible outside the

constructor. Do not define one

listener class inside another or

the one inside will not be visible

from the constructor.

Sadly, a common error is to put

the definition of one listener

class entirely inside the

definition of another.



Multiple Buttons


GUIs and listeners.


When working with numbers and text, remember that the argument passed to the setText method must be a


Similarly, remember that the return type passed out of the setText method is always a string. If you want

to do arithmetic on the return type, you’ll need to parse it, either to an int or to a double.

Some static (class) methods in the Math class that you should know:

Math function Example command

Absolute value x = Math.abs(y);

Square root x = Math.sqrt(y);

Square x = y * y;

Cube root x = Math.pow(y, 1.0/3.0);

Set x equal to 1 x = Math.pow(y, 1/3); //due to integer division, 1/3  0

Raise to a power x = Math.pow(2, 10); //Recall that 2

= 1024

Sine, y in degrees x = Math.sin(y * Math.PI / 180.0);

Cosine, y in degrees x = Math.cos(Math.toRadians(y));


Filename Unit3\Lab02\ Create an appropriate driver. Make sure to add a panel object of type

Panel02. Size recommendations for the frame are included as part of the on-

line demo.

Filename Unit3\Lab02\ Reverse engineer the panel based on the on-line demo. Notice that there

is no text box, but that there is only one label. Since you have four buttons, you will have to have four

listeners. To make the Quit button work, check the System class in Sun‘s Java API for some hints.

Test Data
Go to




1) label.setText(number)gives an error message. What is the error, and how

do you fix it?

2) How do you change a string into a double?

3) Define and/or explain every underlined item.

private class Handler implements ActionListener

public void actionPerformed(ActionEvent e)


int num = Integer.parseInt( text.getText() );

int result = num * num;

label2.setText (“The square of the number is ” + result);


Vocabulary practice:

3a) In the code above, ActionListener is a(n) __________________

3b) In the code above, actionPerformed is a(n) __________________

3c) In the code above, Integer is a(n) __________________

3d) In the code above, parseInt is a(n) __________________

3e) In the code above, text is a(n) __________________

3f) In the code above, getText is a(n) __________________

3g) In the code above, int is a(n) __________________

3h) In the code above, result is a(n) __________________

3i) In the code above, label2 is a(n) __________________

3j) In the code above, setText is a(n) __________________



Primitive Data Types

A data type defines a specific kind of data, e.g., numbers, Strings, or Robots, and how a computer internally

stores and manipulates that data. A class, either imported or user-defined, defines some specific data type.

Java also provides several primitive data types including int (for integers) and double (for decimal

numbers). Primitive data types do not contain any methods. Useful integer methods are instead defined in a

wrapper class. The integer wrapper class is called Integer and the decimal wrapper class is called Double.

Thus, we have Integer.parseInt and Double.parseDouble. Other useful methods are in the API.

Internally, objects are accessed by references, but primitives store their data directly. The convention in Java

is that names of classes start with a capital letter and names of primitives are lower case, reserved words.

Robot karel = new Robot(); Turtle smidge = new Turtle(); int x = 5; double d = 5.00;

karel smidge x 5 d 500 2

Robot is a class, Turtle is a class, primitive type: int primitive type: double

karel is a pointer smidge is a pointer x stores 5 d stores 5.00

One tricky part about ints and doubles is casting, which means changing the data type from one to the

other. Sometimes Java casts automatically and sometimes you must cast explicitly. Suppose your code is:

int x = 4; //creates room for an integer, calls it “x”, and stores 4 in it.

double y = 0; //creates room for a double, calls it “y”, and stores 0.0 in it.

y = (double)x; //it works: the code casts 4 explicitly, which becomes 4.0 and is stored in y.

y = x; //it works: the integer 4 is promoted to 4.0 automatically.


x = y; //illegal, due to loss of precision. The 0.0 does not become 0 automatically.

x = (int)y; //it works: you must explicitly tell the computer to truncate the decimal.

Presumably, the Java creators decided that 4 can become 4.0 without risk, but that decimals shouldn’t lose their

decimal parts without the programmer explicitly saying that it is okay.

If you copy and paste code too much you may accidentally apply parseInt or parseDouble when you

need the other one. Always look at the type of the variable and choose appropriately.

int x = Integer.parseInt(“5”);

double y = Double.parseDouble(“5.0”);

Don‘t forget how to change numbers into strings: label.setText(“” + number);

Java is a strongly typed language, meaning that Java is very particular about requiring the correct data type,

either int, double, String, or some other object. A large part of the compiler‘s job is to guarantee

type-safe code. Other, uncompiled, languages do not care so much about type-safe code.



Hailstone Numbers


Integer division and modulus.

Here‘s the Hailstone algorithm: start with a random integer from 1 to 100. If the number is even, divide it by

two to generate the next number. If the number is odd, multiply it by three and add one to generate the next

number. Keep generating in that way. What happens? The answer is the hailstone numbers, which you will

see in action once your Lab03 is working.

This is new for you: in Java, when you divide two integers you will always get an integer quotient! The

remainder, if any, is ignored and thrown away. For example:

int x = (10 * 6 + 7 – 30) / 8;

Sometimes, finding the remainder is quite useful. The remainder is calculated by the modulus operator,

whose symbol in Java is %. For instance:

int y = (10 * 6 + 7 – 30) % 8;

To understand integer division and modulus, think back to long division. For example, 37 8

Notice that the / does not round up. Any remainder is truncated. Truncated means discarded. So even if you

took 9,999/10,000 it would equal zero.

The Hailstone algorithm requires you to determine if an integer is even. A good way to do this is to check to

see if the remainder (%) obtained from dividing the integer by two equals zero. For example:
number % 2 == 0

Filename Unit3\Lab03\ Create an appropriate

driver. Make sure to add a panel object of type Panel03. Size

recommendations for the frame are included as part of the on-

line demo.

Filename Unit3\Lab03\ (load). Complete the

definition of each listener‘s actionPerformed to reverse

engineer the on-line demo.

Test Data

Be sure to play with the on-line demo that is at

Extension for math geniuses: Every sequence of Hailstone numbers seems to end in 4, 2, 1, but no one has

proved it to be so. If you come up with a proof, your name will be honored among mathematicians.

x 4

y 5


8 37



37 / 8  4

37 % 8  5




1) Practice integer division, modulus division, and decimal division. Remember the order of operations.

14 / 5 

14 % 5  14.0 / 5.0  3 + 19 % 6 – 4 

15 / 5 

15 % 5  15.0 / 5  1 + 8 % 2 

16 / 5 

16 % 5  16 / 5.0  2 / 3 * 3 

17 / 5 

17 % 5  17 / 5.  1234 % 10 / 1 

3 / 5 

3 % 5  3 / 5.  1234 % 100 / 10 

0 / 5  0 % 5  0.0 / 5  1234 % 1000 / 100 

2) int amount = Integer.parseInt (―143‖); amount
int quarters = amount / 25; quarters
amount = amount % 25;
int dimes = amount / 10; dimes
amount = amount % 10;
int nickels = amount / 5; nickels
int pennies = amount % 5; pennies
int numCoins = quarters + dimes + nickels + pennies; numCoins

3) Given totalSeconds, the total number of seconds, write assignment statements to store the number of

minutes and the number of extra seconds. For example, if totalSeconds = 121, then min = 2 and sec = 1.

4) Write an assignment statement to store the remainder when an integer is divided by 3.

5) Write the code for: if some number x is odd, set a label to print ―odd‖.

6) int x = Double.parseDouble(box.getText()); generates an error. What is it, and how

do you fix it?

Complete this scavenger hunt using Sun’s on-line Java API.

7) What class does the Integer class extend? _________________________

8) What kind of argument does the method parseInt require in the version that requires only a single

argument? _________________________

9) What kind of value does the method parseInt return? _________________________

10) What is the second field listed in the Double class? _________________________



The Black Box

Most of us have no idea how buttons and listeners actually work. They are like a black box to us, in that their

private data and their implementation code are hidden and encapsulated. The client, often another

programmer, uses black box objects without knowing how they are doing what they are doing. Furthermore,

we don’t care how they work! (If you really want to know how buttons and listeners work, ask your teacher

how to view Sun‘s Java source code.)

In Lab04, you get a chance to do your own black box programming. Driver04 looks exactly like all the other

drivers. It hasa Panel04, which has already been written and compiled for you, but is shown below. Do not

type it in!

Lines 4-6: Import some

mysterious classes.

Line 9: declares a private field

of type Odometer.

Lines 14-15: The panel

instantiates and adds an

odometer object to itself. What

is an odometer object? The

panel doesn‘t know!

Lines 17 – 19: create a button,

as usual.

Line 25: When the button is

clicked, the update method in

the odomoter object is called.

What is update? At this

point, we don’t know. All we

know is that it is a method in the

odometer class.

Your job, should you decide to accept it, will be to program the Odometer class.

Draw the CSD scope lines in the code above. Give an example of a global variable: ___________ Give an

example of a local variable: ________________

Fill in the UML diagram for Lab04:




4 import javax.swing.*;
5 import java.awt.*;
6 import java.awt.event.*;

7 public class Panel04 extends JPanel

8 {

9 private Odometer odometer;

10 public Panel04()

11 {

12 setLayout(new FlowLayout());


14 odometer = new Odometer();

15 add(odometer);


17 JButton button = new JButton(“Step”);

18 button.addActionListener(new Listener());

19 add(button);

20 }

21 private class Listener implements ActionListener

22 {

23 public void actionPerformed(ActionEvent e)

24 {

25 odometer.update();

26 }

27 }

28 }







Look inside a black box. Modulus and Integer Division ( % and / )


The shell for the Odometer class is shown below.

An odometer is an object

that displays numbers.

Clearly, the Odometer class

should extend the JPanel

class. Since Odometer isa

JPanel, set the layout. Set

the background to black. Add the GUI components to

make the odometer panel look like an odometer.

Which kind of components do you need? How many?

Default labels are ―clear‖. There is a way to make the

label ―opaque.‖ You’ll also have to set the background

and the foreground colors. Look at Sun‘s API.

An odometer also keeps count. You will have to add a

counter to the odometer.

Someone using Panel04 will

click on the “step” button.

That action causes the

odometer‘s update method

to be called. When update

is called, it increments the

counter and displays the result

in the labels. In the case

shown, the counter variable is storing 57. To display

the result in the labels you will have to use / and %.

Once again we have an example of encapsulation at

work. Updating is something Odometer does; button-

clicking is something Panel04 does; and the frame

holds it all.

Filename Unit3\Lab04\ (load). Complete the implementation of the Odometer class as

described above.

Filename Unit3\Lab04\Panel04.class. This file is given to you in compiled form. Don‘t overwrite it!

Filename Unit3\Lab04\ (load). This file has already been compiled. You do not have to compile

it again. Just run the driver and your Odometer.class file will be found by the system.

Test Data

Go to

2 import javax.swing.*;

3 import java.awt.*;

4 public class Odometer extends JPanel

5 {

6 /****************************/

7 /* */

8 /* Declare 3 fields. */

9 /* */

10 /* Declare 1 int variable. */

11 /* */

12 /****************************/


14 public Odometer()

15 {

16 /*******************************/

17 /* This is the constructor. */

18 /* Set the layout, set the */

19 /* background. */

20 /* Instantiate all objects and */

21 /* set their properties. */

22 /*******************************/

23 }

24 public void update()

25 {

26 /***************************/

27 /* */

28 /* Increment the counter, */

29 /* set the labels. */

30 /* */

31 /***************************/

32 }

33 }



Random Numbers

One of the most valuable uses of computers has been to allow massive calculations on a scale that human

beings themselves could not perform in a lifetime. This ability has led to large simulations of real-world

phenomenon based on mathematical models and randomly generated data. (Theoretically, a computer cannot

generate a pure random number but it can generate a number that is pseudorandom.) Of course, in order to

make use of this ability you have to know how to make your computer generate a random number. In Java

there are two popular ways of generating random numbers.

The Math class includes a method named random that returns a pseudorandom value that is greater than or

equal to zero and strictly less than one. These numbers are of the form…, where each letter represents

a single digit. Notice that the digit in front of the decimal point is always a zero. Since a computer is a finite

machine, it cannot store 0.999… repeating forever. At some point the digits must stop. Thus, a call to the

method Math.random cannot return one. Graphically we show it as:

Some examples of using Math.random:

double w = Math.random();

double x = Math.random() * 6;

double y = Math.random() * 6 + 1;

double z = Math.random() * 50 + 25;

These produce w on the interval [0, 1), x on the interval [0, 6), y on the interval [1, 7), and z on the interval

[25, 75). Written another way, 0 <= w < 1, 0 <= x < 6, 1 <= y < 7, and 25 <= z < 75. The general formula

for using Math.random is

double d = Math.random() * RANGE_OF_VALUES + LOWEST;

where the range of the values is 1 plus the difference between the largest and smallest possible values. Or:

double d = Math.random() * (HIGHEST – LOWEST + 1) + LOWEST;

Since random returns a double, how can we generate integers? What if we want to simulate rolling a six-

sided die? In this case you must cast the double into an integer, using (int) as follows:

int n = (int)(Math.random() * 6 + 1); //n є {1, 2, 3, 4, 5, 6}

Be careful! If you write

int n = (int)Math.random() * 6 + 1; //n = 1; bad, don’t do this

then n will always equal one. Without parentheses to specify the order of operations, the integer cast simply

truncates a random number of the form…, which of course will always equal zero. Multiplying 0

times 6 and adding 1 always results in 1.

The other popular way of generating a random number is to use the Random class from the java.util package.

You can research this technique for yourself using Sun‘s on-line Java API.

-1 0 1 2 3 4 5 6 7



7 public class Panel05 extends JPanel

8 {

9 private Display05 display;

10 public Panel05()

11 {

12 setLayout(new FlowLayout());


14 display = new Display05();

15 add(display);


17 JButton button = new JButton(“Press Your Luck”);

18 button.addActionListener(new Listener());

19 add(button);

20 }

21 private class Listener implements ActionListener

22 {

23 public void actionPerformed(ActionEvent e)

24 {


26 }

27 }

28 }

Press Your Luck


Random numbers.


Play with the on-line demo at When do

Value and Total change? When does High Score change?

How many labels do you need? How many buttons? When you

click the button, what happens?

This lab is organized with a driver, a panel, and a display. The

display encapsulates the three labels. The panel holds the display

and the button. Locate these elements at the right.

How is panel designed? Notice

that Line 9 declares a reference

that is empty at this point.

The concrete display object is

instantiated in Line 14 and

added to the panel in Line 15,

exactly as the odometer was

instantiated and added in


If we want to see the code for a

display object, we have to go to

the Display05 class and look.

Lines 17-25 code the typical

steps to create a working



Filename Unit3\Lab05\ (load). Complete the implementation of the Display05 class. Update

picks a random number from 1 to 11. If the number is 1 or 2 then your score goes to zero. Otherwise, add the

current value to your running total. Lastly, if there is a new high score, update it.

Filename Unit3\Lab05\ (load). Complete the Listener. What should the button do?

Filename Unit3\Lab05\ (load).


Create a second button that acts as an

on-off switch. Include a javax.swing

timer that calls update every 500 ms.

The text on the second button changes.

Test Data
Go to




1) Complete the UML class drawing for Lab05.

2) Give the range of values that the following will generate:

a) double x = Math.random(); _____________________

b) double x = Math.random() * 10; _____________________

c) int n = (int)(Math.random() * 10); _____________________

d) int n = (int)(1 + Math.random() * 10); ____________________

3) Assign n a random integer value from 1 to 100 inclusive.

4) Assign n a random integer value from 2 to 100 inclusive such that n must be an even number.

5) Assign x a random integer value from 40 to 50, inclusive.

6) Assign y a random integer value from 40 to 50 (inclusive) such that y does not equal the x from Question 5.

7) Assign y a different random integer value from 40 to 50 (inclusive) such that it does not equal its previous


8) Count the number of times a coin comes up heads in 10000 coin flips.

9) Count the number of times a six-sided die comes up 5 in 10000 rolls.









Luck of the Roll


Images, switch statement, return statement.


The panel has a Dice object and one button. The Dice object has two labels

which display the dots. The Dice class also defines the method roll. The

roll method rolls each die separately, i.e., it calls rollOne twice, and

returns the sum of the dice.

Return statements return values to the place where the method was

called. Since the method roll was called from the panel, the value

a+b will be returned to the panel. Similarly, since rollOne was

called from roll, the value of x will be returned to roll.

Because the code says int rollOne, the rollOne method must

have a return statement. In this case, rollOne will return a

single integer value from one to six, chosen randomly to simulate

the rolling of a single die. The private method rollOne will

return its value to where it was called in the method roll.

The rollOne method also sets the dots, which are ImageIcons.

Rolling a 1 has to set ―one ,‖ rolling a 2 has to set ―two ,‖ etc.

We could use an if-else ladder, but we can also use a switch

statement to do this. A switch statement makes decisions much like

an if-else ladder. Look at the Exercise #2 on the next page to see

the syntax for a switch statement.

Whether you use switch or if, recall the image commands from Unit2 to put a on a graphics object:

ImageIcon thomas = new ImageIcon(“tj “);

g.drawImage(thomas.getImage(), 150, 75, 110, 150, null);

The Unit3 commands to put a on a label is somewhat simpler:

ImageIcon thomas = new ImageIcon(“tj “);



Filename Unit3\Lab06\ (load). Implement the method rollOne. Pick a random number from one

to six to simulate rolling a real six-sided die. A label is being passed as an argument to rollOne. Put an

appropriate image on this label based on the value of the roll. Your method rollOne must have a return

statement to communicate the random value back to the method roll.

Filename Unit3\Lab06\ (load). Write actionPerformed. Ask yourself: when the button is

clicked, what should happen? Only if the roll is a seven should you display ―Winner!‖ on the label.

Filename Unit3\Lab06\ Create an appropriate driver.

Test Data Go to




Write the output exactly as it would appear on the screen. Check your prediction by typing each fragment into

a driver program.

# Code Fragment Output


for(int k=1; k<=5; k++)

if(k==1 || k==3)


else if(k==2 || k==4)




for(int k=1; k<=5; k++)



case 1:

case 3: System.out.println(“Odd.”);


case 2:

case 4: System.out.println(“Even.”);


default: System.out.println(“Foo.”);


int step = (int)(Math.random() * 3);



case 0: karel.move();


case 1: karel.turnLeft();


case 2: karel.turnRight();



for(int k=1; k<=5; k++)

if(k == 1 || k % 2 == 0)




for(int k=1; k<=5; k++)

if(k == 1 && k % 2 == 0)




public boolean isPrime(int a)


for(int k=a/2; k >= 2; k–)

if(a % k == 0)

return false;

return true;


System.out.println( isPrime(23) );

System.out.println( isPrime(25) );



30 public void showGCD()

31 {

32 int x = Integer.parseInt(box1.getText());

33 int y = Integer.parseInt(box2.getText());

34 int z = gcd(x, y);

35 label.setText(“” + z);

36 }

37 public void showLCM()

38 {

39 int x = Integer.parseInt(box1.getText());

40 int y = Integer.parseInt(box2.getText());

41 int z = x * y / gcd(x, y);

42 label.setText(“” + z);

43 }

44 private int gcd(int a, int b)

45 {

46 /************************/

47 /* */

48 /* Your code goes here. */

49 /* */

50 /************************/

51 }

Helper Method

Study these instance methods in

Display07. Each of these methods

consists of input, process, and output.

Input is taken from text boxes. Since the

input from a text box is always a string, it

must be parsed into an integer. A

calculation is made (that‘s the process)

and the result is displayed to a label.

Notice that each method calls a helper

method named gcd (lines 34 and 41) that

actually does the work. In other words,

the programmer has encapsulated the gcd

calculation. Programmers split their

programs into parts because it is easier to

think and write that way. Also, if we ever

came up with a faster way of finding the

gcd we would only have to rewrite our

algorithm once in the private gcd helper


The gcd helper method is private to the Display07 class. This method is tagged private in order to restrict

access to it. Any outside object (in this case, the Panel07 object) is allowed to call the Display07‘s public

methods showGCD and showLCM, but not its private method gcd. An API lists only a class’s public methods.

Make sure you include a return statement when you write the private helper method gcd. Look at the header

for gcd (it’s Line 44). Notice that in place of the keyword void is the keyword int. This is a signal that

the method calculates and returns an integer value. That integer value is passed back to the place where gcd

was called (the right-hand side of Line 34). Code for any non-void method will not compile without a return

statement. All non-void methods require you to return a value of the specified type.

Here is some sample input and output. Study it to make sure you understand GCD and LCM.

a b GCD(a,b) LCM(a,b) a b GCD(a,b) LCM(a,b)

8 12 4 24 11 11 11 11

12 8 4 24 1 7 1 7

6 16 2 48 5 7 1 35

7 14 7 14 2 9 1 18

There are at least six algorithms to calculate the GCD of two numbers. One popular algorithm works by trial-

and-error, as follows: test to see if some number ―goes evenly into‖ both the given numbers. Systematically

try different numbers until you find one which ―goes evenly into‖ both the given numbers. What is the GCD if

no number works?





Local panels; using return statements to communicate results.


The panel “hasa” display and two buttons. The display “hasa” local subpanel to keep its four GUI components

side by side. The local subpanel forces our prompt labels (“One: ” and “Two: “) and our text boxes to remain

together. These four components do not flow because they are all contained by the object named “panel.”

Line 6: Display07 isa JPanel.

Lines 8-9: Declare 3 fields.

Line 13: If you want, look up

setPreferredSize and the

Dimension class in the Java API.

Lines 15-25: create, format, and

add a local JPanel object named


Lines 17, 20, 21, and 24: add two

JLabels and two JTextFields to the

local subpanel.

Lines 19 and 23: the method

changes the justification of our

text boxes. The default

justification for a text box is right

justified. SwingConstants is

actually an interface, but it has no

abstract methods. Often interfaces

are used to define certain useful

constants. These constants are

defined as public static final variables and, by convention, are written in ALL CAPS.

Lines 27-30: instantiate and add a JLabel for the “?” directly to Display07.


Filename Unit3\Lab07\ (load). Implement the private helper method gcd.

Filename Unit3\Lab07\ Create Panel07 that instantiates and adds a display object. Create two

buttons and add them to Panel07. Have the buttons call the display’s private helper methods.

Filename Unit3\Lab07\ Create an appropriate driver.

Test Data
Go to


display’s subpanel


6 public class Display07 extends JPanel

7 {

8 private JLabel label;

9 private JTextField box1, box2;

10 public Display07()

11 {

12 setLayout(new FlowLayout());

13 setPreferredSize(new Dimension(200, 125));


15 JPanel subpanel = new JPanel();

16 subpanel.setLayout(new FlowLayout());

17 subpanel.add(new JLabel(“One: “));


box1 = new JTextField(“”, 5);

19 box1.setHorizontalAlignment(SwingConstants.CENTER);

20 subpanel.add(box1);

21 subpanel.add(new JLabel(“Two: “));

22 box2 = new JTextField(“”, 5);

23 box2.setHorizontalAlignment(SwingConstants.CENTER);

24 subpanel.add(box2);

25 add(subpanel);


27 label = new JLabel(“?”);

28 label.setFont(new Font(“Serif”, Font.BOLD, 75));

29 label.setForeground(;

30 add(label);

31 }

32 }




Turn your Lab07 into an applet by following the directions shown below.

Applications typically run

in frames from a console

while applets are designed

to be viewed through web

browsers over the internet.

Mr. Torbert‘s

is shown here to the right.

One advantage to working

with panels is that minimal

changes are required to

display a panel with either a

frame or an applet. The real

bulk of your program exists

in the panel itself.

Line 4: Import JApplet.

Line 5: extend JApplet.

Line 7: Do not define main. Instead, define

init. The init method is called

automatically when a web page is loaded into a

browser the same way that main is called when a

program is run.

Line 9: set the content pane of the applet, just

like setting the content pane of a frame.

Compile the applet to produce Applet07.class.

Then create a new text file, something like this, which will run in a browser:

Save this file as Applet07.html. Open a browser, then use File | Open | Browse to run Applet07.html.

The minimal command to load your applet in a browser is Line 8, not including ―&nbsp200x175‖.



Border and Grid Layouts

FlowLayout, BorderLayout, and GridLayout are the three kinds of LayoutManagers that we will use on panels.

As you have seen, in FlowLayou the GUI components change position as you resize the panel. In contrast, the

BorderLayout assigns each GUI component to one of five distinct regions as shown.






Conveniently, BorderLayout‘s add method takes two arguments which specify the GUI component and the

region. Take care to add only one component per region. If you add more than one component to a particular

region then only the last component will show.

setLayout(new BorderLayout());

add(label1, BorderLayout.NORTH);

add(label2, BorderLayout.CENTER);

add(button, BorderLayout.SOUTH);

Be careful! If you don‘t specify a region, the default region is CENTER. A common error is to not specify a

region and then ask the teacher why only the last object shows up, covering everything. The teacher will

answer that you have added components on top of each other in the center.

You do not have to use all the regions. Any region that doesn‘t get a component will disappear. Often we will

not use the east or west regions, in which case the center region will expand horizontally.

Panel08 has a BorderLayout that uses the center and the south. Panel08’s center region hasa Display08, which

hasa GridLayout. GridLayout makes rows and columns.

public Display08()

setLayout(new GridLayout(4, 2));

add(new JLabel(“Terms:”, SwingConstants.RIGHT));

box1 = new JTextField(“”, 5);


//more code

Notice that Display08 has four rows and two columns in its grid. Labels and/or textfields are added from left

to right across each row of the grid from the top of the grid to the bottom. Be sure to add exactly the number

of components that the grid is expecting (in this case, 8), or unpredictable things may happen. Add anonymous

blank labels if you want cells of the grid to appear unoccupied.

Notice that Panel08’s south region has subpanel, which hasa Grid Layout with two buttons.

Convention dictates rows first, then columns. You can use RC Cola (stands for Royal Crown Cola) as a

mnemonic to remember that we always treat the rows (R) first and the columns (C) second.



Sum of a Series


Work with BorderLayout and GridLayout. Put buttons in a subpanel in a panel.


A geometric series is the sum of a sequence of terms, where each term is

generated by a ratio. A series may be finite or infinite. All finite series have

sums, but not all infinite series have sums. Infinite series in which the absolute

value of the ratio is strictly less than one have a sum; otherwise the series

diverges and does not have a sum.

Study the series shown below. Two are finite and two are infinite. One of the infinite series has no sum. How

does ratio work?

1 + 2 + 4 + 8 + 16 + 32 +

64 + 128 + 256

terms 9

first 1

ratio 2.0

sum 511.0

1 + 2 + 4 + 8 + 16 + 32 + 64 +

128 + 256 + . . .


first 1
ratio 2.0

sum NONE

1 + 0.2 + 0.04

terms 3

first 1

ratio 0.2

sum 1.24

1 + 0.2 + 0.04 + 0.008 + 0.0016

+ 0.00032 + . . .

first 1
ratio 0.2

sum 1.25

What primitive type is terms?______ What primitive type is first? _____ What primitive type is ratio? ______

We will calculate the sums of both finite and infinite series. For the sum of a finite series, the algorithm uses a

for-loop. Inside the for-loop, calculate one term from the previous term by multiplying by the common ratio.

Given the first term, you can find the second term. From the second term you can find the third, from the third

the fourth, and so on. Keep a running total (the sum) of the terms as you go. At the end of the loop, you will

have calculated the sum of the entire series.

The sum of an infinite series (if it has a sum) can be found with the formula




Filename Unit3\Lab08\ (load). Implement the methods sumFinite and sumInfinite

using the information above. All finite series have a sum. If the infinite series has no sum, display “NONE.”

Filename Unit3\Lab08\ (load). Put the Display08 object in the center and two buttons side-by-

side in a subpanel in the south. Make the buttons call the Display08 object’s methods.

Filename Unit3\Lab08\ (load). Compile and run.

Test Data
Compare your program’s output with that of Unit 3, Lab08 at



16 total = 0.0;

. . .

39 private class Listener implements ActionListener

40 {

41 private double myX;

42 public Listener(double x)

43 {

44 myX = x;

45 }

46 public void actionPerformed(ActionEvent e)

47 {



50 }

Generic Listeners

Looking at Lab09‘s center panel, we see six buttons and six listeners, or 12 different objects. Do we need to

write 12 different classes, one for each object? No! We can write one button-making method and call it six

different times. The listener class needs a constructor with an argument, which gets stored in a private field.

When we call the listener‘s constructor, we pass an argument, either 1.0, -1.0, 0.1, etc., so that it creates a

unique object. (Previous listener classes used the default constructor and had no fields.) The code shows how

to make a generic listener.

Line 41: the private field myX stores

doubles. It will store a different

double value for each listener object.

Lines 42-45 is the listener’s

constructor, which requires a double

type argument. It takes that value and

stores it in myX (Line 44). For

example, when we instantiate the

Listener, we might write the code new

Listener(0.10);. After the

code is finished executing, that listener

will have a myX that stores 0.1. We

will eventually instantiate six button objects with six listener objects, each with a different value in myX.

When the user clicks the button, that button’s myX is added to total and displayed on the label with a ―$‖

symbol. Write the code for actionPerformed


You may have noticed that doubles sometimes show lots of decimal places and sometimes not. That is

unwelcome behavior when the number represents dollars and cents. Java’s solution is typically Javanese: first,

import a class, namely java.text.DecimalFormat . Instantiate a DecimalFormat object, whose 1-arg

constructor takes a String that acts as the formatting pattern. Decimal Format extends NumberFormat, whose

API lists a format method with one integer argument that returns a formatted string. You know that labels

have a setText method that accepts a string argument. Now put it all together, to make the label display

total formatted as dollars and cents.

listener with myX = -1.0

listener with myX = 1.0

listener with myX = -0.01

listener with myX = 0.01

listener with myX = -0.1
listener with myX = 0.1

46 public void actionPerformed(ActionEvent e)

47 {




51 }



13 public Panel09()

14 {

15 setLayout(new BorderLayout());

16 total = 0.0;


18 JPanel panel = new JPanel();

19 panel.setLayout(new GridLayout(2,3,10,0));

20 add(panel, BorderLayout.CENTER);

21 addButton(panel, “+1.00”, 1.0);

22 addButton(panel, “+0.10”, 0.1);

23 addButton(panel, “+0.01”, 0.01);

24 addButton(panel, “-1.00”, -1.0);

25 addButton(panel, “-0.10”, -0.1);

26 addButton(panel, “-0.01”, -0.01);

33 private void addButton(JPanel panel, String s, double x)

34 {




38 }

Subway Tokens


Create a generic factory method to produce button objects.


Panel09 has a BorderLayout (Line 15), with a label in the north

and a grid in the center.

Line 16. Notice that the total

field is initialized to zero.

Lines 18-20. Instantiate, format,

and add a local panel.

GridLayout can take 4 arguments.

Notice the 2 rows and 3 columns.

The 10 puts 10 pixels between the

columns and the 0 puts 0 pixels

between the rows.

Lines 21-26. Add six anonymous

button objects to the panel by

calling addButton. Notice that

the method addButton requires

three arguments. What type is each argument? ____________, _____________, ____________ What is the

purpose of each argument?

What are the steps in creating a button? (See page Three-4.) The addButton method must add a button to a

panel with a specified string as its text. The button must register a listener, passing the decimal value on to the

listener constructor. Write the private factory method addButton below:


Filename Unit3\Lab09\ (load). Complete the implementation of the two methods addButton

and actionPerformed.

The actionPerformed method must adjust the total appropriately, format the total as currency, and update

the display.

Filename Unit3\Lab09\ Create an appropriate driver.

Test Data
Go to




Here is an object diagram produced by the program BlueJ:

The dotted lines indicate a uses or hasa relationship. Driver10 hasa Panel10, as usual. Panel10 in turn hasa

Display10 and a Scoreboard10. Notice that Display10 and Scoreboard10 are not related to each other. In fact,

the scoreboard and the display do not interact at all. The objects are like black boxes, in that all methods and

private data are encapsulated within each object. All communication of data is accomplished through

methods’ arguments and return statements. Furthermore, the communication between scoreboard and display

is managed by a third object, the panel.

A certain method in Display10 will pick random numbers from 1 to 9 and compare each new number to its

immediate predecessor. The method returns a boolean, communicating whether or not the new number is

higher or lower than the previous number.

A certain method in Scoreboard10 accepts a boolean through its arguments. Depending on the value of that

boolean, certain other things happen in the scoreboard.

The panel has the scoreboard, the display, buttons and their listeners. The panel passes information from the

display to the scoreboard by a listener with code like this:


Explain in your own words how the code above works:



30 public boolean guessHigh()

31 {

32 pickNext();

33 return next > last;

34 }

High – Low


Multiple resource classes that pass arguments.


The panel has the scoreboard, the display, buttons and their listeners.

three areas of panel

The scoreboard is added to the northern region of the panel. The display is added to the central region of the

panel. A separate panel defined locally in the Panel10 constructor takes care of the buttons in the south. When

you press the High button, this code is in its ActionListener:


Here is the code for guessHigh in the Display07

object. The first method call in guessHigh is to

pickNext. The method pickNext has to store the old

number and pick a new integer between 1 and 9 inclusive.

Write pickNext so that the same number is not picked

twice in a row. After pickNext is finished,

guessHigh returns a boolean which is true if the next

number is greater than the previous number, and false otherwise. The method guessLow works much the

same way.


Filename Unit3\Lab10\ (load). Implement the method pickNext as described above.

Filename Unit3\Lab10\ (load). Implement the method update. The update method

requires one argument of type boolean. This argument indicates whether or not the user‘s most recent guess

was correct. If the argument is true, set the scoreboard’s label to “Yes”, update the current run of correct

guesses, and update the maximum streak of correct guesses. If false, set the label to “—No—”, and set the

current run of correct guesses to zero.

Filename Unit3\Lab10\ (load). Compile.

Filename Unit3\Lab10\ Create an appropriate driver.

Test Data
Go to



buttons on a gridLayout



Last Stone Wins


Synthesize to solve a problem.


This version of Nim uses multiple classes as in Lab10: driver,

panel, display, and perhaps a scoreboard. It uses the

addButton and listener field ideas from Lab09. It uses the

image icon concepts from Lab06. It uses grid layouts and

border layouts as appropriate. Your goal in planning a solution

is to make your work as simple and as understandable as


The game you‘re writing is Nim for two people. Our Nim has

one pile with 12 stones from which players alternate removing

stones. Each player may remove 1, 2, or 3 stones per turn. You

must take at least one stone on each turn. Whoever takes the

last stone wins.

Hint: the program doesn’t actually pick up 2 stones. Instead, it

subtracts 2 from the amount of stones, and displays a pile with

the correct number of stones.

Think about the responsibilities of each class:

In Tic Tac Toe, if both players play perfectly, the result is always a tie. In Nim, the second player has a

strategy so that he or she always wins. What is that strategy?


The files provided for you are called Unit3\Lab11\stones1 , \stones2 , and so on.

You create all the other files. Make a panel and a display as in Lab10. For the three buttons, make one

listener, as in Lab09.

Add a scoreboard to the panel that keeps track of each person’s number of wins. The scoreboard also changes its

background color to indicate who is playing at the moment.

Test Data
Go to

3 buttons





label1, label2

count1, count2




Sometimes making a GUI from scratch is tedious. Luckily, Java has a JOptionPane class which contains static

methods that produce standardized GUIs. Without you yourself creating a frame or a panel or a button or any

other type of object, the method showInputDialog produces a small GUI that allows the user to input data.

All data is read in as a string, just like reading text from a text box in Unit 3.

Because all data is read in as a string, numeric data must be converted from text to numbers with either

parseInt or parseDouble. Of course, if the data is words then no parsing is required. For the dialog box

shown above, one item of data could be prompted, read, parsed, and stored into a variable fahrenheit with

the commands:

fahrenheit = Double.parseDouble(

JOptionPane.showInputDialog(“#1 – Degrees Fahrenheit”));

Where is the prompt?_______________________ Which command returns a string?________________

Which command parses the string? ____________ Which command stores the number? ________________

There is also a JOptionPane class method showMessageDialog that can be used to output text to a GUI.

Be careful! Don‘t forget to include the first argument, null, when calling showMessageDialog.

Notice that you can display output on more than one line using the “\n” escape sequence for a newline.

The last line in an application that uses JOptionPane should always be System.exit(0), in order to close

the GUI thread that is running behind the scene.



4 import javax.swing.JOptionPane;

5 public class Driver12

6 {

7 public static void main(String[] args)

8 {

9 while(true)

10 {

11 int rows = Integer.parseInt(

12 JOptionPane.showInputDialog(

13 “How many rows? (-1 to quit)”));

16 if(rows == -1)

17 {

18 System.out.println(“Bye-bye!”);

19 System.exit(0);

20 }

21 String message = “What type? (1-4)”;

22 message = message + “\n1. Standard”;

23 message = message + “\n2. Backward”;

24 message = message + “\n3. Pyramid”;

25 message = message + “\n4. Box with X”;

26 int type = Integer.parseInt(


27 switch(type)

28 {

29 case 1: standard(rows);

30 break;

31 case 2: backward(rows);

32 break;

33 case 3: pyramid(rows);

34 break;

35 case 4: box(rows);

36 break;

37 default: System.out.println(“Not valid type.”);

38 }



40 }

41 }

42 public static void standard(int n)

43 {

I/O Window output

The next three labs will prompt the user to enter data, process it, and

output the results to the default I/O window.

The user will enter data through Java’s built-in JOptionPane methods.

The JOptionPane class provides standard GUI pop-up panes, like the

ones pictured at the right. You don’t always have to build your own

GUIs from scratch.

Here is Driver12‘s main method:

Line 9: while(true)

looks like an infinite

loop. However, if the

user enters a -1,

then Lines 16-19 will

end the program.

Line 11: since

returns a string, we

must parse the result.

We store it in rows.

Line 12:

is a class method in the

JOptionPane class. Line

13 is the prompt string.

Lines 11-13 make the

GUI window shown


Lines 21-25: this

is a

clever way to create a

long string, later used

to prompt the user.

“\n” makes a new line

in the string.

Line 26: creates the

GUI window, waits for

the user to press OK,

parses the result, and

stores it in type.

Lines 27-39: the switch statement calls the methods, passing the argument rows, that draws the patterns.





Print patterns of asterisks using nested loops.


The next three labs are not object oriented programming and do not output to a GUI window. Instead, each

application outputs to a default I/O window. Currently, the only output from the shell is:

This type is not currently supported.

Your job is to make each method print the given pattern, as shown below. The integer argument n specifies

the number of rows. Use an outer for-loop to control the number of rows. Inside that for-loop, use a

combination of for-loops and if-statements to control the number of asterisks. Use print or println to

control the line returns. As a starting example, this code with two nested loops prints a square of asterisks

arranged in n rows and n columns. If n = 4, you get the square pattern shown at the right.

for (int r = 1; r <= n; r++)


for (int c = 1; c <= n; c++)




# Type n equals 7 # Type n equals 7

1 Standard *






4 Box with X *******

** **

* * * *

* * *

* * * *
** **

2 Backward








For the Box with X, start by understanding the output of these

nested for-loops:

for (int row = 1; row <= n; row++)


for (int col = 1; col <= n; col++) if( (row + col) % 2 == 0 ) //if its true


System.out.print(“ ”);



3 Pyramid

is a


plus a










Filename Unit3\Lab12\ (load). Implement each of the asterisk pattern methods.

Test Data
Go to




input output

for(int k=1; k<=5; k++)

System.out.print(“” + k);

for(int k=1; k<=5; k++)

System.out.println(“” + k);


The Necklace


Implement an algorithm.


A digit is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. There are ten digits. The necklace begins with any two of these

digits. For example, start with four and seven.

Add four and seven to get eleven. We‘re only interested in the last digit so call this one instead of eleven.

Add seven and one to get eight.

Add one and eight to get nine.

Add eight and nine to get seventeen. Again, just call this seven.

Continue this process until you get back to the two digits you started with in the order they started. Keep track

of how many times you had to add to get back to the start. For our example we have:

4 7 1 8 9 7 6 3 9 2 1 3 4 7

Iterations: 12

There are a hundred possible ordered pairs of digits to start with. Do they all take twelve iterations to return to

where they started? The answer is no. For three and seven we have:

3 7 0 7 7 4 1 5 6 1 7 8 5 3 8 1 9 0 9 9 8 7 5 2 7 9 6 5 1 6 7 3 0 3

3 6 9 5 4 9 3 2 5 7 2 9 1 0 1 1 2 3 5 8 3 1 4 5 9 4 3 7

Iterations: 60

What patterns can you discover about necklace iterations?


Filename Unit3\Lab13\ Use as a model. Prompt the user for two numbers and

output the necklace numbers. Also output the number of times to get back to the starting numbers.

If the user enters a number that is not a single digit, prompt him or her repeatedly until a single digit is entered.

Test Data
Go to





Practice with user input, loops, and integers.


Here is a not-very-precise algorithm to score a (simplified)

game of bowling for one person.

1. A game of bowling takes ten frames. Each frame has ten pins and two balls, if needed.

2. Enter the number of pins that were knocked down by the first ball. Use an input window, reporting the

current score, frame, and ball, like the one shown above.

3. If the number entered is impossible, prompt to enter it again, repeatedly, if necessary. Otherwise, add

the pins to the total score.

4. If all tens pins are knocked down by the first ball, the frame is over. Otherwise, prompt the user to

enter the number of pins knocked down by the second ball. If the number entered is impossible, prompt to

enter it again, repeatedly, if necessary. If the sum of the pins reported for the two balls is impossible, prompt

to enter it again, repeatedly, if necessary. When the number is satisfactory, add the pins to the total score.


Filename Unit3\Lab13\ Write the code to score a game of bowling for one person. Make a

welcoming message, a closing message, and do some error-checking. Use the on-line demo as a model.

Test Data
Go to

The real game of bowling rewards bowlers for spares and strikes. A spare occurs when all ten pins are

knocked down using both balls in one frame. In that case, the pins knocked down on the next ball are counted

twice, once in the frame before and once in its own frame. In the box score below, since frame #2 has a spare,

the next ball in frame #3 is counted once in frame #2 and once for itself.

A strike occurs when all ten pins are knocked down on the first ball. In that case, no second ball is rolled for

that frame and the pins knocked down with the next two balls are counted twice. Each strike counts the next

two balls twice. Since frame #4 has a strike, the balls in frames #5 and #6 are each counted twice. Study the

scores below, which is what you would see in a bowling alley. Finally, if a strike or spare is rolled in the tenth

frame then an appropriate number of bonus balls are rolled. This scoring system works out so that a perfect

game of 12 strikes earns a score of 300.

frame 1 2 3 4 5 6 7 8 9 10

pins 5 0 5 5 3 0 10 10 10 0 1

score 5 5 10 18 21 21 51 71 82 82 83

You don’t (yet) know about 2-dimensional arrays, but in this lab you can still calculate the total score that

follows the real scoring rules. Just display the score at the end.



More GUI components


Use a text area, radio buttons, check boxes, a drop-down menu, and item listeners.


Panel15 has a border layout. The

center has a JTextArea with lineWrap

turned on. The south is formatted in a

flowLayout and has a NamePanel, a

StylePanel, and a SizePanel.

A text area allows you to display

multiple lines of text, which is not

possible with a label or a text box.

The NamePanel has three objects of

class JRadioButton. The StylePanel

has two objects of class JCheckBox.

The drop down menu in SizePanel is

an object of the class JComboBox.

Each of these panels has factory

constructors with one private field.

Each of these objects is similar to a button, but different. These objects register a listener using the command

addItemListener. The Listener class implements the ItemListener interface, so that all ItemListeners

must have a method named itemStateChanged(ItemEvent e).

Study the three panels that are given to you.


Filename Unit3\Lab15\ (load). Set the layout and add the text area and a sub-panel. Add the

three sub-sub-panels to the sub-panel in the south. By looking at the NamePanel constructor, observe that the

text area is passed as an argument to each of the NamePanel, StylePanel, and SizePanel constructors. This

means that each panel will have its own reference (or pointer) to the text area so that the font attributes of the

display can be directly manipulated by the listeners.

Filename Unit3\Lab15\ (load). Open this and look at the constructor carefully. It takes an

argument of type JTextArea.

Filename Unit3\Lab15\ (load).

Filename Unit3\Lab15\ (load).

Filename Unit3\Lab15\ (load). Compile and run.

Test Data
Go to



The Debugger

Sometimes, even after our program compiles, we know there is a run-time error in our code. The JGrasp

debugger allows us to step through the code line by line, so that we may stop at every step to see if the

program is still working the way we want it to. This allows us to find the exact point at which our program

goes wrong, so that the code becomes much easier to correct.

In this example, our program doesn‘t actually have any errors in it. But it is useful to run the debugger on it

anyway, so that we can understand how it works and what information it can tell us.

 How do I turn it on?

First, you must insert what we call a breakpoint somewhere in the code. The image below shows the

breakpoints, like red stop signs, which have been inserted at line 40. These were inserted by left-clicking once

in the gray stripe down the left margin next to each line.

To actually start

the debugger,

click the ladybug

icon to the right of the ‗Run‘


The program will

begin to run, but

as soon as it

reaches line 40, it

will stop. Once you are

ready to move on, you can hit

the ‗Step‘ button on the left

menu, which will cause the

debugger to continue

executing the program line-

by-line until the program is


 What am I looking at when it runs?

When you run the JGrasp Debugger, a window opens in

the left pane that shows the values of all variables that

have been defined to that point. At each breakpoint,

you can check whether the variables you‘ve defined are

set to the values that you expect. As soon as you see an

unexpected number, you can conclude that either your

code is doing something you don‘t want it to do, or that

the problem itself has attributes you didn‘t know about!

 How can I get it to move backward to the last


Bad news, you can‘t. The only thing you can do is stop it (by pushing the ‗End‘ button) and restarting

by pushing the ladybug button again.



The jGrasp Debugger

This exercise requires you to have a working solution to Lab13, The Necklace.

The user inputs any two digits between 0 and 9. The necklace begins with those two digits

and each subsequent digit is obtained by adding the previous two digits and keeping only the

ones digit of the sum. For example, if 7 and 6 are the selected digits, the next term in the

necklace is 3, because 7 + 6 = 13, and the ones digit of 13 is 3. The term after that is 9,

because now the previous two terms are 6 and 3. The necklace continues

7..6..3..9..2..1..3..4..7..1..8..9..7..6…at which point it stops because the final two terms are

the same as the initial two terms. Twelve iterations were required to arrive at the same two

digits as the first two.

(If you have not finished Lab13, then a working program can be found in the Lab16 folder.)

1) Compile and run the program and notice that it actually works. Study the code and understand it.

2) Set a breakpoint at Line 40. Then click on the Ladybug button to start the debugger. As in the example

above, enter 7 for the first digit and 6 for the second digit.

3) Notice the variables in the left pane are grouped according to “static,” “arguments,” and “local.”

4) What are the values of the variables when the program is first at Line 40?

5) Then hit the ‗Step‘ button to get the program moving again and stop at line 47.

6) Now what are the values of the variables when the program is first at Line 47?

7) Keep hitting the “Step” button and fill in the values below:

8) Are the values that you see those that you expected to see? If the program is not calculating as you expect,

you can now look for ways to correct the code to get the desired behavior. That is the whole purpose of using

the debugger. Using the debugger can be quite helpful.









temp previous current count







Mixing Graphics and GUIs


Unit 2 graphics with Unit 3 buttons.


This lab has the same structure as Lab10, but the JFrame has a

Panel17, instead of a display.

Panel17 has the BumperPanel from Unit 2 Lab 14, the three

buttons, and the slider. The three buttons all call methods in the


The BumperPanel isa JPanel. It has all the (unchanged) polkadots,

balls, and bumpers from Unit 2. It has all the unchanged methods,

such as paintComponent, collide, and distance. It has

two new methods jumpAll and stepAnimation. The latter

method does all the work of clearing the panel, moving the balls,

checking for collisions, painting all the objects, and updating the


Unlike in Unit 2, the BumperPanel does not have a Timer. The

timer is instantiated in Panel17. Every time the timer fires, it calls

the BumperPanel’s stepAnimation.

Think about the responsibilities of each class:

When clicked, the “Run Animation” Button changes to “Pause

Animation”, using an idea from the extension to Unit 3, Lab05.

When the animation is running, the “Step” Button is grayed out. setEnabled(false) is a helpful method.


There are no shells. Write the classes as described above. Good luck.

Implement the slider to adjust the speed of the timer, which makes the movement faster or slower. JSlider has

a helpful command getValue.

Test Data
Go to

3 buttons




collide, distance




Still stressed with your coursework?
Get quality coursework help from an expert!