JAVA BASICS

PROGRAM OUTPUT AND SOURCE CODE

    Peace on Earth!

to your console (computer screen).

For a detailed description of this program, see Sections 18.2.1 - 18.2.8 of the class text Austin/Chancogne.

Java application programs and java applet programs are both compiled into executable bytecodes. But, then, an applet bytecode can be downloaded over the network and run locally on any computer that has a java virtual machine (JVM). To facilitate this process, most modern web browsers contain a JVM. You can also execute an applet with the appletviewer program, i.e.,

    appletviewer Peace2.html

The appletviewer will ignore all of the html markup except those tags directly conneted to the display and execution of the applet.

Our third version of Peace on Earth! displays the message as a character string on a graphical component.

Figure 1. Screendump of Peace on Earth! graphics frame.

The graphical component is an object of type JComponent, and it is embedded inside a frame (an object of type JFrame).

Figure 2. Screendump of Peace on Earth! graphics frame.

This new capability is enabled by attaching a mouse-motion listener to the graphical component. Whenever a mouse motion event occurs within the component, the program will be notified, and the text will be drawn in its new location.

This program demonstrates declaration of Java's most commonly used basic data types (int, float, double, boolean), their arithmetics and use of the math functions.

This program demonstrates how output of the basic data types (int, float, double), can be easily formatted through use of the System.out.printf() method. A summary of very basic formatting specifications is as follows:

For more details, see Sections 3.4.7 and 12.2 in Austin/Chancogne.

• Overflow and underflow of numbers (i.e., Infinity and -Infinity),
• Arithmetic expressions where the result is not-a-number (i.e., NaN).

The last part of the program contains a looping contruct to evaluate a function y(x) that is designed to generate all three error conditions.

• A Scanner breaks its input into tokens, which by default will be delimited by whitespace.
• The tokens may then be converted into values of different types using the various next methods.

This program demonstrate use of a Scanner for input of text, integers, and floating-point numbers from the keyboard (i.e., System.in).

This program demonstrates wht use of if() branching contructs, if-else constructs, and branching with else-if clauses. Conditional statements can be very simple, or complicated, involving multiple relational and logical operators.

For more info, see Section 18.7.1 of Austin/Chancogne. Branching constructs in Java are very similar to those in C. Hence, also see Section 6.3 of the C tutorial in Austin/Chancogne.

A switch statement begins with an expression whose type is either an int or char or byte. As of Java 5, Enums are also allowed. This expression is followed by a block of code in curly braces that contains entry points corresponding to the possible values for the expression.

This program contains a few straight forward implementation of the switch statement.

In logic we use variables to represent propositions (or premises). Java allows for the representation of these propositions as boolean variables; they can take only one of two values -- true (T) or false (F). For example, the statement

    boolean p = (3 >= 2);

sets up a boolean variable p whose value evaluates to true (T).

Any logical statement which contains a finite number of logical variables (which of course covers any problem we have to deal with) can be analyzed using a table which lists all possible values of the variables: a "truth table". Since each variable can take only two values, a statement with "n" variables requires a table with 2n rows.

Table 2 shows, for example, a simple truth table for two propositions represented by p and q. The notation p ^ q means p AND q. The notation p v q means p OR q. Notice that p AND q is true if an only if both p and q are true.

This program demostrates use of "while" and "for" looping constructs, and nested looping constructs...

See Section 18.7.2 of Austin/Chancogne. Looping constructs in Java are almost identical to those in C. Hence, also see Section 6.4 in the C tutorial.

However, unlike Scanner1.java, this version includes support for repeating a prompt until the correct type of data is supplied. This expanded level of functionality is acheived by putting the scanning operation inside a while loop -- looping operations continue until the correct type of data is provided.

• It's name,
• The number, order, type and name of the parameters used by the method, and
• The type of the value returned by the method.

Polymorphism, on the other hand, is the capability of an action to do different things based on the details of the object that is being acted upon. This is the third basic principle of object oriented programming.

This program demonstrates "polymorphism of methods" in Java. The program contains three versions of a method called doSomething(). However, each implementation is unique in its argument specfications. The test program exercises these methods and shows how Java automatically determines which implementation to call, based upon the details of argument usage.

This program demonstrates the declaration and usage of one-dimensional arrays of numbers and Strings, including the printing contents of a large array in a tidy format.

Figure 3 shows, for example,

Figure 3. Declaration and layout of memory for a one-dimensional array of ints.

the declaration for an array of five integers called iaA, and the corresponding layout of memory. Notice that the array element indices range from iaA [0] through iaA [4].

