•         advanced

Java consists of:

	a language specification,
	a bytecode compiler,
	a virtual machine that interprets the bytecode at runtime,
	a set of class library APIs,
	implementations of the class libraries specific to the target machine,
	a runtime environment in which the interpreter, bytecode verifier, class loader, etc. run, also specific to the target machine, and
	other development tools such as a debugger, a disassembler and an appletviewer for testing applets outside of a web browser.

There is also a web browser written in Java called HotJava.

Sun has finished the language specification, and a draft is available at [Sun 95].

The library APIs are frozen, and consist of the following packages:

	java.lang is considered part of the language itself, and is automatically imported by the compiler. It creates classes for math functions, (limited) process control, a security manager, strings, threads, and wrapping primitive data types. The class System creates an interface to system facilities, such as stdin/stdout/stderr, environment variables, garbage collection, exec'ing processes, etc.
	java.awt: GUI/windowing toolkit.
	java.awt.images: image processing
	java.io: file input/output, pipes.
	java.net: sockets, Internet addresses, URLs.
	java.util: hashtable, bit sets, dates, random numbers, vectors, etc.

Sun has beta version implementations completed on Solaris 2.3 and greater, and on Windows NT and Windows 95. Sun is actively encouraging ports to other platforms, apparently sharing class implementation source in exchange for the port. The SGI port is reputably stable.

Language Design Overview

Java is an evolution of current object oriented programming languages, influenced by the design of Eiffel, Smalltalk, C++, Objective-C and Cedar/Mesa, among others.

The syntax of the language comes from C/C++. The way that Java is presented gives the impression that it was designed as an improvement to C++, removing features that were judged to be redundant, confusing, or not worth the complexity. There is no preprocessor, since preprocessing can make the source code unreadable and non-local (i.e. you have to read all the include files before knowing what your code actually does). Its object design obviates the need for typedefs and structs. Unions and pointers are removed as a way to break type safety. The goto statement is removed in favor of structured control. Multiple inheritance, operator overloading, and automatic coercion are removed as not worth the complexity and obfuscation they entail. Finally, there are no standalone functions, but only class methods, in keeping with a purer object design.

Java looks a lot like Smalltalk: single inheritance class hierarchy with "Object" at the root of all classes, reference semantics, garbage collection, dynamic binding, and an interpreter. However, it is statically typed, and avoids the extreme of Smalltalk "everything is an object" philosophy, having primitive types as well as reference types for efficiency. By deferring memory layout until runtime, a class definition can be changed without breaking its subclasses

An important addition to the language is the use of interfaces, like Objective-C "protocols", that allows some separation of data abstraction and inheritance. An interface defines an abstract type, independent of the class hierarchy. An implementation of the interface can be provided by a class without revealing details of the implementing class.

Another useful addition is packages, which group classes together and allow "friend" access among the classes in a package. Packages also provide namespace encapsulation, which prevents name collisions and prevents untrusted (remote) code from overriding local classes.

Built in language support for concurrency and multiple threads of execution reflect the developments in this area in the past few years, although only nonpreemptive multithreading is assumed to be implementable. Garbage collection is now considered more tractable than when C++ was designed. Exceptions are supported and look much like C++. Native code can be linked in for efficiency.

Some features considered missing by some: version control for classes, templates (parameterized types), first class functions, and dynamic method dispatch.

Security against untrusted code pervades both the language design and implementation. It is important to distinguish between two types of Java programs. Applications are stand-alone programs whose source is local and trusted. Applets are downloadable programs that operate within a web browser or some other Java application, and whose code must be verified and resource access limited.

Language Features

Types

Java has four data types: class types, interface types, array types, and primitive types. All variables hold either a value of a primitive type or a reference to a dynamically allocated object.

