JDK 1.1 New Feature Summary

1. Internationalization
   Allows the development of localizable applets. Enhancements include the display of UNICODE characters, a locale mechanism, localized message support, locale-sensitive date, time, time zone and number handling, collation services, character set converters, parameter formatting, and support for finding character/word/sentence boundaries.
   
2. Security and Signed Applets
   The Java Security API is designed to allow developers to incorporate both low-level and high-level security functionality into their Java applications. The first release of Java Security in JDK 1.1 contains a subset of this functionality, including APIs for digital signatures and message digests. In addition, there are abstract interfaces for key management, certificate management and access control. Specific APIs to support X.509 v3 certificates and other certificate formats, and richer functionality in the area of access control, will follow in subsequent JDK releases.
          JDK 1.1 also provides a tool that can sign Java ARchive (JAR) files, which can contain classes and other data (such as images and sounds). The appletviewer allows any downloaded applets in JAR files signed (using the tool) by a trusted entity to run with the same full rights as local applications. That is, such applets are not subject to the "sandbox" restrictions of the original Java security model. Later releases will provide more sophisticated security policies, including greater granularity in the allowable trust levels.
   
3. AWT Enhancements
   Enhancements are aimed at solving some major AWT (Abstract Window Toolkit) deficiencies with a strong focus on quality and performance. The AWT enhancements will include the beginnings of a richer infrastructure for larger-scale GUI development, including APIs for printing, easier/faster scrolling, popup menus, clipboard (copy/paste), cursors per component, a delegation-based event model, imaging and graphics enhancements, and more flexible font support for internationalization. Additionally, the Windows (Win32) version of AWT has been completely re-written for improved speed, quality, and consistency with the other platforms.
   
4. JavaBeans^TM
   The JavaBeans APIs define a software component model for Java allowing third party ISVs to create and ship Java components that can be composed together into applications by end users.
   
5. JAR File Format
   JAR (Java Archive) is a platform-independent file format that aggregates many files into one. Multiple Java applets and their requisite components (.class files, images and sounds) can be bundled in a JAR file and subsequently downloaded to a browser in a single HTTP transaction, greatly improving the download speed. The JAR format also supports compression, which reduces the file size, further improving the download time. In addition, the applet author can digitally sign individual entries in a JAR file to authenticate their origin. It is fully backward-compatible with existing applet code and is fully extensible, being written in Java.
   
6. Networking enhancements
   Support for selected BSD-style socket options in the java.net base classes. With JDK 1.1, Socket and ServerSocket are non-final, extendable classes. New subclasses of SocketException have been added for finer granularity in reporting and handling network errors. The class MulticastSocket moves from sun.net to java.net. Also includes general performance improvements and bug fixes.
   
7. IO Enhancements
   The I/O package has been extended with character streams, which are like byte streams except that they contain 16-bit Unicode characters rather than eight-bit bytes. Character streams make it easy to write programs that are not dependent upon a specific character encoding, and are therefore easy to internationalize. Nearly all of the functionality available for byte streams is also available for character streams.
   
8. Math Package
   The math package provides two new classes: BigInteger and BigDecimal. BigInteger numbers are immutable arbitrary-precision integers, which provide analogs to all of Java's primitive integer operators, and all relevant static methods from java.lang.Math. Additionally, BigInteger numbers provide operations for modular arithmetic, GCD calculation, primality testing, prime generation, single-bit manipulation, and a few other odds and ends.
   BigDecimal numbers are immutable, arbitrary-precision signed decimal numbers, suitable for monetary calculations. BigDecimal numbers provide operations for basic arithmetic, scale manipulation, comparison, format conversion and hashing.
   
9. Remote Method Invocation
   RMI enables the programmer to create distributed Java-to-Java applications, in which the methods of remote Java objects can be invoked from other Java virtual machines, possibly on different hosts. A Java program can make a call on a remote object once it obtains a reference to the remote object, either by looking up the remote object in the bootstrap naming service provided by RMI or by receiving the reference as an argument or a return value. A client can call a remote object in a server, and that server can also be a client of other remote objects. RMI uses Object Serialization to marshal and unmarshal parameters and does not truncate types, supporting true object-oriented polymorphism.
   
10. Object Serialization
    Object Serialization extends the core Java Input/Output classes with support for objects. Object Serialization supports the encoding of objects and the objects reachable from them into a stream of bytes and the complementary reconstruction of the object graph from the stream. Serialization is used for lightweight persistence and for communication via sockets or Remote Method Invocation (RMI). The default encoding of objects protects private and transient data, and supports the evolution of the classes. A class may implement its own external encoding and is then solely responsible for the external format.
    