Figure 4. Declaration and layout of memory for a two-dimensional array of ints.

the declaration for a five-by-two array of integers called iaaA, and the corresponding layout of memory. In the first level of indirection, the array element indices range from iaaA [0] through iaaA [4]. Each of these elements is a reference to a row in the matrix. Then, the array elements themelves are referenced by iaaA[0][0] .. through .. iaaA[4][1].

This program demonstrates the declaration and usage of two-dimensional arrays of numbers and Strings.

Java also supports ragged arrays; that is, two-dimensional arrays where the length of each row may be different. For matrices that are symmetric and/or are only sparsely populated with non-zero elements, use of ragged array mechanisms can lead significant savings in required storage.

This program demonstrates the use of "character strings," arrays of character strings, and conversion of strings to numerical values of type integer, float and double.

A few examples of these methods and their usage can be found in Section 18.9.4 of Austin/Chancogne.

A static enumerated type is an enumerated type whose set of possible values is fixed, and does not vary at run time. For example, the concept of days of the week includes the set:

    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday.

Not only are these seven values the only possible values for the concept, but there will never be another possible value, and none of these values will ever become obsolete.

This program demonstrates how an enumerated data type for days of the week can be used in conjuction with selection implemented via a switch statement.

Note: In recent semesters students have written programs with equivalent functionality by using a Scanner, a feature now supported by Java 5.

    4
    Red1  25   18  true
    Red2  25  -23  false
    Blue  03  123  true
    Green 13   03  false

    4
    Red1  25   18  true
    Red2  25  -23  false
    Blue  03  123  true
    Green 13   03  false

located at:

    http://www.isr.umd.edu/~austin/ence200.d/data.d/data.txt

Here are a few simple application programs. In most cases, they are solutions to problems in the "java programming exercises" handout.

From a software perspective, this program demonstrates use of functions and constants in the Math library, and simple decision making with an if() branching construct.

Input from the keyboard is handled by the method keyboardInput() and a character string sLine. Equivalent functionality can be achieved with the method getTextFromConsole().

Note. In recent semesters some students have used the Scanner class to read and process numbers typed at the keyboard.

Note. Notice use of getTextFromConsole() as a replacement for keyboardInput().

From a software standpoint, this program demonstrates use of the if()-elseif()-else branching construct.

From a software standpoint, this program demonstrates use of the modulo arithmetic operator. The software implementation is simplified by organizing the code into methods: main() and windForce(). Notice how windForce accepts one argument of type double, and returns the wind force as a double.

You will need these routines if you are working with Java 1.3/1.4. In Java 1.5, much of the same functionality can be achieved with the System.out.printf(...) method.

So far, the only objects we have seen are those associated with character strings and arrays. In this section we see how to create objects having user-defined data and methods.

Figure 5. Data and methods in the Circle class.

Two constructor methods are provided for the instantiation of circle objects. The first constructor simply creates a circle object with centerpoint (0,0) and radius 0. The second constructor allows for the specification of circles with centerpoint (dX,dY) and radius (dRadius). The method Area() computes the circle area and returns the result as a type double. The toString() method assembles and returns a String representation of the circle object. The main() method exercises methods in the Circle class.

For a more detailed writeup, see Section 18.8 of Austin/Chancogne.

Figure 6. Relationship between the ColoredCircle and Circle classes.

The implementation extends the Circle class and adds color for individual colored circle objects.

For a more detailed writeup, see Section 18.8.7 of Austin/Chancogne.

Code in the main() method systematically exercises each of the opertors for complex number arithmetic.

Figure 7 shows a typical statement for setting up a data array object, followed by the layout of memory that is generated.

Figure 7. DataArray object creation and layout of memory.

Notice that the array element values are automatically set to zero. Individual array elements can be initialized with statements of the type:

    A.setElement ( 0, 1.0 );
    A.setElement ( 1, 2.0 );

and so forth.

Version 2 (April 2009): The method readData() has been added. Arrays can now be read from a file located locally on your computer. File format: The first line contains the number of elements in the array. Then, one array element is located on each line. See, for example, the layout of data in sensor1.txt .

Figure 8. Model and class diagram for line segments.

The adjacent figure shows that line segments can be modeled by their two endpoints (i.e., with the classes Vector, Node and LineSegment).

Figure 9. Model and class diagram for triangles.

The class Vector models two dimensional vectors characterised by (x,y) coordinate pairs. The class Node extends Vector. It adds a name. An edge line segment is characterised by its two "node" end points (i.e., The class Edge uses instances of class Node). Finally, the class Triangle uses three instances of class Node and three instances of class Edge.