The primitive types are integer (8, 16, 32, and 64 bit, two's complement), float (32 and 64 bit IEEE 751), character (16 bit Unicode) and Boolean (1 bit). The format of these primitive types is fixed by the language definition and is not implementation specific.

The other three types are called reference types because they are implemented using references to dynamically allocated objects. A dynamically allocated object is either a class instance or an array instance. A variable of type interface holds a reference to a class instance which implements the interface.

Primitive types can be converted between each other, with the exception of the boolean type. There are no conversions possible between primitive types and reference types. Class types can be converted only to types that are superclasses of itself. Similarly, the run-time type of a variable must be a subtype of its compile-time type.

With these restrictions, Java implements strong compile-time type checking, but allows subtypes to replace types at runtime. Objects are tagged and can be queried at runtime to discover their runtime type.

Arrays

Arrays are dynamically created objects containing some number of variables called components. All components have the same type T, and the array has type T[ ]. T may be any type: class, interface, array, or primitive. As in C/C++, arrays are always one-dimensional, but multidimensional arrays can be created from arrays of arrays. An array of objects is actually an array of pointers to objects. An array whose components are primitive types, however, are allocated efficiently in contiguous memory as in C/C++.

The length of an array is not part of the array type, so that a variable may contain references to arrays of different lengths. However, once an array object is allocated, its length is never changed. All array accesses are checked at runtime that the index is within bounds, or an exception is thrown.

Classes

Each class type has exactly one parent class ("immediate superclass") which it extends by overriding parent methods and adding new methods or variables. Like Smalltalk, classes thus constitute a single inheritance hierarchy, with all classes having Object at their root.

Classes may be declared abstract, in which case they cannot be instantiated, but only subclassed. Classes may be declared final, in which case they cannot be subclassed.

There are no standalone functions: everything is a method in some class. Methods that are declared static within a class ("class methods") are the closest to a standalone function, because they do not belong to a class instance, but to the class itself. Class methods can only refer to other class methods or static class variables.

All classes are themselves instances of the class "Class", and a class object is instantiated when the class is loaded.

Interfaces

An interface creates a new abstract type that specifies a set of methods and named constants, but does not specify an implementation, like Objective C's protocols . Interfaces may optionally extend one or more other interfaces, meaning that it implicitly specifies all of the methods and constants of the interfaces that it extends. Thus interfaces constitute a multiple inheritance hierarchy similar to C++.

A class may be declared to implement one or more interfaces, meaning that any instance of the class implements all of the methods specified by the interface.

Interfaces thus allow code reuse between classes independent of the class inheritance hierarchy. It allows the creation of a specialized "view" of an object for export. Since the implementation of an interface must be provided by a single class, interfaces do not allow you to combine the methods of multiple classes into a single type, independent of the inheritance hierarchy

Program Structure

A compilation unit is a single file containing one or more classes or interfaces, only one of which is declared public. The source file must be called <Name>. Java, and the resulting bytecode is placed in the file <Name>.class, where <Name> is the name of the public class or interface.

One or more compilation units may be grouped together into a package. Classes within the same package have access to each other, similar to "friend" classes in C++. Packages are given globally unique names to facilitate finding them on the web. All compilation units of a package are kept in the same subdirectory, and the package name becomes the subdirectory name, starting from some specified list of root directories. Thus on UNIX, the package EDU.ucar.unidata.netcdf is found in a subdirectory EDU/ucar/unidata/netcdf off the root directories specified in the CLASSPATH environment variable.

By convention, an organization's Internet Domain name is used, in reverse order, for packages that are to be accessible across the web. The first component (e.g. EDU) is capitalized.

Information Hiding

There are 4 levels of access control : 1) public: accessible to anyone who imports it; 2) protected: accessible to anyone in the same package, and to any subclasses; 3) friendly: accessible to anyone in the same package; and 4) private: accessible only within the class body where it is declared.

A class may be declared public or private, and defaults to friendly.

A class variable or method may be declared public, protected, or private, and defaults to friendly.

Interfaces can be thought of as a way to hide some of the methods of a class.

Method overloading and overriding

Like C++, Java allows the same method name to be declared with different number or types of parameters. This is called method overloading, and the compiler can correctly match the calling signature with the correct method.

Methods in a class are accessible to its subclasses unless declared private. A method in a subclass with the same name and parameter signature as a method in one of its superclasses is said to override the superclass' method. Overridden methods can still be accessed by using the syntax "<name>.<method>", where <name> is the name of the superclass, and <method> is the overridden method name. Methods can be declared final to prevent overriding.

All non-static methods are dynamically bound, i.e. runtime lookup is used.

Control

Java looks much like C, having for, while and do statements. The goto statement is eliminated completely, but unconditional jumps can be done within iterations using break and continue statements. Labels can be used to break out of nested iterations.

Exceptions

A throw statement signals a run-time exception. "Normal" exceptions are status returns to be passed up through possibly many nested method calls, typically signaling some unusual but legal condition such as disk error or file access denial. "Abnormal" exceptions are subclasses of class Error or RuntimeException which signal an illegal operation or method call. Both kinds of exceptions can be caught and handled by an exception handler.

Methods must declare any normal exceptions that are thrown. This declaration becomes part of the method signature, and is thought of as part of the "contract" with the calling routine. Overriding methods may only throw exceptions already declared by the overridden method.

