JAVA PROGRAMMING EBOOK

WRITTEN BY K.J. FERNANDO

What is a program?
A program is an algorithm written in a special language.
It is a piece of text written in a way that the computer can understand.
The language has to be very precise.
There cant be any confusion over what is meant.
It must cover all possibilities
Human languages leave to much scope for confusion.
Noughts and Crosses Algorithm
1. Go in a corner.
2. If the other player went in the opposite corner then go in a free corner.
Otherwise go in that opposite corner.
3. If there are two Xs and a space in a row then go in that space.
Otherwise if there are two Os and a space in a row then go in that space.
Otherwise go in a free corner.
4. Repeat Instruction 3 above.
5. Go in the free space.
An example program
class hello
{
public static void main (String[] param)
{
helloMessage();
System.exit(0);
} // END main
public static void helloMessage ()
{
System.out.println("Hello World!");
return;
} // END helloMessage
} // END class hello
To run a program
1. create it using a text editor (gedit/emacs)
2. save it as a file
3. compile the file(convert the instructions in the program to a form the computer
can follow) javac hello.java
4. run the compiled program (tell the computer to follow the instructions in
thecompiled program) java hello
5. If you have problems with steps 3 or 4 go back to 1.
Some common pitfalls. . .
name of file MUST be <name of program>.java
o Java puts the executable in <name of program>.class
o not <name of file>..class
change but dont save
o If you dont save the file you recompile the old version
change but dont recompile
o If you dont recompile, you run the old executable
Input and Output
Java input and output is more complicated than the simple thing being done!
There are also many different things you could be trying to do it
o so different ways to achieve the same aim.
Name of a program
class hello
{
public static void main (String[] param)
{
helloMessage();
eSystem.exit(0)
;
} // END main
public static void helloMessage ()
{
System.out.println("Hello World!");
return;
} // END helloMessage
} // END class hello
Where the work gets done
class hello
{
public static void main (String[] param)
{
helloMessage();
System.exit(0);
} // END main
public static void helloMessage ()
{
System.out.println("Hello World!");
return;
} // END helloMessage
} // END class hello
Printing messages to the screen
To print messages to the screen use:
System.out.println("The message goes here!");
System.out.println is the command you use to tell the computer to print a
message.
The message goes inside the brackets and inside the quotes.
Programs as a recipe book
Think of a program like a recipe book with a series of recipes (the methods).
Each recipe (method) says how to do one specific task.
All Java programs have a method called main
o It is where the computer goes to start
o It then says which other methods to execute
o Like saying which meals are on a menu and the order
Methods
Here 2 methods called main and helloMessage
Note the instruction in main that says
go do the instructions in method helloMessage
class hello
{
public static void main (String[] param)
{
helloMessage();
System.exit(0);
} // END main
public static void helloMessage ()
{
System.out.println("Hello World!");
return;
} // END helloMessage
} // END class hello
System.out.println
System.out.println is just a method (a recipe) that the inventors of Java wrote
for you
System.out.println(The message goes here!");
This is actually just jumping to a method called System.out.println
Compare it with the command:
helloMessage( );
The brackets are the thing that says this command is a method call - go
execute it then come back here (to this instruction) when done
return
Every method ends with a return command.
It returns control back to the method that called it so that it can carry on where
it left off.
main is an exception here it uses System.out.exit to do a similar thing it
returns back to the operating system
A bunch of hieroglyphics
The rest is stuff that (for now) just put in all your programs.
Notice how the curly brackets mark the structure of the program (where
methods start and end)
Some terminology
method: a named operation (like main, System.out.println)
class: a named group of related methods (hello)
keyword: (or reserved word) a word that has a special meaning to Java and
cannot be used for anything else, e.g. if, new, return, while
Output Exercise
Write a program that prints out: Hello my name is C3PO
to the screen.
Variables: Storing things for use later
Variables are what languages use for storing information in a way that lets you
get at it again later.
A variable is like a named box into which you can put a piece of data.
Variables
If you want to use a box to store something in, you have to do two things:
o get a box of the right kind/size
o put something in it
Its the same with variables.
o declare the variable (tells the computer to create the kind of box you
asked for)
o initialize it (tells the computer to put something in)
Declaring Variables
You include a statement in the program introducing the variable:
String name;
This tells the computer to create a variable (a storage space) called name
suitable for holding a string of characters.
It does not put anything in the box. It declares the variable called name
Putting values in Variables (Assignment)
The command:
name = "fred";
puts the string of characters "fred" in a box called name
Box name gets the string "fred"
Accessing the contents of a variable
You get at the contents of a variable by giving the variables name
name1 = "fred";
name2 = name1;
This first stores a string of text fred in a box called name1 and then makes a
copy of it and puts that into name2.
That means we now have 2 boxes with the same text stored in both.
Information from the user
import javax.swing.*; // import the swing library for I/O
class inputbox
{
public static void main (String[] param)
{
askForFact();
System.exit(0);
} // END main
public static void askForFact()
{
String userfact =
JOptionPane.showInputDialog
("Go on tell me something you believe!");
JOptionPane.showMessageDialog(null,
"So... you think... + userfact + " do you");
return;
} // END askForFact
} // END class inputbox
An input method
If you write the following at the top of your program then it makes available
more sophisticated methods with names starting JOptionPane for input and
output
import javax.swing.*;
The method JOptionPane.showInputDialog both prints a message to the screen
and waits for the user to type something. That string of characters is then
assigned into the variable by a normal assignment
String userfact = JOptionPane.showInputDialog
("Go on tell me something you believe!");
A new output method
JOptionPane.showMessageDialog is a method that prints a message to the
screen a bit like System.out.println but in a popup box with an OK button.
JOptionPane.showMessageDialog(null, Hello);
Prints Hello to the screen in a box
You can combine text with the text stored in variables.
If variable (box) called userfact holds the string of characters Jo loves me
because that is what the user typed in earlier. Then:
JOptionPane.showMessageDialog(null,
"So... you think... + userfact + " do you");
Prints "So... you thinkJo loves me do you to the screen
Input Exercise
Write a program that asks the user for their favourite film, then prints out that
it likes it too eg:
What is your favourite film?
The Matrix
The Matrix! I like that too
where the bold part is typed by the user, the rest is typed by the computer.
Java Program Template
All the programs you write will have the form below. The parts in bold will appear
exactly as below. Parts starting //*** can be deleted as they just indicate what things
need changing. Other parts not in bold need changing to suit the program (like giving
it a sensible name.
You do not need to type this in
/* ***************************************
AUTHOR:***PUT YOUR NAME HERE
***WRITE A SHORT DESCRIPTION OF WHAT YOUR MODIFIED PROGRAM DOES HERE.
This is not a just an outline of a program set up so you can fill
in the gaps. Stuff in CAPITALS WITH STARS indicates what you need
to change to create a program that work. The rest is common to
all programs you write.
****************************************/
class template // ***THE WORD AFTER CLASS MUST BE THE NAME OF THE FILE
// ***(BEFORE the .java) YOU SAVE THIS IN
{
public static void main (String[] param)
{
DOTHIS(); // ***REPLACE DOTHIS WITH THE NAME YOU USE BELOW
System.exit(0);
} // END main
/* ***************************************
*
* ***PUT A COMMENT HERE TO EXPLAIN WHAT THIS METHOD IS FOR
*/
public static void DOTHIS () // ***REPLACE THE NAME 'DOTHIS'
// ***WITH THE NAME YOU USED ABOVE
// ***THE NAME SHOULD HELP THE READER
// *** UNDERSTAND WHAT THIS CODE DOES
{
// *** DELETE THIS LINE. THE ACTUAL CODE GOES IN HERE
// *** THESE ARE THE ACTUAL INSTRUCTIONS YOU WANT TO BE FOLLOWED
return; // *** IT WILL END WITH A RETURN STATEMENT
} // END DOTHIS
// ****DONT FORGET TO CHANGE 'DOTHIS' HERE TO YOUR METHOD NAME
} // END class template
// ***DONT FORGET TO CHANGE 'template' HERE
// ***TO YOUR CLASS (IE PROGRAM) NAME FROM THE TOP
Unit 1 Compiling and running Java programs
First you need to make sure you can compile and run programs written by others.
Here is one to start with that prints "Hello World!" to the screen
/* ***************************************
A program that prints a welcome message Notice how the program called
hello is made of 2 methods. One called main and one called helloMessage.
****************************************/
class hello // hello is the name of the program
// make sure it is identical to the filename
{
public static void main (String[] param)
{
// We want to print out the message defined in method helloMessage
helloMessage();
System.exit(0);
} // END main
/* ***************************************************
Define some commands of our own to use above
*************************************************** */
/* ***************************************
* Define a method to print a welcome message
*/
public static void helloMessage ()
{
System.out.println("Hello World!");
return;
} // END helloMessage
} // END class hello
1. Saving a program You should have created a directory prog1 if you followed the
module Getting started sheet. If you havent already, save the program into that
directory as a file called hello.java Type ls to list the contents of the directory and you
should see the single file hello.java there if youve saved it correctly.
2. Compiling You need to create a version of the program that a computer can
actually follow ie execute. This is done by compiling it using the Javac
command. Compile the program you just saved (Type javac hello.java) and check to
see that you now have a file hello.class that you did not have previously using ls
again. It is the compiled version of the program the version the computer can
actually execute.
3. Run the program. Run the program that is make the computer do what the
instructions in the program tell it to do, using the java command (Type java hello)
and check that it does print "Hello World!". Note you compile files so need the .java
ending when using the javac hello.java command. We execute programs and this
program is called hello so no ending is used in the java hello command.
Continue on the next page to start writing your own programs...
Unit 1 Example Programs and Programming Exercises
1 Experimenting with the Hello World program
a) Writing your first program: make it print a message of your choice
If youve followed the compiling and running Java programs sheet you are now ready
to write your first program by editing the one you just compiled and executed
(hello.java).
You can make changes to this existing program by opening the .java file into a text
editor (we recommend gedit from the Applications-Accessories menu at the top of
your screen but you can use others if you prefer), editing it then saving it again.
By looking at the program, even though most of it probably looks like gobbledygook,
you should be able to tell which bit in the program determines what prints Hello
World to the screen. Work out that and change it and you can make it print your
name instead. Remember you MUST SAVE AND COMPILE the program using
javac every time you make a change to the program.
In the following exercises, experiment with the program, making predictions about
what will happen if you make a change, then do it, compile the program again and
run it to see if you were right.
b) Printing anything
Edit the program to make it print other things. Make sure you can write a program to
print anything you like instead of "Hello World".
c) Multiple commands
i) Find out what happens if you replace the line
System.out.println("Hello World!");
with the two lines
System.out.println("Hello");
System.out.println("World!");
ii) What happens if you put those two lines the other way round?
d) Duplicating commands
i) Predict what happens if you add a second copy of the following line immediately
after the first?
System.out.println("Hello World!");
Now edit the program and see if you were right.
ii) What happens if you add a second copy of the following line immediately after the
first?
helloMessage();
2. Experimenting with different programs that print things
Now move on to the other programs from the QM+ module site listed as below.
Save them onto your computer, compile them (eg typing "javac name.java" then run
them: type eg "java name" where name is the name.java of the file you saved them as
and name of the program in that file).
The programs illustrate how to do the following:
hello.java : Create a command to print a welcome in the console
hellotwice.java : Doing the same instructions twice by calling the method twice
hellobox.java : Print a welcome in a pop-up box
helloboxnl.java : Print a welcome in a pop-up box over two lines
helloboxsure.java : You can define more than one command of your own and
each method can do a series of things
a) Modify them so they print messages of your choice. You should be able to guess
which bit you need to change!
Make sure you are happy: you understand and can modify these programs to print
other messages before moving on.
b) Modify one of the programs to print your name 5 times. (Your name should only
appear once in the program!)
c) Write a program that prints out your name and address formatted for an address
label.
d) Write a program to print out your initials in big letters out of the letter itself using a
series of commands for each line of letters, eg:
PPPPPPP
P P
P P
PPPPPPP
P
P
P
e) Write a program that prints a letter as above twice by calling a method twice.
You should only have to write commands to spell out the letter once.
3. Storing information in Variables and getting info from the user
Next experiment with the following labeled programs you can download from the
in a similar way
hellovariable.java : Store a string to be printed out in a variable first
concatstrings.java : Combine strings and multiple variables
inputbox.java : Create a command to print a welcome in the console
inputbox2.java : Get several pieces of information
Once you understand them try the following:
a) Write a program that asks the question What is your name?
and then reads the user's name (e.g. Hamish) and displays the greeting
Hello there Hamish!
4. Error messages
Take the hello world program (hello.java) and experiment with making single
changes that introduce errors that cause the compiler to complain. Compile them,
make a note of the compiler's error message and work out what the error message
means given you know what mistake you introduced. If it compiles then run it to see
if it still runs or if that gives errors. Then correct the program and recompile it, before
introducing the next error so that there is always only one problem with the program.
For example:
a) Delete one of the semicolons.
b) Change the word main to man.
c) Delete a single line
d) Remove the quotation marks from around Hello World!
5. A chat program
Write a program that displays one question at a time, inputs the user's answers from
the keyboard and then outputs a brief (unimaginative) response. Make use of string
concatenation (put a + between two strings).
Here is an example conversation that might take place (with the user's input in italics).
What is your name?
Hamish
Hi there Hamish. How are you?
I'm very well thanks.
I'm glad to hear it Hamish. What type of music do you like?
Heavy metal
I like Heavy metal music too. Do computers worry you?
No
You say "No." I wonder why that is?
Because I am familiar with them.
I'm glad to hear that but I have to go now. I've enjoyed talking with you.
6. A programto describe people
Write a program that asks the user a series of questions asking for words such as
favourite colour, colour of eyes, etc then uses string concatenation to put them into a
sentence describing the person, such as
Paul has blue eyes and black hair, is tall, likes the colour red and is handsome.
Catching Bugs
Everyone catches colds. Everyone who writes programs gets bugs. One of the skills of
programming is to come up with ways that help you work out what you did wrong.
Early in your programming career it will mainly be getting bits of the language
wrong: mispelling things, getting the punctuation wrong,... Those things the compiler
spots for you, but you have to learn how to work out what the compiler is telling you.
TIP 1: Keep a bug book - where you record the error messages, what the problem
was and what the fix was...so when you do it again you won't waste time working it
all out again.
TIP 2: If there are multiple errors then just focus on the first one, until you are sure
you have solved it (some of the others may be caused by it anyway.
TIP 3: The mistake may not be on the line indicated but shouldn't be beyond it. It
could be at the end of the previous line (like a missing semicolon!)
Compile time errors are grammar and spelling mistakes that the compiler picks up -
you haven't created a complete program yet. Once compiled there are run-time errors
to come. Run time errors are when the program does run but does the wrong thing in
some way. The simplest kind are ones where it just prints the wrong message! Note
that spelling mistakes in the messages a running program prints are run-time errors.
Spelling errors in the program commands themselves (other than the messages) are
likely to be compile-time errors (the compiler will complain)! There are much more
serious run-time errors to come though!
TIP 4: Check the messages printed by your program very carefully when it runs - are
there any spaces missing or two many. Should it move on to a new line but doesn't?
Are there any spelling mistakes in it or in variable names?
TIP 5: (This happens to everyone at some point) If you made a change and nothing at
all seemed to change when you run it, double check you did save the file (and in the
right place - check its time stamp changed) and also that you did compile it (did you
compile the right file). Check the name of the file is the one you are running. Try
adding in an extra statement to print the message "ARRRggggggHHH!" (or other
suitable message) at the start. If even that doesnt appear when you run the program,
you almost certainly didnt save it or compile it (or you are running the wrong file). If
you havent recompiled it you will just be rerunning the old program over and over.
Avoiding Bugs
Its always better to avoid a bug in the first place, rather than cure it afterwards. That
is where programming "style" comes in...Be a stylish programmer and make your
programs easier to follow.
TIP 1: When ever you type an open bracket of some kind ('(', '{') or double quote.
Immediately type the matching quote. Then go back and fill in between them. It is so,
so easy to forget the end one otherwise. I DO RESEARCH ON HUMAN ERROR SO
BELIEVE ME ON THIS - you will save yourself so much anguish if you get into the
habit of doing this.
TIP 2: When writing a close curly bracket, add a comment to say what it is closing.
Missing matching brackets is very easy and this way it will be easier to see which one
is missing.
TIP 3: Use indentation to help you see the structure and separate parts of a program.
Put each curly bracket on a newline and then push inwards (indent) by the same
amount all the commands that follow, up to the close curly bracket. That way it is
easy to see where a method or class starts and ends and that the brackets match.
The structure of a program then becomes easier to follow:
class wombat
{
public static void main (String[] param)
{
} // END main
/* **************************
*/
public static void carrots()
{
} // END carrots
} // END class wombat
Some common compile time errors
pc$ java hellotwice
Exception in thread "main" java.lang.NoClassDefFoundError: hellotwice
Oops I forgot to compile my program (turn it into a form to execute it).
pc$ javac hellotwice.java
pc$ java hellotwice
Hello World on this most wonderful day, it's a joy to be alive!
Hello World on this most wonderful day, it's a joy to be alive!
Input boxes
pc$ javac inputbox.java
inputbox.java:34: cannot find symbol
symbol : method showMessageDialog(java.lang.String)
location: class javax.swing.JOptionPane
JOptionPane.showMessageDialog("So... you think..." + userfact + "do you");
^
1 error
Oops, I forgot to add the null argument at the start of the showMessageDialog
command. Notice the error is about finding symbols - it is confused thinking you must
have meant a different command as you didn't give enough information for this one.
JOptionPane.showMessageDialog(null, "So... you think..." + userfact + "do you");
Compare your answer with the model answer. How good are your explanations? How
good is your code?
Question 1 [25 marks]
This question concerns writing simple programs
a. [9 marks]
Explain what the following program fragment does, both line by line and overall.
String name = JOptionPane.showInputDialog("What is your name?");
String response = "Hello " + name;
JOptionPane.showMessageDialog(null, response);
b. [6 marks]
The following program fragments contain bugs. Identify and Correct the bugs
justifying your corrections.
i)
String hello1 = "Hello " + "There;
ii)
String hello2 = "Hello" + "There";
iii)
strng hello3 = "Hello There";
c. [10 marks]
Write a Java program using that asks the user what colour eyes they have, then prints
out a message confirming it:
What colour are your eyes? blue
So your eyes are blue are they. I like blue.
A second run might go (where the user types brown rather than blue):
What colour are your eyes? brown
So your eyes are brown are they. I like brown.
Explaining concepts
To show that you understand the programming concepts you will be asked to explain
them. An explain question is basically asking you to teach. Someone reading your
explanation ought to then understand it themselves and so be able to clearly explain
the concept to someone else. A good idea when giving explanations is to use an actual
example (in an exam think your own up to show you can) and then explain the
example.
Here is a typical question.
1. Explain what is meant by a variable with respect to programming languages.
Here is a very poor answer:
A variable is a named place that a program can store values.
Whilst it is strictly correct it only barely explains the concept, and unless the question
was only worth 1 mark you would not get much credit for it.
Here is one good answer (there are many good answers not a single right answer):
A variable is a named place used in a program to store data as the program is
executed. Data (a value) is stored in the variable so that it can be accessed at a later
point by using the name of the variable. The variable can store different values at
different times depending on what is put in to it. However, if something new is stored
the previous value is lost. In languages like Java, variables have a type associated
with them. It determines what kind of data (eg numbers or Strings) can be stored in
the variable.
In Java variables have to be declared before they can be used. For example,
the statements
int a;
String b;
declare two variables, one called a that can hold integers (as indicated by int) and the
other called b which can hold strings of text.
Once declared the variable can be used in commands that are later executed.
For example
a = 5;
stores the value 5 in variable a. If later in the execution of the program we executed
the statement
System.out.println(a);
then, unless it had been changed by another instruction in the interim, the 5 would be
retrieved from the variable a and printed to be screen.
A variable can be thought of as a little like a box. Things can be put in the box
for safe keeping and later retrieved. The box has a name (like a above) so we know
which box we are referring to. A difference to physical boxes though is that when we
use the value of a variable we do not remove it but make a copy of the value that was
stored. Also adding a new value destroys the previous value that was in the box.
For example
int c = a;
copies whatever was in variable a into new variable c. Variable a still retains the
value though so both would hold value 5 after this is executed if 5 had previously
been stored in a.
This is a good explanation because it not only explains what a variable is in detail, but
also gives examples and explains how they illustrate the concepts concerned. Note the
examples are not just dumps of whole programs but small fragments to illustrate
specific points.
This answer could be improved still further by, for example, using diagrams to
illustrate the answer.
Example questions:
Here are some of the concepts you should be able to explain by now (possibly after
doing some reading around the topics first)...
Explain what is meant by:
a) a compiler
b) compiling a program
c) executing a program
d) a variable
e) a value
f) declaring a variable
g) initializing a variable
h) assignment
i) an input method
j) an output method
k) an algorithm
l) a keyword
m) a program
n) a method
o) a class
Try answering the above questions, thinking up your own examples to illustrate your
explanations.
Unit 2: Manipulating Values
Learning Outcomes
Once you have done the reading and the exercises you should be able to:
write and run simple programs that manipulate data
write programs that do calculations on values stored
write programs that print out messages that include the results of calculations.
write programs that store and manipulate different types of values.
explain how your above programs work and the concepts involved.
Before moving on to this section you should be able to:
explain what is meant by an algorithm,
write, compile and run simple programs,
write programs that print out a messages,
write programs that read input from the user and store it in a variable,
write programs that print out messages that include the contents of variables,
explain how your above programs work and the concepts involved.
You should be able to write programs like the following
import javax.swing.*; // import the swing library for I/O
class inputbox
{
public static void main (String[] param)
{
askForFact();
System.exit(0);
} // END main
public static void askForFact()
{
String userfact =
JOptionPane.showInputDialog
("Go on tell me something you believe!");
JOptionPane.showMessageDialog(null,
"So... you think... + userfact + " do you");
return;
} // END askForFact
} // END class inputbox
Types: Exercise
Put the following into groups of similar things:
1 true hello 5 p 17 false 6.2 + 12345 3.14 a 2.3 z afghj
What properties do they share?
What operations can they be used for?
Types
Grouping values into different types with similar properties means:
the computer can make sure there is appropriate storage space for them, and
make sure the instructions only tell it to do sensible things with them.
so you do not try to, for example, multiply two strings together (as it is
meaningless).
Example Method
public static void add3ages()
{
int age1; int age2; int age3;
int totalAge;
String textinput;
textinput = JOptionPane.showInputDialog(Your age?);
age1 = Integer.parseInt(textinput);
age2 = 13;
age3 = 10;
totalAge = age1 + age2 + age3;
JOptionPane.showMessageDialog(null,
"The total age of the three people is " + totalAge);
return;
} // END add3ages
Variables: Storing things for use later
Variables are used by computer languages for storing information in a way
that lets the program get at it again later
o ie commands can work on data collected earlier.
A variable is like a named box into which you can tell the computer to put a
piece of data.
Different types of data need boxes of different shapes and sizes to store them
o integers, decimals, strings of characters, single characters, true or false
values, output channels...
Variables
If you want to use a box to store something in, you have to do two things:
o get a box of the right kind/size
o put something in it
Its the same with variables.
o declare the variable (tells the computer to create the type of box you
asked for)
o initialize it (tells the computer to put something in it)
Declaring Variables
You include a statement in the program introducing the variable:
int X;
String film;
These introduce two variables called X and film.
The computer is told that X holds an integer (a number) (int), and film holds a
string of characters (String).
These declare the variables X and film
Restrictions on Names
There are some restrictions on what you can use as the name of a variable.
They cannot start with a number for example.
There are also some reserved keywords that already mean something else
such as class and while.
You cannot use a keyword as a variable (the computer would get confused!)
Exercise: What do the following do?
Give 2 example values that would be stored in each of the following declared
variables:
Strings
String message;
int age;
char initial;
boolean finished;
String values are in quotes.
Eg "The Matrix
That is how you tell they are string values and not the names of variables like
film
An operation you can do on string values is to combine them using the
operator +:
"The Matrix" + " is cool!" creates the string "The Matrix is cool!"
film + " is cool!" creates the string made of whatever is in variable film with
the string " is cool!"
The Type: boolean
We also have a type: boolean
It has two possible values:
o true and false
It is just like the other types
o ( int, char, double, String).
There are functions that return boolean.
You can have boolean variables.
Assignment
You store something in a variable by assignment
You can assign the result of doing a calculation
title = JOptionPane.showInputDialog(Title?);
stores the result of the method call in the variable called title.
age = age+1;
adds one to the value in variable age and stores it back in age.
year = 2004 - age;
sets the variable year to be 2004 minus the value in the variable age.
Putting values in Variables
The commands:
X = 1;
film = "The Matrix";
puts 1 in X and "The Matrix" in film
Box X gets the number 1
Box film gets the string "The Matrix"
All at once
Its bad manners (and dangerous) to leave variables around without values in
them.
So you will often want to declare a variable, and immediately store something
in it.
Most languages let you do this all at once:
int X = 1;
String film = "The Matrix";
These declare the variable and intialise it to contain an initial value.
Variables: the box metaphor
You can think of a variable as a box in which data can be stored.
int number;
creates a box called number which is the right size and shape to store integers
(whole numbers):
number
int
Variables: the box metaphor
String words;
creates a box called words which is the right size and shape to store a string:
words
String
Since Strings can be any length, you have to think of a box for them as being a
stretchy box
words
Other types in Java
String
Other things you can put in variables:
o double: floating point numbers 3.14159
o char: single characters a, b, c, . . .
Note that the character 1, is different to the integer 1 which is different to the
floating point number 1.0
They are different types, are stored differently and have different operations
performed on them.
Assignment
The operation for setting the contents of a variable is called assignment:
number = 3*4;
puts 12 in the box number, obliterating whatever was there before:
number
12
int
The calculation on the right hand side is done first, then the value calculated
stored
Boolean Assignment
boolean finished = true;
creates a box called finished which is the right size and shape to store
booleans and stores true in it:
finished
true
boolean
Assignment Copies Information
You can copy information from one variable (box) to another:
number = age;
puts a copy of whatever was in the box age into box number , obliterating
whatever was in number before but leaving age unchanged
Suppose age held 42 the above would make number 42 too.
Assignment Exercise
Draw before and after box diagrams that show what the following does
assuming it started off holding the number 42
number = number+1;
Integer Operations
You can do the normal operations on integers as with a calculator.
For example:
f = (c * 9 / 5) + 32;
multiplies c by 9, divides that by 5 then adds 32, putting the result in f.
Arithmetic operations happen in the normal priority order (BODMAS)
Eg multiplication before addition
Integer.parseInt
Integer.parseInt(textinput);
This is a method that converts a String held in the variable textinput into an
Integer (as you can only do calculations on integers!)
Eg The string 123 of characters 1 then 2 then 3 is converted to the
number 123 (one hundred and twenty three)
Expressions
An expression is essentially just a fragment of a program that evaluates to give
a value.
The value it results in depends on the values of variables in it.
If an
For example.
(a + 1) *2 is an integer expression
If a is 5 at the time it is executed it would evaluate to the value 12.
Expressions are used in assignments to calculate the value to be assigned
For example
x = a + b + c;
Here a + b + c is the expression as it is the part that evaluates to a value. It
adds together the values of a, b and c. Only once the expression has been
evaluated can the value calculated be stored in another variable by the
assignment.
The above examples are integer expressions. They evaluate to give an integer
expression.
You can have expressions of any type. For example,
"Hello " + "World from" + name
is a string expression as it evaluates to a string. If variable name holds
Paul it would evaluate to the string "Hello World from Paul"
Expressions can include method calls if the method computes a value. For
example
Integer.parseInt(textinput) + 25
is an integer expression that includes a call to the parseInt method. Whatever
value it returns has 25 added to it to get the final value of the expression
Exercise
Write a program that asks the user for 2 numbers and prints out their average
(adding together and dividing by two).
Assignment
General form:
<variable> = <expression>;
evaluates <expression>, (that is works out its value) and puts the result in
<variable>, completely obliterating the previous contents.
Tracing: What does this do?
Draw a series of box pictures with a box for each variable to work out what
this code does...
int x;
int y;
x=1;
y=2;
x=y;
y=x;
Tracing: What does this do?
Draw a series of box pictures to work out what this code does...
int x;
int y;
int t;
x=1;
y=2;
t=x;
x=y;
y=t;
Remember
Before you use a variable you need to do two things:
Create the box (declare the variable):
int count;
Put something in the box(initialise the variable):
count = 0;
You can do both at the same time:
int count = 0;
Some rules about variables
Always call them by a name that tells you about their function: in the
fahrenheit, celsius example a mathematician might have
int f,c;
. . .
f = (c * 9 / 5) + 32;
a computer scientist would more likely have
int fahr,cel;
. . .
fahr = (cel * 9 / 5) + 32;
Or better still write fahrenheit and celcius in full
Some rules about variables
Always put your declarations in a sensible place, so you can find them later.
For example:
o do them in an initialisation phase for that part of the program.
o Initialise variables immediately when possible.
Functions and procedures
Methods divide up into functions and procedures.
A function returns a value that you can use later in the computation:
age = Integer.parseInt(text);
A procedure simply does something (no value returned to put somewhere):
System.out.writeln(Hellooooo);
Methods
The documentation for functions tells you what type of thing is returned, and
what types of things any arguments have to be.
public char read()
Functions and procedures have a lot in common, and Java treats them as the
same kind of thing (a method): a procedure is a function that returns nothing.
public static void askForFact()
Comments
It is essential to add explanations (comments) to programs explaining what
they do and how they work at a high level.
This is so that subsequent programmers including yourself can understand
them.
Comments are ignored by java - they are not computer instructions.
/* This is a
comment */
// So is this
Random Numbers
Various Java libraries define a whole host of more complicated types than
basic numbers and strings
For example, suppose you want to create a virtual coin or dice that introduces
randomness into your program, one way is to load the Random library
import java.util.Random;
You can then create a variable that holds a random number generator.
o When you want one you can ask it for a new random number like
rolling a dice.
o One way to think of it is as an endless stream of random numbers
where you can only ever see the next one in the sequence
Random dice = new Random();
This declares a new variable weve called dice of type Random
o dice is now something that will give you random numbers.
Now to get the next random number (throw the dice) you use the method
nextInt. It takes an argument that gives the range of numbers involved
int dicethrow = dice.nextInt(6) + 1;
Here dice.nextInt(6) says get me the next random number from dice .
The argument 6 says make the number one of the 6 values 0,1,2,3,4 or 5.
If we want an actual dice we want a number between 1 and 6 not 0 and 5 so
we add 1 to the value.
What we get is just an integer so we can store it (using an assignment) in an
integer variable just like any other integer
o here weve called the integer variable dicethrow
For example the following might be used to roll a 10 sided dice.
Random bigdice = new Random();
int diceroll = bigdice.nextInt(10) + 1;
System.out.println(You rolled + diceroll +
on a 10-sided dice);
Unit 2 Example Programs and Programming Exercises
Only try these exercises once you feel confident with those. Do them before trying
the next assessed exercise.
Manipulating Integers
Compile and run the following programs experiment with them modifying them
to do slightly different things until you understand how they work. Make them
do longer calculations (add 4 numbers, do other operations like subtraction, etc)
add3.java : Add a series of numbers and print the result
calculate.java : Convert text to numbers and do more complex calculations
yearborn.java : More calculations to do something a bit more interesting
Here is a typical simple program using expressions and assignment.
/* *****************************************
AUTHOR
Converts a length of time given
in days to a length of time in minutes.
For example 1 day would be
converted to 1440 minutes (as 1x60x24=1440).
******************************************** */
import javax.swing.*; // import the swing library for I/O
class daysminutes
{
public static void main (String[] param)
{
convertDaysToMinutes();
System.exit(0);
} // END main
/* ***************************************************
Define some commands of our own to use above
*************************************************** */
/* ***************************************************
Get a number of days from the user and print
the corresponding number of minutes.
*/
public static void convertDaysToMinutes()
{
// Declare variables
//
int days; // a length of time in days
int minutes; // the same length of time in minutes
// constant multipliers for hours in a day and
//minutes in an hour
final int HOURS_IN_DAY = 24;
final int MINS_IN_HOUR = 60;
String textinput; // whatever number the person types as text
String answertext; // construct the text to give
// the answer back
// Get a number of days (a string) from the user
textinput = JOptionPane.showInputDialog
("What is the time interval in days?");
days = Integer.parseInt(textinput);
// Now do the calculation
// multiply minutes in an hour by hours in a day
minutes = days * MINS_IN_HOUR * HOURS_IN_DAY;
answertext = days + " days is "+ minutes + "minutes";
// Finally give the user the answer
JOptionPane.showMessageDialog(null, answertext);
return;
} // END convertDaysToMinutes
} // END class daysminutes
1. Number input
Write a program that reads in a whole number n, and prints it out again. Modify your
code so that it prints out n+1 (ie one more than the number typed in).
2. Fahrenheit to Celsius
Write a program that reads a temperature in degrees Fahrenheit and prints out the
corresponding temperature in degrees Celsius (C = (F - 32) * 5 / 9).
Make the program 'user friendly' (this applies to all subsequent programs you write -
ever!). The messages to the user should be clear and easy to understand what is
expected of them.
3. Celsius to Fahrenheit
Write a program that reads a temperature in degrees Celsius and prints out the
corresponding temperature in degrees Fahrenheit (F = (C * 9 / 5) + 32).
4. Year Born (again)
Modify the year born program from above so that it asks the user for the current year
first (so won't get the answer wrong in future.
5. Area of a rectangle
Write a program that reads in the length and breadth of a rectangle in cm and
computes its area.
6. Compiler Messages
Take your completed working program that calculates the area of a rectangle, and
make a series of single changes that introduce errors (for example delete single lines,
change the names of variables in one place only as for a typing error, delete brackets,
etc). After each change made, compile the program, make a note of the error message
and its cause, work out what the error message means, correct the program and
recompile it to ensure it has been fixed, then insert the next error.
7. Average
Write a program that reads a series of 3 numbers and computes their average (adding
and dividing by 3).
Does your program give an accurate answer? If not you may wish to consider how
might this be done (HINT decimal numbers are a different type to integers - use type
keyword float (for floating point number))
8. 12-sided dice
Write a program that rolls a 12-sided dice printing the result of the roll.
Once you have done these, try the next assessed exercise. The assessed exercises must
be done on your own. If you have problems with them then go back to the non-
assessed exercises.
Harder Exercises
The following are additional, harder exercises. The more programs you write this
the easier you will find next work and the assessments and the quicker you will
learn to program. If you complete these exercises easily, you may wish to read
ahead and start thinking about next exercises.
9. Giving change
Write a program that works out the best way for a cashier to give change when
receiving payment for some goods. There will be two inputs, the amount due and the
amount of cash received. Calculate the difference and then the pounds, 50p's, 20p's,
10p's etc that the customer should receive in return. Hint: transform the difference
into a whole number of pence. Then calculate the whole number of pounds due in the
change. Subtract this from the original balance of change. Then calculate the number
of 50p's needed...and so on.
10. Inland revenue
Write a program that reads in a person's annual income and then computes and
outputs their income tax liability assuming the following:
there is a 4200 tax free allowance
the first 4500 of taxable income is taxed at the 'lower rate' of 20%
the next 22,600 of taxable income is taxed at the 'basic rate' of 23%
any further income is taxed at the 'higher rate' of 40%
You can do this exercise without the use of conditional instructions (topic)
if you are very clever although they make it much easier (so read ahead!).
11. Funny 6-sided dice
Write a program that rolls a 6-sided dice that has numbers 5, 6, 7, 8, 9, 10 on its faces,
printing the result of the roll.
12. Odd 6-sided dice
Write a program that rolls a 6-sided dice that has odd numbers 1, 3,5,7,9,11 on its
faces, printing the result of the roll.
Java programming in Greenfoot
Once you are comfortable with exercises like the ones above why not play at
programming in Greenfoot (obtained from http://greenfoot.org/).
One of the beauties of Java is the ease with which you can combine your code with
library code written by others. Greenfoot is one example. It is just a Java development
environment that comes with lots of code for creating 2D games.
Try out the Flying Hippo scenario that is on the The basic code I needed to write for
it was that below which calls Greenfoot methods getX, getY and setLocation. The
program only works if you run it in Greenfoot as it needs those methods (and lots of
other hidden code Greenfoot gives you).
import greenfoot.*;
/** * Hippos drop to the ground */
public class Hippo extends Actor
{
/**
* This is an empty method that says what to do,
* if anything, when we create a new hippo.
* With my Hippos nothing is done - the brackets are empty.
*/
public Hippo()
{
}
/** In Greenfoot you write an act method a bit like
* the main method as the place to start. It says what to
* do with a Hippo on every clock tick.
*/
public void act()
{
// Variables that hold the hippos current position.
// getX and getY are methods to get the position
int newX = getX();
int newY = getY();
// If we leave the X coordinate alone and
// increase the Y coordinate then
// the hippo sinks by one step every time
// the method act is called.
newX = newX;
newY = newY + 1;
// To make the hippo move you pass the new location
// to the predefined Greenfoot setLocation method
setLocation(newX, newY);
return;
}
}
import greenfoot.*;
import java.util.Random;
/**
* A world where hippos live.
*/
public class HippoWorld extends World
{
/**
* Create a new world with 10x10 cells and
* with a cell size of 60x60 pixels
*/
public HippoWorld()
{
super(10, 10, 60);
setBackground("space.gif");
Hippo w1 = new Hippo();
addObject(w1, 5, 0);
return;
}
/**
* Populate the world with a fixed scenario of a hippo.
*/
public void populate()
{
Hippo w1 = new Hippo();
addObject(w1, 5, 0);
return;
}
}
Download the file flyinghippo.zip and unzip it. Run greenfoot and open the scenario
flyinghippo from where you saved it sing the Greenfoot drop-down menu Scenario-
Open. Click Compile all in the bottom corner and then the run button at the bottom to
run my code and see a hippo fly.
The Java code that makes it happen can be viewed and edited via the right hand panel.
There are two program files I wrote Hippo (the code above) and HippoWorld that just
sets up a starry sky with a hippo in it. Double click on either the Hippo box or the
HippoWorld box and you will see the code I wrote. Try changing it can you make
the hippo fly instead of fall? After any changes click the compile button, then close
that editor window and go back to the main window and see what happens when you
run it. The compile button is essentially just calling javac for you and the run button is
calling java.
Avoiding Bugs
Its always better to avoid a bug in the first place, rather than cure it afterwards. That
is where programming "style" comes in...Be a stylish programmer and make your
programs easier to follow.
TIP 1: Always put all the variable declarations together at the start of the method -
like an ingredient list in a recipe. It makes it easier to check you haven't missed
anything. eg
int age1; // each will hold the age of a different child
int age2;
int age3;
int totalAge; // the answer when the three ages are added
TIP 2: Write comments with variables that say what they will be used for (not just
repeating their names and types - give information you can't tell just from the
declarations themselves)
TIP 3: Use variable names that tell you what the variable does. A variable called t
could do anything. A variable called temperature is presumably storing a temperature.
It is even easier to work out what the variable called todaysTemperature will be used
for! That way you won't get confused about your intentions for variables you
declared.
TIP 4: Use blank lines to make it easier to see how related commands are grouped or
not grouped - and comment each group of commands (not each line).
TIP 5: Step through the method you have written executing it (doing what each
instruction says in your head or on paper) line by line as though you were the
computer, checking it does what you expect.
TIP 6: If your program uses specific numbers (like 2006) then declare a final variable
and set it to that number then use the variable elsewhere in the program in place of the
number. final before a declaration just tells the compiler that this variable will not be
assigned to in the program (so the compiler can tell you if it does because of a mistake
by you.)
final int CURRENTYEAR = 2006;
.
.
.
year = CURRENTYEAR - age;
There are two advantages to this. First the name used can tell you what the number
means - like "its the current year" so avoiding confusion - perhaps it stands for
something else. Secondly, if the number is used twice and you decide to change it, (eg
to 2007) you only have to do the change in one place (less work and you won't miss
any of the changes by mistake)
Catching Bugs
Everyone catches colds. Everyone who writes programs gets bugs. One of the skills of
programming is to come up with ways that help you work out what you did wrong.
Early in your programming career it will mainly be getting bits of the language
wrong: misspelling things, getting the punctuation wrong,... Those things the compiler
spots for you, but you have to learn how to work out what the compiler is telling you.
TIP 1: Double check that you have declared all the variables you have used at the
start of each method. (eg by writing int age; if you used an integer called age)
TIP 2: Watch out for having mistyped 1 (one) instead of I (the letter i) or 0 (zero)
instead of O (the letter O).
TIP 3: If you are using an editor that knows about Java it may use colours to
emphasise part of the program - strings in one colour, variables in another etc. Use the
colours to see where things have gone wrong. If the last part of the program has all
turned pink it might mean for example you forgot a closing string quote for the string
where the pinkness starts!
Some Common Compile-time errors
Undeclared Variables
pc$ javac add3.java
add3.java:52: cannot find symbol
symbol : variable totalAge
location: class add3
totalAge = age1 + age2 + age3;
^
Oops I forgot to declare the variable totalAge - it is telling me it "cannot find symbol"
- that just means there is a name Im using that it doesn't have a clue what I am
talking about. It is guessing I meant it to be a variable but it can't be sure what type (is
it a String or an Integer). I have to tell it by adding earlier the line: int totalAge;
The same kind of message will be given if I had misspelled a variable I had declared
(including putting in capitals by mistake) or just misremembered what I had called it.
pc$ javac yearborn.java
yearborn.java:61: ';' expected
year + " or " (year - 1);
^
This is an example where the compiler is confused. It thinks Ive missed a semicolon
when actually Ive missed a +. It could just tell it needed something other than a
bracket after quotes as a bracket made no sense: year + " or " + (year - 1);
Explaining concepts
You should by now be able to explain lots more concepts. Here are some questions to
check. If you cant write detailed answers then do some more background reading but
focus on being able to understand. Working out an answer for yourself will help you
understand and so remember far better.
Make sure you can write answers in your own words without a book or computer in
front of you. Remember there is no one right answer. Every ones answers should be
different.
Explain what is meant by the following concepts, using Java programming examples
to illustrate your answer:
a) a type
b) a String
c) assignment
d) a name
e) a boolean
f) an integer variable
g) a string variable
h) an integer assignment
i) a function
j) a procedure
k) an expression
l) an integer expression
m) a string expression
n) a boolean expression
You should be able to explain some of the concepts frombetter now too.
Compare and contrasting concepts or code
Exam questions test your understanding in different ways and different kinds of
answers are expected depending on the questions asked. So far weve looked at
Explain questions. You can also be asked to Compare and contrast concepts
(or just compare or just contrast them). A compare and contrast question is asking you
to do more than just explain the concepts but to actively draw out the similarities and
the differences.
For example you might be asked a question like:
1. Compare and contrast variables and values.
Notice how the following answer not only explains the concepts but also points out
the similarities and differences.
Variables and values are both elements of programs. A variable is a location where
data can be stored. It is has a name and a type. A value on the other hand refers to an
actual piece of data. They are the things that can be stored in a variable. Values also
have types though they do not have names. For example, in the code fragment
n = 55;
n is a variable and 55 is a value. This particular instruction when executed stores the
value 55 in the variable called n.
Like variables values have types. For example in the above fragment both n and 55
are of type integer. For a variable the type refers to the kind of thing it can hold,
whereas for a value it refers to the kind of thing it is. In Java variables and values can
be various types including integers, Strings and booleans. The only boolean values
are true and false. String values are given in quotes. They superficially look like the
names of variables and so are easily confused. Whereas s is a variable (no quotes),
"s" is a String value and s is a character value. The assignment
s = "s";
stores the string value consisting of a single character the letter s into the variable
with name s.
Variables have to be declared in a program before they can be use whereas there is
no equivalent of declaration for a (simple at least) value. For example before the
above fragment, n would be declared ie given its name and type as follows:
int n;
Variables and values are the basic building blocks of expressions. They are simple
expressions themselves but can be built into more complex expressions using
operators like + or *. For example
n +75 k *2
is an expression that is built from the variables n and k and the values 75 and 2
Unit 2 Exam Style Question
Attempt the following questions in exam conditions. Compare your answer with the
model answer. How good are your explanations? How good is your code?
Question 1 [25 marks]
This question concerns assignment and expressions
a. [6 marks]
State whether each of the following are good or bad choices for variable names,
justifying your answer.
i) t
ii) class
iii) hair_colour
iv) hairColour1
v) 4cast
vi) timeOfDay?
b. [9 marks]
Compare and Contrast the following fragments of code
i)
t = a;
a = b;
b = t;
ii)
c = d;
d = c;
c. [10 marks]
Write a Java program that converts a length of time given in days to a length of time
in minutes. For example 1 day would be converted to 1440 minutes (as
1x60x24=1440).
Unit 3: Making Decisions
Learning Outcomes
Once you have done the reading and the exercises you should be able to:
write programs that make decisions
explain the use of boolean expressions
explain what is meant by if statements
trace / dry run programs containing if statements
write simple procedures
You should now be able to:
write and run simple programs that manipulate data
write programs that do calculations on values stored
write programs that print out messages that include the results of calculations.
write programs that store and manipulate different types of values.
explain how your above programs work and the concepts involved.
You should be able to make methods like this one by now:
public static void average3ages()
{
int age1;
int age2 = 13;
int age3 = 10;
int averageAge;
String textinput;
textinput = JOptionPane.showInputDialog(Your age?);
age1 = Integer.parseInt(textinput);
averageAge = (age1 + age2 + age3) / 3;
JOptionPane.showMessageDialog(null,
"The average age of the three people is "
+ averageAge);
return;
} // END average3ages
Decisions, Decisions
Straight line programming isnt enough. You have to be able to do different
things in different circumstances.
Examples:
Q: Which course do I take?
A: if you are a G400 student, then Computers and Society, but if you are a G452
student, then Intro to Multimedia, and if you are a . . .
Or imagine a cash machine: Do you want cash or the balance?
...or your mobile phone with all those menus of options.
or the Noughts and Crosses AI that was all about decisions
When you made a decision on what to type in the program has to make a
decision on how to act in responsedifferently depending on what you did.
If statements
Programming languages solve this by having if statements:
We need a way in the language to spell out a decisionwe need
Something that says what follows is a decision - we need a new keyword
A way of asking a question - is this true or false?
A way of giving the two alternative sequences of commands (mini-programs)
depending on the answer.
if statement form
if ( <test> )
{
<statement>
}
else
{
<statement>
}
Example
String ans= no;
ans = JOptionPane.showInputDialog(
Can I insult you, please?");
if (ans.equals(yes))
{
}
else
{
JOptionPane.showMessageDialog(null, You smell!");
JOptionPane.showMessageDialog(null,You smell of
roses!");
}
JOptionPane.showMessageDialog(null, Thank you!);
Flow of Control
Exercise
Write a method that asks the user to type in their name.
If they are called Paul print Thats the name of a true genius.
If its not just print Never mind.
Doing more than one thing
if (ans.equals(y))
{
JOptionPane.showMessageDialog (null,You smell!");
JOptionPane.showMessageDialog (null,I mean it!");
}
else
{
JOptionPane.showMessageDialog(null,
You smell of roses!");
JOptionPane.showMessageDialog (null,Wow!!");
}
Blocks
JOptionPane.showMessageDialog(null, Thank you!);
Simple statements can be grouped into a block using curly brackets
{
JOptionPane.showMessageDialog (null,You smell!");
JOptionPane.showMessageDialog (null,I mean it!");
}
You can put as many statements as you like in a block and they will get
executed together in sequence
You can even put if statements inside a block
You can combine tests
if (ans.equals(yes))
{
JOptionPane.showMessageDialog (null,You smell!");
}
else if (ans.equals(no))
{
JOptionPane.showMessageDialog(null,You smell of roses!");
}
else
{
JOptionPane.showMessageDialog(null,Yes or No!");
}
You can easily build these up to the point where your code is very opaque.
Dont.
Exercise
Write a method that asks the user to type in the kind of pet they own if any.
Print out a suitable message like Ahh, a dog they keep you fit or Goldfish
look after themselves etc depending on the kind of pet they reply. If the
program doesnt recognize the name. Print Not heard of that one.
The test
The test has to be something that has two answers - one for each possible
follow-on command
The answer can either by true or it can be false
Integer expressions like n+1 evaluate to numbers
For tests we need boolean expressions - that evaluate to booleans (true or
false)
ans is equal to yes .TRUE
Some example boolean expressions
letter == y
letter is equal to y ? True or false?
X <= 34
X is less than or equal to 34 ?
X*Y > 0
X times Y is greater than 0 ?
ans.equals(yes")
ans is equal to the string yes ?
They all are either true or false depending on the values in the variables
The Type: boolean
We have a type: boolean for true or false things!
It has two elements: true and false
It is just like the other types( int, char, double, String).
There are functions that return boolean.
You can have boolean variables.
So you can assign to them using boolean expressions just like with integer
variables and integer expressions
Constructing boolean expressions
standard comparison operators:
equal: ==,
not equal: !=,
less than: <,
greater than: >,
less than or equal: <=,
greater than or equal: >=
Exercise
Assume x is 0 and y is 1, which of these boolean expressions evaluate to true
and which to false?
x > y
y < 1
y <= x+1
x == y-1
Beware .equals() = and ==
USE == (for comparing ints and chars)
USE .equals() (for comparing strings)
pet.equals(dog)
DO NOT USE = (assignment)
In JAVA it is a command saying move data from one place to another NOT a
question with a true false answer
Read = as gets the value of NOT equals.
Constructing boolean expressions
combinations through boolean operators (called connectives ):
and: & or &&
or: | or ||
not: !
(cf. Logic and Proof course)
Examples:
ans==y | ans ==Y
X>0 & Y>0
Equals for strings
Java has two types of objects, simple and complicated (not technically called
that).
= = only works for simple objects. For complicated objects they only tell you
whether the objects are represented internally in Java by the same bit of
memory.
Strings are complicated. This means:
USE
mystring.equals(Hello World!)
DONT USE
mystring == Hello World!
Tracing if statements
You can trace if statements using boxes as variables just as with straight line
code.
As you trace you just make sure that you jump to the correct lines of code
according to the test (following the flowchart)
Just trace those lines missing the ones on the branch of the if not executed.
Its a good idea to have extra question boxes where you write the answers to
the tests.
Tracing If statements
Trace the following code 3 times for values input of 3, 10 and11.
int price = 0;
String weighttext =
JOptionPane.showInputDialog(Weight?);
int weight = Integer.parseInt(weighttext);
if (weight <= 5)
{price = 2;}
else if (weight <= 10)
{price = 4;}
else
{price = 6;}
JOptionPane.showMessageDialog(null,"The cost is " +
price);
Systematic testing
Youre writing programs whose behaviour is more complicated now.
Systematic testing is very important.
In industry more effort goes into testing code than writing it.
That is why weve put you into test pairs in the labs
It is impossible to test programs exhaustively (every possible input), so
representative cases have to be picked.
Systematic testing
The idea is to test each possible program behaviour, not each possible input.
For complex program behaviours there are still lots of cases, and the testing
has to be done on an automated test-bed.
Complex programs have to be broken down into bits, and each bit tested
separately. Microsoft employs more people to test code, than to write it.
You have to take testing seriously too.

Programming style and layout

The point of having a high-level language is that it can be read and understood
by people.
This point is lost if the code is written down in a way that is hard for people to
understand.
Most industrial coding is maintenance. This means you will have to read,
understand and change code written by other people.
Worse: This means you will have to read, understand and change code written
by yourself!
You will need all the help you can get!
Programming style and layout, cont
There are some simple rules you can follow to make your program more easily
readable.
See the web and example programs and copy their style.
These boil down to:
choose informative names for variables (and later other things)
use layout to make the grammatical structure of the program clear (indent at {
go back in at } )
Explain what blocks of your code do with useful comments
Further Extensions
If you really want to be a good programmer, once you have mastered if
statements explore the variations
o Switch statements
o Assigning boolean expressions to boolean variables
Random Numbers
Combining random numbers with if then-else we print results other than numbers
Random coin = new Random();
int cointoss = coin.nextInt(2);
if (cointoss == 0)
System.out.println(You tossed Heads);
else
System.out.println(You tossed Tails);
Starting to defining methods procedures
Defining methods
One of the most important things to start to do is split your programs into
methods.
As programs get larger it becomes harder to read them, find mistakes and to
change.
It is better to split them into small bits
Each method should do a clear self-contained job.
o a bit like a single recipe in a recipe book
You have been writing methods from the start.
An example from earlier
Look at the following code that we were playing around with fragments of earlier:
It uses two methods main and insultme.
methods like this that just do things are called procedures (more on that later)
insultme is getting a little complicated
we have also changed the messages several times in our different variations
earlier
can we make it easier to see what it does overall
make it so that we can change parts
import javax.swing.*;
class insultornot
{
public static void main (String[] param)
{
insultme();
System.exit(0);
} // END main
/* *********************************
A method that asks to insult you
*/
public static void insultme()
{
String ans= no;
ans = JOptionPane.showInputDialog(Can I insult you, please?");
if (ans.equals(y))
{
JOptionPane.showMessageDialog (null,You smell!");
JOptionPane.showMessageDialog (null,I mean it!");
}
else
{
JOptionPane.showMessageDialog(null,You smell of roses!");
JOptionPane.showMessageDialog (null,Wow!!");
}
JOptionPane.showMessageDialog (null,Bye!");
return;
} // END insultme
} // END class insultornot
We can take out the chunks of code that print a message and replace them by calls to
new methods
if (ans.equals(y))
{
printInsultingMessage();
}
else
{
printNiceMessage();
}
We have just introduced two new methods called printInsultingMessage and
printInsultingMessage
Each is intended to do a clear well-defined task.
We can see from the above cade what the fragment is intended to do either print
an insulting or nice message
o without seeing the details of the new methods
In the above fragment we call the new methods.
o the program says go and find some code with that name and when youve
finished come back and carry on.
We dont need to worry what they do precisely while writing this bit
We then need to define exactly what they do do what message does each print.
Here is what we might write for the insulting message
/* *********************************
Print an insulting message
*/
public static void printInsultingMessage()
{
JOptionPane.showMessageDialog (null,You smell!");
JOptionPane.showMessageDialog (null,I mean it!");
return;
} // END printInsultingMessage
It is a self contained method.
We have given it a name in the first line: printInsultingMessage
We have also now said what it does precisely
Someone who does want to see the detail of the insulting message just looks here.
return
Notice that the last instruction is return.
That says Now we have finished here, go back to where you came from.
All methods should execute a return statement as the last thing they do
main is an exception as it uses System.exit for a similar purpose.
o it says quit the program and return to the operating system
o rather than just quit this method
All together
The new program with it all put together is below
It consists of 4 methods and the program jumps around between them:
The program starts executing main. It says go execute insultme
It jumps to insultme which asks for the person to make a choice.
If they want to be insuted then the program jumps to printInsultingMessage and
starts to follow the commands there. When done it returns back to insultme which
carries on where it left of.
insultme next prints Bye and then hits its return statement
so it jumps back to main which carries on where it left off.
The next thing its instructions say to do is exit so it does
What would happen if the person asked not to be insulted? Which methods would
be called then?
import javax.swing.*;
class insultornot
{
public static void main (String[] param)
{
insultme();
System.exit(0);
} // END main
/* *********************************
A method that asks to insult you
*/
public static void insultme()
{
String ans= no;
ans = JOptionPane.showInputDialog(Can I insult you, please?");
if (ans.equals(y))
{
printInsultingMessage();
}
else
{
printNiceMessage();
}
JOptionPane.showMessageDialog (null,Bye!");
return;
} // END insultme
/* *********************************
Print an insulting message
*/
public static void printInsultingMessage()
{
JOptionPane.showMessageDialog (null,You smell!");
JOptionPane.showMessageDialog (null,I mean it!");
return;
} // END printInsultingMessage
/* *********************************
Print a nicemessage
*/
public static void printNiceMessage()
{
JOptionPane.showMessageDialog(null,You smell of roses!");
JOptionPane.showMessageDialog (null,Wow!!");
return;
} // END printNiceMessage
} // END class insultornot
From now on start to split your programs into methods
Unit 3 Example Programs and Programming Exercises
Only try these exercises once you feel confident with those from the previous unit.
1. If statements (and starting to write methods)
Compile and run the following programs from the experiment with them
modifying them to do slightly different things until you understand how they
work. Make them ask for different information, make different decisions, or do
different things depending on the result. Change the question to be
the opposite of it (eg ask if the two things are not equal rather than equal and see what
happens).
if_boolean.java : See how a boolean test of an if switches between commands
to execute
if_String.java : You can do tests on strings Change the assignment to ans to
see the effect. Note == is not used to compare strings
if_int.java : You can do tests on numbers What happens if you type a number
other than 1 or 2 when testing this program.
if_char.java : You can chain a whole series of tests together if there are lots of
choices. What happens if you type in a full word instead of a character when
this program asks?
if_char2.java : You can put any command inside if statements: here
assignments
insultornot.java : You can start to split your programs into methods
2. Question and response
Write a program that asks the user
How many beans make five?
If the user responds 5, print
Correct!
otherwise print
Wrong!
Now change the program so that it prints
About right!
if the user responds 4 or 6
3. Maximum of two integers
Write a program that asks the user to input two integers and then prints out the larger
of the two.
4. Maximum of three integers
Write a program that asks the user to input three integers and then prints out the
largest of the three.
5. Pass or fail
The Queen Mary grading scheme for BSc course units awards a letter grade based on
the numerical score between 0 and 100 as follows:
less than 40 : F
40 to 44 : E
45 to 49 : D
50 to 59 : C
60 to 69 : B
70 and above : A
Write a program that inputs a numerical score from the keyboard and outputs the
appropriate letter grade.
6. Postage
Write a program that computes the cost of posting a parcel.
The cost is calculated using the following rates:
first kilogram......................6
each additional kilo up to 5kg.......4
each additional kilo up to 10kg......3
each additional kilo.................2
There is a maximum weight limit of 20kg. The program should print a prompt:
Type Weight (kg):
When you have typed a weight, say 4, the program should respond with:
The cost is 18
unless the weight is over 20kg, in which case it should respond:
There is a maximum weight limit of 20kg.
7. The planets
Write a program that asks the user to input the name of a planet (Mercury, Venus,
Mars etc.) and outputs its place in order from the sun.
So, if the user correctly gives the name of a planet (e.g. Mars) then the program
should respond with
Yes. Mars is the 4th planet from the sun.
If the user does not respond with the name of a planet (e.g. Sun) then the program
should reject this as follows:
No. Sun is not a planet.
The program will input the user's answer and store it in a String variable as follows:
String planet = JOptionPane.showInputDialog ("Give me the name of a planet");
If the user types Mars (and then presses return) the above method invocation (or call)
has the same effect as
String planet = "Mars";
Hint: The program should first check whether the answer is "Mercury" (which is the
planet closest to the sun):
if (planet.equals("Mercury"))
System.out.println("Yes, Mercury is the 1st planet from the sun.");
else . . .
8. Days in a month
Write a program that asks the user to input the number of a month (1,2,...,12) and
outputs the number of days in that month. For February output "28 or 29". If the user
does not input an integer in the range 1 to 12 then output a suitable message (e.g. "A
month is denoted by an integer in the range 1 to 12.").
9. Leap year
Write a program that inputs an integer giving the year and outputs whether or not it is
a leap year. For example,
Please input year: 1996
1996 is a leap year
A year is a leap year if it is exactly divisible by 4 (i.e. no remainder) and not exactly
divisible by 100, unless it is divisible by 400. This is why the year 1900 was not a
leap year but the year 2000 is. A number is exactly divisible by 4 if the remainder on
integer-division is 0. To discover the remainder on integer-division use the Java
operator % (5 % 3 is 2). The test x % 3 == 0 for example, checks if x is divisible by 3.
10. Pounds and pence
Write a program that inputs a price given as a number of pence, and prints out the
price as pounds and pence. For example,
Enter price in pence: 1415
14.15
You will need integer division by 100 (.../100) to get the pounds, and the remainder
(...%100) to get the pence. You may need to consider two cases, or you will end up
with
Enter price in pence: 1405
14.5
Once you have done these, try the next assessed exercise. The assessed exercises must
be done on your own. If you have problems with them then go back to the non-
assessed exercises.
Extras
Greenfoot pingpongpiglet
Download and play around with the Greenfoot pingpongpiglet scenario from the
. Modify it so that piglets bounce up and down instead of side to side. Then make
piglets bounce diagonally. Add a new object of rocks and make piglets bounce off.
Days in a month again
Write a program that asks the user to input the number of a month (1,2,...,12) and
outputs the number of days in that month. This time use a switch statement. For
February output "28 or 29". If the user does not input an integer in the range 1 to 12
then output a suitable message (e.g. "A month is denoted by an integer in the range 1
to 12.").
Avoiding Bugs
Its always better to avoid a bug in the first place, rather than cure it afterwards. That
is where programming "style" comes in...Be a stylish programmer and make your
programs easier to follow.
TIP 1: Start writing an if statement (and other constructs with brackets) by typing in
its outline structure with all the brackets - then go back and fill in the gaps. That way
you wont forget the brackets or the else statement.
if ( )
{
}
else
{
}
TIP 2: Indent your if statements. Every time you type an open curly go in 3 spaces
for the following lines. Only go back when you hit the close curly. See how easy it is
to see what is in each branch of the following, compared to the version after...with
long programs it gets harder unless you indent. Its also easier to see you haven't
missed close curly brackets.
if (result == 1)
{
temperature = "hot";
raining = false;
}
else
{
temperature = "cold";
raining = true;
}
JOptionPane.showMessageDialog(null,
"That was the weather");
if (result == 1){
temperature = "hot";
raining = false;}
else { temperature = "cold";
raining = true;}
JOptionPane.showMessageDialog(null,
"That was the weather");
TIP 3: Put a blank line before the start of an if statement and after the end (its final
curly bracket) so its easy to see where it starts and finishes.
TIP 4: Whenever you write an if statement that tests a value input by the user, check
that what happens if they type in the wrong thing - make sure the program does a
sensible thing. It can be a good idea to use a final else specifically just to catch these
cases and print a warning.
Catching Bugs
Everyone catches colds. Everyone who writes programs gets bugs. One of the skills of
programming is to come up with ways that help you work out what you did wrong.
Early in your programming career it will mainly be getting bits of the language
wrong: misspelling things, getting the punctuation wrong,... Those things the compiler
spots for you, but you have to learn how to work out what the compiler is telling you.
+++++HOT+++++ TIP 1: If the program compiles but then does the wrong thing
and it is totally baffling why (the normal state with runtime errors!) add in extra print
statements so you can see which parts of the program get executed. Comment them
out once you have found the bug. Why? Because it allows you to tell which
commands are executed - to see into your code as it runs. It can also help you see how
and at what point a program crashes (if it does).
if (result == 1)
{
weather = "hot";
JOptionPane.showMessageDialog(null,
"DEBUG: DID HOT"); // add this to debug
}
else
{
weather = "cold";
JOptionPane.showMessageDialog(null,
"DEBUG: DID COLD"); // add this to debug
}
+++++HOT+++++ TIP 2: When you add in debugging print statements, include
printing the values of variables so you can see if they have the value you expect at
that point.
if (result == 1)
{
weather = "hot";
JOptionPane.showMessageDialog(null,
"DEBUG: DID HOT: weather is " + weather);
// add this to debug
}
else
{
weather = "cold";
JOptionPane.showMessageDialog(null,
"DEBUG: DID COLD: weather is " + weather);
// add this to debug
}
TIP 3: Make sure you haven't added a semicolon after the test. It might not be spotted
by the compiler (if you left out the else) but make the program behave really weirdly.
If it does cause a compile error the compiler will appear to be complaining about
something later.
if (result == 1); // THIS ; IS WRONG
{
weather = "hot";
}
else
{
weather = "cold";
}
TIP 4: Double check you haven't written = (assignment) instead of == (test for
equality).
if (result = 1) // THIS IS WRONG SHOULD BE ==
{
weather = "hot";
}
else
{
weather = "cold";
}
Some Common Compile-time errors
Forgot to change to the right directory
error: cannot read: if_boolean.java
1 error
Oops I forgot to declare the change directory to the place where I'd saved the new
program
pc$ java if_int
Exception in thread "main" java.lang.NumberFormatException: For input string: "a"
at
java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
at java.lang.Integer.parseInt(Integer.java:447)
at java.lang.Integer.parseInt(Integer.java:497)
at if_int.chooseDirection(if_int.java:37)
at if_int.main(if_int.java:18)
Notice this happened when I ran the program not when I compiled it (it compiled fine.
It is therefore a run time error not a compile-time error. Things seem to work fine. I
ran the program several times before this without problem. Then I typed in a character
'a' when I was asked for an integer. The program is complaining that at a point when it
needed a string containing a number, it got something else. To fix this we would need
to write code to check that the string entered did hold a number before we do the
conversion. That is complicated to write yourself. Alternatively we would need to
"catch the exception" using an "exception handler". We are not going to cover that
here but you may want to read about it yourself in your text book. A simpler
alternative for now would be to do the if test on strings directly if this was a real
program.
Unit 3 Exam Style Question
Attempt the following questions in exam conditions. A model answer can be found on
the Compare your answer with the model answer. How good are your explanations?
How good is your code?
Question 1 [25 marks]
This question concerns programs making decisions.
a. [6 marks]
Explain what is meant by each of the following illustrating your answer with
examples.
i) a type
ii) a boolean expression
b. [9 marks]
Give initial values for variable x in each example below that would lead to "Hello"
being printed justifying your answer.
i) [2 marks]
if (x==0)
{
JOptionPane.showMessageDialog(null, "Hello");
}
ii) [2 marks]
if (x<5)
{
JOptionPane.showMessageDialog(null, "Hello");
}
iii) [2 marks]
if (x>11)
{
JOptionPane.showMessageDialog(null, "Goodbye");
}
else
{
JOptionPane.showMessageDialog(null, "Hello");
}
iv) [3 marks]
if (x>11 & x<20)
{
JOptionPane.showMessageDialog(null, "Goodbye");
}
else if (x>2)
{
JOptionPane.showMessageDialog(null, "Hello");
}
else
{
JOptionPane.showMessageDialog(null, "Goodbye");
}
c. [10 marks]
Write a Java program that is given 2 integers by the user: the first is a number from 1
to 7 representing a day of the with 1 for monday etc. The second is a number from 1
to 12 representing a month. The program should convert the numbers into a text
equivalent. For example if 1 and 12 were supplied by the user, the program should
print:
A monday in December
Unit 4: Bounded For Loops
Learning Outcomes
Once you have done the reading and the exercises you should be able to:
write programs that follow instructions a fixed number of times
explain what is meant by a for loop
trace the execution of programs containing for loops
write methods that return results
You should now be able to:
write programs that make decisions
explain the use of boolean expressions
explain what is meant by if statements
trace / dry run programs containing if statements
You should be able to write programs like the following before moving on.
String ans= no;
ans = JOptionPane.showInputDialog
(Can I insult you, please?");
if (ans.equals(y))
{
JOptionPane.showMessageDialog (null,You smell!");
JOptionPane.showMessageDialog (null,I mean it!");
}
else
{
JOptionPane.showMessageDialog(null,You smell of roses!");
JOptionPane.showMessageDialog (null,Wow!!");
}
JOptionPane.showMessageDialog(null, Thank you!);
Exercise
Write a program that prints out a punishment given to you of writing the
following line 10 times:
I must not be late for class
Doing things repeatedly
You can do this by writing a method that includes 10 print statements.
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
System.out.println(I must not be late for class);
Very long winded...there must be a better way.
A better way
It could be worse - I could have said do it 100 times
But Computer Scientists are lazy and look for better waysEach line is the
same:
System.out.println(I must not be late for class);
We need a Java command that says follow that instruction 10 times.
If we were the Java inventors, we would need
o A new keyword to say we are looping, and
o A way of indicating what command should be repeated, and
o A way of saying how many times to do it
Inventing our own repetition command
Suppose we decided on the key word for to say we are looping, and
put the commands to be repeated in curly brackets to be consistent
we would need something like
for (10 times)
{
System.out.println(I must not be late for class);
}
Java is slightly more complicated than that (but not much)
Counters
What if we had been told to number each line:
System.out.println(1: I must not be late for class);
System.out.println(2: I must not be late for class);
System.out.println(3: I must not be late for class);
System.out.println(4: I must not be late for class);
System.out.println(5: I must not be late for class);
System.out.println(6: I must not be late for class);
System.out.println(7: I must not be late for class);
System.out.println(8: I must not be late for class);
System.out.println(9: I must not be late for class);
System.out.println(10:I must not be late for class);
Now every line is differentare we stuffed...back to doing it by hand? NO
Counters
Notice that every line is still virtually the same
System.out.println(????: I must not be late for class);
The only thing that differs is where I have put the question marks.
So all we need is a way of putting something in the place of the ???? that can
hold a number that we can then change each time we do the instruction again
But we can do that - we just need a variable!
System.out.println(i + : I must not be late for class);
Remember using the + sign is just to build a string up from parts
In this case it combines the contents of variable i with the rest of the string
given
I just need a way to set i to 1 at the start, add 1 each time round the loop and
stop when it gets to 10
Java for loop
The Java for loop allows you to build in a counter that can start and end at any
point:
for (int i = 1; i<=10; i=i+1)
{
System.out.println
(i + : I must not be late for class);
}
This says
Start a counter variable called i at 1
Stop when it gets to 10
Change its value each time round the loop
i++ is shorthand for the assignment i=i+1;
so you can write for (int i = 1; i<=10; i++)
Each time round the loop print the message with the current value of i
A flexible loop command
This gives a really flexible mechanism for doing things repeatedly.
Suppose your punishment was to write the 2 times table out. Example lines of
code are
System.out.println(2 times + 4 + is + 2*4);
System.out.println(2 times + 5 + is + 2*5);
Taking the common parts we get:
System.out.println(2 times + ???? + is + 2*????);
Replace the ???? By a loop counter variable and put it in a loop
The 2 times table
for (int i = 1; i<=10; i++)
{
Exercise
System.out.println(2 times+ i + is + 2*i);
}
Write a program that prints out a series of squares up to 5 squared: ie it prints
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25
A terminating variable
The user can supply the number of times the loop executes.
Just use a variable for the finish value (thats what variables are for).
String text = JOptionPane.showInputDialog(What is n?);
int n = Integer.parseInt(text);
for (int i = 1; i<=n; i++)
{
System.out.println(2 times + i + is + 2*i);
}
Accumulator variables
A common thing we need to do is gradually build a result up a bit at a time in
a variable
Eg write a loop that adds the first 5 integers
We can add the loop counter on to a running sum each time round the loop
int sum = 0;
for (int i = 1; i<=5; i++)
{
sum = sum + i;
}
JOptionPane.showMessageDialog(null,The answer is +sum);
Exercise
Write a program that multiplies the first 10 integers.
For loops in general
The general form of a for loop is
for (int i= <start>; i<= <finish>; i++)
{
<body>
}
<body> is the thing you do repeatedly
Work that out first by working out what is common and what changes about
the instructions to be repeated.
For loops
for (int i= <start>; i<= <finish>; i++)
{ <body> }
means:
for i changing from <start> to <finish>
do the <body>instructions over and over
(unless you change i in the <body>- DONT)
In other words,
execute <body> with i=<start>then
execute <body> with i=<start>+1then
execute <body> with i=<start>+2then
. . . then finally
execute<body> with i=<finish> then
go on to the rest of the program immediately below the loop.
Tracing
You can put print statements in a program to see how the variables change as the
program executes line by line.
You can also do this on paper. Step through the execution writing down at each stage
which point of the program you are at, and what the different variables contain.
One way is to write down the program with boxes for the variable. As you execute the
program, fill in the boxes.
Another is to write a table with line numbers.
Dry Run/Trace of Loops
You need a box to keep track of the value of each variable including i
i is initialized when the loop is first encountered and changed every time you
get back to the top of the for loop again.
int sum=0;
for (int i=1; i<= 5; i++)
{ sum i
sum = sum + i;
}
Tracing in a table
By labelling the lines you can also trace variables in a table.
Each line you encounter in the program has a row allocated where you fill in the
values of the variables at that point
int sum =0; //L1
for (int i=1; i<= 2; i++) //L2
{
sum = sum + i; //L3
}
System.out.println(sum); //L4
eg
LINE sum i notes
L1 0 i doesnt exist yet
L2 0 1 Set i to 1 and test to check it is less than or equal to
2. It is so enter the loop body at line L3
L3 1 1 adding sum and i to get a new value for sum
L2 1 2 Add one to i then test of i<=2 is true so stay in the
loop
L3 3 2 Adding 1 and 2 to get a new value for sum
L2 3 3 Add one to i. Now I is greater than 2 the test is
false so move on to line L4
L4 3 3 Prints 3 to the screen
Nested For loops
Any commands can go into the body of a for loop: eg if statements or another
for loop.
Suchnested for loops allow things to be done in two dimensions:
for (int i=1; i<=3; i++)
{
for (int j=1; j<=5; j++)
{
System.out.println(*);
}
System.out.println();
}
Good idioms/patterns
Rather than working out how to do a loop from scratch each time there are
some common patterns that you will use over and over for particular tasks.
They are common across lots of programming languages - not just Java
Idiom: Counter controlled loop
How to do something exactly m times.
for (int i=1; i<=m; i++)
{
<the thing to do m times>
}
Idiom: Accumulating a result
How to build a result up in an accumulator a bit at a time over m times.
This might be used to build up a string of output to then print in one go
for (int i=1; i<=m; i++)
{
<preparation for calculation>
acc = acc + <calculation>;
}
Idiom: Conditioned loops
How to process something m times but only when a condition is fulfilled for
the element processed
We will see this used later for searching for data.
for (int i=1; i<=m; i++)
{
if( <test depending on i> )
{
<process i>
}
}
Idiom: Rectangular for loop
Process n elements in some series m times
We will see this used in an algorithm to sort data.
for (int i=1; i<=m; i++)
{
for (int j=1; j<=n; j++)
{
<body>
}
}
Idiom: lower triangular for loop
We will see this used in a faster sort algorithm. Notice the inner test depends
on the outer counter
for (int i=1; i<=n; i++)
{
for (int j=1; j<=i; j++)
{
<body>
}
}
Idiom: upper triangular for loop
Notice how here the start point of the inner loop depends on the outer counter.
for (int i=1; i<=n; i++)
{
for (int j=i; j<=n; j++)
{
<body>
}
}
Further Extensions
Experiment with loops where you change the initialisation of the loop counter
Use different kinds of tests for its termination and put different assignment
commands in place of i++ (like i=i+2 or i=i-1 )
More on methods: methods that return results
Up till now the methods we have defined have just done something like print
messages and then returned.
Their purpose has not been to compute a result to be used elsewhere.
That is for example what is done by existing method
JOptionPane.showInputDialog
It is used in the following way
textinput = JOptionPane.showInputDialog(Give me a value);
The method doesnt just print something to the screen and let you type stuff in,
it delivers that value typed back to the program and allows it to store it in a
variable.
What if we want to do something like that.
Example: Averages
Suppose for example that we want to repeatedly get the ages of husbands and
wives from the user and take their average.
We might sensibly decide to split it off as a method.
The code to do this might be:
for (int i=1; i<=10; i++)
{
int averageAge;
averageAge = calculateAverage();
System.out.println(i + : + averageAge);
}
We have invented the method calculateAverageAge
It is easy to define but we need a way to pass the answer we have calculated
back.
That is easy to we just give the thing to return after the keyword return
public static int calculateAverage()
{
int value1; int value2; int average;
String textinput;
textinput = JOptionPane.showInputDialog("Give me the first");
value1 = Integer.parseInt(textinput);
textinput = JOptionPane.showInputDialog("Give me the second");
value2 = Integer.parseInt(textinput);
average = (value1 + value2) / 2;
return average;
}
Notice though that we have also changed the word void weve been putting in
the header line.
It is now int
That says that this method returns an integer value
Put different types there if you want to return Strings, floats, etc
It must match the type of the thing after the keyword return
If there is no value returned we use void as that means return nothing
Thats why weve used it so far as our methods have not been returning
values.
Start to use methods that return values from now on
Unit 4 Example Programs and Programming Exercises
Only try these exercises once you feel confident with those from the previous
1. For statements
Compile and run the following programs from the
experiment with them modifying them to do slightly different things until you
understand how they work. What happens when you type in different numbers?
How about 0 or -1? What is the thing that is repeated each time?
for4.java : Doing something a fixed number of times (here 4 times)
iloveyou.java : Here is a simple use of a loop for lovers where the user gives
the number of times to do it
for0.java : Doing the same thing over and over with different values
for1.java : Build an answer up a bit at a time in an accumulator variable. Each
time round the loop adds more
exp_fact.java : Here is an example of doing a calculation at each step building
a calculation a line at a time
ages.java : Returning results from a method
Here is a typical for loop program
/* *****************************************
AUTHOR
A program to print the averages of a series of
pairs of ages.
Illustrates how methods can return values.
******************************************** */
import javax.swing.*;
class ages
{
public static void main (String[] param)
{
averageAges();
System.exit(0);
} // END main
/* *********************************
Ask for 10 pairs of ages printing their average
*/
public static void averageAges()
{
for (int i=1; i<=10; i++)
{
int averageAge;
JOptionPane.showMessageDialog(null,
"I need you to give me a pair of ages");
averageAge = calculateAverage();
System.out.println(i + ": " + averageAge);
}
return;
} // END averageAges
/* *********************************
A method that asks for two numbers and returns their average
*/
public static int calculateAverage()
{
int value1;
int value2;
int average;
String textinput;
textinput = JOptionPane.showInputDialog("Give me the first");
value1 = Integer.parseInt(textinput);
textinput = JOptionPane.showInputDialog
("Give me the second");
value2 = Integer.parseInt(textinput);
average = (value1 + value2) / 2;
return average;
} // END calculateAverage
} // END class ages
2. Adding trace statements
Add console print lines (System.out.println) to the above programs to trace their
execution - so you can see what happens to the variables in the loop each time as it
executes. (See the catching bugs tips for more on this).
3. Punishment made easy
Write a program that outputs a punishment message of your choice such as "Paul
must not sleep in class" 20 times.
4. List the integers
Write a program that outputs the list of integers from 1 to 20.
Write a program that inputs a non-negative integer n from the keyboard and outputs
the list of the integers from 1 to n.
5. Add the integers
Write a program which inputs a non-negative integer n from the keyboard and outputs
the sum of the integers from 1 to n. For example given the number 5 it adds the
numbers from 1 to 5.
Once you have done these, try the next assessed exercise. The assessed exercises must
be done on your own. If you have problems with them then go back to the non-
assessed exercises.
6. Nested for loops
The following exercises concern nested for loops - loops inside loops and the
difference between this and to loops that follow loops.
Compile and run the following programs, experiment with them modifying them to do
slightly different things. What happens when you type in different numbers? How
about 0 or -1? What is the thing that is repeated each time?
You can put for loops one after the other
or one inside another
7. Squares
Write a program that inputs a positive integer n from the keyboard and outputs an n
by n square of 'P' characters to the console. HINT Write one for loop first that prints a
single row of n 'P's. Get that working then put a loop round it to turn it into a square.
8. Rectangles
Write a program which inputs two positive integers m and n from the keyboard and
outputs an m by n rectangle of '*' characters.
9. Tables
Write a program which outputs a multiplication table to 12; i.e.
1 2 3 4 5 6 7 8 9 10 11 12
2 4 6 8 10 12 14 16 18 20 22 24
10. Printing triangles
...
Write a program which inputs a positive integer n and outputs an n line high triangle
of '*' characters whose right-angle is in the bottom left corner. For example, if 5 is
input the output should be
*
**
***
****
*****
11. Repeated dice throws
Write a program that throws a 6 sided dice 20 times printing the result of the throw
each time. Extend the program to print out how many times each number came up.
Additional Exercises
The following are additional, harder exercises. The more programs you write this
the easier you will find and the quicker you will learn to program. If you complete
these exercises easily, you may wish to read ahead and start thinking about next
Clockwork
Write a program that behaves like a 24-hour digital watch. The program should ask
the user to input the day of the week (Mo, Tu, ...) and the hour, minute and seconds. If
the user inputs a valid day of theand a valid time the clock advances the time
by one second and then displays the new day and time. For example,
Input day : Sa
Input hour : 23
Input minute : 59
Input second : 59
then your program will output
Su 0 0 0
Now put your clock into the body of a for statement and make it 'tick' (advance by 1
second) 100 times.
Avoiding Bugs
Its always better to avoid a bug in the first place, rather than cure it afterwards. That
is where programming "style" comes in...Be a stylish programmer and make your
programs easier to follow.
TIP 1: Indentation is very important with loops do it in a similar way as for if
statements. Open { mean indent, } mean undo the indentation (see below)
Catching Bugs
TIP 1: ADD TRACE STATEMENTS If a program with a loop does something
really strange and doesnt seem to do the loop, you need to see what its doing step by
step. Add some console print statements that show you where the program got to. Add
one before the loop, one inside and one after the loop. For example if trying debug the
following loop:
for (int i=1; i<=n; i++)
{
resulttext = resulttext + "*";
}
Add the following print statements:
System.out.println("Entering the loop");
for (int i=1; i<=n; i++)
{
System.out.println("In the loop");
resulttext = resulttext + "*";
}
System.out.println("Left the loop");
You will then be able to see if the problem is because the loop is never entered, or is
entered but doesnt go round the correct number of times or does the loop properly
and leaves - so the problem is somewhere else such as how the results are later
printed.
TIP 2: ADD PRINT STATEMENTS THAT SHOW THE VALUES OF
VARIABLES If after following tip 1, you know the loop isn't working properly but
still can't see why, the next thing is to add some trace statements to show the values of
the variables. The values inside the loop as the loop goes round and round are most
important. It is always a good idea to print out the loop counter's value (i below) and
any other variables whose values change in the loop. For example the above for loop
might be modified as follows:
System.out.println("Entering the loop");
System.out.println("n has value " + n);
System.out.println("resulttext has value " + resulttext);
for (int i=1; i<=n; i++)
{
System.out.println("In the loop");
System.out.println("i has value " + n);
System.out.println("n has value " + n);
System.out.println("resulttext has value " + resulttext);
resulttext = resulttext + "*";
}
System.out.println("Left the loop");
System.out.println("i has value " + n);
System.out.println("n has value " + n);
System.out.println("resulttext has value " + resulttext);
Remember only to try and print the values of variables after they have been declared.
For example in the above you would get a compile error if you tried to print the value
of i before the loop as it doesnt exist then.
TIP 3: DON"T FORGET TO REMOVE ALL THE DEBUGGING LINES
ONCE IT WORKS!
TIP 4: OVER RUNNING LOOPS A common problem with loops is they loop one
time to many or too few. Check explicitly every time you write a loop that you got the
end test right.
The following loop goes round 5 times, with the loop counter i counting 1,2,3,4,5 and
then stopping.
for (int i=1; i<=5; i++)
{
resulttext = resulttext + "*";
}
If you put a less than sign instead of a less than or equal to sign as below it would
only count 1,2,3,4 and then stop.
for (int i=1; i<=4; i++)
{
resulttext = resulttext + "*";
}
Some Common Compile-time errors
Did not initialise a variable that is used to build up a result in a loop
pc$ javac for1.java
for1.java:52: variable resulttext might not have been initialized
resulttext = resulttext + "*";
When running loops its easy to forget to initialise the variables changed in the loop.
Here the line of code with the problem is inside a loop:
for (int i=1; i<=n; i++)
{
resulttext = resulttext + "*";
}
The first time round the loop, resulttest has no value set at all. I have to give it a value
before entering the loop to add things to.
resulttext ="";
for (int i=1; i<=n; i++)
{
resulttext = resulttext + "*";
}
It is easy to use the wrong variable in the loop!
pc$ javac iloveyou.java
iloveyou.java:57: cannot find symbol
symbol : variable j
location: class iloveyou
JOptionPane.showMessageDialog(null, j+": I love you!");
^
1 error
Here we used a loop counter of i but then used j by mistake in the loop - the compiler
is just saying "j - what is j. You didnt tell me about a j?"
for (int i=1; i<=n; i++)
{
JOptionPane.showMessageDialog(null, j+": I love you!");
}
Better still it should be done as part of the declaration of the variable
pc$ javac expFactTable.java
error: cannot read: expFactTable.java
1 error
Oops the file didnt exist - I forgot to add the .java on the name of the file when I
saved it. A similar message would have occurred if I got the capitals wrong or had
saved the file in a different directory to this one.
Run time errors
A run time error that is easy to make is to get the formatting of the thing printed
wrong in a loop - forgetting to add the new line character (\n) in so everything goes on
one line.
Take care as well that you dont put things in loops that you only want done once or
vice versa.
It is also easy to get the control character slashes the wrong way round - it is \n that
goes to a new line - not /n
Unit 4 Exam Style Question
Question 1 [25 marks] This question concerns programs acting repeatedly.
a. [9 marks]
For each of the following statements state how many times the letter 'p' will be
printed justifying your answer.
i) [2 marks]
for(int i = 1; i < 4; i++)
{
JOptionPane.ShowMessageDialog(null, "p");
}
ii) [2 marks]
for(int i = 1; i < 1; i++)
{
JOptionPane.ShowMessageDialog(null, "p");
}
iii) [2 marks]
for(int i = 1; i <= 4; i++)
{
for(int j = 1; j <= 4; j++)
{
JOptionPane.ShowMessageDialog(null, "p");
}
}
iv) [3 marks]
for(int i = 1; i <= 4; i++)
{
for(int j = 1; j <= i; j++)
{
JOptionPane.ShowMessageDialog(null, "p");
}
}
b. [6 marks]
The following code fragments contain errors. For each state what the error is and
whether the compiler would detect it justifying your answer.
i) [3 marks]
/* write Hello 10 times */
for(int i=0; i < 10; i++);
{
JOptionPane.ShowMessageDialog(null, "Hello");
}
ii) [3 marks]
/* write numbers from 1 to 10 */
for(int i=1; i < 10; i++)
{
JOptionPane.ShowMessageDialog(null, i);
}
c. [10 marks]
Write a Java program that uses a for loop to print the n times table, where n is a
number supplied by the user. An example run might be:
Which times table should I print? 2
1x2=2 2x2=4 3x2=6 4x2=8 5x2=10