11. Reflection
    Enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts on objects, within security restrictions. The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class.
    
12. JDBC^TM - Java Database Connectivity
    Java Database Connectivity is a standard SQL database access interface, providing uniform access to a wide range of relational databases. It also provides a common base on which higher level tools and interfaces can be built. This comes with an "ODBC Bridge" (except on Mac 68K). The Bridge is a library which implements JDBC in terms of the ODBC standard C API.
    
13. Inner Classes
    Provides a simpler syntax for the creation of adapter classes. An adapter class is a class that implements an interface (or class) required by an API, and delegates the flow of control back to an enclosing "main" object. The new language features apply to Java the concepts of lexical scoping and block structure found in many languages.
    
14. Java Native Interface
    A standard programming interface for writing Java native methods and embedding the Java virtual machine into native applications. The primary goal is binary compatibility of native method libraries across all Java virtual machine implementations on a given platform.
    
15. Performance Enhancements
    • Interpreter loop in assembly code on Win32 and Solaris/Sparc.
    • Non-contiguous heap support on Mac.
    • Monitor speed-ups.
    • Garbage collection of classes.
    • AWT peer class re-write for Win32.
    • JAR (Java Archive) bundling of resources for a single HTTP transaction
16. Miscellaneous
    • Byte, Short and Void Classes - Bytes and shorts are accommodated as wrapped numbers by adding new classes Byte and Short. The abstract class Number gets two new concrete methods: byteValue and shortValue; the default implementations of these use intValue method. Also includes a new class Void that is an uninstantiable placeholder class.
    • The @deprecated tag - Used in documentation comments for unambiguously marking classes, methods and fields that have been superseded by new APIs. The compiler issues a warning when it processes source code that uses a deprecated API feature.
    • Accessing Resource Files - APIs that provide a mechanism for locating resource files in a way that is independent of the location of the resources. For example, this mechanism can locate a resource file whether it is an applet loaded from the net using multiple HTTP connects, an applet loaded using JAR files, or a "library" installed in the CLASSPATH.
    • Additions to APPLET Tag (HTML) Enhancements of the <APPLET> tag used in HTML.

JDK 1.2 New Feature Summary

Core Platform

The Core Platform will be available on all Java Compatible systems supporting 1.2.

1. Security Enhancements
   • Policy-based, Easily-configurable, Fine-grained Access Control introduces the concepts of "permission" and "policy." When code is loaded, it is assigned "permissions" based on the security policy currently in effect. Each permission specifies a permitted access to a particular resource (such as "read" and "write" access to a specified file or directory, "connect" access to a given host and port, etc.). The policy, specifying which permissions are available for code from various signers/locations, can be initialized from an external configurable policy file. Unless a permission is explicitly granted to code, it cannot access the resource that is guarded by that permission.
     These new concepts of permission and policy enable the JDK to offer fine-grain, highly configurable, flexible, and extensible access control. Such access control can now not only be specified for applets, but also for all Java code, including applications, beans, and servlets.
   • Certificate interfaces enable developers to build tools for parsing certificates, enforcing their own site-specific certificate policies, and managing local databases of certificates.
   • X.509 v3 implementation of the new, supported certificate interfaces.
   • The keytool, jar, jarsigner, and policytool security tools - keytool creates key pairs and self-signed X.509 v1 certificates, and manages keystores. Keys and certificates are used to digitally sign your Java applications and applets. A keystore is a protected database that holds keys and certificates. jarsigner signs JAR (Java Archive Format) files, and verifies the signature(s) of signed JAR files. It accesses the keystore when it needs to find the key when signing a JAR file. keytool and jarsigner replace javakey. policytool creates and modifies the external policy configuration files that define your installation's Java security policy.

2. Swing (JFC)
   • Swing is a new set of GUI components with a "Pluggable Look and Feel" that are implemented in 100% Pure Java, and based on the JDK 1.1 Lightweight UI Framework.
   • Pluggable Look and Feel lets you easily design a single set of GUI components that can automatically have the look and feel of any OS platform (Windows, Solaris, Macintosh).
   • Swing Components include both 100% Pure Java versions of the 1.1 AWT component set, plus a rich set of higher level components. The complete set includes borders, buttons, checkboxes, combo boxes, icons, labels, lists, list boxes, menus, menubars, menu items, popup menus, radio buttons, progress bars, scroll panes & viewports, scrollbars, tabbed panes, tables, text areas, text components, text fields, trees and HTML viewers.

