Java Programming/The Java Platform
From Wikibooks, the open-content textbooks collection
This page may need to be 
The newer versions of Java, i.e., version 6.0 and 7.0 are being developed and are known by their code-names Mustang and Dolphin respectively.
You can test-ride their nightly builds, available online via the given links.
The Java platform is the name for a computing environment, or platform, from Sun Microsystems which can run applications developed using the Java programming language and set of development tools. In this case, the platform is not a specific hardware or operating system, but rather an execution engine called a virtual machine, and a set of standard libraries which provide common functionality.
The platform is properly called the Java 2 Platform (although the "2" is to be dropped [1]), and includes a Standard Edition or J2SE (now Java SE), an Enterprise Edition or J2EE (now Java EE), and a Micro Edition or J2ME (now Java ME). The current version of the Java 2 platform is alternatively specified as version 1.6 or version 6 (both refer to the same version). A good overview of the myriad of technologies that makes up the Java 2 Platform can be found on the JDK Documentation Page.
Contents |
[edit] Java technologies
The Java platform consists of a wide array of technologies, each of which provides a distinct portion of the overall development or runtime environment. For example, end-users typically interface with the Java virtual machine and the standard set of class libraries. In addition, there are numerous ways for Java applications to be deployed, including being embedded into a web page. Lastly, developers who are creating applications for the platform use a set of development tools called the Java Development Kit.
[edit] Java Runtime Environment
A program targeting the Java platform needs two components to be present on its host: a Java virtual machine, and a set of class libraries providing any services on which it depends. Sun's distribution of their JVM and their implementation of the standard classes is known as the Java Runtime Environment (JRE).
[edit] Java Virtual Machine
The heart of the Java platform is the concept of a common "virtual" processor that executes Java bytecode programs. This bytecode is the same no matter what hardware or operating system the program is running under. The Java platform provides an interpreter called the Java virtual machine (JVM), which translates the Java bytecode into native processor instructions at run-time. This permits the same application to be run on any platform that has a virtual machine available.
Since JRE version 1.2, Sun's JVM implementation has also included a just-in-time compiler. Instead of interpreting the bytecode one instruction at a time, this converts the bytecode for a program into equivalent native machine code as the program is loaded into the virtual machine, allowing it to execute much faster at the cost of a small delay whenever new bytecode is loaded. This allows the JIT compiler to target a specific host platform and hardware, even potentially optimizing the output code in different ways based on observations of the program's behaviour.
This is not to say that one can truly compile Java code to its fullest extent (in order to reap the benefits of speedy native machine code). Yes, there are "compilers" available that will attempt this feat, but not all Java libraries have a machine code equivalent. For instance, the "reflect" library, which allows Java programmers to delve into instructions only available at runtime, is not well represented (if at all) by machine code.
Java was not the first virtual-machine-based platform, though it is by far the most successful and well-known. Previous uses for virtual machine technology primarily involved emulators to aid development for not-yet-developed hardware or operating systems, but the JVM was designed to be implemented entirely in software, while making it easy to efficiently port an implementation to hardware of all kinds.
[edit] Class libraries
In most modern operating systems, a large body of reusable code is provided to simplify the programmer's job. This code is typically provided as a set of dynamically loadable libraries that applications can call at runtime. Because the Java platform is not dependent on any specific operating system, applications cannot rely on any of the existing libraries. Instead, the Java platform provides a comprehensive set of standard class libraries, containing much of the same reusable functions commonly found in modern operating systems.
The Java class libraries serve three purposes within the Java platform. Like other standard code libraries, they provide the programmer with a well-known set of functions to perform common tasks, such as maintaining lists of items or performing complex string parsing. In addition, the class libraries provide an abstract interface to tasks that would normally depend heavily on the hardware and operating system. Tasks such as network access and file access are often heavily dependent on the native capabilities of the platform. The Java java.net and java.io libraries implement the required native code internally, then provide a standard interface for the Java applications to perform those tasks. Finally, some underlying platforms may not support all of the features a Java application expects. In these cases, the class libraries can either emulate those features using whatever is available, or provide a consistent way to check for the presence of a specific feature.
[edit] Languages
The word Java, by itself, usually refers to the Java programming language which was designed for use with the Java platform. Programming languages are typically outside of the scope of the phrase "platform". However, Sun does not encourage the use of any other languages with the platform, and lists the Java programming language as a core part of the Java 2 platform. The language and runtime are therefore commonly considered a single unit.
Nevertheless, third parties have produced a number of compilers which target the JVM. Some of these are for existing languages, while others are for extensions to the Java language itself. These include:
- Groovy
- Pizza
- GJ (Generic Java), which was incorporated into official Java as of Sun's version 1.5.
- NetREXX
Another option is to use a more interface approach like the Jython.
[edit] Similar Platforms
The success of Java and its write once, run anywhere concept has also led to other similar efforts. The most notable of these is the Microsoft .NET platform, which borrows many of the concepts and innovations of Java; in fact, it has an implementation of a Java-like language called Visual J# (formerly known as J++). (It is Java-like in that J# is not the Java language. Instead, J# contains non-standard extensions of the language.)
Later Microsoft stopped, withdrew its J# support, and created a new language called C#. C# is very similar to J# and Java, but not compatible with them. The differences between Java and C# can be read at w:Comparison of C Sharp and Java.