• You can't "accidentally" corrupt the value of a field -- instead, you have to use a method to change a value.
• The separation of interface and implementation makes it easier to modify the code within a class without breaking any other code that uses it.

In this example we rework the colored circle application to implement encapsulation.

Figure 10. Relationship among Circle, ColoredCircle, and test classes.

As illustrated in Figure 10, this involves:

• Data hiding. Variables and methods internal to the object implementation will be declared as private and/or protected. Private data is only available within the class in which it is declared. Protected data is only available within the class in which it is declared, and, its subclasses.
• Access methods. Access to data/properties of the object will only be possible through setXXX() and getXXX() methods (e.g., the Circle class contains the methods setRadius() and getRadius()).

This program demonstrates the use of an abstract Shape class that contains a reference to a location and three methods: toString(), area() and perimeter(). The abstract class is subclassed by Circle and Rectangle classes. The system is exercised by a test class TestShape.

The class hierarchy is as follows:

Figure 11. Model and class diagram for hierarchy of shapes.

The files before and after program compilation are:

    Before                        After
    ===============================================================
    TestShape.java                TestShape.java    TestShape.class

    Shape.java                    Shape.java        Shape.class
    Location.java                 Location.java     Location.class 
    Circle.java                   Circle.java       Circle.class
    Rectangle.java                Rectangle.java    Rectangle.class
    ===============================================================

Here we present code for a simple interface that represents farm workers, that is, the farmer and the dog and horse that help the farmer.

Figure 12. Class diagram for implementation and use of a farm workers interface.

Figure 12 shows a class diagram for the implementation of farm worker entities. WorkingDog and WorkingHorse are extensions of Dog and Horse respectively, which in turn, are extensions of Animal. The Farmer is an extension of Person. Workers is simply an abstract class that defines an interface, i.e.,

    public interface Working {
        public abstract void hours ();
    }

