Introduction to Java

Getting Started

Java's designers state that it is a simple, robust, object-oriented, architecture-neutral, portable, secure, multithreaded, distributed, interpreted, dynamic, and high-performance language.

A Java program is nothing more than a collection of classes, optionally grouped into packages. Here is a simple program made up of one class that is not part of a package

/**
 * An application class that writes a little greeting.
 */
public class Greeter {

    /**
     * Writes a greeting followed by the first command line argument
     * if one is present.
     */
    public static void main(String[] args) {
        System.out.print("Hello there");
        if (args.length > 0) {
            System.out.print(", " + args[0]);
        }
        System.out.println(".");
    }
}

If you are using Sun's JDK 6 compiler, you would put the above code into the file Greeter.java and compile it like this

This would produce the file Greeter.class, which is only 674 bytes in size (only 580 if you compile with javac -g:none Greeter.java).

Class files are interpreted (run) by a Java interpreter. A Java interpreter can be

• a command-line interpreter, like java.exe
• part of, or a plugin to, a Web Browser
• part of a servlet engine
• part of an application server
• implemented in hardware

(Class files can also be turned into native code before/during interpretation.)

Using Sun's JDK 6, the invocation

interprets (executes) Greeter.class. That's just another way to say "runs the application". Java is said to be "portable" because these class files contain byte codes for an abstract machine which are interpreted, and you can write interpreters for many platforms. There are interpreters running on Solaris, Linux, Windows and many other operating systems as well as consumer electronic devices.

(Note, however, that the "portability of Java" is due only to this Java Virtual Machine, on which class files are interpreted, rather than to the Java language. Hundreds of other languages can be compiled into class files too!)

Classes and Objects

Generally you make classes so that you can make objects of that class.

/**
 * A simple cylinder.
 */
public class Cylinder {
    private double radius;
    private double height;
    public Cylinder(double r, double h) {radius = r; height = h;}
    public double getRadius() {return radius;}
    public double getHeight() {return height;}
    public double getVolume() {return capArea() * height;}
    public double getSurfaceArea() {return 2 * capArea() + sideArea();}
    private double capArea() {return Math.PI * radius * radius;}
    private double sideArea() {return 2.0 * Math.PI * radius * height;}
    public void widen(double factor) {radius *= factor;}
    public void lengthen(double factor) {height *= factor;}
}

The class in this file contains two fields (radius and height), one constructor, and eight methods (getRadius, getHeight, getVolume, getSurfaceArea, capArea, sideArea, lengthen and widen). Compiling this file with Sun's JDK 6 compiler makes the file Cylinder.class. You can give this small class file to a friend who doesn't believe that a glass which is twice as wide as another glass holds four times as much water. Then your friend could write the following:

/**
 * An application that creates some cylinders and calls a couple
 * methods, just for fun.
 */
public class VolumeChecker {
    public static void main(String[] args) {
        Cylinder c1 = new Cylinder(1, 4);
        Cylinder c2 = new Cylinder(1, 4);
        Cylinder c3 = c2;
        c2.widen(2);
        System.out.println("Volume of first glass is " + c1.getVolume());
        System.out.println("Volume of second glass is " + c2.getVolume());
        System.out.println("Volume of third glass is " + c3.getVolume());
    }
}

Here we made two objects of the class Cylinder. Objects are created with the "new" operator. The first object is referenced by the variable c1 while the second is referenced by the variables c2 and c3. Never confuse the term 'variable' with the term 'object'. They are completely different things! See how we have three variables but two objects:

The "new" operator in Java allocates memory for the cylinder objects, but the programmer never explicitly deallocates memory for objects. The Java runtime automatically does garbage collection of objects that are no longer referenced.

Program Structure

Logically, Java programs are made up of classes that are grouped into packages. Physically, your program is written in a collection of source code files. Almost every Java compiler in the world forces this organization:

• At most one class definition can be public (written public class A).
• If the public class is called X, then the file must be called X.java (case sensitive).
• Execution will start at a method with signature public static void main(String[] args) in some designated class.
• Execution ends when all non-daemon threads have finished.

