Contents
Getting started
Performing operations
Introduction
Installing the JDK
Writing a first Java program
Compiling & running programs
Creating a variable
Recognizing data types
Creating constants
Adding comments
Troubleshooting problems
Summary
Doing arithmetic
Assigning values
Comparing values
Assessing logic
Examining conditions
Setting precedence
Escaping literals
Working with bits
Summary
Making statements
Branching with if
Branching alternatives
Switching branches
Looping for
Looping while true
Doing do-while loops
Breaking out of loops
Returning control
Summary
7
8
10
12
14
16
18
20
21
22
24
25
26
28
30
32
34
36
38
40
42
43
44
46
48
50
52
54
56
58
60
Directing values
Manipulating data
Creating classes
Importing functions
Casting type values
Creating variable arrays
Passing an argument
Passing multiple arguments
Looping through elements
Changing element values
Adding array dimensions
Catching exceptions
Summary
Exploring Java classes
Doing mathematics
Rounding numbers
Generating random numbers
Managing strings
Comparing strings
Searching strings
Manipulating characters
Summary
Forming multiple methods
Understanding program scope
Forming multiple classes
Extending an existing class
Creating an object class
Producing an object instance
Encapsulating properties
Constructing object values
Summary
Handling files
Reading console input
Reading files
Writing files
Sorting array elements
Managing dates
Formatting numbers
Calculating currency
Summary
61
62
64
66
68
70
72
74
76
78
79
80
82
84
86
88
90
92
94
96
97
98
100
102
104
106
108
110
112
114
115
116
118
120
122
124
126
128
130
132
Building interfaces
Recognizing events
Creating a window
Adding push buttons
Adding labels
Adding text fields
Adding item selectors
Adding radio buttons
Changing appearance
Arranging components
Summary
Listening for events
Generating events
Handling button events
Handling item events
Reacting to keyboard events
Responding to mouse events
Announcing messages
Requesting input
Playing sounds
Summary
10
Deploying programs
Methods of deployment
Distributing programs
Building archives
Deploying applications
Enabling Web Start
Producing applets
Converting web pages
Deploying applets
Summary
Index
133
134
136
138
140
142
144
146
148
150
151
152
153
154
156
158
160
162
164
166
168
169
170
172
174
176
178
180
182
184
186
187
Foreword
The creation of this book has provided me, Mike McGrath, a welcome opportunity to update
my previous books on Java programming with the latest techniques. All examples I have given
in this book demonstrate Java features supported by current compilers on both Windows and
Linux operating systems, and the books screenshots illustrate the actual results produced by
compiling and executing the listed code.
Conventions in this book
In order to clarify the code listed in the steps given in each example I have adopted certain
colorization conventions. Components of the Java language itself are colored blue, numeric and
string values are red, programmer-specified names are black, and comments are green, like this:
// Store then output a text string value.
String message = Welcome to Java programming! ;
System.out.println( message ) ;
Additionally, in order to readily identify each source code file described in the steps a colored
icon and file name appear in the margin alongside the steps, like these:
110100101010
000101101011
110100101010
000101101011
110100101011
JAVA
CLASS
App.java
App.class
JAR
App.jar
JNLP
App.jnlp
Grabbing the source code
For convenience I have placed source code files from the examples featured in this book into a
single ZIP archive. You can obtain the complete archive by following these easy steps:
l
l
l
1
Browse to http://www.ineasysteps.com then navigate to the Resource Center and
choose the Downloads section
Find Java in easy steps, 4th Edition in the Source Code list, then click on the
hyperlink entitled All Code Examples to download the archive
Now extract the archive contents to any convenient location on your computer
I sincerely hope you enjoy discovering the programming possibilities of Java and have as much
fun with it as I did in writing this book.
Mike McGrath
Getting started
Welcome to the exciting
world of Java programming.
This chapter shows how
to create and execute
simple Java programs and
demonstrates how to store
data within programs.
Introduction
10
Installing the JDK
12
Writing a first Java program
14
Compiling & running programs
16
Creating a variable
18
Recognizing data types
20
Creating constants
21
Adding comments
22
Troubleshooting problems
24
Summary
Getting started
Introduction
The Java programming language was first developed in 1990
by an engineer at Sun Microsystems named James Gosling. He
was unhappy using the C++ programming language so he created
a new language that he named Oak, after the oak tree that he
could see from his office window.
As the popularity of the World Wide Web grew, Sun recognized
that Goslings language could be developed for the internet.
Consequently Sun renamed the language Java (simply because
that name sounded cool) and made it freely available in 1995.
Developers around the world quickly adopted this exciting new
language and, because of its modular design, were able to create
new features that could be added to the core language. The most
endearing additional features were retained in subsequent releases
of Java as it developed into the comprehensive version of today.
The essence of Java is a library of files called classes, which each
contain small pieces of ready-made proven code. Any of these
classes can be incorporated into a new program, like bricks in a
wall, so that only a relatively small amount of new code ever needs
to be written to complete the program. This saves the programmer
a vast amount of time and largely explains the huge popularity of
Java programming. Additionally, this modular arrangement makes
it easier to identify any errors than in a single large program.
There is no truth in the
rumor that JAVA stands
for Just Another Vague
Acronym.
Java technology is both a programming language and a platform.
In Java programming the source code is first written as humanreadable plain text files ending with the .java extension. These are
compiled into machine-readable .class files by the javac compiler.
The java interpreter can then execute the program with an
instance of the Java Virtual Machine ( Java VM):
Compiler
JAVA
Program.java
110100101010
000101101011
110100101010
000101101011
110100101011
Java
VM
CLASS
Program.class
Program
As the Java VM is available on many different operating systems
the same .class files are capable of running on Windows, Linux
and Mac operating systems so Java programmers theoretically
enjoy the cross-platform ability to write once, run anywhere.
...contd
In order to create Java programs the Java class libraries and the
javac compiler need to be installed on your computer. In order
to run Java programs the Java Runtime Environment ( JRE)
needs to be installed to supply the java interpreter. All of these
components are contained in a freely available package called the
Java Platform, Standard Edition Development Kit ( JDK).
The Java programs in this book use version JDK 7 which,
incorporating both the Development Kit itself and the Runtime
Environment, can be downloaded from the Oracle website at
http://www.oracle.com/technetwork/java/javase/downloads
The Oracle download
page also features other
packages, but only
the JDK 7 package is
required to get started
with Java programming.
The JDK 7 package is available in versions for 32-bit and 64-bit
variants of the Linux, Solaris and Windows operating systems
accept the Oracle License Agreement, then select the appropriate
version for your computer to download the Java Development Kit.
Getting started
Installing the JDK
Select the appropriate Java Development Kit package for your
system from the Oracle downloads page and then follow these
steps to install Java on your computer:
Uninstall any previous versions of the JDK and/or Java
Runtime Environment from your system
Start the installation and accept the License Agreement
When the Custom Setup dialog appears either accept the
suggested installation location or click the Change button
to choose your preferred location, such as C:\Java for
Windows systems or /usr/Java for Linux systems
10
A previous version of the
JRE may be installed so
your web browser can
run Java applets. It is
best to uninstall this to
avoid confusion with the
newer version in JDK7.
l
l
l
You can start out
by installing just the
minimum features to
avoid confusion.
l
4
l
5
Ensure that the Development Tools and Public JRE
features are selected from the list. Optionally you may
deselect the other features as they are not required to start
programming with this book
Click the Next button to install all the necessary Java
class libraries and tools at the chosen location
...contd
The tools to compile and run Java programs are normally operated
from a Command Prompt and are located in the bin sub-directory
of the Java directory. These can be made available from anywhere
on your computer by adding their location to the system path:
Windows 7, Windows Vista, or Windows XP, navigate
On
through Start, Control Panel, System, Advanced System
Settings, Environment Variables. Select the System Variable
named Path then click the Edit button. Add the address of
Javas bin sub-directory at the end of the list in the Variable
Value field (for instance C:\Java\bin; ) then click the OK button.
Paths that contain spaces
must be enclosed within
double quotes, such as
C:\Program Files\Java\bin;
Linux, add the location of Javas
sub-directory to the
On
system path by editing the
file in your home directory.
bin
.bashrc
For instance, add PATH=$PATH:/usr/Java/bin then save the file.
If the .bashrc file is
not immediately visible
in your Linux home
directory choose View,
Show Hidden Files to
reveal it.
On older versions of
Windows the JDK tools
can be made globally
available by editing the
autoexec.bat file to add
the location of Javas bin
sub-directory at the end
of the SET PATH line.
11
To test the environment open a prompt window then enter
java -version and hit Return to see the interpreters version number.
Now enter javac -version and hit Return to see the compilers
version number. Both numbers should match in this case each is
version number 1.7.0, and youre ready to start Java programming.
Getting started
Writing a first Java program
All Java programs start as text files that are later used to create
class files, which are the actual runnable programs. This means
that Java programs can be written in any plain text editor such as
the Windows Notepad application.
Follow these steps to create a simple Java program that will
output the traditional first program greeting:
l
1
JAVA
Hello.java
Open a plain text editor, like Notepad, and type this code
exactly as it is listed to create a class named Hello
class Hello
{
12
Java is a case-sensitive
language where Hello
and hello are distinctly
different traditionally
Java program names
should always begin with
an uppercase letter.
l
2
public static void main ( String[] args )
{
}
l
l
3
4
Java programs are always
saved as their exact
program name followed
by the .java extension.
Between the curly brackets of the Hello class, insert this
code to create a main method for the Hello class
Between the curly brackets of the main method, insert
this line of code stating what the program will do
System.out.println( Hello World! ) ;
Save the file at any convenient location, but be sure to
name it precisely as Hello.java the complete program
should now look like this:
...contd
The separate parts of the program code on the opposite page can
be examined individually to understand each part more clearly:
The Program Container
class Hello {
The program name is declared following the class keyword and is
itself followed by a pair of curly brackets. All of the program code
that defines the Hello class will be contained within these curly
brackets.
The Main Method
public static void main ( String[] args ) {
All stand-alone Java
programs must have
a main method. Java
applets are different and
their format is explained
later.
This fearsome-looking line is the standard code that is used to
define the starting point of nearly all Java programs. It will be
used in most examples throughout this book exactly as it appears
above so it may be useful to memorize it.
13
The code declares a method named main that will contain the
actual program instructions within its curly brackets.
Keywords public static void precede the method name to define
how the method may be used and are explained in detail later.
The code ( String[] args ) is useful when passing values to the
method and is also fully explained later in this book.
The Statement
System.out.println( Hello World! ) ;
Statements are actual instructions to perform program tasks and
must always end with a semi-colon. A method may contain many
statements inside its curly brackets to form a statement block
defining a series of tasks to perform, but here a single statement
instructs the program to output a line of text.
Turn to the next page to discover how to compile and run this
program.
Create a MyJava directory
in which to save all your
Java program files.
Getting started
Compiling & running programs
Before a Java program can run it must first be compiled into a
class file by the Java compiler. This is located in Javas bin subdirectory and is an application named javac. The instructions on
page 11 described how to add the bin sub-directory to the system
path so that javac can be invoked from any system location.
Follow these steps to compile the program on the previous page:
l
l
1
Open a Command Prompt/Terminal window then
navigate to the directory where you saved the Hello.java
source code file
At the prompt type javac followed by a space then the
full name of the source code file Hello.java and hit Return
14
Open a Command
Prompt/Terminal window
then type javac and hit
Return to reveal the Java
compiler options.
If the javac compiler discovers errors in the code it will halt and
display a helpful report indicating the nature of the error see
page 22 for Troubleshooting Problems.
You can also compile
the source code from
another location if you
state the files full path
address to the javac
compiler in this case
C:\MyJava\Hello.java.
If the javac compiler does not find any errors it will create a new
file with the program name and the .class file extension.
...contd
When the Java compiler completes compilation the Command
Prompt/Terminal window focus returns to the prompt without
any confirmation message and the program is ready to run.
The Java program interpreter is an application named java that is
located in Javas bin sub-directory alongside the javac compiler.
As this directory was previously added to the system path, on
page 11, the java interpreter can be invoked from any location.
Follow these steps to run the program that was compiled using
the procedure described on the page opposite:
l
l
1
Open a Command Prompt/Terminal window then
navigate to the directory where the Hello.class program
file is located
At the prompt type java followed by a space then the
program name Hello and hit Return
15
The Hello program runs and executes the task defined in the
statement within its main method to output Hello World!.
Upon completion focus returns to the prompt once more.
The process of compiling and running a Java program is typically
combined in sequential steps, and is the same regardless of
platform. The screenshot below illustrates the Hello program being
compiled and run in combined steps on a Linux system:
Do not include the .class
extension when running
a program only use the
program name.
Getting started
Creating a variable
In Java programming a variable is simply a useful container in
which a value may be stored for subsequent use by the program.
The stored value may be changed (vary) as the program executes
its instructions hence the term variable.
Each variable declaration
must be terminated with
a semi-colon character
like all other statements.
A variable is created by writing a variable declaration in the
program, specifying the type of data that variable may contain and
a given name for that variable. For example, the String data type
can be specified to allow a variable named message to contain
regular text with this declaration:
String message ;
Variable names are chosen by the programmer but must adhere
to certain naming conventions. The variable name may only begin
with a letter, dollar sign $, or the underscore character _ , and may
subsequently have only letters, digits, dollar signs, or underscore
characters. Names are case-sensitive, so var and Var are
distinctly different names, and spaces are not allowed in names.
16
Variable names should also avoid the Java keywords, listed in the
table below, as these have special meaning in the Java language.
Strictly speaking, some
words in this table are
not actually keywords
true, false, and null
are all literals, String is a
special class name, const
and goto are reserved
words (currently unused).
These are included in the
table because they must
also be avoided when
naming variables.
abstract
default
goto
package
synchronized
assert
do
if
private
this
boolean
double
implements
protected
throw
break
else
import
public
throws
byte
enum
instanceof
return
transient
case
extends
int
short
true
catch
false
interface
static
try
char
final
long
strictfp
void
class
finally
native
String
volatile
const
float
new
super
while
continue
for
null
switch
...contd
As good practice, variables should be named with words or easily
recognizable abbreviations, describing that variables purpose.
For example, button1 or btn1 to describe button number one.
Lowercase letters are preferred for single-word names, such as
gear, and names that consist of multiple words should capitalize
the first letter of each subsequent word, such as gearRatio the
so-called camelCase naming convention.
Once a variable has been declared, it may be assigned an initial
value of the appropriate data type using the equals sign = , either
in the declaration or later on in the program, then its value can be
referenced at any time using the variables name.
Follow these steps to create a program that declares a variable,
which gets initialized in its declaration then changed later:
l
1
l
l
3
4
class FirstVariable
{
public static void main ( String[] args ) {
}
JAVA
FirstVariable.java
Between the curly brackets of the main method, insert
this code to create, intialize, and output a variable
String message = Initial value ;
System.out.println( message ) ;
Add these lines to modify and output the variable value
message = Modified value ;
System.out.println( message ) ;
Save the program as FirstVariable.java then compile and
run the program
If you encounter
problems compiling or
running the program
you can get help
from Troubleshooting
Problems on page 22.
17
Start a new program named FirstVariable, containing
the standard main method
Getting started
Recognizing data types
The most frequently used data types in Java variable declarations
are listed in this table along with a brief description:
Due to the irregularities
of floating-point
arithmetic the float data
type should never be
used for precise values,
such as currency see
page 130 for details.
Data type:
Description:
Example:
char
A single Unicode character
String
Any number of Unicode
characters
my String
int
An integer number, from
-2.14 billion to +2.14 billion
1000
float
A floating-point number, with 3.14159265f
a decimal point
boolean
A logical value of either true
or false
true
18
Notice that char data values must always be surrounded by single
quotes and String data values must always be surrounded by
double quotes. Also remember that float data values must always
have an f suffix to ensure they are treated as a float value.
In addition to the more common data types above, Java provides
these specialized data types for use in exacting circumstances:
All data type keywords
begin with a lowercase
letter except String
which is a special class.
Data type:
Description:
byte
Integer number from -128 to +127
short
Integer number from -32,768 to +32,767
long
Positive or negative integer exceeding
2.14 billion
double
Extremely long floating-point number
Specialized data types are useful in advanced Java programs
the examples in this book mostly use the common data types
described in the top table.
...contd
Follow these steps to create a Java program that creates, initializes,
and outputs variables of all five common data types:
l
1
l
2
Start a new program named DataTypes containing the
standard main method
class DataTypes
{
public static void main ( String[] args ) {
}
JAVA
Between the curly brackets of the main method, insert
these declarations to create and intialize five variables
char letter = M ;
String title = Java in easy steps ;
int number = 365 ;
float decimal = 98.6f ;
boolean result = true ;
Add these lines to output an appropriate text String
concatenated to the value of each variable
Save the program as DataTypes.java then compile and run
the program
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
Intial is + letter ) ;
Book is + title ) ;
Days are + number ) ;
Temperature is + decimal ) ;
Answer is + result ) ;
Notice how the +
character is used here
to join (concatenate)
text strings and stored
variable values.
The Java compiler will
report an error if the
program attempts to
assign a value of the
wrong data type to a
variable try changing
the values in this
example, then attempt to
recompile the program
to see the effect.
19
l
3
DataTypes.java
Getting started
Creating constants
The final keyword is a modifier that can be used when declaring
variables to prevent any subsequent changes to the values that are
initially assigned to them. This is useful when storing a fixed value
in a program to avoid it becoming altered accidentally.
Variables created to store fixed values in this way are known
as constants and it is convention to name constants with all
uppercase characters to distinguish them from regular variables.
Programs that attempt to change a constant value will not
compile and the javac compiler will generate an error message.
Follow these steps to create a Java program featuring constants:
l
1
JAVA
Constants.java
20
The * asterisk character
is used here to multiply
the constant values, and
parentheses surround
their addition for clarity.
l
l
Start a new program named Constants containing the
standard main method
class Constants
{
public static void main ( String[] args ) {
}
Between the curly brackets of the main method, insert
this code to create and intialize three integer constants
final int TOUCHDOWN = 6 ;
final int CONVERSION = 1 ;
final int FIELDGOAL = 3 ;
Now declare four regular integer variables
Intialize the regular variables using multiples of the
constant values
l
l
int td , pat , fg , total ;
td = 4 * TOUCHDOWN ;
pat = 3 * CONVERSION ;
fg = 2 * FIELDGOAL ;
total = ( td + pat + fg ) ;
Add this line to display the total score
Save the program as Constants.java then compile and run
the program to see the output, Score: 33
( 4 x 6 = 24, 3 x 1 = 3, 2 x 3 = 6, so 24 + 3 + 6 = 33 ).
System.out.println( Score: + total ) ;
Adding comments
When programming, in any language, it is good practice to add
comments to program code to explain each particular section.
This makes the code more easily understood by others, and by
yourself when revisiting a piece of code after a period of absence.
In Java programming, comments can be added across multiple
lines between /* and */ comment identifiers, or on a single line
after a // comment identifier. Anything appearing between /* and
*/, or on a line after //, is completely ignored by the javac compiler.
When comments have been added to the Constants.java program,
described opposite, the source code might look like this:
/*
*/
A program to demonstrate constant variables.
JAVA
class Constants
{
public static void main( String args[] )
{
// Constant score values.
final int TOUCHDOWN = 6 ;
final int CONVERSION = 1 ;
final int FIELDGOAL = 3 ;
Constants.java
(commented)
21
// Calculate points scored.
int td , pat , fg , total ;
td = 4 * TOUCHDOWN ;
pat = 3 * CONVERSION ;
fg = 2 * FIELDGOAL ;
total = ( td + pat + fg ) ;
}
}
// Output calculated total.
System.out.println( Score: + total ) ;
//
//
//
//
4x6=24
3x1= 3
2x3= 6
24+3+6=33
Saved with comments, the program compiles and runs as normal:
You can add a statement
that attempts to change
the value of a constant,
then try to recompile
the program to see the
resulting error message.
Getting started
Troubleshooting problems
Sometimes the javac compiler or java interpreter will complain
about errors so its useful to understand their cause and how
to quickly resolve the problem. In order to demonstrate some
common error reports this code contains some deliberate errors:
JAVA
Test.java
class test
{
public static void main ( String[] args )
{
String text ;
System.out.println( Test + text )
}
}
22
A first attempt to compile Test.java throws up this error report:
Cause the compiler cannot be found
edit the system
variable, as described on
Solution
page 11, or use its full path address to invoke the compiler
javac
PATH
The path address must
be enclosed within
quotation marks if it
contains any spaces, as
indeed it does here.
cannot be found
Cause the file
navigate to the directory where the file is located,
orSolution
use the full path address to the file in the command
Test.java
...contd
Cause the statement is not terminated correctly
Solution in the source code add a semi-colon at the end of
the
statement, then save the file to apply the change
23
Cause the program name and class name do not match
in the source code change the class name from
toSolution, then
save the file to apply the change
test
Test
Cause the variable has no value
Solution in the variable declaration assign the variable a
valid
value, for instance
, then save the file
text
String
= success
You must run the
program from within its
directory you cannot
use a path address
as the java launcher
requires a program
name, not a file name.
Getting started
Summary
Java is both a programming language and a runtime platform
Java programs are written as plain text files with a
extension
.java
The Java compiler
creates compiled
from
original
source code files
javac
.java
.class
program files
The Java interpreter
executes compiled programs using an
instance
of the Java Virtual Machine
java
The Java VM is available on many operating system platforms
Adding Javas
sub-directory to the system
variable
allows
the
compiler to be invoked from anywhere
bin
PATH
javac
Java is a case-sensitive language
The standard method is the entry point for Java programs
statement outputs text
The
A Java program file name must exactly match its class name
Java variables can only be named in accordance with specified
naming
conventions and must avoid the Java keywords
24
main
System.out.println()
In Java programming each statement must be terminated by a
semi-colon
character
The most common Java data types are
and
boolean
String, int, char, float
values must be enclosed in double quotes,
values in
single quotes,
and
values must have an f suffix
String
char
float
The keyword can be used to create a constant variable
can be added to Java source code between and
onComments
one or more lines, or after on a single line
final
/*
//
Error reports identify compiler and runtime problems
*/,