3. Java 2D (JFC)
   • Java 2D API is a set of classes for advanced 2D graphics and imaging. It encompasses line art, text, and images in a single comprehensive model. The API provides extensive support for image compositing and alpha channel images, a set of classes to provide accurate color space definition and conversion, and a rich set of display-oriented imaging operators. These classes are provided as additions to the java.awt and java.awt.image packages (rather than as a separate package).

4. Accessibility (JFC)
   • Accessibility API provides a clean interface which allows assistive technologies to interact and communicate with JFC and AWT components. Assistive technologies are used by people with and without disabilities and include screen readers, screen magnifiers, and speech recognition.

5. Drag & Drop (JFC)
   • Drag & Drop enables data transfer both across java and native applications, between Java applications, and within a single Java application.

     These features are not part of Swing because they require native methods, and Swing is 100% Pure Java.

6. Application Services (JFC)
   • Keyboard Navigation makes it possible to substitute the pressing of predetermined key combinations for mouse-driven events such as the selection of a menu item or a dialog-box button.
   • Multithreaded Event Queue is an enhanced event queue that makes it easier for developers to synchronize events from multiple sources. This simplifies thread management by making use of new methods such as invokeLater(), which makes it possible for an application to access the user interface from a separate thread.
   • Undo makes it possible to reverse the effects of a previously executed command.
   • Bounded Range Model sets limits on the values that can vary with a bounded range, such as with sliders, progress bars and scroll bars. It also corrects some shortcomings of the AWT Adjustable interface.
   • Custom Cursors allow programs to create their own custom mouse cursors using arbitrary images. The hotspot can also be defined.
   • Debug Graphics Utility is a design tool that you can use to test whether your Swing components are being drawn correctly. With DebugGraphics, you can highlight component parts in bright red as they are being drawn. Then you can monitor them as they are being created and observe exactly how all drawing operations are taking place.
   • Repaint Batching is a mechanism that provides ways to optimize the repainting of screen regions. It lets you mark a component region as out-of-date, and compute the intersection of all out-of-date regions and repaint what is appropriate. It also provides a way for objects to be aware of all out-of-date regions in a component hierarchy at a given time so advanced optimization will be possible. Lastly, it allows you to plug in a custom repaint batching system for special applications.
   • Target Manager allows actions to dynamically affect different targets. Objects can register with target managers, specifying the actions that they are capable of supporting. Subsequently, an action can query a target manager to find out what its current target is.

7. Collections
   • Java Collections API is a unified framework for representing and manipulating collections, allowing them to be manipulated independent of the details of their representation. It allows for interoperability among unrelated APIs, reduces the effort in designing and learning new APIs that would otherwise have their own collection interfaces, and fosters software reuse. The API includes interfaces, concrete implementations, abstract implementations, and a few polymorphic algorithms.

8. Extensions Framework
   • Extension Framework supports the dynamic downloading and installation of extensions as JAR files onto the Java Platform. An extension is a group of Java packages that implement an API that extends the Java platform. Extensions are identified by the package name "javax" and are usable by both applications and applets. Extension will be available from both Sun's JavaSoft and from third parties.

9. JavaBeans^TM Enhancements
   • Interaction with Applet Semantics fixes the limitations in the specification and implementation of JavaBeans that implement Applet semantics. These shortcomings made it difficult to implement some Applet and Bean behaviors in the same object.
   • Better Design-Time Support adds infrastructure during the JavaBeans design time to enable a more sophisticatated builder environment.
   • Beans Runtime Containment and Services Protocol adds additional context to the execution lifetime of JavaBeans including but not limited to AppletContext and the ability to parent into an AWT presentation hierarchy.

10. Input Method Framework
    • Input Method Framework enables all text editing components to receive Japanese, Chinese, or Korean text input through input methods. An input method lets users enter thousands of different characters using keyboards with far fewer keys. Typically a sequence of several characters needs to be typed and then converted to create one or more characters. Components can actively use the API to support the on-the-spot input style; otherwise the framework provides root-window style input as a fallback.

11. Version Identification
    • Version Identification introduces package level version control where applications and applets can identify at runtime the version of a specific Java Runtime Environment, VM, and class package.

12. RMI Enhancements
    • Remote Object Activation introduces support for persistent references to remote objects and automatic object activation via these references.
    • Custom Socket Types allow a remote object to specify the custom socket type that RMI will use for remote calls to that object. RMI over a secure transport (such as SSL) can be supported using custom socket types.
    • Minor API Enhancements allow the following: unexporting a remote object, obtaining the stub for an object implementation, obtaining a local object implementation from a stub, and exporting an object on a specific port.