Each class definition is compiled into a .class file. Packages can be split over several source code files, but each class has to be wholly contained in a file.

If you don't give a package declaration your class(es) will go in the "default package". This is considered unprofessional and stupid, but it's fine when you are learning or experimenting.

Standard Libraries (APIs)

People have written millions of classes since Java was created, but a few thousand of them have been collected into one of Java's standard, or core, APIs. The APIs vary by platform, of which there are three:

• Micro Java (Java ME): for embedded systems like cell phones, device controllers, and appliances (with or without displays)
• Standard Java (Java SE): for workstations
• Enterprise Java (Java EE): for large-scale applications, especially those found behind behind big web applications. Supports databases, HTTP, middleware, scaling, messaging, mail, authentication, etc. etc.

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * An application which displays each of the times on a twelve-hour
 * clock that the hour and second hands make an angle of 180 degrees.
 */
public class AntiparallelClockHandsComputer {
    public static void main(String[] args) {
        long midnight = new GregorianCalendar(0, 0, 0).getTimeInMillis();
        for (int i = 0; i < 12; i++) {
            Date d = new Date(midnight + Math.round((0.5+i) * 43200000/11.0));
            System.out.println(new SimpleDateFormat("hh:mm:ss").format(d));
        }
    }
}

Our AntiparallelClockHandsComputer class uses the classes

    java.lang.String
    java.lang.System
    java.lang.Math
    java.text.SimpleDateFormat;
    java.util.Date;
    java.util.GregorianCalendar;

