Introduction to Programming Using Java, Version 9, JavaFX Edition
Source Code
This page contains links to the source code for
examples appearing in the free, on-line textbook Introduction
to Programming Using Java, Version 9, JavaFX Edition.
The index page
has links for downloading the entire web site. If you do that, you will find
the source code files in a directory named source. There is also
a link for downloading just the source code files.
The README file from the download includes some
instructions for compiling and running the programs.
Note however that some of these
examples depend on other source files, such as TextIO.java ,
that are not built into Java. These are classes that I have written. All necessary files
are included in the downloads, and links to the individual files are provided below.
The solutions to end-of-chapter exercises are not
listed on this page. Each end-of-chapter
exercise has its own Web page, which
discusses its solution. The source code of a sample solution of each exercise
is given on the solution page for that exercise. If you want to compile
the solution, you should be able to copy-and-paste the solution out of a Web
browser window and into a text editing program. (You can't copy-and-paste from
the HTML source of the solution page, since it contains extra HTML markup
commands that the Java compiler won't understand; the HTML markup does
not appear when the page is displayed in a Web browser.)
Exercise solutions are also available as a download from the
front page of the web site. The README file
from the download has more information.
Many of the sample programs in the text are based on console-style
input/output, where the computer and the user type lines of text back and forth
to each other. Almost all of these programs use the standard output object,
System.out, for output. Many of them use my non-standard class,
TextIO, for input. For the programs that use TextIO,
one of the files TextIO.java or TextIO.class must
be available when you compile the program, and TextIO.class must be available
when you run the program. Since TextIO is defined in a package
named textio, this means that
TextIO.java and/or TextIO.class must be in a directory named textio,
which must be in the same directory as the program. There is also a GUI version of TextIO;
you can find information about it at the end of this web page.
-
HelloWorld.java , from Section 2.1, a trivial program that does
nothing but print out the message, "Hello World!". A Hello World program is typically the first program
for someone learning a new programming language.
-
Interest.java , from Section 2.2, computes the interest on
a specific amount of money over a period of one year.
-
TimedComputation.java , from Section 2.3,
demonstrates a few basic built-in subroutines and functions.
-
TextBlockDemo , from Subsection 2.3.4, demonstrates
text blocks, a kind of multiline string literal. This demo requires Java 17.
-
EnumDemo.java , from Section 2.3, a very simple
first demonstration of enum types. The enum types used in this program are defined in the same
file as the program. An alternative version,
SeparateEnumDemo.java , uses the same
enums, but the enums are defined in separate files,
Day.java and Month.java
-
PrintSquare.java , from Section 2.4, reads an integer
typed in by the user and prints the square of that integer. This program depends on
TextIO.java . The same is true for almost all of the programs in the
rest of this list.
-
Interest2.java , from Section 2.4, calculates
interest on an investment for one year, based on user input. Uses TextIO for user input.
-
CreateProfile.java , from Section 2.4, a simple
demo of output to a file, using TextIO.
-
Interest2WithScanner.java , from Section 2.4, is a version
of Interest2.java that uses Scanner instead of
TextIO to read input from the user.
-
Interest3.java , from Section 3.1, the first
example that uses control statements.
-
ThreeN1.java , from Section 3.2, outputs a 3N+1 sequence
for a given stating value.
-
ComputeAverage.java , from Section 3.3, computes the average
value of some integers entered by the user.
-
CountDivisors.java , from Section 3.4, counts the number of
divisors of an integer entered by the user.
-
ListLetters.java , from Section 3.4, lists all the distinct
letters in a string entered by the user.
-
LengthConverter.java , from Section 3.5, converts length
measurements input by the user into different units of measure.
-
ComputeAverage2.java , from Section 3.7, computes the average
value of some real numbers entered by the user. Demonstrates the use of try..catch for Double.parseDouble.
-
AverageNumbersFromFile.java , from Section 3.7, finds the sum
and the average of numbers read from a file. Demonstrates the use of try..catch statements with TextIO.
-
BirthdayProblem.java , from Section 3.8, demonstrates
random access to array elements using the "birthday problem" (how many people do you have
to choose at random until two are found whose birthdays are on the same day of the year).
-
ReverseInputNumbers.java , from Section 3.8,
illustrates the use of a partially full array by reading some numbers
from the user and then printing them in reverse order.
-
GuessingGame.java , from Section 4.2, lets the user
play guessing games where the computer picks a number and the user tries to guess it.
A slight variation of this program, which
reports the number of games won by the user, is GuessingGame2.java .
-
RowsOfChars.java , from Section 4.3, a rather useless
program in which one subroutine calls another.
-
CopyTextFile.java , from
Section 4.3, demonstrates the use of command-line arguments by using
file names from the command line.
-
ThreeN2.java , from Section 4.4, is an improved
3N+1 program that uses subroutines and prints its output in neat columns.
-
RollTwoPairs.java ,
from Subsection 5.2.2, uses PairOfDice.java
to simulate rolling two pairs of dice until the same total is rolled on both pairs.
-
HighLow.java , from Section 5.4, a simple card game.
It uses the classes Card.java and Deck.java , which are
given as examples of object-oriented programming. Also available, the card-related classes
Hand.java and, from Subsection 5.5.1,
BlackjackHand.java .
-
ReverseWithDynamicArray.java ,
from Section 7.2, reads
numbers from the user then prints them out in reverse order. It does this using the
class DynamicArrayOfInt.java
as an example of using dynamic arrays. ReverseWithArrayList.java ,
from Section 7.3,
is functionally identical, but it uses an ArrayList<Integer>
instead of a DynamicArrayOfInt.
-
SymmetricMatrix.java ,
from Section 7.6, implements a symmetric 2D array of double.
The program TestSymmetricMatrix.java
tests the SymmetricMatrix class.
-
LengthConverter2.java ,
from Section 8.2,
converts measurements input by the user to inches, feet, yards, and miles.
This improvement on LengthConverter.java
allows inputs combining
several measurements, such as "3 feet 7 inches," and it detects illegal inputs.
-
TryStatementDemo.java ,
from Section 8.3, a small demo program with a try..catch
statement that includes autoclosing of a resource.
-
LengthConverter3.java ,
from Section 8.3, is
a revision of LengthConverter2.java
that uses exceptions to handle errors in the user's input.
-
TowersOfHanoi.java ,
from Section 9.1,
prints out the steps in a solution to the Towers of Hanoi problem; an example
of recursion.
-
StringList.java , from Section 9.2,
implements a linked list of strings. The program ListDemo.java
tests this class.
-
PostfixEval.java , from Section 9.3,
evaluates postfix expressions using a stack. Depends on the StackOfDouble
class defined in StackOfDouble.java .
-
SortTreeDemo.java , from Section 9.4,
demonstrates a binary sort tree of strings.
-
SimpleParser1.java ,
SimpleParser2.java , and
SimpleParser3.java ,
from Section 9.5, are three programs that parse and evaluate
arithmetic expressions input by the user. SimpleParser1 only handles fully parenthesized expressions.
SimpleParser2 evaluates ordinary expressions where some parentheses can be omitted.
SimpleParser3 constructs expression trees to represent input expressions and uses
the expression trees to evaluate the expressions.
-
WordListWithTreeSet.java , from Section 10.2,
makes an alphabetical list of words from a file. A TreeSet
is used to eliminate duplicates and sort the words.
-
WordListWithPriorityQueue.java , from Section 10.2,
makes an alphabetical list of words from a file. This is a small modification of the previous example
that uses a PriorityQueue instead of a TreeSet. The result is an alphabetical list of words in
which duplicates are not removed.
-
SimpleInterpreter.java , from Section 10.4,
demonstrates the use of a HashMap as a symbol table in a
program that interprets simple commands from the user.
-
WordCount.java , from Section 10.4,
counts the number of occurrences of each word in a file. The program uses
several features from the Java Collection Framework.
-
RiemannSumStreamExperiment.java ,
from Section 10.6, demos Java's stream API. Runs an experiment to measure
the compute time for a problem when it is solved using a for loop, using a sequential stream,
and using a parallel stream.
-
ReverseFileWithScanner.java ,
from Section 11.2, shows how to read and write files in a simple command-line application.
ReverseFileWithResources.java
is a version that uses the "resource" pattern in try..catch statements.
-
DirectoryList.java , from Section 11.2, lists
the contents of a directory specified by the user; demonstrates the use of
the File class.
-
CopyFile.java , from Section 11.3, is a
program that makes a copy of a file, using file names that are given as command-line
arguments. CopyFileAsResources.java
is a version of the program that also demonstrates uses the "resource" pattern in a
try..catch statement.
-
PhoneDirectoryFileDemo.java , from Section 11.3, demonstrates
the use of a file for storing data between runs of a program.
-
FetchURL.java , from Section 11.4, reads and displays the contents
of a specified URL, if the URL refers to a text file.
-
ShowMyNetwork.java , mentioned in Section 11.4, is
a short program that prints information about each network interface on the computer
where it is run, including IP addresses associated with each interface.
-
DateClient.java and
DateServer.java , from
Section 11.4, are very simple first examples of network client and
server programs.
-
CLChatClient.java and
CLChatServer.java , from
Section 11.4, demonstrate two-way communication over a network by
letting users send messages back and forth; however, no threading is used and
the messages must strictly alternate.
-
ThreadTest1.java , from section Section 12.1,
runs one or more threads that all perform the same task, to demonstrate that they
run simultaneously and finish in an indeterminate order.
-
ThreadTest2.java , from section Section 12.1,
divides up a task (counting primes) among several threads, to demonstrate parallel
processing and the use of synchronization. ThreadTest3.java ,
from the same section, is a minor modification of ThreadTest2.java that uses
an AtomicInteger instead of synchronization to safely add up values from
several threads.
-
DateServerWithThreads.java and
DateServerWithThreadPool.java ,
from Section 12.4, are modifications of chapter11/DateServer.java
(Subsection 11.4.4) that use threads to handle communication with clients.
The first program creates a new thread for each connection. The second uses a thread
pool, and it uses a blocking queue to send connections from the main program to
the pool. The threaded servers will work with original client program,
chapter11/DateClient.java .
-
CLMandelbrotMaster.java ,
CLMandelbrotWorker.java ,
and CLMandelbrotTask.java , from Section 12.4, are
a demonstration of distributed computing in which pieces of a large computation
are sent over a network to be computed by "worker" programs.
The following sample programs use a graphical user interface. All of these programs use JavaFX
as the GUI toolbox.
-
GUIDemo.java is a simple demonstration of some basic
GUI components from the JavaFX graphical user interface library. It appears in
the text in Section 1.6, but you won't be able to understand
it until you learn about GUI programming.
-
SimpleGraphicsStarter.java , from Section 3.9,
draws a large number of randomly colored, randomly positioned disks. This simple graphics program is our first
example of a GUI program. It is meant both as an introduction to graphics and as an example of using
control structures.
-
MovingRects.java , from Section 3.9,
draws a set of nested rectangles that seem to move infinitely towards the center. This program is based on
SimpleAnimationStarter.java , which can
be used as a starting point for writing similar animation programs.
RandomCircles.java
is another animation in which the computer continuously adds random colored disks to an image.
-
RandomMosaicWalk.java , a
program that displays a window full of colored squares with a moving
disturbance, from Section 4.7. This program depends on
MosaicCanvas.java and
Mosaic.java .
-
RandomMosaicWalk2.java
is a version of the previous example,
modified to use a few named constants. From Section 4.8.
-
GrowingCircleAnimation.java ,
from Section 5.3, shows an animation of growing, semi-transparent circles. Requires
CircleInfo.java . Used as a simple example of
programming with object.
-
ShapeDraw.java , from Section 5.5, is a program
that lets the user place various shapes on a drawing area; an example of
abstract classes, subclasses, and polymorphism.
-
HelloWorldFX.java
from Section 6.1, displays a the message in a window, with three buttons
for changing the message and quitting the program. One of the messages is "Hello World", and
this program is used as the first example for learning about JavaFX programming.
-
SimpleColorChooser.java , used in Section 6.3
to demonstrate RGB and HSB colors. This program uses techniques that are not
covered until later in the text, and it is not presented as a programming
example. You can run it to experiment with colors.
-
RandomStringl.java ,
from Section 6.2, shows 25 copies of the string "Hello JavaFX!" in random colors and fonts.
-
RandomCards.java ,
from Section 6.2, shows 5 cards selected at random from a deck.
Depends on the files Deck.java
Card.java ,
and the image resource file Cards.png
-
SimpleTrackMouse.java , from Section 6.3,
shows information about mouse events as the user moves and clicks with the mouse.
-
SimplePaint.java , from Section 6.3,
lets the user draw curves in a drawing area and select the drawing color from a palette.
-
KeyboardEventsDemo.java ,
from Section 6.5, shows how to use keyboard events.
-
SubKiller.java , from Section 6.3, lets the
user play a simple arcade-style game. Uses an AnimationTimer
as well as keyboard events.
-
SliderDemo.java and
TextInputDemo.java ,
small programs that demonstrate basic components, used as examples in Section 6.4
-
OwnLayoutDemo.java , from Section 6.5, shows
how to lay out the components in a Pane, which allows you to do your own layout.
-
SimpleCalc.java , from Section 6.5, lets the
user add, subtract, multiply, or divide two numbers input by the user. A demo
of text fields, buttons, and layout with nested subpanels.
-
HighLowGUI.java , from Section 6.5,
implements a GUI version of the card game
HighLow.java , in which the user sees a playing card and guesses
whether the next card will be higher or lower in value. This program depends on
Card.java , Hand.java ,
Deck.java , and an image resource file,
cards.png .
-
MosaicDraw.java , from Section 6.6,
demonstrates menus. In this program, the user colors the squares of a mosaic by clicking-and-dragging the mouse. It uses
MosaicCanvas.java to define the mosaic itself.
-
RandomStringsWithArray.java ,
from Section 7.2,
shows multiple copies of a message in random colors, sizes, and positions. There is an animation in
which the copies move around in the window. This is an
improved version of RandomStrings.java that uses an
array to keep track of the data.
-
SimplePaint2.java , from Section 7.3, lets
the user draw colored curves and stores the data needed for repainting the
drawing surface in a list of type ArrayList<CurveData>.
-
Complex.java and
FullName.java are examples of record classes,
from Section 7.4. RecordDemo.java
is a simple program that tests the two record classes.
-
Life.java , from Section 7.6,
implements John H. Conway's game of life and is an example of using 2D arrays. This program
depends on MosaicCanvas.java .
-
Checkers.java , from Section 7.6, lets two
users play a game of checkers against each other. Illustrates the use of a
two-dimensional array and a variety of programming techniques.
(This is the longest program in the book so far, at over 700 lines!)
-
Maze.java and
LittlePentominos.java
are demo programs mentioned in Section 9.1 as examples of
recursion. They use techniques that have not covered until Chapter 12.
Note that LittlePentominos depends on MosaicCanvas.java .
-
Blobs.java , from Section 9.1,
uses recursion to count groups of colored squares in a grid.
-
DepthBreadth.java , from Section 9.3,
demonstrates stacks and queues.
-
TrivialEdit.java , from Section 11.3, lets
the user edit short text files. This program demonstrates reading and writing
files and using file dialogs.
-
SimplePaintWithFiles.java , from Section 11.3,
demonstrates saving data from a program to a file in both binary and character form. The
program is a simple sketching program based on SimplePaint2.java .
-
SimplePaintWithXML.java ,
from Section 11.5, demonstrate saving data from a program to a file in XML format.
This program is a modification of SimplePaintWithFiles.java .
-
XMLDemo.java , from Section 11.5, is a simple
program that demonstrates basic parsing of an XML document and traversal of the Document Object
Model representation of the document. The user enters the XML to be parsed in
a text area.
-
RandomArtWithThreads.java , from Section 12.2,
uses a thread to drive a very simple animation.
-
QuicksortThreadDemo.java , from Section 12.2,
demonstrates using a separate thread to perform a computation, with simple inter-thread
communication.
-
BackgroundComputationDemo.java , from Section 12.2,
demonstrates using a thread running at a lower priority to perform a lengthy computation
in the background. (The program computes a visualization of a small piece of the Mandelbrot
set, but the particular computation that is done is not important.)
-
MultiprocessingDemo1.java , from Section 12.2,
is a modification of the previous example that uses several threads to perform the
background computation. This speeds up the computation on multi-processor machines.
-
MultiprocessingDemo2.java , from Section 12.3,
is a modification of the previous example that decomposes its task into a large number
of fairly small subtasks, in order to achieve better load balancing. The program
uses a thread pool and a queue of tasks.
-
MultiprocessingDemo3.java , from Section 12.3,
is yet another version of the previous examples. This one uses a pool of threads
that run forever, taking tasks from a queue and executing them. To make this possible,
a blocking queue is used, defined by the standard LinkedBlockingQueue
class. MyLinkedBlockingQueue.java is a simple example of
using wait() and notify() directly that can be used
as a replacement for LinkedBlockingQueue in
MultiprocessingDemo3.
-
MultiprocessingDemo4.java , from Section 12.3
has the same functionality as MultiprocessingDemo3, but uses an ExecutorService,
from package java.util.concurrent, to execute the tasks.
-
TowersOfHanoiGUI.java , from Section 12.3,
shows an animation of the famous Towers Of Hanoi problem. The user can control
the animation with Run/Pause, Next, and StartAgain buttons. The program is
an example of using wait() and notify() directly
for communication between threads.
-
GUIChat.java , from Section 12.4, is a simple GUI program
for chatting between two people over a network. It demonstrates using a thread for
reading data from a network connection.
-
netgame.common , from Section 12.5,
is a package that defines a framework for networked games. This framework is used in several
examples: A chat room, defined in package netgame.chat ;
a tic-tac-toe game, defined in package netgame.tictactoe ;
and a poker game, defined in package netgame.fivecarddraw .
-
BoundPropertyDemo.java ,
from Section 13.1, demonstrates bindings and bidirectional bindings of
JavaFX observable properties.
-
CanvasResizeDemo.java ,
from Section 13.1, shows how to use property bindings to resize a Canvas whenever
the Pane that contains the Canvas is resized.
-
StrokeDemo.java , from Section 13.2, demonstrates the
use of various line properties for stroking lines and rectangles.
-
PaintDemo.java , from Section 13.2, demonstrates
using a LinearGradient paint and using an ImagePattern paint
to fill a polygon. Uses the image resource files tile.png
and face-smile.png .
-
TransformDemo.java ,from Section 13.2, demonstrates
applying various transforms, such as scale and rotate, to the drawing that is done in canvas. Uses the
image resource file face-smile.png .
-
ToolPaint.java , from Section 13.2, is a little
paint program that illustrates pixel manipulation and the use of a transparent overlay canvas for some drawing operations.
This program requires SimpleDialogs.java .
-
SillyStamper.java , from Section 13.3, demonstrates using
a ListView whose items are ImageViews. The user can "stamp" images
of a selected icon onto a drawing area. This program uses the icon images in the
directory stamper_icons as resources.
-
SimpleTableDemo.java , from Section 13.3, is
a small demo of an uneditable TableView.
-
ScatterPlotTableDemo.java ,
from Section 13.3, demonstrates an editable TableView. The table
holds (x,y) coordinates of points, and the user can edit the coords. A scatter plot of
points is displayed.
-
SimpleDialogs.java , from
Section 13.4, contains static methods for
showing several kinds of dialog box. The program TestDialogs.java
tests the dialog methods by letting the user click buttons to open the different kinds of dialog.
-
WebBrowser.java , from
Section 13.4, is a simple web browser
based on JavaFX's WebView control. This program shows how to manage multiple
windows in a JavaFX application. It requires BrowserWindow.java ,
a subclass of Stage that does most of the work, and on
SimpleDialogs.java .
- The Mandelbrot program from Section 13.5, which computes and
displays visualizations of the Mandelbrot set, is defined by several classes in the
package edu.hws.eck.mdbfx. The source code files can be found in
the directory edu/hws/eck/mdbfx .
This section lists some of the extra source files that are required by
various examples in the previous sections. The files listed here
are those which are general enough to be potentially useful in
other programming projects. Links to these files are also given above,
along with the programs that use them.
-
TextIO.java defines a class containing some
static methods for doing input/output. These methods make it easier to use the
standard input stream, System.in. TextIO also has
methods for printing to System.out.
It also supports other input sources and output destinations,
such as files. TextIO is in a package named textio.
The TextIO class is only useful in a command-line
environment, and it might be inconvenient to use in integrated development environments such
as Eclipse in which standard input does not work particularly well. In that case, you might want to use
the following file instead.
-
textiogui/TextIO.java , a GUI version of TextIO that opens
a window where TextIO I/O operations are performed. This is part of a package
named textiogui to distinguish it from the normal TextIO. A companion
class in that package, textiogui/System.java , is a fake System
class that makes it possible to use System.out and other features
of System in the same window. I use these classes to build
executable jar files for my text-oriented examples that run in a window instead of
on the command line. See the comments in the source code files for more information.
(Note that this GUI version of TextIO uses the Swing GUI toolkit rather than JavaFX.)
-
SimpleGraphicsStarter.java and
SimpleAnimationStarter.java are
small programs that you can edit to make very simple pictures and animations
These programs were used in Section 3.9 and in some of the exercises for Chapter 3.
-
Mosaic.java contains
subroutines for opening and controlling a
window that contains a grid of colored rectangles.
It depends on MosaicCanvas.java .
It is used in several examples and exercises in Chapter 4.
-
MosaicCanvas defines a subclass of
Canvas
that shows little rectangles arranged in rows and columns, with many options.
-
StatCalc.java is a simple
class that computes some statistics of a set of numbers. It is used only
for a couple exercises in Chapter 5 and
Chapter 6.
-
Expr.java defines a class Expr that
represents mathematical expressions involving the variable x. It is used only
in a couple of the exercises in Chapter 8.
-
TextReader.java
is not used in this textbook, but it might be useful to some readers.
A TextReader reads character data from input streams. Input methods
in an object of type TextReader are similar to the static input
methods in TextIO.
-
netgame.common is a package that defines a
framework for networked games, which is discussed in detail in Section 12.5.
The netgame packages also includes several examples.
-
PokerRank.java can be
used to assign ranks to hands of cards in poker games. The cards are defined
in the class PokerCard.java .
There is also a PokerDeck.java
All of these classes are part of the package netgame.fivecarddraw ,
which is discussed in Subsection 12.5.4, but these classes can be used independently
of the netgame framework.
-
SimpleDialogs.java contains easy-to-use
static methods for showing several kinds of JavaFX dialog box and getting back the results of user
interaction when appropriate.