The interface is implemented by using the keyword "implements" in the class declaration, e.g.,

    public class Farmer implements Working { ....

This declaration sets up a contract that guarantees the Farmer class will provide a concrete implementation for the method hours().

The class FarmWorkers builds a model of the working entities on the farm. (i.e., Farmer, WorkingDog and WorkingHorse objects). The key benefit in using interfaces is that they allow collections of objects to be manipulated independently of the details of their representation. Hence, instead of writing code that looks like:

    Farmer       mac = new Farmer (...);
    WorkingDog   max = new WorkingDog (...);
    WorkingHorse silver = new WorkingHorse (...);

we can treat this group of objects as a set of Working entities, i.e.,

    Working    mac = new Farmer (...);
    Working    max = new WorkingDog (...);
    Working silver = new WorkingHorse (...);

Methods and algorithms can be defined in terms of all "Working" entities, independent of the lower-level details of implementation.

The files before and after program compilation are:

    Before                        After
    ==================================================================
    FarmWorkers.java              FarmWorkers.java   FarmWorkers.class

    Animal.java                   Animal.java        Animal.class
    Dog.java                      Dog.java           Dog.class
    Farmer.java                   Farmer.java        Farmer.class
    Horse.java                    Horse.java         Horse.class
    Person.java                   Person.java        Person.class
    Working.java                  Working.java       Working.class
    WorkingDog.java               WorkingDog.java    WorkingDog.class
    WorkingHorse.java             WorkingHorse.java  WorkingHorse.class
    ===================================================================

The Java Collections framework is a set of utility classes and interfaces (located in the java.util package) for working with collections of objects. The framework includes implementation of four interfaces:

• Collection (groups of objects),
• Map (sets of mappings or associations between objects),
• Set (a type of collection without duplicates), and
• List (a collection in which the items are ordered).

Customized implementations of classes are provided for each interface. For example, the List interface may be implemented as an ArrayList or a Linked List.

In simple terms, Figure 13 says:

• A FamilyMember is a Person who has one set of Relatives,
• The Relatives object contains references to zero or more family members, and
• There are multiple family members in the Simpson Family.

Figure 13. UML class diagram for relationships among Person, FamilyMember,
Relations and SimpsonFamily classes.

Relatives is a generalized (or abstract) concept for the set of family members that fullfil the roles of father, mother, spouse, children and siblings.

Each person object is instantiated with the relevant name and date of birth.

Then the objects are added to an array list and printed by walking along the list. Notice how the toString() method in Person is used to print the abbreviated details of a person's credentials.

Finally, the person objects are ordered according to their age -- from youngest to oldest. Because an arraylist is a Collection, we can use the sort() method in Collections to take care of the details. All that we have to provide is a method to compare relative age of two person objects. These details can be found in Family.java.

When two inputs hash to the same key, then items are chained into a linked list, e.g.,

Figure 14. Layout of memory in a hash table.

Here is a very simple example. The fragment of code:

    SymbolTable st = new SymbolTable();
    st.put(   "mark", "acura" );
    st.put( "dianne",   "bmw" );

stores two entries in the symbol table, namely, that "mark drives an acura" and "dianne drives a bmw." To retrieve these records from the symbol table, we write something like:

    String s = "mark"
    System.out.println ( s + " drives a " + st.get(s) );
    String t = "dianne"
    System.out.println ( t + " drives a " + st.get(t) );

The example code creates a series of MetroStation objects, which are then stored in the symbol table.

Then an array of "metro station names" are defined for the red and green lines. The corresponding metro station objects are retrieved from the symbol table, and the "line" attribute is added to the metro station object description. Some metro stations will service more than one metro line.

Figure 15. Relationship among concrete and interface classes in an abstract factory setup.

• Client. Classes in the Client role use various widget classes to request or receive services from the product that the client is working with. Client classes only know about the abstract widget classes. They should have no knowledge of any concrete widget classes.

• AbstractFactory. AbstractFactory classes define abstract methods for creating instances of concrete widget classes. Abstract factory classes have a static method shown in the above diagram as getFactory. Another common name for that method is getToolkit. A Client object calls that method to get an instance of a concrete factory appropriate for working with a particular product.

• ConcreteFactory1, ConcreteFactory2. Classes in this role implement the methods defined by their abstract factory superclasses to create instances of concrete widget classes. Client classes that call these methods should not have any direct knowledge of these concrete factory classes, but instead access singleton instances of these classes by calling a method of their abstract factory superclass.

• WidgetA, WidgetB. Interfaces in this role correspond to a feature of a product. Classes that implement an interface in this role work with the product to which the interface corresponds.

• Product1WidgetA, Product2WidgetA. Classes in this role are concrete classes that correspond to a feature of a product that they work with. You can generically refer to classes in this role as concrete widgets.

This example creates and prints date objects in a variety of formats. It then shows how dates can be compared and incorporated into if-else statements.

All of the source code is contained within a single file DemoGUI.java. The files before and after compilation are as follows:

    Before Compilatioon                           After Compilation
    ===============================================================
           DemoGUI.html                                DemoGUI.html
           DemoGUI.java                                DemoGUI.java
                                                 ButtonAction.class
                                                      DemoGUI.class
                                           DemoGraphicsScreen.class
                                             GraphicsListener.class
    ===============================================================

The buttons are positioned within a panel and connected to button listeners. A "border layout manager" is used to position the canvas in the center of the window and the panel along the South border.

Figure 16. Class hierarchy for basic implementation of a thread.

Lifecyle of a thread. .....

Figure 17. Methods in the lifecyle of a thread.

Insert screendump ....

Insert screendump ....

A JAR file is simply a ZIP file that contains classes, possibly other files that a program may need (e.g., image and sound files), and a manifest file describing the special features of the archive.

This example demonstrates how java source code can be organized into packages, compiled, and then bundled into a jar file. The unpacked source code will be in a directory called packages-and-jar.d. Move to that directory and then read the file called README.txt.

To unpack the zip tar file, type:

    unzip PackagesAndJar.zip

The unpacked source code will be in a directory called packages-and-ant.d. Move to that directory and then read the file called README.txt.

To unpack the zip tar file, type:

    unzip PackagesAndAnt.zip

This program computes the distance of a point from the edge contour of a polygon.

Figure 19. Screendump of triangle and point program

The triangle is composed of three edges and three nodes. Each edge is simply a line segment. Hence, the problem of computing the closest distance to the edge of the triangle boils down to computing the distance of the point from each edge and then taking the minumum value. These computations can be found in Edge.java and Triangle.java, respectively.

To compile the program, type:

   javac DemoGUI.java

The program can be run as an applet. I just type:

   appletviewer DemoGUI.html

where DemoGUI.html is a suitable file containing a reference to the point-and-triangle bytecode files.

Many potentially difficult problems can be avoided by modeling the footprint as a collection of simple triangular regions. The next figure shows, for example, a six-triangle footprint model for the AV. Williams Building.

Figure 20. Footprint model for AV Williams Building

Now let's move onto details of the software implementation.

Figure 21. Class diagram for footprint implementation

Simply put, the adjacent figure says that one Footprint object will be composed of many Triangle objects. In turn, triangles will be defined in terms of Node and Edge objects. Nodes are an extension of Vector. Properties of the building footprint (e.g., area, center of mass) will be computed and summed across the ensemble of triangles.

Download the zipped source code . To compile the program, type:

   javac Footprint.java

The program can be run as an application.

Figure 22. Cross section model of a Wheel.

In this specific example, the minumum radius is 50 and the maximum radius is 150. Coordinates in the radial and angular directions are divided into three and sixteen intervals, repectively. Theoretical considerations indicate that the cross section will be 62,831. However, because the triangles only approximate the circular cross section, the computed area will be a little less.

Individual triangle objects are assembled from Node and Edge objects, as shown above in the Footprint model. The wheel cross section is simply a collection of triangles stored in an array list.

The mesh of triangles in generated with a double loop. One loop increments the coordinates from the minumum radius to the maximum radius. A second loop systematically generates nodal coordiates in an angular direction, from 0.0 through 2*pi radians.

Download the zipped source code .

To compile the program, type:

   javac DemoWheel.java

The program can be run as an applet i.e.,

appletviewer DemoWheel.html

Figure 23. Screendump of bridge cross section and engineering properties ...

Polygon cross sections are modeled as an exterior ring, possible containing multiple interior rings. Each ring corresponds to a list of nodes have (x,y) coordinates. The nodes in an exterior ring are stored in a clockwise direction. Interior rings (holes) have nodes stored in an anti-clockwise direction.

Polygon cross sections are defined in an xml file. For example:

<?xml version="1.0" encoding="UTF-8"?>

<!-- Polygon Layout XML document -->
<!DOCTYPE polygon SYSTEM 'polygon.dtd'>

<polygon>
  <loop type="exterior">
        <coordinate>   100.0   0.0 </coordinate>
        <coordinate>   100.0 200.0 </coordinate>
        <coordinate>   300.0 200.0 </coordinate>
        <coordinate>   300.0   0.0 </coordinate>
  </loop>
</polygon>

defines a small square.

To unpack the tar file, type:

    tar xvf BridgeAnalysis.tar

The unpacked program will be in a directory called bridge-analysis.d. Move to that directory and then compile the program with the command:

    javac PolygonGUI.java

To run the program, type:

    appletviewer PolygonGUI.html

Figure 24. Screendump of Day Planner application.

The schedule of events in stored in an XML file called planner.xml. Here is an abbreviated snippet of code:

<?xml version="1.0" encoding="UTF-8"?>
<!-- Travel Planner XML document -->
<!DOCTYPE planner SYSTEM 'planner.dtd'>

<planner>
    <year value="2004">
        <date month="1" day="27">
            <note time="0000"> Last day to
                  cancel spring registration </note>
        </date>

        .... details of code removed ....

    </year>
</planner>

The following figure is a simplified model of the Washington DC metro system (most of the stations have been omitted):

Figure 25. Simplified view of the Washington DC Metro System

Passengers need to be familiar with the routes, schedule, and cost of using the metro. Typical questions include:

• When will the metro open? When will it close?
• How do I get from station A to station B?
• Will I have to change trains? Where?
• How long will it take to get there? And how must will it cost?
• I'm going to the Smithsonian -- what station should I get off?
• I'm at station A. When is the last train to station B?

The Smithsonian question is particularly interesting because: (1) it requires that a transportation model be linked to a geographic information systems (GIS) model, and (2) there really isn't a unique answer.

In its most rudimentary form, the Metro System can be modeled as a graph structure. Nodes in the graph correspond to train stations; the edges correspond to the tracks connecting stations. Graph theory is useful because it provides algorithms to answer questions about routes connecting stations A and B.

The adjacent code is a first-cut implementation at modeling this problem domain.

Question
How would you extend the basic node-edge graph structure to make the model more realistic.

Figure 26. Framework for route selection problem

As indicated in the adjacent figure, this problem is complicated by the multitude of physical/.geographic, environmental, economic and political factors that can influence the final cost and efficiency of the system. Suppose, for example, that we want to build a road from city A to city B, but that a mountain range spans the most direct route. Is it better to build a road around the mountains, or pay more money upfront to build a tunnel through the mountains and provide a shorter route?

The standard approach to problems of this type is to deal with each concern separately, and then combine the results. For example, the physical constraints might look like:

Figure 27. Dealing with physical constraints in the route selection problem

The final result is always never a single point, but rather a family of good solutions:

Figure 28. Pareto Optimal Curves