Concurrency

The standard package java.lang provides a Thread class to implement multiple threads of control similar to the Cedar/Mesa languages. The implementation is platform-specific, and should be assumed to be nonpreemptive, that is the thread must explicitly relinquish control.

A method can be declared synchronized, in which case a monitor lock is obtained on entry , and released on exit. Each class instance has its own monitor.

The I/O class library is thread-aware, thus allowing parallelism during I/O requests, which tend to be very slow.

Security

A number of language features provide security against untrusted code:

	object access is restricted by use of the public/private class attributes and the public/private/protected method attributes.
	strong typing ensures that the runtime type is a subclass of the compile time type.
	pointers are eliminated altogether; the untrusted code has no way to point itself to specific memory locations.
	packages provide a namespace encapsulation so that the runtime can distinguish between remote and local classes; local classes are always scanned first, so that a remote class cannot override a local class.
	Garbage collection eliminates the possibility of object aliasing by clever use of allocating and freeing memory.

See [BankJ 95] and [Yellin 95] for more details.

Garbage Collection

Objects are explicitly allocated, but not explicitly deallocated. A garbage collection algorithm runs in its own thread, detects that an object is not referenced anywhere, and reclaims that memory. If the class has a finalize() method declared, that method will be called before garbage collecting the object.

The finalizer may resurrect the object by storing a reference to it. Thus an object with a finalizer is not reclaimed until the garbage collector determines it is garbage again, after the finalizer is called. The finalizer is called only once, however. I'm not sure what problem this resurrection is solving.

Because of the asynchronous nature of the garbage collector, the finalizer is called at an indeterminate time after the object is actually garbage. There is some criticism in the news group about this.

Implementation

Java Virtual Machine

Java source is compiled into bytecodes that run on a virtual machine implemented by the Java interpreter and run-time system. The use of virtual machines trades efficiency for portability: It is significantly easier to implement a bytecode interpreter for a given CPU than it is to write a native code compiler. Thus the Java compiler that compiles Java source code into bytecodes needs only be written once. Each different CPU architecture and operating system then needs to implement a Java bytecode interpreter and provide an implementation of the runtime classes.

Currently, interpreted Java runs about 30 times slower than an equivalent C program.

There is some discussion about the JavaVM being a target for other languages. There is already an implementation of an Ada to javaVM compiler, and a discussion of having Guile use the JavaVM. There are ways that the JavaVM is limited in its functionality, that would make this currently impossible for an arbitrary program written in C (e.g. lack of pointers in Java) or Lisp ( e.g. lack of closures in Java).

Memory Layout and Runtime Loading

Memory allocation and layout is not accessible to the programmer, but is handled entirely by the Java runtime. References to objects are not compiled into memory offsets from a base pointer as in C/C++, but remain symbolic until runtime, when they are checked by the bytecode verifier and then assigned (actually overwritten by) a memory offset. Thus the memory layout is done by the Java interpreter specific to the target machine. This runtime layout allows classes to add new methods and members without having to recompile subclasses that reference them (sometimes called the "fragile superclass" problem).

Security

Before the Java bytecode is executed, the bytecode verifier verifies that it is a legal program. It checks for forged pointers, access violations, that runtime types are compatible with compile time types, that all method calls' actual parameters are compatible with declared parameters, and that there are no stack under/over flows. The bytecode verifier is supposed to work on arbitrary bytecode sequences, not just compiler-generated ones.

The SecurityManager class is provided by the runtime to provide a flexible way to implement a security policy. Access to environment variables, local files, etc. can be controlled in this way.

It is critical that the class library implementations be correctly written, as well as the web browser. If I was trying to break Java security, I would try to induce unsuspecting sites to install a web browser or library implementation which I had altered to provide a security hole that I could exploit.

Native Code

Part of the long term strategy for improving performance is to provide "just in time" compilation of the bytecodes into native code. Since the bytecodes have been verified to be secure, the compiled native code can be presumed to be secure also. Sun has hinted it will be another 3-6 months before any native code compilers are available.

Methods can be declared native, and implemented in C or some other native language. Native code is linked into the Java runtime system by a call to System.loadLibrary( ). For security reasons, applets can only load native code that is local to the host machine.

Garbage Collection

The current garbage collection routine uses a conservative mark and sweep algorithm, with an optional compaction stage. It takes approximately 70ms on Java's default 1M heap, and runs in a background thread that abandons its work when a user event occurs in order to maintain responsiveness. Comments from Java's developers that the design can support incremental and generational garbage collection imply that these might be added in the future.

