Basic Java — September 29, 2016

As we have seen previously, types in Java can be split into two main groups: primitive and object types. The former ones are technically defined by the language itself and the compiler has built-in support for them (for example int that represents integers), and the latter ones are object classes that are defined in the standard libraries. New elements to the set of object classes can be (and should be) added by the programmer through class definitions.

For example, let us assume that we want to represent two-dimensional points and their associated operations from mathematics.

// A class that represents two-dimensional points.
class Point2D {
    // Coordinates as fields.
    double x;
    double y;

    // Translate a point by a vector.
    void translate(double dx, double dy) {
        x += dx;
        y += dy;
    }

    // Scale a point to the origin by a scalar value.
    void scale(double c) {
        x *= c;
        y *= c;
    }

    // Rotate a point by an angle.
        void rotate(double phi) {
        double nx = x * Math.cos(phi) - y * Math.sin(phi);
        double ny = x * Math.sin(phi) + y * Math.cos(phi);
        x = nx;
        y = ny;
    }

    // Obtain the textual representation of a point.
    String show() {
        return String.format("{ x = %.3f, y = %.3f }", x, y);
    }

    // Distance of two points.
    static double distance(Point2D p0, Point2D p1) {
        double xd = p0.x - p1.x;
        double yd = p0.y - p1.y;
        return (Math.sqrt((xd * xd) + (yd * yd)));
    }

    // Mirror a point to a another one.
    static Point2D mirror(Point2D c, Point2D p) {
        Point2D result = new Point2D();
        result.x = (2 * c.x) - p.x;
        result.y = (2 * c.y) - p.y;
        return result;
    }
}

// Utility functions for working with angles.
class Angle {
    static double degreeToRadian(double x) {
        return x * Math.PI / 180;
    }

    static double radianToDegree(double x) {
        return x * 180 / Math.PI;
    }
}

// "Main program"
public class Point2DDemo {
    public static void main(String[] args) {
        Point2D p0 = new Point2D();
        p0.x = Math.E;
        p0.y = Math.PI;
        p0.translate(0.1, 12.34);
        p0.scale(0.78);
        p0.rotate(Angle.degreeToRadian(90));
        System.out.println("p0 = " + p0.show());

        Point2D p1 = new Point2D();
        p1.x = 2 * Math.PI;
        p1.y = Math.E / 2;
        p1.scale(1.445);
        p1.rotate(Angle.degreeToRadian(-33));
        System.out.println("p1 = " + p1.show());

        System.out.println("distance(p0, p1) = " + Point2D.distance(p0, p1));

        Point2D p2 = Point2D.mirror(p1, p0);
        System.out.println("mirror(p1, p0) = " + p2.show());
    }
}

Note that it is sufficient to compile the main class only, which is Point2DDemo. That is because the compiler tries to compile all the other referenced classes as part of this process.

Functions (methods)

The source code example above also shows that operations in classes are given by (member) functions, or as they are called in Java, methods. Their format in general is as follows.

<modifiers> <return type> <name>( <list of parameters> )
        [ throws <list of thrown exceptions> ] {
    <statement1>;
    <statement2>;
    ...
}

Packages

A package is a collection of classes and interfaces. It is recommended to use packages in the following cases:

Packages must have names, they are often composed of a sequence of identifiers, separated by dots. It is a generic naming convention that package names are unique at the top (world-wide) level, so their structure resembles to domain names on the Internet, such as org.ietf.jgss.

The standard packages in Java usually have the java. prefix, and during the lab sessions, we are also going to work with a simplified package naming scheme.

Importing Packages

All the fundamental classes and interfaces in the Java language (for example Object, String, and so on) are contained by the java.lang package, whose elements are automatically available anywhere in the sources. Contents of any other package can be made accessed by calling them by their fully-qualified name. For instance, java.util.Scanner refers to the Scanner class in the java.util package.

public class Simple {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("? ");
        if (sc.hasNextInt()) {
            int x = sc.nextInt();
            System.out.println("x = " + x);
        }
        else System.out.println("No valid input.");
    }
}

If we do not want to use those fully-qualified names every time when a class from some external package is named, import statements shall be added to the beginning (prologue) of the source code. The import section instructs the compiler to import names from other packages to the name space of the package to be compiled.

import java.util.Scanner;   // Importing a specific class.
import java.math.*;         // Importing everything from a package.

import java.util.Scanner;

public class Simple {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println("x = " + x);
    }
}

Creating Packages

Of course, our own source may be structured through packages. In order to so, the following steps have to be made:

For illustration, let us partition our previous program on two-dimensional points into multiple packages. Move the Point2D class to the geo.basics package, move the Angle class to the geo.utils package, and finally, move the Point2DDemo class to the main package.

First we shall have to build up the corresponding directory layout, and place the source code files at the different parts of it:

Once this is done, every source file must be tagged with the respective package identifier. For example, the following line must be added to the beginning of the Point2D.java file:

package geo.basics;

package geo.utils;

package main;

import geo.basics.Point2D;
import geo.utils.Angle;

In addition to that, all classes and their members (fields and methods) must be declared public with the public modifier. This makes it possible to access them from other packages. By default, they are only visible inside the package where they were defined.

Compiling and Running

The compiler does not support recursive compilation of the source files, but there can be a file name prefixed with @ passed to it that has all the files to be compiled.

Applications with packages can be run from package root by giving the fully-qualified name of the main class (Point2DDemo).

Debugging Programs

Sometimes we need to find mistakes in programs, or we need to understand how they work exactly. This process is called debugging or tracing. In order to be able to debug programs, the sources must be compiled with the -g flag of javac. This will instruct the compiler to add all the necessary meta information to the generated byte code.

After the sources have been successfully compiled this way, the jdb (as in "Java DeBugger") utility may be used to work with the embedded debugging information. First, launch it from the command prompt, which is going to give us an interactive interface.

In the debugger, the available commands can be listed by the help command. Here, only the must important ones will be discussed.

The first, and probably the most important command is stop at, which may be used to stop program execution at a given point. With this command, so-called breakpoints can be placed in the sources. When the program hits any of those breakpoints during execution (inside the debugger), it will stop and returns to the interactive interface.

Breakpoints may be set without loading any class into the memory as they will be activated only once the execution reaches the respective part of the program. The run command may be used for launching the main() method of the loaded class.

On hitting the breakpoint, the debugger will show the affected line, together with its number. In the meantime, the execution of the program is suspended. This gives us the opportunity to inspect the values for all the variables that are visible in the current scope. One can also evaluate expressions composed of those values.

As we can see here, only the args variable can be accessed at this point. This variable has the command-line parameters for the program. The contents of args can be displayed with the print command.

The p0 variable in the source code will be allocated only if the corresponding statement was executed. The step commands lets us to execute the subsequent statements step by step, one at a time.

Then the control is passed to the initialization routine of the Point2D class, because that has be done on every instantiation. Step the execution until the value of the p0 variable is eventually created.

Variables in the program may be changed if needed. This is useful when some bad value has to be corrected or we want to experiment with something else.

If we want to continue with the program execution in the usual pace, use the cont command. In this way, the program will normally run until it hits a breakpoint or it terminates.

Basic Java — September 29, 2016

Recap from the Previous Lab

Defining and Instantiating Classes