The import statements at the top of the source file allow us to avoid specifying the full name of these classes throughout our code. Note that import statements are never necessary, they are simply a convenience. (Also note that classes from java.lang don't have to be mentioned in import statements.)

Besides the 202 "core" packages, there are many hundreds of additional packages that you can buy or download for free.

The core classes are, as a rule, bundled into the file rt.jar which your compiler always knows how to find.

Evolution

Java has evolved over time. Java SE has evolved like this:

Some Useful Facts

• Java programs are written in the Unicode character set. If you are working on a non Unicode system, you can write "escape sequences" such as "\u30c6" (backslash, 'u' then 4 hex digits). The conversion into Unicode is done before the source code is processed, so for example "\u000a" DOES NOT make a string with a single new line character in it.
• An application is made by making a public class with a public static void method called main() whose sole argument is a String array.
• In Java, there are no global variables, nor global functions. Just classes. Java classes can be grouped into packages. Packages are important because they prevent name clashes that could occur when you have millions of classes.
• From classes we instantiate objects. So class names should be nouns: so far we have made Greeters, Cylinders, and VolumeCheckers, and AnitparallelClockHandsComputers.
• Java arrays know how many elements they contain.
• The object out in the class java.lang.System has methods (among others) called print() and println().
• There is this cool "+" operator that concatenates strings. It can also add things other than strings to strings, by first converting them to strings.
• Java programs are (almost always) compiled into class files.
• Class files are interpreted by a "Java Virtual Machine", which is why Sun talks about "write once run anywhere." As long as you have a JVM on your system, you are set.
• Java is very similar to C#, but very different from C++.
• Objects are instances of classes, and are instantiated with the "new" operator and garbage collected by the Java runtime system.

Language Reference

The official reference for the language is The Java Language Specification. It contains a nice one-page syntax of the language.

Some useful items follow here anyway:

Reserved Words

Reserved words are words that cannot be used as identifiers.

        abstract    continue    for           new          switch
        assert      default     if            package      synchronized
        boolean     do          goto          private      this
        break       double      implements    protected    throw
        byte        else        import        public       throws
        case        enum        instanceof    return       transient
        catch       extends     int           short        try
        char        final       interface     static       void
        class       finally     long          strictfp     volatile
        const       float       native        super        while

Note that false, true, and null are not reserved words, but they are literals of built-in types, so you can't use them as identifiers even if you tried.

Statements

The statements are

• ; (the empty statement)
• any declaration is a statement
• any expression is a statement (assignments and method calls happen to be expressions)
• { statements } (this is a "block" of statements)
• assert (exists only in Java 1.4 and later)
• try (can optionally have catch parts and a finally part)
• if (can optionally have an else part)
• switch (very messy multiway branch)
• while (loop with termination test at the beginning)
• do ... while (loop with termination test at the end)
• for (two versions)
• throw (throws an exception)
• return (to return from a function)
• break (immediate exit from the given loop or innermost enclosing loop or switch if no label argument)
• continue (jump to end of the given loop, or innermost enclosing loop if no label argument. Note it doesn't jump out the loop, it just skips the rest of the loop body for the particular iteration.)
• synchronized locks an object (blocking until it gets the lock) then executes a statement

Operators

Here are the Java operators, presented from highest to lowest precedence.

Types

Every expression in Java has a value and a type. There are two kinds of types.

• Primitive Types, of which there are eight:
  • boolean (either true or false)
  • byte (an 8-bit integer in the range -128..127)
  • char (a 16-bit value representing a UTF-16 code unit — not a codepoint!)
  • short (a 16-bit integer in the range -32768..32767)
  • int (a 32-bit integer in the range -2147483648..2147483647)
  • long (a 64-bit integer in the range -9223372036854775808..9223372036854775807)
  • float (an IEEE 754 32-bit floating point number)
  • double (an IEEE 754 64-bit floating point number)
• Reference Types, implemented as classes. (Objects are instances of classes. Arrays are objects, though with quite a bit of special syntax!)

The value of an expression of a primitive type is the primitive entity (like true or 759 or 4322.95 or '@'), but the value of a variable of a reference type (object or array) is either null or a reference to the object or array, NOT the object itself.

Primitive entities can just be written down; objects (and arrays) are only created using "new."

Important: Remember that variables of non-primitive types contain references; therefore, the "=" and "==" operators DO NOT copy and test the equality of object values. (There may be clone() and equals() methods available, or you can define these if needed.)

This example shows how variables of primitive types differ from variables of reference types:

float x;
x = 3;                          // value 3 stored in x
float y = x;                    // value 3 stored in y
y = 4;                          // after this x is still 3

Cylinder c1;                    // just declares a variable
c1 = new Cylinder(1, 1);        // now we have a cylinder created
Cylinder c2 = c1;               // does NOT create a new cylinder
c2.widen(2);                    // exactly the same effect as c1.widen()
c1 = null;                      // the cylinder still exists

double d = c1.getRadius();      // OOPS!! Throws a NullPointerException

double r = c2.getRadius();      // This is perfectly fine: c2 isn't null
c2 = null;                      // Now the object is unhooked.  It is
                                // "garbage" and the runtime system
                                // will eventually reclaim the storage.

An interesting note: variables which are fields of a class are automatically initialized in Java: for primitive types they are automatically initialized to 0 for numbers and false for booleans; for objects they are initialized to null.

Exceptions

There are dozens of "throwable" classes in the Java Core API. Throwables are either errors or exceptions. Exceptions are either runtime exceptions (a.k.a unchecked exceptions) or checked exceptions.

In many cases you will define your own exceptions, but if your situation can use a pre-existing one, please do so. The most common pre-defined exceptions that you will have occasion to throw are:

Garbage Collection

Programmers have a couple responsibilites when it comes to using memory and other resources efficiently:

• Sometimes you will have to "help the garbage collector out" by setting some variables to null — a lot of Java programmers are naive and they "hold onto" objects way too long, wasting tons of memory and either slowing down their programs or making them run out of memory.
• If your Java program uses resources given to you by the operating system (lock sockets or windows or file handles) you almost certainly will have to call some kind of close() or dispose() method on them to free up O.S. resources. The Java garbage collector will only free up the memory in the Java virtual machine used by the Java object that refers to the O.S. resource.

More Notes

• Java Classes
• Building Large Java Applications
• Java Graphics
• Java Threads
• Java Networking Examples
• Comparing Java, C++, and C#