Use Report

To test Java, I implemented several small "applets" to work on the Netscape browser 2.0b3. I used a Sparc 10 running Solaris 2.4. I downloaded the Java Developers Kit (JDK) from http://java.sun.com. After uncompressing and untarring, the distribution was 10 Mbytes in size.

Since the first uses for Java are to add some pizzazz to web pages, I decided to find out how simple it was to manipulate some graphics. I ended up writing two applets, one to change the colors on a graphics image, the other to show a rotating graphics image.

To date, there is no good programmer documentation. Presumably all of Sun's effort is going into a book series from Addison-Wesley due out in March 1996. As an experienced C programmer, I already knew most of Java's syntax, which was a real advantage. By following the news group, and examining some of the many posted examples of source code, I learned much of the semantics. I also found reading the language specification useful, both straight through (once) and as a reference as questions came up.

Before coding in Java, I wrote code in C to test an algorithm for rotating arbitrary images through an arbitrary angle using brute force computation on every pixel. It is instructive to see how close the code is in this case. In the C code, I use pointer arithmetic for the 2D image array, but that maps very directly to using index arithmetic in a 1D Java array. The image is assumed to be stored in an integer array in memory.

The C code:

#define PI 3.1415
static void Rotate(int *original, int nrows, int ncols, double rotate, int *rotated)
    {
        int *colorp = original;
        int x,y,ok;

        printf("rotate = %f deg\n", rotate);
        rotate *= PI/180.0;

	/* set the target array to original, since not all pixels get covered */
        memcpy( rotated, original, nrows * ncols * sizeof(int));

        for (y=0;y<nrows;y++)
            for (x=0;x<ncols;x++)
                {
                double xp = (double) x - .5 * (ncols-1);
                double yp = (double) y - .5 * (nrows-1);

                double theta = atan2( yp, xp) - rotate;
                double r = sqrt(xp*xp + yp*yp);
                double xnewp = r * sin(theta);
                double ynewp = r * cos(theta);

                int xnew = (int) (xnewp + .5*(ncols-1));
                int ynew = (int) (ynewp + .5*(nrows-1));

                ok = ((xnew > 0) && (xnew < ncols) && (ynew > 0) && (ynew < nrows));
                if (ok)
                    *(rotated + ynew * ncols + xnew) = *colorp;
                colorp++;
                }
    }

public class Rotate extends java.applet.Applet implements Runnable {
    int nrows;
    int ncols;
    double rotate = 0.0;
    double rotate_inc = 15.0;
    int original[];
    int rotated[];
    Image img;
	...

    void rotate() 
	{
        rotate += rotate_inc;
        System.out.println("rotate through angle of " + rotate + "deg");
        double rot_rad = rotate * Math.PI /180.0;

        // start from original, since not all pixels get set
        for (int i=0; i<nrows*ncols; i++)
            rotated[i] = original[i];

        // rotate through an angle of "rotate"
        for (int y=0;y<nrows;y++)
            for (int x=0;x<ncols;x++)
                {
                double xp = (double) (x - .5 * (ncols-1));
                double yp = (double) (y - .5 * (nrows-1));

                double theta = Math.atan2( yp, xp) - rot_rad;
                double r = Math.sqrt(xp*xp + yp*yp);
                double xnewp = r * Math.sin(theta);
                double ynewp = r * Math.cos(theta);

                int xnew = (int) (xnewp + .5*(ncols-1));
                int ynew = (int) (ynewp + .5*(nrows-1));

                boolean ok = ((xnew>0)&&(xnew<ncols)&&(ynew > 0)&&(ynew <nrows));
                if (ok)
                    rotated[ynew*ncols + xnew] = original[y*ncols + x];
                }
    }

		/*** Set the cursor image*/
   	 	public void setCursor(Image img) {
        		FramePeer peer = (FramePeer)this.peer;
        		if (peer != null) {
           		     peer.setCursor(img);
        		    }
    		}

World Wide Web Virtual Library http://www.acm.org/~ops/java.html Lots of pointers to more Java-related resources.

Contact Us   •   Site Map   •   Search   •   Terms and Conditions   •   Privacy Policy   •   Participation Policy

Unidata is a member of the UCAR Office of Programs, is managed by the University Corporation for Atmospheric Research, and is sponsored by the National Science Foundation. P.O. Box 3000   •   Boulder, CO 80307-3000 USA   •   Tel: 303-497-8643   •   Fax: 303-497-8690