13. Serialization Enhancements
    • Persistent Field API allows the persistent data of an object to be specified independently of the fields of the class and allows those persistent data fields to be written to and read from the stream using the existing protocol. This ensures compatibility with the default writing and reading mechanisms.

14. Reference Objects
    • Reference objects reify references in much the same way that Class objects reify Java classes. That is, a reference object encapsulates a reference to some other object so that the reference itself may be examined and manipulated like any other object.

      Reference objects allow a program to maintain a reference to an object that does not prevent the object from being considered for reclamation by the garbage collector. They also allow a program to be notified some time after the collector has determined that an object has become eligible for reclamation. Reference objects are therefore useful for building simple caches as well as caches that are flushed only when memory is low, for implementing mappings that do not prevent their keys (or values) from being reclaimed, and for scheduling post-mortem cleanup actions in a more flexible way than is possible with the Java finalization mechanism.

15. Audio Enhancements
    • Java Sound replaces the existing sound engine with a new sound engine that provides playback for MIDI files and the full range of .wav, aiff and .au files. It also provides much higher sound quality. It introduces no new API.
    • getNewAudioClip is a new static method in java.Applet to get an audio clip. This enables applications to create audio clips without requiring an AppletContext.

16. Java IDL
    • Java IDL adds CORBA (Common Object Request Broker Architecture) capability to Java, providing standards-based interoperability and connectivity. Java IDL enables distributed Web-enabled Java applications to transparently invoke operations on remote network services using the industry standard OMG IDL (Object Management Group Interface Definition Language) and IIOP (Internet Inter-ORB Protocol) defined by the Object Management Group. Runtime components include a fully-compliant Java ORB for distributed computing using IIOP communication. The idltojava compiler generates portable client stubs and server skeletons that work with any CORBA-compliant ORB implementation.

17. Performance Enhancements
    • Solaris Native Thread Support can provide several advantages over the default threads package. In a multi-processor environment, the Solaris kernel can schedule native threads on the parallel processors for increased performance. The native threads VM can call into C libraries that use Solaris native threads. The VM can avoid some inefficient remapping of I/O system calls that are otherwise necessary.
    • Memory Compression for Loaded Classes
      Constant strings are shared among different classes, resulting in reduced memory consumption for Java applications.
    • Faster Memory Allocation and Garbage Collection
      The thread-local heap cache eliminates the need of locking for majority of heap allocations. Memory allocation speed is drastically increased. Garbage collection pauses are shorter. The garbage collector no longer excessively consumes the C stack.
    • Monitor Speedups
      The thread-local monitor cache enables synchronized methods to run closer to the speed of normal methods.
    • Native Library JNI Port
      Native libraries supporting core Java classes (e.g., AWT) have been rewritten using the Java Native Interface (JNI). The resulting code is more efficient and can run unmodified on different Java Virtual Machines.
    • Just In Time (JIT) Compilers
      JIT compilers are being included with the JDK. The Solaris JIT compiler is available with Beta 2. The Win32 JIT compiler will be available with the final release.

18. JAR Enhancements
    • JAR Enhancements extend the utility of the Java Archive format. Improvements to the command-line JAR tool for creating and updating signed JAR files. New standard APIs for reading and writing JAR files. Policy and mechanism for handling dependencies on standard extensions and other third-party libraries packaged as JAR files.

19. JNI Enhancements
    • JNI Enhancements extend the Java Native Interface (JNI) to incorporate new features in the Java platform. The changes are driven by licensee and user comments.

20. Reflection Enhancements
    • Reflection Enhancements enables a field, method or constructor object to be explicitly flagged as suppressing default Java language access control.

21. Java Virtual Machine Debugger Interface
    • The Java Virtual Machine now provides low level services for debugging, the Java Virtual Machine Debugger Interface (JVMDI).

22. JDBC Enhancements
    • JDBC Enhancements include an improved version of the JDBC-ODBC Bridge.

Extensions Standards

Standard Extensions extend the Java Platform with capabilities beyond what is provided within the Java core platform. The Java Servlet API (described below), is one of many planned Standard Extensions that will be available from Sun's JavaSoft. Standard extensions must conform to the Extension Architecture.

• Java Servlet API enables the creation of Java Servlets.
  Servlets are a means of extending the functionality of servers. For example, servlets can extend a web server's functionality in the same way that CGI scripts do. Servlets, however, are much less resource intensive than CGI scripts. Because servlets are written entirely in Java, again unlike CGI scripts, they are cross-platform as well.

Tools

Several of the JDK tools have improvements; the one listed here has a substantial design change and corresponding documentation.

• Javadoc Doclets can be used to customize the content and format of the output of the JDK javadoc tool.