Contents - Cultural View

Contents
Articles
Java (programming language) 1
Web Language 15
AgentSheets 16
Oak (programming language) 19
Lightweight Java 21
.properties 22
Apache Harmony 24
Apache Muse 30
Apache Shiro 31
Java applet 32
Associació d'Usuaris de Java de Catalunya 40
Automated exception handling 48
Bean Scripting Framework 49
CJAN 50
Celtix 52
Chainsaw (log file viewer) 53
clone (Java method) 54
Comparison of Java and C Sharp 58
Comparison of Java and C++ 82
Comparison of the Java and .NET platforms 93
Constant interface 100
Java 4K Game Programming Contest 102
CookXml 106
Cougaar 109
Deterministic Parallel Java 110
Devoxx 110
Doclets 111
Elastic Path 112
Electronic Disturbance Theater 113
Event dispatching thread 116
Facelets 118
final (Java) 120
FloodNet 122
FormEngine 123

Generics in Java 124
G-java 129
GlassFish Metro 130
James Gosling 132
Gray Flimmer 134
Todd Greanier 135
Head First (book series) 136
Jim Hugunin 137
Inner class 138
Interface (Java) 140
Internet Foundation Classes 143
JAD (JAva Decompiler) 146
JAD (file format) 147
JAMWiki 149
JGroups 151
JPicus 152
Java Class Library 153
Java Classloader 156
Java compiler 159
Java Development Kit 160
Java Interface Definition Language 163
Java resource bundle 163
Java TV 164
Java Work Framework 166
Java annotation 168
Java collections framework 172
Java concurrency 173
Java syntax 175
Java: View Technologies and Frameworks 198
JavaBeans Activation Framework 201
JavaThreads 201
javac 202
JavaFX 204
Jawin 208
JExamples 209
Jfig 210
Jikes 211
jnSynch 212

Michael Kölling 212
List of Java keywords 214
Marker interface pattern 220
Name mangling 221
Patrick Naughton 230
New I/O 231
Object type (object-oriented programming) 237
Omniscient Debugger 239
OpenJDK 239
PHP/Java Bridge 244
Java package 245
Parboiled (Java) 248
Plain Old Java Object 250
Pluggable look and feel 253
Primitive wrapper class 255
Project Semplice 256
Quark Framework 257
REPLAY (software) 266
Real time Java 268
Resource (Java) 269
Restlet 270
Retrotranslator 272
SLAMD 273
SLAMD Server 275
SLF4J 275
Bruno Souza 277
Static import 278
StormMQ 279
strictfp 280
String Buffer 281
Sun Web Developer Pack 283
Swing (Java) 284
SwingLabs 290
Synth Look and Feel 292
TeachScheme! 294
The Java Posse 297
Unified Expression Language 298
Java Virtual Machine 299

Xerlin 304
XStream 306
References
Article Sources and Contributors 308
Image Sources, Licenses and Contributors 313
Article Licenses
License 314

Java (programming language) 1
Java (programming language)
Paradigm Object-oriented, structured, imperative
Appeared in 1995
Designed by Sun Microsystems (Now owned by Oracle Corporation)
Developer James Gosling & Sun Microsystems
Stable release Java Standard Edition 6 (1.6.0_21) (July 7, 2010)
Typing discipline Static, strong, safe, nominative, manifest
Major
implementations
Dialects Generic Java, Pizza
Influenced by
Numerous; primarily: OpenJDK, HotSpot
Ada 83, C++, C#, [1] Delphi Object Pascal, [2] Eiffel, [3] Generic Java, Mesa, [4] Modula-3, [5] Objective-C, [6]
UCSD Pascal, [7] [8] Smalltalk
Influenced Ada 2005, BeanShell, C#, Clojure, D, ECMAScript, Groovy, J#, JavaScript, PHP, Python, Scala
OS Cross-platform (multi-platform)
License GNU General Public License / Java Community Process
Usual file extensions .java, .class, .jar
Website [9]
Java Programming at Wikibooks
Java is a programming language originally developed by James Gosling at Sun Microsystems
(which is now a subsidiary of Oracle Corporation) and released in 1995 as a core component
of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++
but has a simpler object model and fewer low-level facilities. Java applications are typically
compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless
of computer architecture. Java is a general-purpose, concurrent, class-based, object-oriented
language that is specifically designed to have as few implementation dependencies as possible.
It is intended to let application developers "write once, run anywhere". Java is currently one of
the most popular programming languages in use, and is widely used from application software
[10] [11]
to web applications.
Duke, the Java
The original and reference implementation Java compilers, virtual machines, and class libraries were developed by
Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun
relicensed most of its Java technologies under the GNU General Public License. Others have also developed
mascot
alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.

Java (programming language) 2
History
James Gosling and Patrick Naughton initiated the Java language project in June 1991 for use in one of his many
set-top box projects. [12] Java was originally designed for interactive television, but it was too advanced. [13] The
language was initially called Oak after an oak tree that stood outside Gosling's office; it went by the name Green
later, and was later renamed Java, from a list of random words. [14] Gosling aimed to implement a virtual machine
and a language that had a familiar C/C++ style of notation. [15]
Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run
Anywhere" (WORA), providing no-cost run-times on popular platforms. Fairly secure and featuring configurable
security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run
Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as
J2SE 1.2 in December 1998–1999), new versions had multiple configurations built for different types of platforms.
For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile
applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed
new J2 versions as Java EE, Java ME, and Java SE, respectively.
In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to
formalize Java, but it soon withdrew from the process. [16] Java remains a de facto standard, controlled through the
Java Community Process. [17] At one time, Sun made most of its Java implementations available without charge,
despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for
specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit
(SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the
compiler, utility programs, and header files.
On November 13, 2006, Sun released much of Java as open source software under the terms of the GNU General
Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free
software/open-source distribution terms, aside from a small portion of code to which Sun did not hold the
copyright. [18]
Sun's vice-president Rich Green has said that Sun's ideal role with regards to Java is as an "evangelist." [19]
Principles
There were five primary goals in the creation of the Java language: [20]
1. It should be "simple, object oriented, and familiar".
2. It should be "robust and secure".
3. It should be "architecture neutral and portable".
4. It should execute with "high performance".
5. It should be "interpreted, threaded, and dynamic".
Practices
Java Platform
One characteristic of Java is portability, which means that computer programs written in the Java language must run
similarly on any supported hardware/operating-system platform. This is achieved by compiling the Java language
code to an intermediate representation called Java bytecode, instead of directly to platform-specific machine code.
Java bytecode instructions are analogous to machine code, but are intended to be interpreted by a virtual machine
(VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE)
installed on their own machine for standalone Java applications, or in a Web browser for Java applets.

Java (programming language) 3
Standardized libraries provide a generic way to access host-specific features such as graphics, threading and
networking.
A major benefit of using bytecode is porting. However, the overhead of interpretation means that interpreted
programs almost always run more slowly than programs compiled to native executables would. Just-in-Time
compilers were introduced from an early stage that compile bytecodes to machine code during runtime. Over the
years, this JVM built-in feature has been optimized to a point where the JVM's performance competes with natively
compiled C code.
Implementations
Sun Microsystems officially licenses the Java Standard Edition platform for Linux, [21] Mac OS X, [22] and Solaris.
Although in the past Sun has licensed Java to Microsoft, the license has expired and has not been renewed. [23]
Through a network of third-party vendors and licensees, [24] alternative Java environments are available for these and
other platforms.
Sun's trademark license for usage of the Java brand insists that all implementations be "compatible". This resulted in
a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support RMI or JNI and
had added platform-specific features of their own. Sun sued in 1997, and in 2001 won a settlement of $20 million as
well as a court order enforcing the terms of the license from Sun. [25] As a result, Microsoft no longer ships Java with
Windows, and in recent versions of Windows, Internet Explorer cannot support Java applets without a third-party
plugin. Sun, and others, have made available free Java run-time systems for those and other versions of Windows.
Platform-independent Java is essential to the Java EE strategy, and an even more rigorous validation is required to
certify an implementation. This environment enables portable server-side applications, such as Web services, Java
Servlets, and Enterprise JavaBeans, as well as with embedded systems based on OSGi, using Embedded Java
environments. Through the new GlassFish project, Sun is working to create a fully functional, unified open source
implementation of the Java EE technologies.
Sun also distributes a superset of the JRE called the Java Development Kit (commonly known as the JDK), which
includes development tools such as the Java compiler, Javadoc, Jar and debugger.
Performance
Programs written in Java have a reputation for being slower and requiring more memory than those written in some
other languages. [26] However, Java programs' execution speed improved significantly with the introduction of
Just-in-time compilation in 1997/1998 for Java 1.1, [27] [28] [29] the addition of language features supporting better
code analysis (such as inner classes, StringBuffer class, optional assertions, etc.), and optimizations in the Java
Virtual Machine itself, such as HotSpot becoming the default for Sun's JVM in 2000.
To boost even further the speed performances that can be achieved using the Java language Systronix made JStik, [30]
a microcontroller based on the aJile Systems [31] line of embedded Java processors. In addition, the widely used ARM
family of CPUs has hardware support for executing Java bytecode through its Jazelle option.
Automatic memory management
Java uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines
when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer
in use. Once no references to an object remain, the unreachable memory becomes eligible to be freed automatically
by the garbage collector. Something similar to a memory leak may still occur if a programmer's code holds a
reference to an object that is no longer needed, typically when objects that are no longer needed are stored in
containers that are still in use. If methods for a nonexistent object are called, a "null pointer exception" is thrown. [32]
[33]

Java (programming language) 4
One of the ideas behind Java's automatic memory management model is that programmers can be spared the burden
of having to perform manual memory management. In some languages memory for the creation of objects is
implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. Either way, the responsibility
of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak
occurs. If the program attempts to access or deallocate memory that has already been deallocated, the result is
undefined and difficult to predict, and the program is likely to become unstable and/or crash. This can be partially
remedied by the use of smart pointers, but these add overhead and complexity. Note that garbage collection does not
prevent 'logical' memory leaks, i.e. those where the memory is still referenced but never used.
Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is guaranteed to be
triggered if there is insufficient free memory on the heap to allocate a new object; this can cause a program to stall
momentarily. Explicit memory management is not possible in Java.
Java does not support C/C++ style pointer arithmetic, where object addresses and unsigned integers (usually long
integers) can be used interchangeably. This allows the garbage collector to relocate referenced objects, and ensures
type safety and security.
As in C++ and some other object-oriented languages, variables of Java's primitive data types are not objects. Values
of primitive types are either stored directly in fields (for objects) or on the stack (for methods) rather than on the
heap, as commonly true for objects (but see Escape analysis). This was a conscious decision by Java's designers for
performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language.
However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their
wrapper class.
Syntax
The syntax of Java is largely derived from C++. Unlike C++, which combines the syntax for structured, generic, and
object-oriented programming, Java was built almost exclusively as an object oriented language. All code is written
inside a class and everything is an object, with the exception of the intrinsic data types (ordinal and real numbers,
boolean values, and characters), which are not classes for performance reasons.
Java suppresses several features (such as operator overloading and multiple inheritance) for classes in order to
simplify the language and to prevent possible errors and anti-pattern design.
Java uses similar commenting methods to C++. There are three different styles of comment: a single line style
marked with two slashes (//), a multiple line style opened with a slash asterisk (/*) and closed with an asterisk slash
(*/) and the Javadoc commenting style opened with a slash and two asterisks (/**) and closed with an asterisk slash
(*/). The Javadoc style of commenting allows the user to run the Javadoc executable to compile documentation for
the program.
Example:
//This is an example of a single line comment using two slashes
/* This is an example of a multiple line comment using the slash
and asterisk. This type of comment can be used to hold a lot of
information
or deactivate code but it is very important to remember to close the
comment. */
/** This is an example of a multiple line Javadoc comment
which allows compilation from Javadoc of this comment. */

Java (programming language) 5
Examples
Hello world
The traditional Hello world program can be written in Java as:
// Outputs "Hello, world!" and then exits
public class HelloWorld {
}
public static void main(String[] args) {
}
System.out.println("Hello world!");
Source files must be named after the public class they contain, appending the suffix .java, for example,
HelloWorld.java. It must first be compiled into bytecode, using a Java compiler, producing a file named
HelloWorld.class. Only then can it be executed, or 'launched'. The java source file may only contain one public class
but can contain multiple classes with less than public access and any number of public inner classes.
A class that is not declared public may be stored in any .java file. The compiler will generate a class file for each
class defined in the source file. The name of the class file is the name of the class, with .class appended. For class
file generation, anonymous classes are treated as if their name were the concatenation of the name of their enclosing
class, a $, and an integer.
The keyword public denotes that a method can be called from code in other classes, or that a class may be used by
classes outside the class hierarchy. The class hierarchy is related to the name of the directory in which the .java file
is.
The keyword static in front of a method indicates a static method, which is associated only with the class and not
with any specific instance of that class. Only static methods can be invoked without a reference to an object. Static
methods cannot access any method variables that are not static.
The keyword void indicates that the main method does not return any value to the caller. If a Java program is to exit
with an error code, it must call System.exit() explicitly.
The method name "main" is not a keyword in the Java language. It is simply the name of the method the Java
launcher calls to pass control to the program. Java classes that run in managed environments such as applets and
Enterprise JavaBean do not use or need a main() method. A java program may contain multiple classes that have
main methods, which means that the VM needs to be explicitly told which class to launch from.
The main method must accept an array of String objects. By convention, it is referenced as args although any other
legal identifier name can be used. Since Java 5, the main method can also use variable arguments, in the form of
public static void main(String... args), allowing the main method to be invoked with an arbitrary number of String
arguments. The effect of this alternate declaration is semantically identical (the args parameter is still an array of
String objects), but allows an alternative syntax for creating and passing the array.
The Java launcher launches Java by loading a given class (specified on the command line or as an attribute in a JAR)
and starting its public static void main(String[]) method. Stand-alone programs must declare this method explicitly.
The String[] args parameter is an array of String objects containing any arguments passed to the class. The
parameters to main are often passed by means of a command line.
Printing is part of a Java standard library: The System class defines a public static field called out. The out object is
an instance of the PrintStream class and provides many methods for printing data to standard out, including
println(String) which also appends a new line to the passed string.
The string "Hello, world!" is automatically converted to a String object by the compiler.

Java (programming language) 6
A more comprehensive example
// OddEven.java
import javax.swing.JOptionPane;
public class OddEven {
// "input" is the number that the user gives to the computer
private int input; // a whole number("int" means integer)
/*
* This is the constructor method. It gets called when an object of
the OddEven type
* is being created.
*/
public OddEven() {
/*
* Code not shown for simplicity. In most Java programs
constructors can initialize objects
* with default values, or create other objects that this object
might use to perform its
* functions. In some Java programs, the constructor may simply be
an empty function if nothing
* needs to be initialized prior to the functioning of the object.
In this program's case, an
* empty constructor would suffice, even if it is empty. A
constructor must exist, however if the
one.
}
* user doesn't put one in then the compiler will create an empty
*/
// This is the main method. It gets called when this class is run
through a Java interpreter.
public static void main(String[] args) {
/*
* This line of code creates a new instance of this class
called "number" (also known as an
* Object) and initializes it by calling the constructor. The
next line of code calls
you for a number
}
* the "showDialog()" method, which brings up a prompt to ask
*/
OddEven number = new OddEven();
number.showDialog();
public void showDialog() {
/*

Java (programming language) 7
dialog box
* "try" makes sure nothing goes wrong. If something does,
* the interpreter skips to "catch" to see what it should do.
*/
try {
/*
converted into
instead of a word.
calculate() that will
* The code below brings up a JOptionPane, which is a
* The String returned by the "showInputDialog()" method is
* an integer, making the program treat it as a number
* After that, this method calls a second method,
* display either "Even" or "Odd."
*/
input =
Integer.parseInt(JOptionPane.showInputDialog("Please Enter A Number"));
calculate();
} catch (NumberFormatException e) {
/*
* Getting in the catch block means that there was a
problem with the format of
of a number.
* the number. Probably some letters were typed in instead
*/
numerical value.");
}
/*
}
System.err.println("ERROR: Invalid input. Please type in a
* When this gets called, it sends a message to the interpreter.
* The interpreter usually shows it on the command prompt (For
Windows users)
}
* or the terminal (For Linux users).(Assuming it's open)
*/
private void calculate() {
}
if (input % 2 == 0) {
System.out.println("Even");
} else {
}
System.out.println("Odd");
• The import statement imports the JOptionPane class from the javax.swing package.
• The OddEven class declares a single private field of type int named input. Every instance of the OddEven class
has its own copy of the input field. The private declaration means that no other class can access (read or write) the

Java (programming language) 8
input field.
• OddEven() is a public constructor. Constructors have the same name as the enclosing class they are declared in,
and unlike a method, have no return type. A constructor is used to initialize an object that is a newly created
instance of the class.
• The calculate() method is declared without the static keyword. This means that the method is invoked using a
specific instance of the OddEven class. (The reference used to invoke the method is passed as an undeclared
parameter of type OddEven named this.) The method tests the expression input % 2 == 0 using the if keyword to
see if the remainder of dividing the input field belonging to the instance of the class by two is zero. If this
expression is true, then it prints Even; if this expression is false it prints Odd. (The input field can be equivalently
accessed as this.input, which explicitly uses the undeclared this parameter.)
• OddEven number = new OddEven(); declares a local object reference variable in the main method named
number. This variable can hold a reference to an object of type OddEven. The declaration initializes number by
first creating an instance of the OddEven class, using the new keyword and the OddEven() constructor, and then
assigning this instance to the variable.
• The statement number.showDialog(); calls the calculate method. The instance of OddEven object referenced by
the number local variable is used to invoke the method and passed as the undeclared this parameter to the
calculate method.
• input = Integer.parseInt(JOptionPane.showInputDialog("Please Enter A Number")); is a statement that
converts the type of String to the primitive data type int by using a utility function in the primitive wrapper class
Integer.
Special classes
Applet
Java applets are programs that are embedded in other applications, typically in a Web page displayed in a Web
browser.
// Hello.java
import javax.swing.JApplet;
import java.awt.Graphics;
public class Hello extends JApplet {
}
public void paintComponent(Graphics g) {
}
g.drawString("Hello, world!", 65, 95);
The import statements direct the Java compiler to include the javax.swing.JApplet and java.awt.Graphics classes
in the compilation. The import statement allows these classes to be referenced in the source code using the simple
class name (i.e. JApplet) instead of the fully qualified class name (i.e. javax.swing.JApplet).
The Hello class extends (subclasses) the JApplet (Java Applet) class; the JApplet class provides the framework for
the host application to display and control the lifecycle of the applet. The JApplet class is a JComponent (Java
Graphical Component) which provides the applet with the capability to display a graphical user interface (GUI) and
respond to user events.
The Hello class overrides the paintComponent(Graphics) method inherited from the Container superclass to
provide the code to display the applet. The paintComponent() method is passed a Graphics object that contains the
graphic context used to display the applet. The paintComponent() method calls the graphic context

Java (programming language) 9
drawString(String, int, int) method to display the "Hello, world!" string at a pixel offset of (65, 95) from the
upper-left corner in the applet's display.
Hello World Applet
An applet is placed in an HTML document using the HTML element. The applet tag has three attributes
set: code="Hello" specifies the name of the JApplet class and width="200" height="200" sets the pixel width and
height of the applet. Applets may also be embedded in HTML using either the object or embed element, [34] although
support for these elements by Web browsers is inconsistent. [35] However, the applet tag is deprecated, so the object
tag is preferred where supported.
The host application, typically a Web browser, instantiates the Hello applet and creates an AppletContext for the
applet. Once the applet has initialized itself, it is added to the AWT display hierarchy. The paintComponent()
method is called by the AWT event dispatching thread whenever the display needs the applet to draw itself.
Servlet
Java Servlet technology provides Web developers with a simple, consistent mechanism for extending the
functionality of a Web server and for accessing existing business systems. Servlets are server-side Java EE
components that generate responses (typically HTML pages) to requests (typically HTTP requests) from clients. A
servlet can almost be thought of as an applet that runs on the server side—without a face.
// Hello.java
import java.io.*;
import javax.servlet.*;
public class Hello extends GenericServlet {
public void service(ServletRequest request, ServletResponse
response)
}
}
throws ServletException, IOException {
response.setContentType("text/html");
final PrintWriter pw = response.getWriter();
pw.println("Hello, world!");
pw.close();
The import statements direct the Java compiler to include all of the public classes and interfaces from the java.io
and javax.servlet [36] packages in the compilation.

Java (programming language) 10
The Hello class extends the GenericServlet [37] class; the GenericServlet class provides the interface for the server
to forward requests to the servlet and control the servlet's lifecycle.
The Hello class overrides the service(ServletRequest, ServletResponse) [38] method defined by the Servlet [39]
interface to provide the code for the service request handler. The service() method is passed a ServletRequest [40]
object that contains the request from the client and a ServletResponse [41] object used to create the response returned
to the client. The service() method declares that it throws the exceptions ServletException [42] and IOException if a
problem prevents it from responding to the request.
The setContentType(String) [43] method in the response object is called to set the MIME content type of the
returned data to "text/html". The getWriter() [44] method in the response returns a PrintWriter object that is used
to write the data that is sent to the client. The println(String) method is called to write the "Hello, world!" string to
the response and then the close() method is called to close the print writer, which causes the data that has been
written to the stream to be returned to the client.
JavaServer Pages
JavaServer Pages (JSP) are server-side Java EE components that generate responses, typically HTML pages, to
HTTP requests from clients. JSPs embed Java code in an HTML page by using the special delimiters . A
JSP is compiled to a Java servlet, a Java application in its own right, the first time it is accessed. After that, the
generated servlet creates the response.
Swing application
Swing is a graphical user interface library for the Java SE platform. It is possible to specify a different look and feel
through the pluggable look and feel system of Swing. Clones of Windows, GTK+ and Motif are supplied by Sun.
Apple also provides an Aqua look and feel for Mac OS X. Where prior implementations of these looks and feels may
have been considered lacking, Swing in Java SE 6 addresses this problem by using more native GUI widget drawing
routines of the underlying platforms.
This example Swing application creates a single window with "Hello, world!" inside:
// Hello.java (Java SE 5)
import javax.swing.*;
public class Hello extends JFrame {
}
public Hello() {
}
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
add(new JLabel("Hello, world!"));
pack();
public static void main(String[] args) {
}
new Hello().setVisible(true);
The first import includes all of the public classes and interfaces from the javax.swing package.
The Hello class extends the JFrame class; the JFrame class implements a window with a title bar and a close
control.
The Hello() constructor initializes the frame by first calling the superclass constructor, passing the parameter "hello",
which is used as the window's title. It then calls the setDefaultCloseOperation(int) method inherited from JFrame

Java (programming language) 11
to set the default operation when the close control on the title bar is selected to
WindowConstants.EXIT_ON_CLOSE — this causes the JFrame to be disposed of when the frame is closed (as
opposed to merely hidden), which allows the JVM to exit and the program to terminate. Next, a JLabel is created for
the string "Hello, world!" and the add(Component) method inherited from the Container superclass is called to add
the label to the frame. The pack() method inherited from the Window superclass is called to size the window and lay
out its contents.
The main() method is called by the JVM when the program starts. It instantiates a new Hello frame and causes it to
be displayed by calling the setVisible(boolean) method inherited from the Component superclass with the boolean
parameter true. Once the frame is displayed, exiting the main method does not cause the program to terminate
because the AWT event dispatching thread remains active until all of the Swing top-level windows have been
disposed.
Generics
In 2004 generics were added to the Java language, as part of J2SE 5.0. Prior to the introduction of generics, each
variable declaration had to be of a specific type. For container classes, for example, this is a problem because there is
no easy way to create a container that accepts only specific types of objects. Either the container operates on all
subtypes of a class or interface, usually Object, or a different container class has to be created for each contained
class. Generics allow compile-time type checking without having to create a large number of container classes, each
containing almost identical code.
Class libraries
• Java libraries are the compiled
bytecodes of source code developed
by the JRE implementor to support
application development in Java.
Examples of these libraries are:
• The core libraries, which
include:
• Collection libraries that
implement data structures
such as lists, dictionaries,
trees and sets
• XML Processing (Parsing,
Transforming, Validating) libraries
• Security
• Internationalization and localization libraries
Java Platform and Class libraries diagram
• The integration libraries, which allow the application writer to communicate with external systems. These
libraries include:
• The Java Database Connectivity (JDBC) API for database access
• Java Naming and Directory Interface (JNDI) for lookup and discovery
• RMI and CORBA for distributed application development
• JMX for managing and monitoring applications
• User interface libraries, which include:
• The (heavyweight, or native) Abstract Window Toolkit (AWT), which provides GUI components, the
means for laying out those components and the means for handling events from those components

Java (programming language) 12
• The (lightweight) Swing libraries, which are built on AWT but provide (non-native) implementations of the
AWT widgetry
• APIs for audio capture, processing, and playback
• A platform dependent implementation of Java Virtual Machine (JVM) that is the means by which the byte codes
of the Java libraries and third party applications are executed
• Plugins, which enable applets to be run in Web browsers
• Java Web Start, which allows Java applications to be efficiently distributed to end-users across the Internet
• Licensing and documentation.
Documentation
Javadoc is a comprehensive documentation system, created by Sun Microsystems, used by many Java developers. It
provides developers with an organized system for documenting their code. Whereas normal comments in Java and C
are set off with /* and */, the multi-line comment tags, Javadoc comments have an extra asterisk at the beginning, so
that the tags are /** and */.
Editions
Java Card
Micro Edition (ME)
Standard Edition (SE)
Enterprise Edition (EE)
PersonalJava (discontinued)
Sun has defined and supports four editions of Java targeting different application environments and segmented many
of its APIs so that they belong to one of the platforms. The platforms are:
• Java Card for smartcards.
• Java Platform, Micro Edition (Java ME) — targeting environments with limited resources.
• Java Platform, Standard Edition (Java SE) — targeting workstation environments.
• Java Platform, Enterprise Edition (Java EE) — targeting large distributed enterprise or Internet environments.
The classes in the Java APIs are organized into separate groups called packages. Each package contains a set of
related interfaces, classes and exceptions. Refer to the separate platforms for a description of the packages available.
The set of APIs is controlled by Sun Microsystems in cooperation with others through the Java Community Process
program. Companies or individuals participating in this process can influence the design and development of the
APIs. This process has been a subject of controversy.
Sun also provided an edition called PersonalJava that has been superseded by later, standards-based Java ME
configuration-profile pairings.

Java (programming language) 13
See also
• Comparison of programming languages
• Comparison of Java and C++
• Comparison of Java and C#
• JavaOne
• Javapedia
• List of Java virtual machines
References
• List of Java APIs
• List of JVM languages
• C#
• Java version history
• Oak
• Jon Byous, Java technology: The early years [45] . Sun Developer Network, no date [ca. 1998]. Retrieved April
22, 2005.
• James Gosling, A brief history of the Green project [46] . Java.net, no date [ca. Q1/1998]. Retrieved April 29, 2007.
• James Gosling, Bill Joy, Guy Steele, and Gilad Bracha, The Java language specification, third edition.
Addison-Wesley, 2005. ISBN 0-321-24678-0 (see also online edition of the specification [47] ).
• Tim Lindholm and Frank Yellin. The Java Virtual Machine specification, second edition. Addison-Wesley, 1999.
ISBN 0-201-43294-3 (see also online edition of the specification [48] ).
External links
• Sun Microsystems: Java home page [49]
• Sun Microsystems: Developer Resources for Java Technology [50] .
• Chamber of Chartered Java Professionals International: Professionalism for Java Technology [51] .
• Sun Microsystems: Java Language Specification 3rd Edition [52] .
• Java SE 6 API Javadocs
• A Brief History of the Green Project [46]
• Michael O'Connell: Java: The Inside Story [53] , SunWord, July 1995.
• Patrick Naughton: Java Was Strongly Influenced by Objective-C [54] (no date).
• David Bank: The Java Saga [55] , Wired Issue 3.12 (December 1995).
• Shahrooz Feizabadi: A history of Java [56] in: Marc Abrams, ed., World Wide Web – Beyond the Basics, Prentice
Hall, 1998.
• Patrick Naughton: The Long Strange Trip to Java [57] , March 18, 1996.
• Open University (UK): M254 Java Everywhere [58] (free open content documents).
• is-research GmbH: List of programming languages for a Java Virtual Machine [59] .
• How Java's Floating-Point Hurts Everyone Everywhere [60] , by W. Kahan and Joseph D. Darcy, University of
California, Berkeley.
References
[1] Java 5.0 added several new language features (the enhanced for loop, autoboxing, varargs and annotations), after they were introduced in the
similar (and competing) C# language (http:/ / www. barrycornelius. com/ papers/ java5/ ) (http:/ / www. levenez. com/ lang/ )
[2] "About Microsoft's "Delegates"" (http:/ / java. sun. com/ docs/ white/ delegates. html). . Retrieved 2010-01-11. "We looked very carefully at
Delphi Object Pascal and built a working prototype of bound method references in order to understand their interaction with the Java
programming language and its APIs. [...] Our conclusion was that bound method references are unnecessary and detrimental to the language.
This decision was made in consultation with Borland International, who had previous experience with bound method references in Delphi
Object Pascal."
[3] "The Java Language Environment" (http:/ / java. sun. com/ docs/ white/ langenv/ Intro. doc1. html#943). May 1996. .
[4] "The Java Language Specification, 2nd Edition" (http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ intro. doc. html#237601). .
[5] "The A-Z of Programming Languages: Modula-3" (http:/ / www. computerworld. com. au/ index. php/
id;1422447371;pp;3;fp;4194304;fpid;1). Computerworld.com.au. . Retrieved 2010-06-09.

Java (programming language) 14
[6] Patrick Naughton cites Objective-C as a strong influence on the design of the Java programming language, stating that notable direct
derivatives include Java interfaces (derived from Objective-C's protocol) and primitive wrapper classes. (http:/ / cs. gmu. edu/ ~sean/ stuff/
java-objc. html)
[7] TechMetrix Research (1999). "History of Java" (http:/ / www. fscript. org/ prof/ javapassport. pdf). Java Application Servers Report. . "The
project went ahead under the name "green" and the language was based on an old model of UCSD Pascal, which makes it possible to generate
interpretive code"
[8] "A Conversation with James Gosling – ACM Queue" (http:/ / queue. acm. org/ detail. cfm?id=1017013). Queue.acm.org. 2004-08-31. .
Retrieved 2010-06-09.
[9] http:/ / www. oracle. com/ technetwork/ java/
[10] "Programming Language Popularity" (http:/ / www. langpop. com/ ). 2009. . Retrieved 2009-01-16.
[11] "TIOBE Programming Community Index" (http:/ / www. tiobe. com/ index. php/ content/ paperinfo/ tpci/ index. html). 2009. . Retrieved
2009-05-06.
[12] Byous, Jon (ca. 1998). "Java technology: The early years" (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html). Sun Developer
Network. Sun Microsystems. . Retrieved 2005-04-22.
[13] "The History of Java Technology" (http:/ / www. java. com/ en/ javahistory/ ). Sun Developer Network. ca. 1995. . Retrieved 2010-04-30.
[14] "Jonathan Schwartz's Blog: Different Isn't Always Better, But Better's Always Different" (http:/ / blogs. sun. com/ jonathan/ entry/
better_is_always_different). Blogs.sun.com. . Retrieved 2010-06-09.
[15] Heinz Kabutz, Once Upon an Oak (http:/ / www. artima. com/ weblogs/ viewpost. jsp?thread=7555). Artima. Retrieved April 29, 2007.
[16] Java Study Group (http:/ / www. open-std. org/ JTC1/ SC22/ JSG/ ); Why Java Was – Not – Standardized Twice (http:/ / csdl2. computer.
org/ comp/ proceedings/ hicss/ 2001/ 0981/ 05/ 09815015. pdf); What is ECMA—and why Microsoft cares (http:/ / techupdate. zdnet. com/
techupdate/ stories/ main/ 0,14179,2832719,00. html)
[17] "Java Community Process website" (http:/ / www. jcp. org/ en/ home/ index). Jcp.org. 2010-05-24. . Retrieved 2010-06-09.
[18] "JAVAONE: Sun – The bulk of Java is open sourced" (http:/ / open. itworld. com/ 4915/ 070508opsjava/ page_1. html). open.itworld.com. .
Retrieved 2010-06-09.
[19] "Sun’s Evolving Role as Java Evangelist" (http:/ / onjava. com/ pub/ a/ onjava/ 2002/ 04/ 17/ evangelism. html). O'Reilly Media. .
[20] "1.2 Design Goals of the JavaTM Programming Language" (http:/ / java. sun. com/ docs/ white/ langenv/ Intro. doc2. html). Java.sun.com.
1999-01-01. . Retrieved 2010-06-09.
[21] Andy Patrizio (2006). "Sun Embraces Linux With New Java License" (http:/ / www. internetnews. com/ dev-news/ article. php/ 3606656).
Internet News. Web Media Brands. . Retrieved 2009-09-29.
[22] "Java for Mac OS X" (http:/ / developer. apple. com/ java/ ). Apple Developer Connection. Apple. . Retrieved 2009-09-29.
[23] "Microsoft Java Virtual Machine Support" (http:/ / www. microsoft. com/ mscorp/ java/ default. mspx). Microsoft.com. . Retrieved
2010-06-09.
[24] "Java SE – Licensees" (http:/ / java. sun. com/ javase/ licensees. jsp). Java.sun.com. 2008-08-12. . Retrieved 2010-06-09.
[25] James Niccolai (January 23, 2001). "Sun, Microsoft settle Java lawsuit" (http:/ / www. javaworld. com/ javaworld/ jw-01-2001/
jw-0124-iw-mssuncourt. html). JavaWorld (IDG). . Retrieved 2008-07-09.
[26] Jelovic, Dejan. "Why Java Will Always Be Slower than C++" (http:/ / www. jelovic. com/ articles/ why_java_is_slow. htm). . Retrieved
2008-02-15.
[27] "Symantec's Just-In-Time Java Compiler To Be Integrated Into Sun JDK 1.1" (http:/ / www. symantec. com/ about/ news/ release/ article.
jsp?prid=19970407_03). .
[28] "Apple Licenses Symantec's Just In Time (JIT) Compiler To Accelerate Mac OS Runtime For Java" (http:/ / findarticles. com/ p/ articles/
mi_hb6676/ is_/ ai_n26150624). .
[29] "Java gets four times faster with new Symantec just-in-time compiler" (http:/ / www. infoworld. com/ cgi-bin/ displayStory. pl?980416.
ehjdk. htm). .
[30] "Official JStik Website" (http:/ / www. jstik. com/ ). Jstik.com. . Retrieved 2010-06-09.
[31] "aJile Systems Inc" (http:/ / www. ajile. com/ index. php?option=com_content& task=view& id=21& Itemid=28). Ajile.com. . Retrieved
2010-06-09.
[32] "NullPointerException" (http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ api/ java/ lang/ NullPointerException. html). Java.sun.com. . Retrieved
2010-06-09.
[33] "Exceptions in Java" (http:/ / www. artima. com/ designtechniques/ exceptions. html). Artima.com. . Retrieved 2010-08-10.
[34] "Using the applet Tag (The Java Tutorials > Deployment > Applets)" (http:/ / java. sun. com/ docs/ books/ tutorial/ deployment/ applet/
applettag. html). Java.sun.com. . Retrieved 2010-06-09.
[35] "Deploying Applets in a Mixed-Browser Environment (The Java Tutorials > Deployment > Applets)" (http:/ / java. sun. com/ docs/ books/
tutorial/ deployment/ applet/ mixedbrowser. html). Java.sun.com. . Retrieved 2010-06-09.
[36] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ package-summary. html
[37] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ GenericServlet. html
[38] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ Servlet. html#service(javax. servlet. ServletRequest,javax. servlet.
ServletResponse)
[39] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ Servlet. html
[40] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletRequest. html

Java (programming language) 15
[41] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletResponse. html
[42] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletException. html
[43] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletResponse. html#setContentType(java. lang. String)
[44] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletResponse. html#getWriter()
[45] http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html
[46] https:/ / duke. dev. java. net/ green/
[47] http:/ / java. sun. com/ docs/ books/ jls/ index. html
[48] http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ html/ VMSpecTOC. doc. html
[49] http:/ / www. java. com/
[50] http:/ / java. sun. com/
[51] http:/ / www. ccjpint. org/
[52] http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html
[53] http:/ / sunsite. uakom. sk/ sunworldonline/ swol-07-1995/ swol-07-java. html
[54] http:/ / cs. gmu. edu/ ~sean/ stuff/ java-objc. html
[55] http:/ / www. wired. com/ wired/ archive/ 3. 12/ java. saga. html
[56] http:/ / ei. cs. vt. edu/ ~wwwbtb/ book/ chap1/ java_hist. html
[57] http:/ / www. blinkenlights. com/ classiccmp/ javaorigin. html
[58] http:/ / computing. open. ac. uk/ m254/
[59] http:/ / www. is-research. de/ info/ vmlanguages/
[60] http:/ / www. eecs. berkeley. edu/ ~wkahan/ JAVAhurt. pdf
Web Language
HP's Web Language (formerly known as WebL and renamed to avoid a possible trademark conflict [1] ) is a
scripting language for automating tasks on the World-Wide Web. It is an imperative, interpreted programming
language implemented in Java and running on the Java Platform that has built-in support for common web protocols
like HTTP and FTP, and popular data types like HTML and XML.
External links
• Archived Web site [2]
References
[1] "FAQ - Why the name change?" (http:/ / web. archive. org/ web/ 20070428123803/ http:/ / www. hpl. hp. com/ downloads/ crl/ webl/ faq.
html#name). . Retrieved 2009-03-20.
[2] http:/ / web. archive. org/ web/ 20070507043202/ http:/ / www. hpl. hp. com/ downloads/ crl/ webl/ index. html

AgentSheets 16
AgentSheets
rule based visual programming
Paradigm object-oriented, educational, Conversational Programming
Appeared in 1999
Designed by Alexander Repenning
Stable
release
3.0 (February 7, 2010)
Influenced by Lisp, Logo, Smalltalk
Influenced Etoys, Scratch
OS OS X, Windows, Linux
Website http:/ / www. agentsheets. com
AgentSheets is an educational Cyberlearning [1] tool to create Web-based simulation games. AgentSheets is used
worldwide to teach students programming and related information technology skills through game design. The
built-in drag-and-drop language is accessible enough that students without programming background can make their
own simple Frogger-like game, and publish it on the Web, in their first session. At the same time, AgentSheets is
powerful enough to make sophisticated The Sims-like games with artificial intelligence. To transition from visual
programming to more traditional programming students can render their games into Java source code.
AgentSheets is supported by a middle and high school curriculum called Scalabable Game Design aligned with the
ISTE National Educational Technology Standards (NETS). The mission of this project is to reinvent computer
science in public schools by motivating & educating all students including women and underrepresented
communities to learn about computer science through game design starting at the middle school level. Through this
curriculum students build increasingly sophisticated games and, as part of this process, learn about computational
concepts at the level of computational thinking that are relevant to game design as well as to computational science.
The curriculum is made available through the Scalable Game Design Wiki [2] . Research investigating motivational
aspects of computer science education in public schools is currently exploring the introduction of game design in
representative regions of the USA including technology hubs, inner city, rural and remote/tribal areas. Previous
research has already found that game design with AgentSheets is universally accessible across gender as well as
ethnicity and is not limited to students interested in playing video games [3] .
The results [4] of the NSF ITEST program supported research investigating motivational and educational aspects of
introducing computer science at the middle school level are extremely positive in terms of motivational levels,
number of participants and participation of women and underrepresented communities. The participation is
extremely high because most middle schools participating in the study have made Scalable Game Design a module
that is part of existing required courses (e.g., computer power with keyboarding and power point). Many of the
middle schools instruct all of their students in scalable game design reaching in some schools over 900 students per

AgentSheets 17
year, per school. Of the well over 1000 students participating in the project in the first semester over 52% were girls.
Of the girls 85% enjoyed the scalable game design course and 78% would like to take another game design course.
Similar to a spreadsheet, an agentsheet is a computational grid. Unlike spreadsheets, this grid does not just contain
numbers and strings but so called agents. These agents are represented by pictures, can be animated, make sounds,
react to mouse/keyboard interactions, can read web pages, can speak and even recognize speech commands (Mac).
This grid is well suited to build computational science applications modeling complex scientific phenomena with up
to tens of thousands of agents. The grid is useful to build agent-based simulations including cellular automata or
diffusion-based models. These models are used in a wide variety of applications. How does a mudslide work? When
does a bridge collapse? How fragile are ecosystems? This ability to support game as well as computational science
applications with the inclusion of scientific visualizations makes AgentSheets a unique computational thinking tool
that is used computer science and STEM education.
This work including research, development and commercialization is supported by the National Science Foundation.
Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and
do not necessarily reflect the views of the National Science Foundation.
How AgentSheets is used
AgentSheets is used in a number of contexts worldwide:
• Middle school students create food web simulations to explore the
complexity of ecological systems
• Middle school computer clubs students build computer games
ranging from simple arcade classic such as Frogger to sophisticated
AI-based games such as The Sims.
• High school students use AgentSheets as story telling and
simulation tool of historical events such as the César Chávez grape
boycott [5]
• High school students simulate predator prey worlds and analyzed
data created with spreadsheets and plots
• After school science programs show students how to build their own
science simulations ranging from forest fire simulations to the spreading of viruses.
• High school students use AgentSheets as introduction to programming tool [6]
• Graduate and undergraduate courses on educational game design use AgentSheets to prototype, playtest, refine,
and publish simple educational games [7]
• Research exploring Artificial intelligence and collaborative agents, e.g., Antiobjects
History
The original goal of this research was to explore new models of computational thinking. The first prototype of
AgentSheets ran in 1989 at the University of Colorado, NCAR, Connection Machine 2. The Connection Machine is
a highly parallel computer with up to 64,000 CPUs. Realizing how hard it was to program the Connection Machine
the insight that "CPU cycles will always be ultimately cheaper than cognitive cycles" led to the exploration of
several new programming paradigms:
• Agent-Based Graphical Rewrite Rules: (1991) Behavior such as a train following train tracks can be specified
through before/after rules. These rules can be created by programming by example. The user would tell the
system to watch the train; the user would move the train on train track one step and stop recording; the system
would create the rule allowing trains to follow train tracks. Agent-Based Graphical Rewrite Rules were later also
used in the KidSim/Cocoa/Creator kid programming tool.

AgentSheets 18
• Semantical Rewrite Rules: (1994) It became clear that Agent-Based Graphical Rewrite Rules used in
AgentSheets91 and KidSim/Cocoa/Creator were not powerful enough for a number of applications that required
more general pattern. For instance, it was simple to create a rule to make a train follow a straight segment of train
track but the number of rules quickly exploded when trying to have trains follow all combinations of turns and
intersections. Semantic rewrite rules could interpret rules topologically. With a single rule a user could create a
complete train that follows train track behavior.
• Programming by Analogous Examples: (1995) New behavior can be created through analogies. For instance
the behavior of a car can be described as analogy to trains. A car moves on a road like a train on a train track. A
challenge to this approach is conceptual exception handling. Analogies are often either incomplete or too general.
This requires that users can refine programs produced by Programming by Analogous Examples.
• Tactile Programming: (1996) AgentSheets becomes the world's first drag and drop educational programming
environment. Drag and drop interfaces can be used to compose syntactically correct programs. In Visual
AgenTalk (VAT), a rule-based visual programming language, users create rules by dragging and dropping
conditions and actions from palettes. The tactile aspect of Visual AgenTalk allows users to perceive through drag
and drop what programs do. By dragging and dropping conditions, actions, rules and even methods onto agents
they see the consequence of invoking program fragment without having to write a test program. Similar drag and
drop programming can later be found in the Etoys language (part of Squeak), in Alice and in Scratch.
• AgentSheets Inc.: (1996) With the support of the National Science Foundation AgentSheets has become a
commercial product. The programming model has been extended, more interaction modalities have been added
(e.g., speech recognition (Mac)), scientific visualization has been refined (e.g., 3D real time plotting (Mac)), and
AgentSheets has been localized (e.g., Japanese and Greek).
• Scalable Game Design: (2008) A game design based free curriculum covering computational thinking ideas from
elementary to graduate school based on AgentSheets. The mission of Scalable Game Design is to: Reinventing
computer science in public schools by motivating & educating all students including women and
underrepresented communities to learn about computer science through game design starting at the middle school
level. The project is funded by the National Science Foundation.
• Conversational Programming: (2010) AgentSheets 3 is the world first programming environment supporting
computational thinking by providing information about the meaning of the program. Unlike visual programming
approaches, which only help with syntactic challenges, such as avoiding missing semicolons, Conversational
Programming helps with the semantics, that is the meaning of your program. Is this condition true right now?
Would this rule fire? Why does that rule fail? A conversational programming agent will tell all this and more in a
non intrusive kind of way.
See also
• Web based simulation (WBS)
External links
• Middle school students making games after 2 hours (YouTube HD movie) [8]
• AgentSheets papers [9]
• Educational use of AgentSheets in the Edutech Wiki [10]
• AgentSheets Inc [11]
• AgentSheets European Union Project (Greek) [12]

AgentSheets 19
References
[1] Cyberlearning defined by the National Science Foundation (http:/ / www. nsf. gov/ pubs/ 2008/ nsf08204/ nsf08204. pdf)
[2] Scalable Game Design Wiki (http:/ / scalablegamedesign. cs. colorado. edu/ wiki/ )
[3] publications related to the Scalable Game Design project (http:/ / scalablegamedesign. cs. colorado. edu/ wiki/ Publications)
[4] http:/ / scalablegamedesign. cs. colorado. edu/ gamewiki/ images/ 2/ 27/ Scalable_Game_Design_Results. pdf
[5] grape boycott project with simulation (http:/ / l3d. cs. colorado. edu/ systems/ agentsheets/ New-Vista/ grape-boycott/ )
[6] An example GK-12 NSF program using AgentSheets: the Memphis Tri-P-LETS project (http:/ / triplets. cs. memphis. edu/ index.
php?page=project)
[7] sample games called gamelets (http:/ / www. cs. colorado. edu/ ~ralex/ courses/ gamelet2006/ gamelets/ Space Invaders/ index. html)
[8] http:/ / www. youtube. com/ watch?v=hcS2CPrYUdY
[9] http:/ / www. cs. colorado. edu/ ~ralex/ papers/
[10] http:/ / edutechwiki. unige. ch/ en/ AgentSheets
[11] http:/ / www. agentsheets. com
[12] http:/ / www. agentsheets. gr
Oak (programming language)
Oak was a programming language created by James Gosling in 1991, initially for Sun Microsystems set-top box
project. The language later evolved to become Java.
The name Oak was used by Gosling after an oak tree that stood outside his office.
History
In 1991, Sun Microsystems was attempting to develop a new technology for programming next generation smart
appliances, which Sun expected to be a major new opportunity.
The team originally considered using C++, but rejected the idea for several reasons (see Java history).
Initially, Gosling attempted to modify and extend C++ but soon abandoned that in favor of creating a new platform
called Green and an entirely new language, which he called Oak, after the tree that stood just outside his office [1] .
By the summer of 1992, they were able to demonstrate portions of the new platform including the Green OS, the
Oak language, the libraries, and the hardware. Their first attempt, demonstrated on September 3, 1992, focused on
building a PDA device named Star7 star7 which had a graphical interface and a smart agent called "Duke" to assist the
user.
Oak was renamed Java in 1994 after a trademark search revealed that Oak was used by Oak Technology [2] . Java 1.0
was finally shipped in 1996 [3] .
Differences with Java
Oak was the basis for what Java 1.0 became later, but there were also some differences [4] [5] : Several concepts were
planned in the Oak specification but remained not implemented in the original language because of time constraints:
• unsigned primitive types turned out never to be implemented in Java [6] .
• The enum keyword for enumerated types was implemented in Java for Java 5.0.
• The assert keyword was implemented in Java for Java 1.4 [7]
Other concepts were different than, or improved later, for Java:
• abstract methods were defined as in C++.
• The package private access level did not exist in Oak. Classes with no access modifier were considered private.
And finally some concepts were later scraped out:
• All exceptions were unchecked.

Oak (programming language) 20
• It was possible by the unprotect keyword to write code that would not signal asynchronous exceptions.
See also
• Java (programming language)
• Java version history
External links
• Oak language specification [8]
• Alternative site for Oak language specification [9]
• Java early history [46]
References
[1] Jon Byous (April 2003). "Java Technology: The Early Years" (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html). Sun Microsystems. .
Retrieved 2009-08-02.
[2] Kieron Murphy (1996-04-10). "So why did they decide to call it Java?" (http:/ / www. javaworld. com/ javaworld/ jw-10-1996/
jw-10-javaname. html). javaworld.com. . Retrieved 2009-08-03. "The lawyers had told us that we couldn't use the name 'OAK' because [it was
already trademarked by] Oak Technologies," said Frank Yellin, a senior engineer at Sun. "So a brainstorming session was held to come up
with ideas for a new name"
[3] Jonathan I. Schwartz (2007-08-30). "Different Isn't Always Better, But Better's Always Different" (http:/ / blogs. sun. com/ jonathan/ entry/
better_is_always_different). . Retrieved 2009-08-02.
[4] Heinz Kabutz (2003-07-15). "Once Upon an Oak ..." (http:/ / www. artima. com/ weblogs/ viewpost. jsp?thread=7555). artima.com. .
Retrieved 2009-08-02.
[5] "Oak language specification" (https:/ / duke. dev. java. net/ green/ OakSpec0. 2. ps). Sun Microsystems. . Retrieved 2009-08-02.
[6] "Java and unsigned int, unsigned short, unsigned byte, unsigned long, etc. (Or rather, the lack thereof)" (http:/ / www. darksleep. com/ player/
JavaAndUnsignedTypes. html). . Retrieved 2009-08-02.
[7] "A Simple Assertion Facility For the Java Programming Language" (http:/ / java. sun. com/ docs/ books/ jls/ assert-spec. html). Sun
Microsystems. . Retrieved 2009-08-02.
[8] https:/ / duke. dev. java. net/ green/ OakSpec0. 2. ps
[9] http:/ / www. me. umn. edu/ ~shivane/ blogs/ cafefeed/ resources/ 14-jun-2007/ OakSpec0. 2. zip

Lightweight Java 21
Lightweight Java
Lightweight Java (LJ) is a fully-formalized and extensible minimal imperative fragment of Java. [1] [2] The language
was designed for academic purposes within the Computer Laboratory, University of Cambridge. The definition of LJ
was proven type-sound in Isabelle/HOL.
References
[1] http:/ / portal. acm. org/ citation. cfm?doid=1297027. 1297064
[2] http:/ / www. cl. cam. ac. uk/ research/ pls/ javasem/ lj/

.properties 22
.properties
Filename
extension
Type of format ASCII
.properties
.properties is a file extension for files mainly used in Java related technologies to store the configurable parameters
of an application. They can also be used for storing strings for Internationalization and localization; these are known
as Property Resource Bundles.
Each parameter is stored as a pair of strings, one storing the name of the parameter (called the key), and the other
storing the value.
Format
Each line in a .properties file normally stores a single property. Several formats are possible for each line, including
key=value, key = value, key:value, and key value.
.properties files can use the number sign (#) or the exclamation mark (!) as the first non blank character in a line to
denote that all text following it is a comment. The backwards slash is used to escape a character. An example of a
properties file is provided below.
# You are reading the ".properties" entry.
! The exclamation mark can also mark text as comments.
website = http://en.wikipedia.org/
language = English
# The backslash below tells the application to continue reading
# the value onto the next line.
message = Welcome to \
Wikipedia!
# Add spaces to the key
key\ with\ spaces = This is the value that could be looked up with the key "key with spaces".
# Unicode
tab : \u0009
In the example above, website would be a key, and its corresponding value would be
http://en.wikipedia.org/. While the number sign and the exclamation mark marks text as comments, it
has no effect when it is part of a property. Thus, the key message has the value Welcome to Wikipedia!
and not Welcome to Wikipedia. Note also that all of the whitespace in front of Wikipedia! is excluded
completely.
The encoding of a .properties file is ISO-8859-1, also known as Latin-1. All non-Latin-1 characters must be entered
by using Unicode escape characters, e. g. \uHHHH where HHHH is a hexadecimal index of the character in the
Unicode character set. This allows for using .properties files as resource bundles for localization. A non-Latin-1 text
file can be converted to a correct .properties file by using the native2ascii tool that is shipped with the JDK or by
using a tool, such as po2prop [1] , that manages the transformation from a bilingual localization format into .properties
escaping.

.properties 23
See also
• java.util.Properties.load(java.io.Reader) - gives the precise semantics of well-formed Java property files
• java.util.PropertyResourceBundle - describes property resource bundles
• YAML is used by some for more complex configuration formats.
References
[1] Translate Toolkit's po2prop (http:/ / translate. sourceforge. net/ wiki/ toolkit/ po2prop) converts native character encodings in a Gettext PO
file into correctly escaped ascii without the need for native2ascii

Apache Harmony 24
Apache Harmony
Developer(s) Apache Software Foundation
Stable release 5.0M14
6.0M2 / June 7, 2010
Development status Active
Written in C++ and Java
Operating system Windows and Linux
Type Java Virtual Machine and Java Library
License Apache License 2.0
Website http:/ / harmony. apache. org
Apache Harmony is an open source / free Java implementation from the Apache Software Foundation, starting with
Java SE 5 and 6. It will be licensed under the Apache License, Version 2. It was announced in early May 2005 and
on October 25, 2006, the Board of Directors voted to make Apache Harmony a top-level project.
History
Initiation
The Harmony project was initially conceived as an effort to unite all developers of the Free Java implementations.
Many developers expected that it would be the project above the GNU, Apache and other communities. GNU
developers were invited into and participated during the initial, preparatory planning. Later it was decided not to use
the code from GNU Classpath, and that Harmony would use an incompatible license; therefore blocking the sharing
of code between Harmony and existing free Java projects. Apache developers would then write the needed classes
from scratch and expect necessary large code donations from software companies.
Reasons for rewriting from scratch
The main reason for disagreements between the GNU Classpath and Apache projects is due to differences between
the GNU General Public License (GNU Classpath's license also contains the linking exception) and Apache License.
These disagreements are inspired by various organizations and individuals [1] that prefer the Apache License, which
allows for closed source derived works. GNU Classpath can also be linked [2] with proprietary code, but it is legally
difficult to make a closed source derivative of GNU Classpath itself. However, many free software developers think
that the licenses and philosophy of these communities are not different enough to split the efforts, and the inability to
find compromises is frequently estimated negatively. The occasionally appearing suggestion to view these projects
as opposing forces does not find wide support. Enthusiasts of the free software tend to break the discussion with the
simple words that "more free software is not a problem". [3]
Difficulties to obtain a TCK license from Sun
The Apache Software Foundation sent a letter to Sun Microsystems CEO, Jonathan Schwartz, on April 10, 2007,
regarding their inability to acquire an acceptable license for the Java SE 5 Technology Compatibility Kit (TCK), a
test kit needed by the project to demonstrate compatibility with the Java SE 5 specification, as required by the Sun
specification license for Java SE 5. [4] What makes the license unacceptable for ASF is the fact that it imposes rights
restrictions through limits on the "field of use" available to users of Harmony, not compliant with the Java
Community Process rules. [5]

Apache Harmony 25
Sun answered on a company blog [6][7] that it intended to create an open source implementation of the Java
platform under GPL, including the TCK, but that their current priority was to make the Java Platform accessible to
the GNU/Linux community under GPL as quickly as possible.
This answer triggered some reactions, either criticizing Sun for not responding "in a sufficiently open manner" to an
open letter [8], or rather Apache Software Foundation; some think that ASF acted unwisely to aggressively demand
something they could have obtained with more diplomacy from Sun, especially considering the timescale of the
opening class library [9] [10] .
Since Sun's release of OpenJDK, Sun has released a specific license to allow to run the TCK in the OpenJDK context
for any GPL implementation deriving substantially from OpenJDK [11] .
Use in Android SDK
Dalvik, the Virtual Machine used in Google's Android platform, use a subset of Harmony for the core of its Class
Library [12] . However, Dalvik does not align to Java SE nor Java ME Class Library profiles (for example J2ME
classes, AWT and Swing are not supported). Instead it uses its own library [13] , built on top of a subset of Harmony.
Development team
Apache Harmony started from being mostly developed by several companies, receiving large code contributions at
once. However, the general discussions on the mailing lists were always opened for everyone, and later the Apache
Software foundation mentors put a lot of effort [14] to bring the development process more in line with the Apache
way, [15] and it seems that their efforts were highly successful. In November 1, 2006, the current team of committers
consisted of 16 developers, 12 of them from IBM and Intel. [16]
Recent development status
Apache Harmony was accepted among the official Apache projects on 29 October 2006.
Architecture
The Dynamic Runtime Layer virtual machine consists of the following components:
1. The VM core: with its subcomponents concentrates most of the JVM control functions.
2. The porting layer: hides platform-specific details from other VM components behind a single interface and is
based on the Apache Portable Runtime layer.
3. The Garbage Collector: allocates Java objects in the heap memory and reclaims unreachable objects using
various algorithms
4. Execution Manager: selects the execution engine for compiling a method, handles profiles and the dynamic
recompilation logic.
5. Class Library: is a Java standard library.
6. The thread manager that handle Operating system threading
7. The execution engine: consists of the following:
1. The just-in-time compiler for compilation and execution of method code.
2. The interpreter for easier debugging.

Apache Harmony 26
Support Platform and Operating System
The project provide a portable implementation that ease development on many platforms and operating systems. The
main focus is on Windows and Linux operating systems on x86 and x86-64 architectures. [17]
IA32 (Pentium III or
better)
x86-64 (Intel 64,
AMD64)
Windows
2000
In progress
Windows XP, Server 2003,
Vista
Linux RHEL, SLES, Debian,
Gentoo, Fedora
Yes Yes
FreeBSD AIX Mac OS
In
progress
X
N/A N/A
N/A Yes Yes N/A N/A N/A
Itanium (IA64, IPF) N/A In progress Yes N/A N/A N/A
PPC32 N/A N/A In progress N/A N/A N/A
PPC64
N/A N/A
In progress
N/A
In
progress
zSeries (31 bit) N/A N/A In progress N/A N/A N/A
Class Library Coverage
The expected donations from software companies were
actually received. The Apache Harmony now contains the
working code, including the Swing, AWT and Java 2D
code which were contributed by Intel.
The part of the implemented classes is still smaller than in
GNU Classpath (97.7% in the trunk versus almost 100%
as of July 2007 [18] ), despite some non-trivial applications
were shown being running in 2006 JavaOne international
conference.
Also Harmony's test suite is less extensive than GNU
Classpath's for now (20000 tests [19] versus 50000 [20] as of October 2006).
Java Platform diagram showing Class Library
The progress of the Apache Harmony project can be tracked against J2SE 1.4 and Java SE 5.0. [21] Also, there is a
branch for Harmony v6.0 in development for Java SE 6.0.
Apache Harmony developers integrate several existing, field-tested open-source projects to meet their goal (not
reinventing the wheel). Many of these projects are mature and well known and other part of the library need be
writing from scratch.
This is a list of existing open source components that are used in the Apache Harmony project; some of them were in
use before the project started.
N/A

Apache Harmony 27
Component Description
ICU Mature C/C++ and Java libraries for Unicode support, software internationalization and software globalization.
Apache Xalan An XSLT stylesheet processor for Java and C++ which implements the XPath language.
Apache Xerces An XML parser library for Java, C++ and Perl
Apache Portable
Runtime
Cross-platform abstraction library provides platform independence.
Apache CXF Robust and high performance Web Services framework work over protocols such as SOAP, XML/HTTP, RESTful HTTP,
and CORBA.
BCEL Libraries for decomposing, modifying, and recomposing binary Java classes (i.e., bytecode)
MX4J Java Management Extensions (JMX) tools for managing and monitoring applications, system objects, devices and service
oriented networks.
vmmagic Set of extensions to the Java language to facilitate systems programming in Java by adding direct memory operations etc.
Bouncy Castle Libraries collection of lightweight cryptography for Java and C#.
ANTLR language tool that provides a framework for constructing recognizers, interpreters, compilers, and translators from
Documentation
grammatical descriptions containing actions in a variety of target languages.
Harmony is currently less documented than the alternative free Java implementations. For instance, in GNU
Classpath every method of the central CORBA class (ORB) has the explaining comment both in the standard
abstract API class [22] and implementation [23]. In the Yoko [24] project, used by Harmony [25], the majority of
methods both in the standard declaration [26] and implementing class [27] were not documented (at the end of
October, 2006). Also, GNU Classpath supported both older and current CORBA features (same as Sun's
implementation). Harmony, differently, left the central method of the older standard (ORB.connect(Object)) fully
unimplemented.
Tools
A complete implementation of the Java platform also requires a compiler that translates Java source code into
bytecodes, a program that manages JAR files, a debugger, and an applet viewer and web browser plugin, to name a
few. Harmony currently has the compiler, appletviewer, jarsigner, javah, javap, keytool, policytool, and unpack200
[28].
Virtual machine support
Harmony currently has seven virtual machine implementations that run Harmony Class Library, all of which were
donations by external groups:
• JC Harmony Edition VM, "JCHEVM," based on the JCVM's interpreter, contributed by the author, Archie Cobbs.
• BootJVM, a simple bootstrapping virtual machine, contributed by Daniel Lydick.
• SableVM, an advanced, portable interpreter, contributed by authors from the Sable Research Group; and the
Dynamic Runtime Layer Virtual Machine.
• DRLVM, a just-in-time compiler contributed by Intel.
• BEA announced the availability of an evaluation version of JRockit VM running Apache Harmony Class
Library [29] .
• JikesRVM, an open-source meta-circular JVM that use the Apache Harmony Class Library [30] .
• Ja.NET SE - the open source project is providing a Java 5 JDK (class libraries, tools, etc.) that run on the .NET
CLR. Ja.NET SE is based on the Apache Harmony Class Libraries [31] .

Apache Harmony 28
In the end of November, 2006, the language support provided by these virtual machine was still incomplete, and the
build instructions recommended to use IBM's proprietary J9 instead to run the class library test suite. However, this
is not necessary anymore (as of July 2007). The DRLVM virtual machine is currently (as of July 2006) under heavy
development, so a fast improvement of its features can be expected.
Applications status
Since its conception, Harmony has steadily grown in its ability to execute non-trivial Java applications (see here
[32] ). As of July 2007, supported applications include:
• Eclipse : 99.3% of the 36000 RI test pass on Harmony's DRLVM + class library. [33].
• Apache Tomcat : 100% of the RI tests pass [34].
• JUnit : 100% of the RI tests pass [35].
• Apache Ant : 97% of the RI tests pass. [36].
• other applications pass with a high success rate, such as Apache Derby, Apache Axis, Log4j, Apache Velocity,
Apache Cocoon, jEdit, and Apache Commons.
However, Harmony's incomplete library prevents it from launching some other applications:
• ArgoUML: because it requires a Java applet implementation, which is still not available in Harmony.
• Apache Geronimo runs on Apache Harmony with some issues and workarounds [37] .
• Vuze, formerly Azureus, because of unimplemented security classes.
See also
• GNU Classpath
• List of Java virtual machines
• Free Java implementations
• Java Class Library
External links
• Official website [38]
• Apache Harmony FAQ [39]
• Apache Harmony source code repository [40]
• JavaOne 2006 Online Harmony Session [41]
• JavaOne 2007 Online Harmony Session [42]
• Apache Harmony [43] by Geir Magnusson Jr at JavaPolis 2006
• The Java open source debate [44] - a good summary of the debate
References
[1] Mark Wielaard (2006-05-24). "Toward a free Java" (http:/ / lwn. net/ Articles/ 184967/ ). LWN.net. .
[2] "GNU Classpath License" (http:/ / www. gnu. org/ software/ classpath/ license. html). .
[3] Dalibor Topic (2006-06-01). "Harmony, JavaONE 2007 and other thoughts" (http:/ / developer. classpath. org/ pipermail/ classpath/
2006-June/ 000965. html). .
[4] Open Letter to Sun Microsystems (http:/ / www. apache. org/ jcp/ sunopenletter. html)
[5] According to ASF, 1) a specification lead cannot impose any contractual condition or covenant that would limit or restrict the right of any
licensee to create or distribute such Independent Implementations (section 5.C.III), and 2) a specification lead must license all necessary IP
royalty-free to any compatible implementation of a specification (section 5.B).
[6] http:/ / blogs. sun. com/ ontherecord/
[7] http:/ / java. sys-con. com/ read/ 360602. htm
[8] http:/ / ianskerrett. wordpress. com/ 2007/ 04/ 16/ the-silence-from-an-open-sun/
[9] http:/ / gnu. wildebeest. org/ diary/ 2007/ 04/ 21/ openjck/

Apache Harmony 29
[10] Gilbert, Dave (2007-04-16). "Five Reasons Why Apache Will Regret That Open Letter" (http:/ / jroller. com/ page/
dgilbert?entry=five_reasons_why_apache_will). . Retrieved 2008-03-08.
[11] "OPENJDK COMMUNITY TCK LICENSE AGREEMENT V 1.1" (http:/ / openjdk. java. net/ legal/ openjdk-tck-license. pdf) (PDF). Sun
Microsystems. . Retrieved 2008-03-08. "Subject to and conditioned upon its Licensee Implementation being substantially derived from
OpenJDK Code and, if such Implementation has or is to be distributed to a third party, its being distributed under the GPL License, Sun
hereby grants to Licensee, to the extent of Sun's Intellectual Property Rights in the TCK, a worldwide, personal, non-exclusive,
non-transferable, limited license to use the TCK internally and solely for the purpose of developing and testing Licensee Implementation."
[12] "Google's Android SDK Bypasses Java ME in Favor of Java Lite and Apache Harmon" (http:/ / www. infoq. com/ news/ 2007/ 11/
android-java). infoq.com. 2007-11-12. . Retrieved 2009-05-31. "Instead of providing a full version of the Java SE or Java ME Google has
diverged on two fronts. First, a limited subset of the core Java packages is provided. (...) By going this route Android is following in the
footsteps of another Google project GWT which uses Java as its development language but does not support the full JDK."
[13] "Package Index" (http:/ / developer. android. com/ reference/ packages. html). Open Handset Alliance. . Retrieved 2009-05-31.
[14] Leo Simons (2006-07-24). ""We would like all the development to happen right here"" (http:/ / article. gmane. org/ gmane. comp. java.
harmony. devel/ 10742). .
[15] "The Apache Way" (http:/ / incubator. apache. org/ learn/ theapacheway. html). .
[16] "List of Apache Harmony Committers" (http:/ / incubator. apache. org/ harmony/ contributors. html). .
[17] Apache Harmony supported platforms and operating systems (http:/ / harmony. apache. org/ supported_platforms. html)
[18] that a class is implemented does not imply that this class behaves as requested in the RI but the empty declaration is not an implemented
method - some core functionality must be present. GNU Classpath uses special class of exception to mark stubs and do not count them as
implemented methods
[19] http:/ / wiki. apache. org/ harmony/ Unit_Tests_Pass_on_DRLVM
[20] http:/ / www. object-refinery. com/ classpath/ mauve/ report/
[21] Apache Harmony Library Coverage against Java SE 5.0 (http:/ / people. apache. org/ ~chunrong/ latest-harmony-japi. html)
[22] http:/ / cvs. savannah. gnu. org/ viewcvs/ *checkout*/ classpath/ org/ omg/ CORBA/ ORB. java?rev=1. 2. 2. 12& root=classpath
[23] http:/ / cvs. savannah. gnu. org/ viewcvs/ *checkout*/ classpath/ gnu/ CORBA/ OrbFunctional. java?rev=1. 6& root=classpath
[24] http:/ / incubator. apache. org/ yoko/
[25] http:/ / www. mail-archive. com/ yoko-dev@incubator. apache. org/ msg01428. html
[26] http:/ / svn. apache. org/ repos/ asf/ incubator/ yoko/ trunk/ yoko-spec-corba/ src/ main/ java/ org/ omg/ CORBA/ ORB. java
[27] http:/ / svn. apache. org/ repos/ asf/ incubator/ yoko/ trunk/ core/ src/ main/ java/ org/ apache/ yoko/ orb/ OBCORBA/ ORB_impl. java
[28] http:/ / incubator. apache. org/ harmony/ roadmap. html#General
[29] BEA JRockit VM under a binary, evaluation-only license (http:/ / mail-archives. apache. org/ mod_mbox/ harmony-dev/ 200701. mbox/
)
[30] Announcing Jikes RVM 3.0 + Apache Harmony (http:/ / mail-archives. apache. org/ mod_mbox/ harmony-dev/ 200808. mbox/
)
[31] Ja.NET SE an open source project is providing a Java 5 JDK running on the .NET CLR (http:/ / www. janetdev. org/ )
[32] http:/ / wiki. apache. org/ harmony/ Application_Status
[33] http:/ / wiki. apache. org/ harmony/ Eclipse_Unit_Tests_Pass_on_DRLVM#PassRate_2007
[34] http:/ / wiki. apache. org/ harmony/ Apache_Tomcat
[35] http:/ / wiki. apache. org/ harmony/ JUnit
[36] http:/ / wiki. apache. org/ harmony/ Apache_Ant
[37] Running Geronimo on Harmony (http:/ / cwiki. apache. org/ confluence/ display/ GMOxDOC20/ Apache+ Harmony)
[38] http:/ / harmony. apache. org/
[39] http:/ / mail-archives. apache. org/ mod_mbox/ incubator-general/ 200505. mbox/
%3CE3603144-2C26-4C31-896D-6CC7445A63EB@apache. org%3E
[40] http:/ / svn. apache. org/ viewcvs. cgi/ incubator/ harmony/ enhanced/ classlib/ trunk/ modules/
[41] http:/ / developers. sun. com/ learning/ javaoneonline/ 2006/ coreplatform/ TS-3752. html
[42] http:/ / developers. sun. com/ learning/ javaoneonline/ j1sessn. jsp?sessn=TS-7820& yr=2007& track=6
[43] http:/ / parleys. com/ display/ PARLEYS/ Apache+ Harmony?showComments=true
[44] http:/ / www. osnews. com/ story. php?news_id=10806

Apache Muse 30
Apache Muse
The Apache Muse Project is a Java-based implementation of the Web Services Resource Framework (WSRF),
WS-BaseNotification (WSN), and Web Services Distributed Management (WSDM) specifications.
See also
• Service-oriented architecture (SOA)
• Apache Tomcat (Servlet Container)
• SOAP (Simple Object Access Protocol)
• WSDL (Web Service Description Language)
External links
• Homepage of Apache Muse [1]
• Homepage of the Web Services Project @ Apache [2]
• Homepage of Apache Axis [3]
• Homepage of Apache Axis2 [4]
• SAAJ from Sun [5]
• Lomboz-Plugin for Eclipse [6]
References
[1] http:/ / ws. apache. org/ muse/
[2] http:/ / ws. apache. org/
[3] http:/ / ws. apache. org/ axis
[4] http:/ / ws. apache. org/ axis2/
[5] http:/ / java. sun. com/ webservices/ saaj/ index. jsp
[6] http:/ / lomboz. objectweb. org/

Apache Shiro 31
Apache Shiro
Developer(s) Apache Software Foundation
Stable release incubation / March 4, 2009
Written in Java
Operating
system
Cross-platform
Type java security framework
License Apache License 2.0
Website [1]
Apache Shiro (formerly known as jSecurity and Apache KI) is a java security framework designed to have a clean
object model, and easy to plugin. Apache Ki has been renamed to Apache Shiro . [2]
Overview
Shiro is designed to be easier to use than JAAS and to be accessible to non-java applications. Shiro supports Role
and User permissions, and has bindings for web applications (JSecurityFilter). The permissions can be stored on a
LDAP or on a database (via JDBC). It also integrates with Spring framework
Example
//Permissions can be checked using object-based permissions
PrinterPermission perm = new PrinterPermission("hplaserjet");
if(perm.isPermitted()) {
//show print button
} else {
}
See also
//grey out button
• Java Authentication and Authorization Service (JAAS)
• Enterprise_JavaBean#Security EJB Container-Managed Security
• JGuard [3] , an LGPL-licensed security framework
• Spring Security, an Apache-licensed Java security framework
External links
• Apache Shiro homepage [1]
• Apache Shiro Presentation [4]
• JSecurity Tutorial by Bruce Philips [5]

Apache Shiro 32
References
[1] http:/ / incubator. apache. org/ shiro/
[2] "Ki to Shiro renaming vote" (http:/ / n2. nabble. com/ Apache-JSecurity-Ki-Project-Rename---VOTE-RESULT-td3057020. html#a3057020).
.
[3] http:/ / jguard. xwiki. com/ xwiki/ bin/ view/ Main/ WebHome
[4] http:/ / www. jsecurity. org/ files/ JSecurity. pdf
[5] http:/ / www. brucephillips. name/ blog/ index. cfm/ 2009/ 4/ 5/ An-Introduction-to-Ki-formerly-JSecurity--A-Beginners--Tutorial-Part-1
Java applet
A Java applet is an applet delivered to the users in the form of Java
bytecode. Java applets can run in a Web browser using a Java Virtual
Machine (JVM), or in Sun's AppletViewer, a stand-alone tool for
testing applets. Java applets were introduced in the first version of the
Java language in 1995. Java applets are usually written in the Java
programming language but they can also be written in other languages
that compile to Java bytecode such as Jython, [7] Ruby, [8] or Eiffel. [9]
Applets are used to provide interactive features to web applications
that cannot be provided by HTML alone. They can capture mouse
input (like rotating 3D object) and also have controls like buttons or
check boxes. In response to the user action an applet can change the
provided graphic content. This makes applets well suitable for
demonstration, visualization and teaching. There are online applet
collections for studying various subjects, from physics [10] to heart
physiology. [3] Applets are also used to create online game collections
that allow players to compete against live opponents in real-time.
An applet can also be a text area only, providing, for instance, a cross
platform command-line interface to some remote system. [11] If needed,
an applet can leave the dedicated area and run as a separate window.
However, applets have very little control over web page content
outside the applet dedicated area, so they are less useful for improving
the site appearance in general (while applets like news tickers [12] or
WYSIWYG editors [13] are also known). Applets can also play media in
formats that are not natively supported by the browser [14]
Java applets run at a speed that is comparable to (but generally slower
than) other compiled languages such as C++, but many times faster
than JavaScript. [15] In addition they can use 3D hardware acceleration
that is available from Java. This makes applets well suited for non
trivial, computation intensive visualizations.
HTML pages may embed parameters that are passed to the applet.
Hence the same applet may appear differently depending on the
parameters that were passed. The first implementations involved
downloading an applet class by class. While classes are small files,
Java applet that was created as a supplementary
demonstration material of the scientific
publication. [1] and is available from the
university site
Java applet that uses 3D hardware acceleration,
downloading from the server 3D files in .pdb
format to visualize [2]

Java applet 33
there are frequently a lot of them, so applets got a reputation as slow
loading components. However, since jars were introduced, an applet is
usually delivered as a single file that has a size of the bigger image
(hundreds of kilobytes to several megabytes).
Since Java's bytecode is platform independent, Java applets can be
executed by browsers for many platforms, including Microsoft
Windows, Unix, Mac OS and Linux. It is also trivial to run a Java
applet as an application with very little extra code. This has the
advantage of running a Java applet in offline mode without the need
for any Internet browser software and also directly from the
development IDE.
Many Java developers, blogs and magazines are recommending that
[16] [17]
the Java Web Start technology be used in place of Applets.
A Java Servlet is sometimes informally compared to be "like" a
server-side applet, but it is different in its language, functions, and in
each of the characteristics described here about applets.
Technical information
Java applets are executed in a sandbox by most web browsers,
preventing them from accessing local data like clipboard or file system.
The code of the applet is downloaded from a web server and the
browser either embeds the applet into a web page or opens a new
window showing the applet's user interface.
A Java applet extends the class java.applet.Applet, or in the case of a
Swing applet, javax.swing.JApplet. The class must override methods
from the applet class to set up a user interface inside itself (Applet is a
descendant of Panel which is a descendant of Container. As applet
inherits from container, it has largely the same user interface
possibilities as an ordinary Java application, including regions with
user specific visualization.
The domain from where the applet executable has been downloaded is
the only domain to which the usual (unsigned) applet is allowed to
communicate. This domain can be different from the domain where the
surrounding HTML document is hosted.
Using applet for non trivial
animation illustrating
biophysical topic (randomly
moving ions pass through
voltage gates) [3]
Using Java applet for computation - intensive
visualization of the Mandelbrot set [4]
Java system libraries and runtimes are backwards compatible, allowing to write code that runs both on current and on
future versions of the Java virtual machine.
Embedding into web page
The applet can be displayed on the web page by making use of the deprecated applet HTML element, [18] or the
recommended object

Java applet 34
element. [19] A non standard embed element can be used [20] with
Mozilla family browsers. This specifies the applet's source and
location. Object and embed tags can also download and install Java
virtual machine (if required) or at least lead to the plugin page. Applet
and object tags also support loading of the serialized applets that start
in some particular (rather than initial) state. Tags also specify the
message that shows up in place of the applet if the browser cannot run
it due any reason.
However, despite object being officially a recommended tag, as of
2010, the support of the object tag was not yet consistent among
browsers and Sun kept recommending the older applet tag for
deploying in multibrowser environments, [20] as it remained the only
tag consistently supported by the most popular browsers. To support
multiple browsers, the object tag currently requires JavaScript (that
recognizes the browser and adjusts the tag), usage of additional
browser-specific tags or delivering adapted output from the server side.
Deprecating applet tag has been criticised. [21] Oracle now provides a
maintained JavaScript code [22] to launch applets with cross platform
workarounds.
Simple examples
A basic example using the java.applet package
The following example is made simple enough to illustrate the
essential use of Java applets through its java.applet package. It also
uses classes from the Java Abstract Window Toolkit (AWT) for
producing actual output (in this case, the "Hello, world!" message).
import java.applet.Applet;
import java.awt.*;
// Applet code for the "Hello, world!" example.
// This should be saved in a file named as "HelloWorld.java".
public class HelloWorld extends Applet {
Sufficient running speed is also utilized in applets
for playing non trivial computer games like
chess [5]
NASA World Wind (open source) is a second
generation applet [6] that makes heavy use of
OpenGL and on-demand data downloading to
provide a detailed 3D map of the world.
// This method is mandatory, but can be empty (i.e., have no actual
Web access to the server console at the hardware
code).
level with the help of a Java applet
public void init() { }
// This method is mandatory, but can be empty.
public void stop() { }
// Print a message on the screen (x=20, y=10).
public void paint(Graphics g) {

Java applet 35
}
}
g.drawString("Hello, world!", 20,10);
More simple applets are available at Wikiversity [23] .
For compilation, this code is saved on a plain-ASCII file with the same name as the class and .java extension, i.e.
HelloWorld.java. The resulting HelloWorld.class applet should be installed on the web server and is
invoked within an HTML page by using an or an tag. For example:
HelloWorld_example.html
A Java applet example
Here it is:
This is where HelloWorld.class runs.
Displaying the HelloWorld_example.html page from a Web server, the result should look as this:
A Java applet example
Here it is: Hello, world!
To minimize download time, applets are usually delivered in a form of compressed zip archive (having jar
extension). If all needed classes (only one in our case) are placed in compressed archive example.jar, the embedding
code would look differently:
Here it is:
This is where HelloWorld.class runs.
Applet inclusion is described in detail in Sun's official page about the APPLET tag. [24]
Advantages
A Java applet can have any or all of the following advantages:
• It is simple to make it work on Linux, Microsoft Windows and Mac OS X i.e. to make it cross platform. Applets
are supported by most web browsers.
• The same applet can work on "all" installed versions of Java at the same time, rather than just the latest plug-in
version only. However, if an applet requires a later version of the Java Runtime Environment (JRE) the client will
be forced to wait during the large download.
• Most web browsers cache applets, so will be quick to load when returning to a web page. Applets also improve
with use: after a first applet is run, the JVM is already running and starts quickly (the JVM will need to restart
each time the browser starts afresh).
• It can move the work from the server to the client, making a web solution more scalable with the number of
users/clients.

Java applet 36
• If a standalone program (like Google Earth) talks to a web server, that server normally needs to support all
previous versions in case a user has not kept his or her client software up to date. In contrast, a properly
configured browser loads (and caches) the latest applet version, so there is no need to support legacy versions.
• The applet naturally supports the changing user state, such as figure positions on the chessboard.
• Developers can develop and debug an applet direct simply by creating a main routine (either in the applet's class
or in a separate class) and calling init() and start() on the applet, thus allowing for development in their favorite
Java SE development environment. All one has to do after that is re-test the applet in the AppletViewer program
or a web browser to ensure it conforms to security restrictions.
• An untrusted applet has no access to the local machine and can only access the server it came from. This makes
such an applet much safer to run than a standalone executable that it could replace. However, a signed applet can
have full access to the machine it is running on if the user agrees.
• Java applets are fast - and can even have similar performance to native installed software.
Disadvantages
A Java applet may have any of the following disadvantages:
• It requires the Java plug-in.
• Some organizations only allow software installed by the administrators. As a result, some users can only view
applets that are important enough to justify contacting the administrator to request installation of the Java plug-in.
• As with any client-side scripting, security restrictions may make it difficult or even impossible for an untrusted
applet to achieve the desired goals.
• Some applets require a specific JRE. This is discouraged. [25]
• If an applet requires a newer JRE than available on the system, or a specific JRE, the user running it the first time
will need to wait for the large JRE download to complete.
• Java automatic installation or update may fail if a proxy server is used to access the web. This makes applets with
specific requirements impossible to run unless Java is manually updated. The Java automatic updater that is part
of a Java installation also may be complex to configure if it must work through a proxy.
• Unlike the older applet tag, the object tag needs workarounds to write a cross-browser HTML document.
Compatibility related lawsuits
Sun has made a considerable effort to ensure compatibility is maintained between Java versions as they evolve,
enforcing Java portability by law if required. Oracle seems to be continuing the same strategy.
The 1997 Sun - Microsoft lawsuit
The 1997 lawsuit [26] was filed after Microsoft modified its own Java Virtual Machine which shipped with Internet
Explorer. Microsoft added about 50 methods and 50 fields [26] into the classes within the java.awt, java.lang, and
java.io packages. Other modifications included removal of RMI capability and replacement of Java native interface
from JNI to RNI, a different standard. RMI was removed because it only easily supports Java to Java
communications and competes with Microsoft DCOM technology. Applets that relied on these changes or just
inadvertently used them worked only within Microsoft's Java system. Sun sued for breach of trademark, as the point
of Java was that there should be no proprietary extensions and that code should work everywhere. Microsoft agreed
to pay Sun $20 million, and Sun agreed to grant Microsoft limited license to use Java without modifications only and
for a limited time. [27]

Java applet 37
The 2002 Sun - Microsoft lawsuit
Microsoft continued to ship its own unmodified Java virtual machine. Over years it has become extremely outdated
yet still default for Internet Explorer. In 2002 Sun filed an antitrust lawsuit, claiming that Microsoft's attempts at
illegal monopolization have harmed the Java platform. Sun demanded Microsoft distribute Sun's current, binary
implementation of Java technology as part of Windows, distribute it as a recommended update for older Microsoft
desktop operating systems and stop the distribution of Microsoft's Virtual Machine (as its licensing time, agreed in
the previous lawsuit, had expired). [27] Microsoft paid $700 million for pending antitrust issues, another $900 million
[28] [29]
for patent issues and a $350 million royalty fee to use Sun's software in the future.
The 2010 Oracle - Google lawsuit
Google has developed their own Android platform that uses Java features and concepts yet is not compatible with
standard libraries. This has been a violation of conditions under that Sun granted OpenJDK patents to use open
source Java for all [30] . 2010 Oracle sued Google [31] for using Java "in a wrong way", claiming that "Google’s
Android competes with Oracle America’s Java" and that "Google has been aware of Sun’s patent portfolio .. since
Google hired certain former Sun Java engineers". Oracle currently seems claiming as much as to stop the further
Android development, trying to replace it by standard Java version [32] . This lawsuit is currently ongoing.
Applet security
There are two applet types with very different security models: signed applets and unsigned applets. [33]
Unsigned applet
Limitations for the unsigned applets are understood as "draconian": [34] they have no access to the local filesystem
and web access limited to the applet download site; there are also many other important restrictions. For instance,
they cannot access system properties, use their own class loader, call native code, execute external commands on a
local system or redefine classes belonging to certain packages. While they can run in a standalone frame, such frame
contains a header, indicating that this is an untrusted applet. Successful initial call of the forbidden method does not
automatically create a security hole as an access controller checks the entire stack of the calling code to be sure the
call is not coming from an improper location. Several specific security problems have been discovered and fixed
since Java was first released, and some, like the Calendar serialization security bug [35] , even persisted as late as
2008 without anybody being aware. Some studies mention applets crashing the browser or overusing CPU resources
but these are classified as nuisances [36] and not as true security flaws. However, unsigned applets may be involved in
combined attacks that exploit a combination of multiple severe configuration errors in other parts of the system. [37]
An unsigned applet can also be more dangerous to run directly on the server where it is hosted because while code
base allows it to talk with the server, running inside it can bypass the firewall. An applet may also try DOS attack on
the server where it is hosted but usually people who manage the web site also manage the applet, making this
unreasonable. Communities may solve this problem via source code review or running applets on a dedicated
domain. [38] [39] .
[36] [40]
As of 1999 no real security breaches involving unsigned applets have ever been publicly reported.
Signed applet
A signed applet [41] contains a signature that the browser should verify through a remotely running, independent
certificate authority server. Producing this signature involves specialized tools and interaction with the authority
server maintainers. Once the signature is verified, and the user of the current machine also approves, a signed applet
can get more rights, becoming equivalent to an ordinary standalone program. The rationale is that the author of the
applet is now known and will be responsible for any deliberate damage. This approach allows applets to be used for

Java applet 38
many tasks that are otherwise not possible by client-side scripting. However, this approach requires more
responsibility from the user, deciding whom he or she trusts. The related concerns include a non-responsive authority
server, wrong evaluation of the signer identity when issuing certificates, and known applet publishers still doing
something that the user would not approve of. Hence signed applets that appeared from Java 1.1 may actually have
more security concerns [42] .
Java security problems are not fundamentally different from similar problems of any client-side scripting platform.
In particular, all issues related to signed applets also apply to Microsoft ActiveX components.
Alternatives
Alternative technologies exist (for example, JavaScript, Curl, Flash, and Microsoft Silverlight) that satisfy some of
the scope of what is possible with an applet. Of these, JavaScript is not always viewed as a competing replacement;
JavaScript can coexist with applets in the same page, assist in launching applets (for instance, in a separate frame or
providing platform workarounds) and later be called from the applet code. [43]
See also
• ActiveX control
• Curl
• Java programming language
• Java Servlet
• Java Web Start
• JavaFX
External links
• Latest version of Sun Microsystems Java Virtual Machine [44] (includes browser plug-ins for running Java applets
in most web browsers).
• Information about writing applets from Sun Microsystems [45]
• Demonstration applets from Sun Microsystems [46] (JDK 1.4 - include source code)
• JavaRanch Applet FAQ [47]
• Pulpcore: Open-source 2D rendering and animation framework for the Java plug-in [48]
References
[1] World of Fungi (http:/ / www. world-of-fungi. org/ Models/ tropisms/ java_a. htm) - page of the scientific project, serving an applet that is
used as an illustration figure
[2] The home site of the 3D protein viewer (Openastexviewer) under LGPL (http:/ / openastexviewer. net/ web/ )
[3] The virtual hearth (http:/ / thevirtualheart. org/ CAPindex. html)
[4] The home site of the Mandelbrot set applet under GPL (http:/ / www. its. caltech. edu/ ~dannyc/ fractals/ simple. html)
[5] The home site of the chess applet under BSD (http:/ / english. op. org/ ~peter/ ChessApp/ )
[6] Java.Sun.com (http:/ / java. sun. com/ developer/ technicalArticles/ javase/ newapplets/ )
[7] Jython applet page (http:/ / www. jython. org/ archive/ 21/ applets/ index. html)
[8] About Java applets in Ruby (http:/ / michal. hantl. cz/ ruby-in-browser-jruby-inside-an-applet/ )
[9] At tool to produce Java applets with SmartEiffel (http:/ / eiffelzone. com/ esd/ wrapj/ index. html)
[10] Paul Falstad online applet portal (http:/ / www. falstad. com/ mathphysics. html)
[11] Jraft.com (http:/ / www. jcraft. com/ jcterm/ )
[12] ObjectPlanet.com (http:/ / www. objectplanet. com/ newsticker/ ), an applet that works as news ticker
[13] Sferyx.com (http:/ / www. sferyx. com/ ), a company that produces applets acting as WYSWYG editor.
[14] Cortado applet to play ogg format
[15] An example of the 2005 year performance benchmarking (http:/ / www. timestretch. com/ FractalBenchmark. html)
[16] JavaWorld.com (http:/ / www. javaworld. com/ javaworld/ jw-07-2001/ jw-0706-webstart. html)
[17] JavaChannel.net (http:/ / javachannel. net/ wiki/ pmwiki. php/ FAQ/ Applets)

Java applet 39
[18] W3.org (http:/ / www. w3. org/ TR/ html401/ struct/ objects. html#edef-APPLET)
[19] W3.org (http:/ / www. w3. org/ TR/ html401/ struct/ objects. html#edef-OBJECT)
[20] Sun's position on applet and object tags (http:/ / download. java. net/ jdk7/ docs/ technotes/ guides/ plugin/ developer_guide/ using_tags.
html#object)
[21] Criticism (http:/ / mindprod. com/ jgloss/ applet. html#OBJECT) of APPLET tag deprecation
[22] Java applet launcher from Oracle (http:/ / www. java. com/ js/ deployJava. txt)
[23] Java applet section in Wikiversity (http:/ / en. wikiversity. org/ wiki/ Java_applets)
[24] Java.Sun.com (http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ guide/ misc/ applet. html) Sun's APPLET tag page
[25] Oracle notes on Java versioning (http:/ / java. sun. com/ javase/ 6/ webnotes/ family-clsid. html)
[26] 1997 year Sun-Microsoft lawsuit in JavaWorld (http:/ / www. javaworld. com/ jw-10-1997/ jw-10-lawsuit. html)
[27] Sun's page, devoted for the lawsuits against Microsoft (http:/ / www. sun. com/ lawsuit/ summary. html)
[28] Sun - Microsoft 2002 lawsuit (http:/ / my. advisor. com/ doc/ 13947)
[29] Microsoft page devoted to the Sun - Microsoft 2002 lawsuit (http:/ / www. microsoft. com/ presspass/ press/ 2004/ apr04/
04-02SunAgreementPR. mspx)
[30] (http:/ / tirania. org/ blog/ archive/ 2010/ Aug-13. html)
[31] Oracle sues Google over Android (http:/ / mobile. venturebeat. com/ 2010/ 08/ 12/ oracle-sues-google-over-android/ )
[32] Discussions on Oracle plans (http:/ / mashable. com/ 2010/ 08/ 12/ oracle-google-android-lawsuit/ ) in mashable.com
[33] Sun's explanation about applet security (http:/ / java. sun. com/ docs/ books/ tutorial/ deployment/ applet/ security. html)
[34] Java Security FAQ Applet Security Restrictions (http:/ / www. wutka. com/ hackingjava/ ch3. htm) by Mark Wutka
[35] Description of Calendar serialization security bug (http:/ / slightlyrandombrokenthoughts. blogspot. com/ 2008/ 12/ calendar-bug. html)
[36] Java Security FAQ (http:/ / www. cs. princeton. edu/ sip/ faq/ java-faq. php3)
[37] Avirubin.com (http:/ / avirubin. com/ block. java. pdf)
[38] Strategy.Wikimedia.org (http:/ / strategy. wikimedia. org/ wiki/ Proposal:Java_applet_support), proposal with discussion about Java applets
in community sites
[39] Ultrastudio.org (http:/ / Ultrastudio. org), user editable educational site with full applet support
[40] ~ G.McGraw, E.W. Felten. Securing Java. ISBN 047131952X (http:/ / www. securingjava. com/ chapter-four/ )
[41] Informit.com (http:/ / www. informit. com/ articles/ article. aspx?p=433382& seqNum=2)
[42] Sid Stamm, Markus Jakobsson, Mona Gandhi (2006). A study in socially transmitted malware (http:/ / www. indiana. edu/ ~phishing/
verybigad/ )
[43] Rgagnon.com (http:/ / www. rgagnon. com/ javadetails/ java-0170. html), calling a Java applet from JavaScript
[44] http:/ / www. java. com/ download/
[45] http:/ / java. sun. com/ docs/ books/ tutorial/ applet/ index. html
[46] http:/ / java. sun. com/ applets/ jdk/ 1. 4/ index. html
[47] http:/ / faq. javaranch. com/ java/ AppletsFaq
[48] http:/ / www. interactivepulp. com/ pulpcore/

Associació d'Usuaris de Java de Catalunya 40
Associació d'Usuaris de Java de Catalunya
Aujac is the acronym of "Associació d'Usuaris de JAva de Catalunya", non-profit association that intended to
group all users of the Java language created by James Gosling at Sun MicroSystems.
Born
Official logo of Aujac
Aujac (Associació d'Usuaris de Java de Catalunya)
born with the initial proposal to bring near the new
information technologies to the people. An effort made
through one of the most active Java Users Groups in
Europe.
AUJAC starts to forge as an idea during the celebration
of a Java course and after the initial creation of the JUG
of Sabadell by Jordi Pujol Ulied, founder and president of the Aujac, in April of year 2000.
The interest was very high and soon summoned a first meeting for establishing the statutes and the first Board of
Directors.
The meetings occurs often and with an important collective effort that it is it could make patent in the several
encounters that they were made in the current headquarters of the entity, in Sabadell.
The members founding of AUJAC was:
Jordi Pujol Ulied (president)
Xavier Pi i Palomés (underpresident)
Marc Munill i Bernandich (secretary)
Josep Folch i Serra (treasurer)
German Munuera Pubill (vowel)
Mònica Rayo Moragon (vowel)
Albert Soler i Crosas (vowel)
Pere Brugue i Pujol
At the end of year 2000, was constituted and recognized by the Generalitat de Catalunya, and being inscribed in the
"Registre General d'Entitats Juridiques" with number of inscription: 23889 / B
On the other hand the AUJAC was recognized by Sun MicroSystems as official JUG of Catalonia.
And in year 2003 the AUJAC becomes the most important 16é JUG of the world: Top25 JUG Program.
Targets
According to the num article. 2 of its statutes:
The purposes of the association:
1. - To group all the users of the Java programming language in Catalonia as well as other aspects that have
relation with this language.
2. - The association is in itself an organic representation of the JUG (Java Users Group) in Catalonia, started
by the company creative of the language, Sun MicroSystems, in the promotion of users associations ( JUGS
[1] ) indicating that it declares as a non-profit association and therefore there is not commercial connection
with the company and just sustains bonds of users associationism.

Associació d'Usuaris de Java de Catalunya 41
3. - To foster and to promote catalan information society, in all the possible areas. The Catalan was the
expression and work language of the association.
President and board of directors
Along its existence, the Aujac is it composed of several boards of directors.
The members who compose the Board of Directors, as they marked the statutes, were chosen every two years in the
General Assembly of Members, and the former members can be presented to the charge without any harm again.
During the first biennium of existence of the AUJAC (2000-2002) the Board of Directors has been composed by the
following persons:
President: Jordi Pujol Ulied
SotsPresident: Xavier Pi Palomes
Treasurer: Josep Folch i Serra
Secretary: Marc Munill Bernándich
Vowels:
German Munuera Pubill
Ignasi Pérez Valls
Mònica Rayo Morajón
Albert Soler Crosas
In the 2002 elections, the Board of Directors for the period 2002-2004 was:
President: Jordi Pujol Ulied
SotsPresident: Josep Ros Navarro
Treasurer: Josep Folch i Serra
Secretary: Mònica Rodríguez Gili
Vowels:
Mònica Rayo Moragón
David Villegas Terrín
Aleix Torres Casas
In the periode 2004-2006, the board of directors comes off composed in the following way:
President: Jordi Pujol Ulied
SotsPresident: Aleix Torres Casas
Treasurer: Jordi Marques del Aguila
Secretary: Maiol Xercavins i Simó
Vowels:
David Villegas Terrín
Josep Folch Serra
Inma Camacho Arellano

Associació d'Usuaris de Java de Catalunya 42
Main activities
The main activities of the Aujac it is they centered in three main axes: formation, broadcast and collaboration
projects.
Formation
In the program of formation it is intended to:
Facilitate the technology access to all the persons concerned to the Java technologies. Establish a shared plan of
formation in all the Catalan area, which they are governed by the same criterion of evaluation and formation, with a
unitary program of courses.
The plan had a remarkable success, and the Barceloba Football club, "Fundación Once" and the University
Autonòma of Barcelona (UAB) was one of their customers.
The plan of formation also allowed the creation of a Java Master Course at the "Fundació Indústries de la
Informació", entity promoted by Mr. Antoni Farrés ca:Antoni Farrés i Sabater.
Otherwise, it is also they imparted several courses in the EUIS, Escola Universitària d'Informàtica de Sabadell,
ascribed to the UAB.
Diffuse
With respect to the diffusion of the Java technology, Aujac organized the "Sun Tech Day" in Sabadell 2004, and
three editions of the "Jornades Java Catalanes", and became the first non-enterprise group to organize an event of
this kind in Spain, copied afterwards by JavaHispano, which made two editions of a similar event, after having
attended the first as a viewer.
As explained in the definition of the "Jornades Java Catalanes" these were:
The "Jornades Java Catalanes" are an event focused to diffuse the Java technology and other similar
technologies to the Catalan community. It is an event open to everybody, focused to several sectors of the
catalan community: university, enterprise, final users and general public.
The goal of the "Jornades Java Catalanes" is to visit all Catalan universities along the several editions,
located in Catalonia, Valencia, Balearic Islands and the North Catalonia, through the hand of technological
companies in this area.
An annual periodicity is established in the event.
The language of expression and work of "Jornades Java Catalanes" is, by default, the Catalan. Excluding in
those activities in which they have to be made, by non-catalan resident of the persons who develop them, in the
languages of expression of the same ones.
The area of performance and divulging of the "Java conference C0atalanes" they are all those regions of
Catalan speech.
The "Jornades Java Catalanes" base their diffusion area on three predominant areas: enterprise, university
and society.
Aujac was pioneer in the Spanish state, the year 2003, in being the first non-profit organization that achieved to
gather in a same event about Java, the university world, the enterprise sector and the general society, acting as link of
union among them.
This joint position of initiative and leadership between Aujac and all the Catalan universities, makes the present
model have been adopted by other similar entities all over the Spanish state when carrying out similar events
certifying the success of the same ones.

Associació d'Usuaris de Java de Catalunya 43
First "Jornades Java Catalanes"
Cartell oficial de les 1eres Jornades Java
Catalanes
Second "Jornades Java Catalanes"
The first "Jornades Java Catalanes" was celebrated at the ETSE, "Escola
Técnica Superior d'Enginyeria" from the "Universitat Autonòma de
Barcelona", on 25 February 2003.
The sponsors of this event were:
Bea Systems
Sun MicroSystems
and the collaborator companies :
Steria
Cast-Info
Borland
We can find press releases in Vilaweb: [2]
Opening meeting of the III Jornades Java Catalanes. From left to right: Fernando
Suarez (IBM), Josep Figols (Sun MicroSystems), Jordi Pujol Ulied
(AUJAC),Monte Kluemper (BEA),Juan Antoni Pastor (UNICA), ? (IBM),Miquel
Boix Planes (Steria),Alvaro Rocabayera (MSS)
The second "Jornades Java Catalanes" was
celebrated at the Universitat Internacional
de Catalunya, the 15th and 16th of April in
2004.
The sponsors of this event were:
Bea Systems
Caixa Penedès
Cast-Info
Data.ti
IBM
Oracle Corporation
MSS
Sun MicroSystems

Associació d'Usuaris de Java de Catalunya 44
Official logo of the II Jornades Java Catalanes
Third "Jornades Java Catalanes"
Quest Software
They receive support from:
Official Logo of III Jornades Java Catalanes
CBA Computers, S.L.
Filnet
You can see several press notes on a different sources:
The participant companies were::
da.vinci
And the collaborator companies were:
CBA Computers, S.L.
Filnet
They receive support from:
Escola Tècnica Superior d'Enginyeria
of UAB University
ATI
SOFTCATALÀ
PuntBarra
Some press notes can be consulted to
several newspapers like : [3]
The second "Jornades Java Catalanes" was
celebrated at the "Sala de Congressos del
Parc d’Innovació La Salle", located at the
University Campus of the given university,
in 14th and 15th of April in 2005.
The sponsors of this event were:
Bea Systems
Borland
Caixa Penedès
Data.ti
Oracle Corporation
Steria
Sun MicroSystems
The participant companies were::
Ilog
MSS

Associació d'Usuaris de Java de Catalunya 45
- Press note at COEIC: [4]
- Press note at LaFarga.cat [5]
Sun Tech Day in Sabadell
From left to right:Angela Caicedo(Sun Evangelist),Reginald Hutcherson(Boss of
the Java Technology Evangelist Team),Jordi Pujol (President of Aujac)
and a T-shirt, and raffled books and other gifts.
Almost 100 persons attended the act.
Belong of the collaboration among the EUIS
and AUJAC, a Sun Tech Day was organized
by them.
Angela Caicedo, Technology Evangelist of
Sun Microsystems, was the speaker of the
presentation of the Java2 Standard Edition
5.0 (Tiger).
That explained the new features and the
technical aspects of this last version of the
Java platform.
Also it made demonstrations of how to
develop applications helping for us of the
new possibilities.
The session took place on the 20th of
December 2004 from 17.30 to 20.00 hours.
The assistants received original CDs of Sun
During the act, AUJAC gives a commemorative diploma of gratitude to Mr. Reginald Hutcherson (boss of the Java
Technology Evangelist).
You can you find references of this event in the web page of the EUIS: [6]
Collaboration projects
The Aujac promotes several collaboration projects with entities from all over the territory. Basicament spread on two
main axes: those activities that offered a series of services to the community, and of another the impulse of the
technology in educational areas.
It is necessary to highlight that in the area of the teaching, the Aujac signs with the UAB University, several
agreements of collaboration among those that highlight the teaching courses as well as the direction of career
projects under the direction of Jordi Pujol Ulied, president of Aujac.
It is necessary to highlight that was signed two final university projects:
• "LABOR": Employment Exchange, by Anna Torres Ribas, that received the qualification of: 10 over 10.
• "hosting.aujac.org", by Aleix Torres Casas, that received the qualification of: 9.75 over 10, with Honour mark.

Associació d'Usuaris de Java de Catalunya 46
Honour members
Aujac gives every April, the Honour Member to a personality or Catalan entity.
With this distinction they want to recognize those personalities or entities that with their disposition, implication,
dedication and effort, have contributed to the growth and development of the technology society in our country.
2001 Honour Member
In 2001, Mr. [7] was elected as Honour Member of Aujac.
Political icon of the democratic movement in the seventies in Sabadell, was the first democratic mayor of the quoted
population, and one of the big social instigators of the post Franco's regime.
Instigator on the other hand, of projects of the technology society, like the creation of the "Fundació Indústries de la
Informació", with headquarters in Sabadell, or instigator of the projects of electronic administrations in Catalonia.
It is necessary to highlight that the open speech of the Aujac social presentation was offered by him in the
headquarters of the ancient F2I, "Fundació Indústries de la Informació", in Sabadell, that today is the Chamber of
Commerce of Sabadell.
2002 Honour Member
Joan Daví i Ferrer, became Member of Honor Aujac the year 2002.
Joan Daví i Ferrer, from Terrassa, director of projects in "Caixa Terrassa", led in the bank world an opening towards
the non-proprietary systems that it led to conceiving unedited bank architectures until then it, and who broke
outlines, and especially with the traditional systems established in the financial environments.
Nowadays, its designs in computer architectures devoted to the bank services are a referent.
For all of this reasons, Aujac considered to distinguish it with the Honour member.
2003 Honour Member
Dr. Jordi Roig de Zarate receiving the 2003 Honour Member
Dr. Jordi Roig de Zarate was called "Honour Member" in year 2003.
2004 Honour Member
Dr. Jordi Roig de Zarate, professor of the IT
Department of the UAB University. It was
Director of the EUIS in Sabadell, during
period 2000-2002.
Constant fighter towards the own difficulties
has always known how to win the battle of
the adversities, demonstrating that many
times, there are not barriers that can be
through with effort, dedication and
constancy.
Their spirit of improvement, together with
its professional profile, they act as him a
person who has known how to transmit its
pupils the illusion about the new
technologies.
Him for this qualities and many others, that

Associació d'Usuaris de Java de Catalunya 47
Mr. Eduard Elias (right) receiving the 2004 Honour Member
The Mr. Eduard Elias (right), dean of the
"Col.legi Official d'Enginyeria en
Informàtica de Catalunya", was elected
"2004 Honour Member". Promoter and
instigator of the Catalan Association of
Engineers in Computer Science (ACEI), he
was some of the craftsmen of the creation of
the Official School of Engineering in
Computer Science of Catalonia.
This Honour Member recognizes years of
dedication of the technology association and
the effort to attain a regularization of the
profession.
His forces and dedication has allowed the
creation of the "Col.legi Official
d'Enginyeria en Informàtica de Catalunya ".
Arrange of this, Aujac want to give him this honour member, in 16 of April 2004, in the UNICA University.
2005 Honour Member
Associació per a Joves TEB, receives on 15 April 2005, during the closing ceremony of "III Jornades Java
Catalanes", the "2005 Honour Member".
With this distinction it is wants to recognize the effort and dedication carried out, for this entity, that have
demonstrated its contribution to the growth and development of information society in zones where the youngsters
live in situations of exclusion, and where the new technologies could not be another barrier.
It is from this project, and other important project like Xarxa-Òmnia, RavalNet and a long list of projects that they
have acted how authentic dynamic social agents and of bridges of cohesion there where bags of social exclusion
could be produced.
Dissolution
According to the agreements taken in the last General Assembly of Members, on Tuesday, 24 October 2006 at 20:00
hours, was approved by over ot the two third parts of the votes, the dissolution of the association.
The reasons that brought to the dissolution were mainly two, as they were explained at the meeting:
• The little support on the part of the implied companies, and especially of the matrix company, Sun
MicroSystems, which finally cut the capital funding of the entity.
• On the other hand, the problem of the technological voluntarism, in Catalonia, a concept that has just not been
understood by the society.
• The people associate the technology with affairs of materialist look, where always to take out a benefit and this
entails that there are few people willing to collaborate if there is not an economic incentive a lot.
• And on "collaborating", we understand in an active and constant contribution way.
• The technological voluntarism must be to grow and to be something more than to participate in the
development of a software or to participate in the net without going out from home.
This close a cycle where AUJAC was the most important non-enterprise entity that promotes the diffusion of Java.

Associació d'Usuaris de Java de Catalunya 48
References
[1] http:/ / community. java. net/ jugs/
[2] I Jornades Java Catalanes: Press notes in Vilaweb (http:/ / www. vilaweb. cat/ www/ noticia?p_idcmp=652475)
[3] II Jornades Java Catalanes: Press note at Vilaweb (http:/ / www. vilaweb. cat/ www/ noticia?p_idcmp=838725)
[4] 'III Jornades Java Catalanes, press note at COEIC' (http:/ / coeic. org/ descarrega/ Butlleti_n. 6_18. 03. 05.
pdf?iwithSession=89ded563b805d53b6ea96a8c3ed7778a)
[5] 'III Jornades Java Catalanes, Press note at LaFarga.cat' (http:/ / www. lafarga. org/ agenda/ iii-jornades-java-catalanes)
[6] Sun Tech Day a l'Escola Universitaria de Sabadell (http:/ / www. uab. es/ servlet/ Satellite/ L-escola/ Miscel-lania/
Sun-Tech-Day-1183530620403. html)
[7] Antoni Farrés i Sabater
Automated exception handling
Automated exception handling is a computing term referring to the computerized handling of errors. runtime
engines such as those for the Java language or Microsoft .Net lend themselves to an automated mode of exception or
error handling. In these environments software errors do not 'crash' the operating system or the runtime engine but
rather generate exceptions. Recent advances in these runtime engines enables specialized runtime-engine add-on
products to provide automated exception handling that is independent of the source code and provides root-cause
information for every exception of interest.
How it works
Upon exception, the runtime engine calls an error interception tool that is attached to the runtime engine (e.g. JVM).
Based on the nature of the exception such as its type and the class and method in which it occurred and based on user
preferences, an exception can be either handled or ignored.
If the preference is to handle the exception, then based on handling preferences such as memory search depth, the
error interception utility extracts memory values from heap and stack memories. This snapshot then produces the
equivalent of a debugger screen (as if there had been a debugger) at the precise moment of the exception.
Advantages
This mechanism enables the automated handling of software errors independent of the source code of the application
and independent of its developers. It is a direct artifact of the runtime engine paradigm and it enables unique
advantages to the software lifecycle that were not available before.

Bean Scripting Framework 49
Bean Scripting Framework
Developer(s) Apache Software Foundation
Stable release 2.4.0 / October 6, 2006
Preview release 3.0 Beta3 / April 5, 2009
Development status Active
Written in Java
Operating system Cross-platform
Type Script Engine
License Apache License 2.0
Website http:/ / jakarta. apache. org/ bsf
The Bean Scripting Framework is a method of allowing the use of scripting in Java code. It provides a set of Java
classes which provides support within Java applications for scripting languages, and also allows access to Java
objects and methods. Some examples of languages that can be used in combination with BSF and Java include
Python, Jython, Tcl, as well as JRuby, and Groovy using their own libraries.
BSF was created by IBM, and then donated to the Apache Software Foundation, where work on BSF is part of the
Apache Jakarta Project.
A counterpart of BSF is the JSR223 ScriptEngine shipped with Java SE 6. Java SE 6 only includes a Script Engine
based on Rhino JavaScript Engine for Java version 1.6R2, while JSR223 framework actually supports a number of
scripting languages. JSR223 uses Script Engine to integrate scripts with Java source codes. So far, Script Engines
included in the JSR223 include BeanShell, Jython, JRuby, JavaScript, Groovy and several others.
Bibliography
• Bosanac, Dejan (August 19, 2007), Scripting in Java: Languages, Frameworks, and Patterns [1] (1st ed.),
Addison-Wesley Professional, pp. 552, ISBN 978-0321321930
See also
• JRuby - Java implementation of Ruby interpreter.
• Jython - Java implementation of Python programming language.
• BeanShell - Java interpreter for Java source codes
• JSR223 - JSR223: Scripting for the JavaTM platform

Bean Scripting Framework 50
External links
• Apache Jakarta - Bean Scripting Framework [2]
• IBM - Bean Scripting Framework [3]
References
[1] http:/ / www. scriptinginjava. net/
[2] http:/ / jakarta. apache. org/ bsf/
[3] http:/ / www. alphaworks. ibm. com/ tech/ bsf
CJAN
CJAN is an acronym standing for Comprehensive Java Archive Network. CJAN as a concept is an extension of
CPAN, the Comprehensive Perl Archive Network. In 2004 the CJAN project has ceased development.
Apache CJAN
Apache CJAN was an attempt at a simple web service for serving Java Jar files. It was started some time prior to
May 2001. It was abandoned in favour of the more promising Apache JJAR project.
Apache JJAR
Apache JJAR is an experimental distributed repository and toolset to navigate and fetch from the repository. While it
met its initial goals and found a couple of niche uses, it never went mainstream due to lack of interest from fellow
developers. Although the project is no longer featured on Apache.org's main pages and is essentially abandoned, this
experimental project is still hosted on their servers.
CJAN.org
Started in November 2001 by Brian Tol [1] , CJAN.org set out to become for the Java community what CPAN
represented to the Perl community - a comprehensive archive of reusable components for their respective
programming languages.
Two key differences between CPAN and CJAN were that Java uses modules known as Jar files and that CJAN was
to use a distributed network topology (the later would ensure that CJAN would scale well with increased numbers of
users and keep server hosting costs to an absolute minimum). The decision was taken to code CJAN from scratch in
Java.
At the beginning of 2002, Michael Davey started working with Brian on the specifications and a prototype.
CJAN.org was managed as an Open Source project, a hobby they worked on in their spare time.
Progress was slow, in part because some of the basic building blocks needed to implement CJAN simply didn't exist
in open-source form in Java at that time so the developers were spending time creating the components and then
trying to persuade the appropriate developer community to adopt the component and take over its management. The
distributed architecture was a problem, too. CJAN was attempting to use the JXTA framework when it was in its
infancy and only offered very fine-grained, low-level control of the framework.
Sun Microsystems became interested in CJAN at the beginning of 2003. After some initial discussions with Brian
and Michael and then the Apache community they sought the opinion of the wider Java community and teamed up
with Collab.Net and O'Reilly publishing. On 11 June 2003 the Java.net community and website was launched [2] .

CJAN 51
Ostensibly, CJAN.org failed because it was too ambitious - trying to build an open-source project on leading-edge
technology. The final straw for the open-source project was the launch of the high-profile Java.Net website.
Although to this day Java.Net does not offer a catalogue of reusable components, it has a huge community and the
website features are good enough for most Java developers most of the time that developers rarely cite the need for
such.
See also
• CPAN
• CRAN
• CTAN
• JSAN
• JXTA
• Java.Net
External links
• Apache.org JJAR [3] is a functional webservice and toolset (at time of writing, JJAR is an abandoned
experimental project)
• Java.net CJAN wiki page [4]
• SorceForge.net CJAN project documentation [5] has a number of documents and code, but activity has ceased.
• Java.Net [6] the closest thing the Java community has to a CJAN repository.
References
[1] CJAN Project Summary on SF.Net (http:/ / sourceforge. net/ projects/ cjan)
[2] Press release: SUN MICROSYSTEMS UNVEILS JAVA.NET (http:/ / www. sun. com/ smi/ Press/ sunflash/ 2003-06/ sunflash. 20030611. 4.
xml)
[3] http:/ / jakarta. apache. org/ commons/ sandbox/ jjar/
[4] http:/ / wiki. java. net/ bin/ view/ Projects/ CJAN
[5] http:/ / sourceforge. net/ docman/ ?group_id=41872
[6] http:/ / java. net/

Celtix 52
Celtix
Celtix delivers a Java enterprise service bus (ESB) runtime and set of APIs that make it easy to add transports,
message formats, and security features. The goal is to simplify the construction, integration and flexible reuse of
technical and business components using a standards-based, service-oriented architecture.
Related Technologies
• ASP.NET 2.0 - Web Services are Basic Profile Compliant compliant [1]
• GlassFish Metro, the bundle including the JAX-WS Reference Implementation (JAX-WS RI) and the Tango
(WSIT) project.
• IBM WebSphere Application Server Version 5.0.2 to 5.1 are BP 1.0 compliant version 6.0+ are BP 1.1 compliant
[2]
• Apache Axis 1.2+ is BP 1.0 compliant
• Apache Axis2
• WebMethods Glue
• JBossWS
• Codehaus XFire
• Apache CXF, the merger of Codehaus XFire and Celtix
• DPWS
External links
• Celtix Homepage [3] at the ObjectWeb
References
[1] http:/ / msdn2. microsoft. com/ en-us/ library/ ms230196. aspx
[2] http:/ / www-128. ibm. com/ developerworks/ webservices/ newto/ ws-websvc. html
[3] http:/ / celtix. objectweb. org/

Chainsaw (log file viewer) 53
Chainsaw (log file viewer)
Developer(s) Apache Software Foundation
Stable release 2.0 / March 2, 2006
Development status Active
Written in Java
Operating system Cross-platform
Type GUI tool to view and analyze log files
License Apache 2.0 Licence
Website [1]
Chainsaw is a java-based GUI tool to view and analyze log files - specifically logs generated by the Log4j logging
system. Both Log4j and Chainsaw are Open source projects under Apache Software Foundation. The latest release is
Chainsaw v2. [2] Chainsaw can read log files formatted in Log4j's XMLLayout [3] , receive events from remote
locations, read events from a DB, or work with JDK 1.4 logging events.
License
The project is licensed under Apache License, V 2.0. Dependencies may not follow the same licensing. [4]
External links
• Apache Logging Services Chainsaw v2 Home [1]
• JavaDoc API reference for Chainsaw v2 [5]
References
[1] http:/ / logging. apache. org/ chainsaw/
[2] "Apache Chainsaw v2 Download'" (http:/ / logging. apache. org/ chainsaw/ ). . Retrieved 2008-01-30.
[3] http:/ / logging. apache. org/ log4j/ 1. 2/ apidocs/ org/ apache/ log4j/ xml/ XMLLayout. html
[4] "Apache Chainsaw Project License'" (http:/ / logging. apache. org/ chainsaw/ license. html). . Retrieved 2008-01-30.
[5] http:/ / logging. apache. org/ chainsaw/ apidocs/

clone (Java method) 54
clone (Java method)
clone() is a method in the Java programming language for object duplication. In Java, objects are manipulated
through reference variables, and there is no operator for copying an object -- the assignment operator duplicates the
reference, not the object. The clone() method provides this functionality.
Overview
Classes that want copying functionality must implement some method to do so. To a certain extent that function is
provided by "clone()".
clone() acts like a constructor. Typically it calls the clone() method of its superclass to obtain the copy, etc. until it
eventually reaches Object's clone() method. The special clone() method in the base class Object provides a standard
mechanism for duplicating objects.
The class Object's clone() method creates and returns a copy of the object, with the same class and with all the fields
having the same values. However, clone() throws a CloneNotSupportedException unless the class you are trying to
use it on implements the marker interface Cloneable.
The default implementation of Object.clone() performs a shallow copy. When a class desires a deep copy or some
other custom behavior, they must perform that in their own clone() method after they obtain the copy from the
superclass.
The syntax for calling clone in Java is:
Object copy = obj.clone();
or commonly
MyClass copy = (MyClass) obj.clone();
which provides the typecasting needed to assign the generic Object reference returned from clone to a reference to a
MyClass object.
One disadvantage with the design of the clone() method is that the return type of clone() is Object, and needs to be
explicitly cast back into the appropriate type. However, overriding clone() to return the appropriate type is preferable
and eliminates the need for casting in the client (using covariant return types, since J2SE 5.0).
Another disadvantage is that one often cannot access the clone() method on an abstract type. Most interfaces and
abstract classes in Java do not specify a public clone() method. As a result, often the only way to use the clone()
method is if you know the actual class of an object; which is contrary to the abstraction principle of using the most
generic type possible. For example, if one has a List reference in Java, one cannot invoke clone() on that reference
because List specifies no public clone() method. Actual implementations of List like ArrayList and LinkedList all
generally have clone() methods themselves, but it is inconvenient and bad abstraction to carry around the actual class
type of an object.

clone (Java method) 55
Alternatives
There are alternatives to clone(), notably the use of a copy constructor - a constructor that accepts as a parameter
another instance of the same class - or a factory method. These methods are not always adequate when the concrete
type of the cloned object is not known in advance. (However, clone() is often not adequate either for the same
reason, as most abstract classes do not implement a public clone() method.)
Also the use of serialization and deserialization is another alternative to using clone.
clone() and the Singleton pattern
When writing a class using the Singleton pattern, only one instance of that class can exist at a time. As a result, the
class must not be allowed to make a clone. To prevent this, override the clone() method using the following code:
public Object clone() throws CloneNotSupportedException {
}
throw new CloneNotSupportedException();
(Note: This is only necessary if a superclass implements a public clone() method, or to prevent a subclass from using
this class's clone() method to obtain a copy. Since classes don't usually inherit a public clone() method (Object
doesn't have a public clone() method), it is usually unnecessary to explicitly implement a non-functional clone()
method.
clone() and class hierarchy
When working with the clone() in a hierarchy of classes, there are several things that must be handled properly.
1) Every type reference that needs to call the clone function must have a clone() method in its own class or a publicly
accessible clone() method in its parent classes. That means that if you want to clone a reference to an abstract base
class, either the base class must have a clone() method, or one of its parents must have a publicly accessible clone()
method.
Example
- since varY1 is of type Y, then Y must have clone(), or a parent of Y must have clone()
abstract public class X implements Cloneable {
}
public Object clone() throws CloneNotSupportedException {
}
return super.clone();
abstract public class Y extends X { }
public class Z extends Y { }
public class test1 {
}
public void function() throws CloneNotSupportedException {
}
Y varY1 = new Z();
Y varY2 = (Y) varY1.clone();

clone (Java method) 56
2) Every class that has any data other than primitives that has to be cloned must contain a clone() function that
handles it. This includes all objects and all primitives that are allocated with the 'new' command such as variable
length arrays. (This assumes that the programmer wants the objects to be cloned (deep copy) and not just have their
reference copied (shallow copy).)
Example
- since class Z has a reference to an object of another class, there needs to be specific code to clone that object.
abstract public class X implements Cloneable {
}
public Object clone() throws CloneNotSupportedException {
}
return super.clone();
abstract public class Y extends X { }
public class ObjectABC implements Cloneable {
}
public Object clone() throws CloneNotSupportedException {
}
public class Z extends Y {
}
return super.clone();
private ObjectABC someABC;
public Object clone() throws CloneNotSupportedException {
}
public class test1 {
}
Z newZ = (Z) super.clone();
newZ.someABC = (ObjectABC) someABC.clone();
return newZ;
public void function() throws CloneNotSupportedException {
}
Easy Solution
Y varY1 = new Z();
Y varY2 = (Y) varY1.clone();
The easiest solution to this is to make the base class "implements Cloneable" and have the base class and all
sub-classes contain the clone() method. When a class has data in it that must be cloned, adding a line or two to the
clone() method is straight forward.
Example
abstract public class X implements Cloneable {
public Object clone() throws CloneNotSupportedException {
return super.clone();

clone (Java method) 57
}
}
abstract public class Y extends X {
}
public Object clone() throws CloneNotSupportedException {
}
public class Z extends Y {
}
return super.clone();
public Object clone() throws CloneNotSupportedException {
}
public class test1 {
}
Downsides
return super.clone();
public void function() throws CloneNotSupportedException {
}
Y varY1 = new Z();
Y varY2 = (Y) varY1.clone();
If every class in your hierarchy has a clone() method, then when the actual class is cloned all of these functions will
be called, adding some overhead. Over many calls this could be significant.
With complex object graphs deep copying can become problematic, with recursive references. Once one object is
cloneable, others tend to follow until the entire graph attempts to implement Cloneable. Sooner or later you run into
a class that you can't make Cloneable.
It is not always appropriate to have multiple copies of the same object floating around. Besides, using clone() tends
to defeat the "single object, multiple references" paradigm.
clone() and final fields
Generally, clone() is incompatible with final fields. Because clone() is essentially a default constructor (one that has
no arguments) it is impossible to assign a final field within a clone() method; a compiler error is the result. Where
the value of the field is an immutable object this is okay; just let the 'constructor' copy the reference and both the
original and its clone will share the same object.
But where the value is a mutable object it must be deep copied. The only solution is to remove the final modifier
from the field, giving up all the benefits it conferred.
For this reason, many programmers prefer to make the objects in the hierarchy Serializable, and create copies by
serializing the old object and then creating a new object from the resulting bitstream, which should be nearly as fast
as the calls to clone(), uses only one object's worth of extra memory, and that only during the operation, and handles
final data members correctly.

clone (Java method) 58
References
• McManus, Eamonn (April 4, 2007). "Cloning Java objects using serialization" (http:/ / weblogs. java. net/ blog/
emcmanus/ archive/ 2007/ 04/ cloning_java_ob. html). Eamonn McManus's Blog. java.net. Retrieved 2009-07-31.
• Bloch, Joshua (2008). Effective Java: A Programming Language Guide. The Java Series (2nd ed.).
Addison-Wesley. ISBN 0321356683.
• "Avoid clone" (http:/ / www. javapractices. com/ topic/ TopicAction. do?Id=71). Collected Java Practices.
Hirondelle Systems. 2009. Retrieved 2009-07-31.
• "Object (Java Platform SE 6)" (http:/ / java. sun. com/ javase/ 6/ docs/ api/ java/ lang/ Object. html#clone()).
Java Platform Standard Ed. 6. Sun Microsystems, Inc.. 2008. Retrieved 2009-07-31.
Comparison of Java and C Sharp
Introduction
This article compares Microsoft's C# programming language with Sun's (now Oracle's) Java programming language.
While the focus of this article is mainly the programming languages and their features, such a comparison will
necessarily also consider some platform features and some library features. A comparison of the platforms are
beyond the scope of this article, however.
Neither Java nor C# can be evaluated without taking the respective platforms and libraries into consideration. For a
platform comparison please see Comparison of the Java and .NET platforms.
The comparison will naturally focus on the areas where the languages differ. This may skew the fact that the two
languages and their platforms are actually more alike than they are different: Both are (primarily) statically, strongly
and explicitly typed, both are class-based object-oriented, both are designed with semi-interpretation or runtime
compilation in mind, both use garbage-collected memory models and both are considered "curly brace" C/C++ style
languages. The common ancestry is also evident in the fact that common concepts are often termed the same way
and more often than not have very similar syntax.
Language and features
Feature comparison
Data types Java C#
Single-root (unified) type system No Yes
Signed integers Yes; 8, 16, 32, 64 bits Yes; 8, 16, 32, 64 bits
Unsigned integers No Yes; 8, 16, 32, 64 bits
Character Yes Yes
Date/time Yes; reference type Yes; value type
IEEE 754 binary32 floating point number Yes Yes
IEEE 754 binary64 floating point number Yes Yes
High precision floating point number No; but see Arbitrary size decimals 128-bit (28 digits) Decimal type
Boolean type Yes Yes
Strings Immutable reference type, Unicode Immutable reference type, Unicode
Arbitrary size integers Reference type; no operators Yes

Comparison of Java and C Sharp 59
Arbitrary size decimals Reference type; no operators No
Complex numbers No Yes
Reference types Yes Yes
Arrays Yes Yes
Value types No; only primitive types Yes
Enumerated types Yes; reference type Yes; scalar
Lifted (nullable) types No; but wrapper types Yes
Tuples No Yes
Pointers No Yes
Reference types Java C#
Garbage collection Yes Yes
Weak references Yes Yes
Soft references Yes No
Proxy support Yes; proxy generation Yes; object contexts
Object initialization Bottom-up (fields and constructors) Top-down (fields); bottom-up (constructors)
Object orientation Java C#
Classes Yes Yes
Interfaces Yes Yes
Abstract classes Yes Yes
Member accessibility levels
Public, package, private, protected
Public, protected, internal, protected internal,
Class level inner classes Yes Yes
Instance level inner classes Yes No
Partial classes No Yes
Deprecation/obsolescence Yes Yes
Overload versioning Some Yes
Properties No Yes
Events No Yes
Operators (operator overloading) No Yes
Indexers No Yes
Implicit conversions No Yes
Explicit conversions No Yes
Fields and initialization Java C#
Fields Yes Yes
Constants Yes Yes
Static (class) constructors Yes Yes
Instance constructors Yes Yes
Finalizers/destructors Yes Yes
Instance initializers Yes No
Hierarchy initialization Top-bottom, lexical order Top-bottom-top, lexical order
private

Comparison of Java and C Sharp 60
Object initializers No Yes
Collection initializers No; can be modelled Yes
Array initializers Yes Yes
Methods and properties Java C#
Virtual Virtual by default Non-virtual by default
Abstract Yes Yes
Sealing Yes Yes
Explicit interface implementation No Yes
Value (input) parameters Yes Yes
Reference (input/output) parameters No Yes
Output (output) parameters No Yes
Variadic methods Yes Yes
Optional arguments No Yes
Named arguments No Yes
Generator methods No Yes
Extension methods No Yes
Conditional methods No Yes
Partial methods No Yes
Generics Java C#
Reified generics No Yes
Co-variance Yes Yes
Contra-variance Yes Yes
Reference type constraint Yes; implicit Yes
Value/primitive type constraint No Yes
Constructor constraint No Yes
Relation constraint Yes Yes
Primitive/value type support No Yes
Migration compatibility Yes No
Functional programming Java C#
Delegates/method references No Yes
Closures/lambdas No; some use cases covered by anonymous inner
classes
Expression trees No Yes
Query expressions No Yes
Runtime (dynamic) binding Java C#
Late-bound (dynamic) type No Yes
Runtime type information and
manipulation
Yes
Java C#
Runtime type information Yes; but with type erasure Yes
Runtime generics realization No Yes

Comparison of Java and C Sharp 61
Runtime type construction No; third party tools exist Yes
Statements Java C#
Loops Yes Yes
Conditionals Yes Yes
Flow control Yes Yes
Assignment Yes Yes
Exception control Yes Yes
Variable declaration Yes Yes
Variable type inference No Yes
Deterministic disposal (ARM-blocks) No Yes
Expressions and operators Java C#
Arithmetic operators Yes Yes
Logical operators Yes Yes
Bitwise logic operators Yes Yes
Conditional Yes Yes
String concatenation Yes Yes
Casts Yes Yes
Boxing Yes; implicit Yes; implicit
Unboxing Yes; implicit Yes; explicit
Lifted operators No Yes
Overflow control No Yes
Strict floating point evaluation Yes; opt-in/out No
Local classes Yes No
Ad-hoc (anonymous) classes No Yes
Verbatim (here-)strings No Yes
Exceptions Java C#
Checked exceptions Yes No
Try-catch-finally Yes Yes
Arrays and collections Java C#
One-dimensional, zero-based index arrays Yes Yes
Rectangular (multidimensional) arrays No Yes
Jagged (arrays of arrays) arrays Yes Yes
Non-zero based arrays No Some
Unified arrays and collections No Yes
Maps/dictionaries Yes Yes
Sets Yes Yes
Lists/vectors Yes Yes
Maps Yes Yes
Queues/stacks Yes Yes

Comparison of Java and C Sharp 62
Bags/multisets Yes Yes
Metadata Java C#
Metadata annotations/attributes Interface based Class based
Positional arguments No; unless a single argument Yes
Named arguments Yes Yes
Default values At definition Through initialization
Nested types Yes Yes
Specialization No Yes
Conditional metadata No Yes
Preprocessing, compilation and
packaging
Java C#
Namespaces Packages Namespaces
Packaging Package Assembly
File contents Restricted Free
Conditional compilation No Yes
Custom errors/warnings No Yes
Explicit regions No Yes
Threading and synchronization Java C#
Native interoperability Java C#
External/native methods Yes Yes
Marshalling External glue code required Yes; metadata controlled
Pointers and arithmetics No Yes
Native types No Yes
Fixed size buffers No Yes
Explicit stack allocation No Yes
Address pinning (fixing) No Yes
Address-of No Yes
Object pinning (fix variable to address) No Yes
Data types
Unified type system
In Java the primitive types are special in that they are not object-oriented and they could not have been defined using
the language itself. The Java reference types all derive from a common root type, however. C# has a unified type
system in which all types ultimately derive from a common root type. Consequently, all types implement the
methods of this root type, and extension methods defined for the object type apply to all types, even primitive int
literals and delegates. Note, that unlike Java, C# this way supports objects with encapsulation which are not
reference types.
In Java compound types are synonymous with reference types; you can not define methods for a type unless it is also
a class reference type. In C# the concepts of encapsulation and methods have been decoupled from the reference
requirement so that a type can support methods and encapsulation without being a reference type. Only reference
types support virtual methods and specialization, however.

Comparison of Java and C Sharp 63
The primitive types of Java are special and could not have been defined using the language itself. They also do not
share a common ancestor with reference types.
Simple/primitive types
Both languages support a number built-in types which are copied and passed by value rather than by reference. Java
calls these types primitive types, while they are called simple types in C#. The simple/primitive types typically have
native support from the underlying processor architecture.
C# has a few more primitive types than Java, due to the fact that it supports unsigned as well as signed integer types,
and a decimal type for decimal floating-point calculations.
Java lacks the unsigned types. In particular, Java lacks a primitive type for an unsigned byte. The Java byte type is
signed, while the C# byte is unsigned and sbyte is signed.
Both languages feature a native char (character) datatype as a simple type. Although the Java char type can used
with bitwise operators, this is actually accomplished by promoting the char to an integer before the operation.
C# has a type for high-precision (28 decimal digits) decimal arithmetic (based on the IEEE 754 Decimal128 format)
for e.g. financial and monetary application. While Java lacks such a built-in type, the Java library does feature an
arbitrary precision decimal type. This is not considered a language type and it does not support the usual arithmetic
operators; rather it is a reference type which must be manipulated using the type methods. See more on arbitrary
size/precision numbers below.
The C# primitive/simple types implement a number of interfaces and consequently offer a number of methods
directly on instances of the types - even on the literals. The C# type names are also merely aliases for Common
Language Runtime types. The C# Long type is exactly the same type as the long type; the only difference is that the
former is the canonical .NET name while the latter is in C# alias for it.
Java does not offer methods directly on the primitive types. Instead methods which operate on the primitive values
are offered through companion wrapper classes. A fixed set of such wrapper classes exist each of which wraps on of
the fixed set of primitive types. As an example, the Java Long type is a reference type which wraps the primitive
long type. They are not the same type, however.
The following table summarizes the corresponding simple/primitive types of the languages:
C# alias .NET CLR type Width (bits) Range (apx.) Java type Java wrapper
sbyte SByte 8 -128 to 127 byte Byte
byte Byte
8 0 to 255 Not
available
Not available
short Int16 16 -32768 to 32767 short Short
ushort UInt16
16 0 to 65535 Not
available
Not available
int Int32 32 -2,147,483,648 to 2,147,483,647 int Integer
uint UInt32
long Int64
ulong UInt64
32 0 to 4,294,967,295 Not
64 -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
available
64 0 to 18,446,744,073,709,551,615 Not
Not available
long Long
available
Not available
float Single 32 -3.402823e38 to 3.402823e38 float Float
double Double 64 -1.79769313486232e308 to 1.79769313486232e308 double Double

Comparison of Java and C Sharp 64
decimal Decimal
128 ±1.0 × 10e−28 to ±7.9 × 10e28 Not
available
Not available
char Char 16 \u0000 to \uFFFF char Character
bool Boolean 8 true, false boolean Boolean
Advanced numeric types
Both languages offer library-defined arbitrary size integer types.
Only Java offers a data type for arbitrary precision decimal point calculations and only C# offers a type for working
with complex numbers.
In both languages the number of operations which can be performed are limited compared to the built-in IEEE 754
floating point types. For instance, none of the types support square root or logarithms.
By leveraging the C# support for type integration through custom operator overloading and custom (implicit and
explicit) type conversions, C# achieves better parity with the built-in types.
Java C#
ze="6.85">
er bigNumber =
igInteger("123456789012345678901234567890");
BigInteger bigNumber =
BigInteger.Parse("1234567890123456789012345
er answer = bigNumber.multiply(new BigInteger("42")); var answer = bigNumber * 42;
er square = bigNumber.multiply(bigNumber);
var square = bigNumber * bigNumber;
er sum = bigNumber.add(bigNumber);
var sum = bigNumber + bigNumber;
Built-in compound data types
Both languages treat strings as (immutable) objects of reference type. In both languages the type contains a number
of methods to manipulate strings, parse, format etc. In both languages regular expressions are considered an external
feature and is implemented in separate classes.
Both languages' libraries define classes for working with dates and calendars in different cultures. The Java
java.util.Date is a mutable reference type where the C# System.DateTime is a struct value type. C# additionally
define a TimeSpan type for working with time periods. Both languages support date/time arithmetic according to
different cultures.
Reference types
Both languages use classes and interfaces as the primary means for defining new, object-oriented types. See below
for further details.
Value types
C# allows the programmer to create user-defined value types, using the struct keyword. Unlike classes, and like the
standard primitives, such value types are passed and assigned by value rather than by reference. They can also be
part of an object (either as a field or boxed), or stored in an array, without the memory indirection that normally
exists for class types.
Because value types have no notion of a null value and can be used in arrays without initialization, they always come
with an implicit default constructor that essentially fills the struct memory space with zeroes. The programmer can
only define additional constructors with one or more arguments. Value types do not have virtual method tables, and
because of that (and the fixed memory footprint), they are implicitly sealed. However, value types can (and

Comparison of Java and C Sharp 65
frequently do) implement interfaces. For example, the built-in integer types implement a number of interfaces.
Apart from the built-in primitive types, Java does not include the concept of value types.
Enumerations
Enumerations in C# are derived from a primitive integer type (8, 16, 32, or 64 bit). Any value of the underlying
primitive type is a valid value of the enumeration type, though an explicit cast may be needed to assign it. C# also
supports bit-mapped enumerations where an actual value may be a combination of enumerated values bitwise or'ed
together.
Enumerations in Java, are full objects. The only valid values are the ones listed in the enumeration. Also, as objects,
each enumeration can contain its own methods and fields, like a dedicated toString() method, for instance, or
comparators. They can be considerered classes with a predefined amount of instances, which are the enum constants.
Special enumeration set and map collections provide fully type-safe functionality with minimal overhead.
In both C# and Java programmers can use them in a switch statement without conversion to a string or primitive
integer type.
Delegates / method references
C# implements object oriented method pointers in the form of delegates. A delegate is a special type which can
capture a type-safe reference to a method. This reference can then be stored in a delegate-type variable or passed to a
method through a delegate parameter for later invocation. C# delegates support covariance and contravariance, and
can hold a reference to any signature-compatible static method, instance method or anonymous method or lambda
expression.
Delegates should not be confused with closures and inline functions. The concepts are related because a reference to
a closure/inline function must be captured in a delegate reference to be useful at all. But a delegate does not always
reference an inline function, it can also reference existing static or instance methods. Delegates form the basis of C#
events but should not be confused with those either.
Java does not have a language-level construct like the C# delegate. To mimic the functionality the developer will
have to create an ad-hoc implementation of a class (typically an anonymous inner class) where one method performs
the desired invocation. The following code snippets show how to mimic most of the delegate functionality in Java.
Java C#

Comparison of Java and C Sharp 66
size="7.15">
define a delegate
terface SomeDelegate {
boolean Invoke(String arg);
a target class
ass Target {
public boolean TargetMethod(String arg) {
// do something
return true;
}
usage
id DoSomething() {
>
// construct a target with the target method
final Target target = new Target();
// capture the delegate for later invocation
SomeDelegate dlg = new SomeDelegate() {
public boolean Invoke(String arg) {
return target.TargetMethod(arg);
}
};
// invoke the delegate
boolean result = dlg.Invoke("argumentstring");
Lifted (nullable) types
// define a delegate
private delegate bool SomeDelegate(string resou
}
// a target class
class Target {
public bool TargetMethod(string arg) {
// do something
return true;
}
}
// usage
void DoSomething() {
// construct a target with the target metho
var target = new Target();
// capture the delegate for later invocatio
SomeDelegate dlg = target.TargetMethod;
// invoke the delegate
bool result = dlg("argumentstring");
C# allows value/primitive/simple types to be "lifted" to allow the special null value in addition to the type's native
values. A type is lifted by adding a ? suffix to the type name. Conversions are implicitly defined to convert between
values of the base and the lifted type. The lifted type can be compared against null or it can be tested for HasValue.
Also, lifted operators are implicitly and automatically defined based on their non-lifted base, where - with the
exception of some boolean operators - a null argument will propagate to the result.
Java does not support type lifting as a concept, but the fixed set of built-in primitive types all have corresponding
(boxed) wrapper types which do support the null value by virtue of being reference types. However, Java operators
such as + are not defined for these companion wrapper types. Instead Java will fall back to the primitive operator and
will attempt to unbox the operands before invocation. If one or both of the operands are null, this unboxing will
cause a NullPointerException to be thrown.
The following example illustrates how the lifted C# operator propagates the null value of the operand where the
corresponding code in Java will throw an exception.
Java C#

e="6.73">
= 42;
= null;
Comparison of Java and C Sharp 67
int? a = 42;
int? b = null;
ill generate a runtime NullPointerException
// c will receive the null value
e the * operator will attempt to unbox the null value // because * is lifted and one of the operands
= a * b;
int? c = a * b;
Not all C# lifted operators have been defined to propagate null unconditionally if one of the operands is null.
Specifically, the boolean operators have been lifted to support ternary logic thus keeping impedance with SQL.
Late-bound (dynamic) type
C# features a late bound dynamic type which supports no-reflection dynamic invocation, interoperability with
dynamic languages as well as ad-hoc binding to (for example) document object models. The dynamic type resolves
member access dynamically at runtime as opposed to statically/virtual a compile time. The member lookup
mechanism is extensible with traditional reflection as a fall-back mechanism.
There are several use cases for the dynamic type in C#:
• Less verbose use of reflection: By casting an instance to the dynamic type, members such as properties, methods,
events etc. can be directly invoked on the instance without using the reflection API directly.
• Interoperability with dynamic languages: The dynamic type comes with a hub-and-spoke support for
implementing dynamically typed objects and common runtime infrastructure for efficient member lookup.
• Creating dynamic abstractions on the fly: For instance, a dynamic object could provide simpler access to
document object models such as XML- or XHTML documents.
Java does not support a late-bound type. The use cases for C# dynamic type have different corresponding constructs
in Java:
• For dynamic late-bound by-name invocation of preexisting types, reflection should be used.
• For interoperability with dynamic languages, some form of interoperability API specific to that language will
have to be used. The Java Virtual Machine platform does have multiple dynamic languages implemented on top if
it, but there is no common standard for how to pass objects between languages. Usually this will involve some
form of reflection or reflection-like API. As an example of how to use JavaFX objects from Java, see How to Use
JavaFX in Your Swing Application [1] .
• For creating and interacting with objects entirely at runtime, e.g. interaction with a document object model
abstraction, a specific abstraction API will have to be used.
Pointers
C# allows use of pointers and corresponding pointer arithmetic. Pointers and pointer-arithmetic are potentially
unsafe in a managed environment as they can be used to bypass the strict rules for object access. C# addresses that
concern by requiring that code blocks or methods that use the feature be marked with the unsafe keyword, so that all
clients of such code can be aware that the code may be less secure than otherwise. The compiler requires the /unsafe
switch to allow compilation of a program that uses such code, and assemblies containing unsafe code may only
execute if explicitly granted security permissions. Generally, unsafe code is either used to allow better
interoperability with unmanaged APIs or system calls (which are inherently "unsafe"), or for performance reasons.
Java does not permit pointers or pointer-arithmetic within the Java runtime environment and native interop is
handled externally through JNI or other mechanisms.

Comparison of Java and C Sharp 68
Object handling
Both C# and Java are designed from the ground up as object oriented languages using dynamic dispatch, with syntax
similar to C++ (C++ in turn derives from C). Neither language is a superset of C or C++, however. Both mainly use
garbage collection as a means of reclaiming memory resources, rather than explicit deallocation of memory (though
C# requires explicit deallocation for graphical, GDI+ objects, in which case it uses the IDisposable interface). Both
include thread synchronization mechanisms as part of their language syntax.
In both languages objects are created with a new.
References
In both languages references are a central concept. All instances of classes are by reference.
While not directly evident in the language syntax per se, both languages support the concept of weak references. An
instance which is only referenced by weak references is eligible for garbage collection just as if there were no
references at all. In both languages this feature is exposed through the associated libraries, even though it is really a
core runtime feature.
In addition to weak references, Java has soft references. Soft references are much like weak references, but the JVM
will not deallocate softly-referenced objects until the memory is actually needed.
Object initialization
In both C# and Java, an object's fields can be initialized either by variable initializers (expressions that can be
assigned to variables where they are defined) or by constructors (special subroutines that are executed when an
object is being created). In addition, Java contains instance initializers, which are anonymous blocks of code with no
arguments that are run before the constructor is executed.
C# initializes object fields in the following order when creating an object:
1. Derived static fields
2. Derived static constructor
3. Derived instance fields
4. Base static fields
5. Base static constructor
6. Base instance fields
7. Base instance constructor
8. Derived instance constructor
Some of the above fields may not be applicable (e.g. if an object does not have static fields). Derived fields are those
that are defined in the object's direct class while base fields is a term for the fields that are defined in one of the
object's superclasses. Note that an object representation in memory contains all fields defined in its class or any of its
superclasses, even if some fields in superclasses are defined as private.
It is guaranteed that any field initializers take effect before any constructors are called, since both instance
constructor of the object's class and its super classes are called after field initializers are called. There is, however, a
potential trap in object initialization when a virtual method is called from a base constructor. The overridden method
in a subclass may reference a field that is defined in the subclass, but this field may not been initialized because the
cubclass' constructor that contains field initialization is called after the constructor of its base class.
In Java, the order of initialization is as follows:
1. Invocation of another constructor (either of the object's class or of object's superclass)
2. Instance variable initializers and instance initializers (in the order they appear listed in source code)
3. The constructor body

Comparison of Java and C Sharp 69
Like in C#, a new object is created by calling a specific constructor. Within a constructor, the first statement may be
invocation of another constructor. If this is omitted, the call to the super class' argument-less constructor is added
implicitly by the compiler. Otherwise, either another overloaded constructor of the object's class can be called
explicitly, or a superclass' constructor can be called. In the former case, the called constructor will again call another
constructor (either of the object's class or its cubclass) and the chain sooner or later ends up at the call to one of the
superclass' constructor.
After another constructor is called (which causes direct invocation superclass' constructor, and so forth, down to the
Object class), instance variables defined in the object's class are initialized. Even if there are no variable initializers
explicitly defined for some variables, these variables are initialized to default values. Note that instance variables
defined in superclasses are already initialized by this point, because they were initialized by superclass' constructor
when it was called (either by constructor's code or by variables' initializers performed before constructor's code or
implicitly to default values). In Java, variable initializers are executed according to their textual order in the source
file.
Finally, the constructor body is executed. This ensures proper order of initialization, i.e. the fields of a base class
finish initialization before initialization of the fields of an object class begins.
There are two main potential traps in Java's object initialization. First, variable initializers are expressions that can
contain method calls. Since methods can reference any variable defined in the class, the method called in variable's
initializer can reference a variable that is defined below the variable being initialized. Since initialization order
corresponds to textual order of variable definitions, such a variable would not be initialized to the value prescribed
by its initializer and would contain the default value. Another potential trap is when a method that is overridden in
the derived class is called in the base class' constructor, which can lead to behavior the programmer would not expect
when object of the derived class is created. According to initialization order, the body of the base class' constructor is
executed before variable initializers are evaluated and before the body of the derived class' constructor is executed.
The overridden method called form the base class' constructor can however reference variables defined in the
derived class, but these are not yet initialized to the values specified by their initializers or set in derived class'
constructor.
Arrays and collections
Arrays and collections concepts featured by both languages. The syntax used to declare and access arrays is
identical, except that C# has added syntax for declaring and manipulating multidimensional arrays.
Java C#
Arrays are implicitly direct specializations of Object. They are
not unified with collection types.
Instead of a common iterable/enumerable interface, the for
loop accepts either arrays or Iterable (a collection interface).
This means that the same short syntax can be used in for-loops.
Arrays and collections are completely separate with no
unification. Arrays cannot be passed where sequences or
collections are expected
Arrays in C# are implicitly specializations the System.Array class which
implement a number of collection interfaces.
The foreach statement iterates through a sequence using the IEnumerable
orIEnumerable interface. Because arrays always implicitly implement these
interfaces, the loop will iterate through arrays as well.
Arrays can be passed where sequences (IEnumerables) or collections/list interfaces
are expected. However, the collection operations which alter the number of
elements (insert/add/remove) will throw exceptions as these operations are not
supported by arrays.
In both languages arrays are covariant. This means that a String[] array is assignable to variables of Object[] because String is a specialization of
(assignable to) Object. In both languages the arrays will perform a type check when inserting new values because type-safety would otherwise be
compromised. This is in contrast to how generic collections have been implemented in both languages.
Multidimensional arrays only in the form of arrays of arrays
(also known as "jagged" arrays); Java does not have true
rectangular multidimensional arrays.
True multidimensional "rectangular" arrays, as well as the arrays-of-arrays (jagged
arrays).

Comparison of Java and C Sharp 70
Multidimensional arrays can in some cases increase performance because of increased locality (as there is a single
pointer dereference, instead of one for every dimension of the array as is the case for jagged arrays). However, since
all array element access in a multidimensional array require multiplication/shift between the two or more
dimensions, this is an advantage only in very random access scenarios.
Another potential advantage is that the entire multidimensional array can be allocated with a single application of
operator new, while jagged arrays require loops and allocations for every dimension. Note, though, that Java
provides a syntactic construct for allocating a multidimensional jagged array with regular lengths; the loops and
multiple allocations are then performed by the virtual machine and need not be explicit at the source level.
Both languages feature an extensive set of collection types which includes various ordered and unordered types of
lists, maps/dictionaries, sets etc.
Type members
Operator overloading and implicit and explicit conversions
Operator overloading and user-defined casts are separate features which both aim to allow new types to become
first-class citizens in the type system. By leveraging these features, types such as Complex and decimal has been
integrated so that the usual operators like addition, multiplication work with the new types.
Java does not include operator overloading nor custom conversions in order to prevent abuse of the feature, and to
keep the language simple. [2] .
Indexers
C# also includes indexers which can be considered a special case of operator overloading (like C++ operator[]), or
parametrized get/set properties. An indexer is a property named this[] which uses one or more parameters (indexes);
the indices can be objects of any type:
myList[4] = 5;
string name = xmlNode.Attributes["name"];
orders = customerMap[theCustomer];
Java does not include indexers. The common Java pattern involves writing explicit get_ and set_ methods where a
C# programmer would use an indexer.
Partial classes
C# allows a class definition to be split across several source files using a feature called partial classes. Each part
must be marked with the keyword partial. All the parts must be presented to the compiler as part of a single
compilation. Parts can reference members from other parts. Parts can implement interfaces and one part can define a
base class. The feature is useful in code generation scenarios (such as UI design) where a code generator can supply
one part and the developer another part to be compiled together. The developer can thus edit their part without the
risk of a code generator overwriting that code at some later time. Unlike the class extension mechanism a partial
class allows "circular" dependencies amongst its parts as they are guaranteed to be resolved at compile time. Java has
no corresponding concept.

Comparison of Java and C Sharp 71
Inner- and local classes
Both languages allow inner classes, where a class is defined lexically inside another class. However, in each
language these inner classes have rather different semantics.
In Java, unless the inner class is declared static, a reference to an instance of an inner class carries a reference to the
outer class with it. As a result, code in the inner class has access to both the static and non-static members of the
outer class. To create an instance of a non-static inner class, one has to name the instance of the embracing outer
class [3] . This is done via a new new-operator introduced in JDK 1.3: outerClassInstance.new Outer.InnerClass().
This can be done in any class that has a reference to an instance of the outer class.
In C#, an inner class is conceptually the same as a normal class. In a sense, the outer class only acts as a namespace.
Thus, code in the inner class cannot access non-static members of the outer class unless it does so through an explicit
reference to an instance of the outer class. Programmers can declare the inner class private to allow only the outer
class to have any access to it.
Java provides another feature called local classes or anonymous classes, which can be defined within a method body.
These are generally used to implement an interface with only one or two methods, which are typically event
handlers. They can also be used to override virtual methods of a super-class however. The methods in those local
classes have access to the outer method's local variables declared final. C# satisfies the use-cases for these by
providing anonymous delegates; see event handling for more about this.
C# also provides a feature called anonymous classes, but it is rather different from Java's concept with the same
name. It allows the programmer to instantiate a class by providing only a set of names for the properties the class
should have, and an expression to initialize each. The types of the properties are inferred from the types of those
expressions. These implicitly-declared classes are derived directly from object.
Explicit member implementation
C# also has "Explicit Member Implementation" which allows a class to specifically implement methods of an
interface, separate to its own class methods, or to provide different implementations for two methods with the same
name and signature inherited from two base interfaces.
Events
C# multicast-delegates are called events. Events provide support for event-driven programming and is an
implementation of the observer pattern. To support this there is a special syntax to define events in classes, and
operators to register, unregister or combine event handlers.
Java does not offer events as a language construct. Java developers instead manually implement the observer [4] .
Anonymous inner classes are commonly used to implement the listener, allowing you to define the body of the class
and create an instance of it in a single point in the code.
Statements and expressions
Boxing and unboxing
Both languages allow automatic boxing and unboxing to translate primitive data to and from their object form.
Effectively, this makes the primitive types a subtype of the Object type. In C# this also means that primitive types
can define methods, such as an override of Object's ToString() method. In Java, separate primitive wrapper classes
provide such functionality. Java does not implicitly box primitive values when dereferenced and an explicit cast is
required for an instance call on a primitive value — ((Integer)42).toString() instead of a C# instance call
42.ToString(). Another difference is that Java makes heavy use of boxed types in generics (see below), and as such
allows an implicit unboxing conversion (in C# this requires a cast). As these implicit unboxing conversions can
potentially throw null pointer exceptions, modern integrated development environments and compilers can be

Comparison of Java and C Sharp 72
configured to highlight them.
Generics
In the field of generics the two languages show a superficial syntactical similarity, but they have deep underlying
differences.
Type erasure versus reified generics
Generics in Java are a language-only construction; they are implemented only in the compiler. The generated
classfiles include generic signatures only in the form of metadata (allowing the compiler to compile new classes
against them). The runtime has no knowledge of the generic type system; generics are not part of the JVM. Instead,
generics classes and methods are transformed during compilation through a process known as type erasure. During
this process the compiler replaces all generic types with their raw version and inserts casts/checks appropriately in
client code where the type and its methods are used. The resulting byte code will contain no references to any
generic types or parameters (See also Generics in Java).
C# builds on support for generics from the virtual execution system itself, i.e. it is not just a language feature. The
language is merely a front-end for cross-language generics support in the CLR. During compilation generics are
verified for correctness, but code generation for actually implementing the generics are deferred to class-load time.
Client code (code invoking generic methods/properties) are fully compiled and can safely assume generics to be
type-safe. This is called reification. Unlike with the Java generics, there is no need to inject down-casts or
type-checks in clients code. At runtime, when a unique set of type parameters for a generic class/method/delegate is
encountered for the first time, the class loader/verifier will synthesize a concrete class descriptor and generate
method implementations. During the generation of method implementations all reference types will be considered a
single type, as reference types can safely share the same implementations. Note, this is merely for the purpose of the
implementing code. Different sets of reference types will still have unique type descriptors; their method tables will
merely point to the same code.
The Java design imposes restrictions on the developer compared to the C# design. The following list is not
exhaustive (see also Java Generics FAQs - Frequently Asked Questions [5] by Angelika Langer):
Java C#
checks and downcasts are injected into client code (the code referencing the
cs). Compared to non-generic code with manual casts, these casts will be the
6] . But compared to compile-time verified code which would not need runtime
nd checks, these operations represent a performance overhead.
ot use primitive types as type parameters; instead the developer must use the
er type corresponding to the primitive type. This incurs extra performance overhead
uiring boxing and unboxing conversions as well a memory and garbage collection
re because the wrappers will be heap allocated as opposed to stack allocated.
ic exceptions are not allowed [7] and the can not use a type parameter in a catch
[8]
members are shared across all generic realizations [9] (during type erasure all
tions are folded into a single class)
parameters cannot be used in declarations of static fields/methods or in definitions
ic inner classes
t "import" a particular realization of a generic class
nt size="7.49">
ort java.util.List // illegal
ont>
C#/.NET generics guarantees type-safety and is verified at compile time and no extra checks/casts are necessary
runtime. Hence, generic code will run faster than non-generic code (and type-erased code) which require casts w
handling non-generic or type-erased objects.
Primitive and value types are allowed as type parameters in generic realizations. At runtime code will be
synthesized and compiled for each unique combination of type parameters upon first use. Generics which are
realized with primitive/value type do not require boxing/unboxing conversions.
Can both define generic exceptions and use those in catch clauses
Static members are separate for each generic realization. A generic realization is a unique class.
No restrictions on use of type parameters
Can "import" (using directive) a specific realization with an alias
using StringList = System.Collections.Generic.List

Comparison of Java and C Sharp 73
t create an array where the component type is a generic realization (concrete
eterized type)
nt size="7.49">
ect tenPairs =
new Pair[10]; // error
ont>
t create an array where the component type is a type parameter
nt size="7.49">
lic class Lookup {
public TValue[] GetEmptyValues(TKey key) {
return new TValue[0]; // error
}
ont>
A generic realization is a 1st class citizen and can be used as any other class; also an array component
object tenPairs =
new Pair[10]; // ok
Type parameters represent actual, discrete classes and can be used like any other type within the generic definiti
is no class literal for a concrete realization of a generic type A generic realization is an actual class.
public class Lookup {
public TValue[] GetEmptyValues(TKey key) {
return new TValue[0]; // ok
}
}
ceof is not allowed with type parameters or concrete generic realizations The is and as operators work the same for type parameters as for any other type.
ot create new instances using a type parameter as the type With a constructor constraint, generic methods or methods of generic classes can create instances of classes wh
information is erased during compilation. Special extensions to reflection must be
o discover the original type.
tion cannot be used to construct new generic realizations. During compilation extra
typecasts) are injected into the client code of generics. This precludes creating new
tions later.
have default constructors.
Type information about C# generic types is fully preserved at runtime, and allows complete reflection support a
well as instantiation of generic types.
Reflection can be used to create new realizations for new combinations of type parameters.
C# allows generics directly for primitive types. Java, instead, allows the use of boxed types as type parameters (e.g.,
List instead of List), but this comes at a small cost since all such values need to be heap-allocated
(however, a generic type can be specialized with an array type of a primitive type in Java, for example List is
allowed). [10]
Migration compatibility
Java's type erasure design was motivated by a design requirement to achieve migration compatibility - not to be
confused with backward compatibility. In particular the original requirements was "... there should be a clean,
demonstrable migration path for the Collections APIs that were introduced in the Java 2 platform" [11] . This was
interpreted [12] by the designers as meaning that any new generic collections should be passable to methods which
expected one of the preexisting collection classes.
Migration compatibility solves a hypothetical, temporal situation where you have two software products (A,B) used
by you to build software product C. Both A and B are beyond your control, e.g. supplied by external vendors.
Product B builds upon product A - i.e. they have a direct relationship which you are unable to intercept through
configuration or otherwise. Vendor-A moves product A to take advantage of generics and stops supporting the
non-generic version of A. The vendor of B does not move his product to take advantage of generics coordinated with
A, creating a situation where the non-generic code of B must be able to call/use generic code of A. Migration
compatibility allows the non-generic code of B to call and even manipulate objects originating in A.
C# generics were introduced into the language while preserving full backwards compatibility: Old code (pre C# 2.0)
runs unchanged on the new generics-aware runtime without recompilation. As for migration compatibility, new
generic collection classes and interfaces were developed which supplemented the non-generic .NET 1.x collections
rather than replacing them. In addition to generic collection interfaces, the new generic collection classes implement
the non-generic collection interfaces where possible. This allows new generic collections to be passed to preexisting
(non-generic aware) methods, as long as those methods are coded to use the collection interfaces and not the specific

Comparison of Java and C Sharp 74
classes. This is not full migration compatibility, however.
Covariance and contravariance
Covariance and contravariance is supported by both languages. Java has use-site variance which allows a single
generic class to declare members using both co- and contravariance. C# has define-site variance for generic
interfaces and delegates. Variance is not supported directly on classes but is supported through their implementation
of variant interfaces. C# also has use-site covariance support for methods and delegates.
Notation and special features
Special feature keywords
keyword feature, example usage
checked,
unchecked
In C#, checked statement blocks or expressions can enable run-time checking for arithmetic overflow.
get, set C# implements properties as part of the language syntax with their optional corresponding get and set accessors, as an alternative for
the accessor methods used in Java, which is not a language feature but a coding-pattern based on method name conventions.
goto C# supports the goto keyword. This can occasionally be useful, for example for implementing finite state machines or for generated
code, but the use of a more structured method of control flow is usually recommended (see criticism of the goto statement). Java
allows labeled breaks and continues, which make up for many of the uses of goto.
switch(color)
{
case Color.Blue:
Console.WriteLine("Color is blue"); break;
case Color.DarkBlue:
Console.WriteLine("Color is dark");
goto case Color.Blue;
// ...
}
out, ref C# has support for output and reference parameters. These allow returning multiple output values from a method, or passing values by
reference.
strictfp Java uses strictfp to guarantee the results of floating point operations remain the same across platforms.
switch In C#, the switch statement also operates on strings and longs but only allows fallthrough for empty statements. Java's switch
statement does not operate on strings nor long primitive type but falls through for all statements (excluding those with 'break').
throws Java requires every method to declare the checked exceptions or superclasses of the checked exceptions that it can throw. Any method
can also optionally declare the unchecked exception that it throws. C# has no such syntax.
public int readItem() throws java.io.IOException
{
// ...
}
using C#'s using causes the Dispose method (implemented via the IDisposable interface) of the object declared to be executed after the code
block has run or when an exception is thrown within the code block.
// Create a small file "test.txt", write a string,
// ... and close it (even if an exception occurs)
using (StreamWriter file = new StreamWriter("test.txt"))
{
file.Write("test");
}

Comparison of Java and C Sharp 75
Numeric applications
To adequately support applications in the field of mathematic and financial computation, several language features
exist. [13] In this category, Java provides the strictfp keyword, which enables strict floating-point calculations for a
region of code. This will ensure that calculations return the exact same result on all platforms. C# provides no
equivalent, but does provide the built-in decimal type, for accurate decimal floating-point calculations. This forgoes
the problems that exist with binary floating-point representations (float, double). Such binary representations are not
suited to accurately represent decimal numbers and hence introduce rounding errors. For financial applications, an
accurate decimal type is essential.
The BigDecimal class also provides such characteristics for Java. BigDecimal and BigInteger are types provided
with Java that allow arbitrary-precision representation of numbers. As of 2010 the current stable release of the .NET
framework (4.0) includes classes for manipulating arbitrary-precision integers and complex numbers (with operators
overloaded for easy use so that BigInteger objects can be used just like any other primitive data type) but still .NET
Framework lacks classes to deal with arbitrary-precision floating point numbers (see Arbitrary-precision arithmetic).
In Java there is no way to provide the same level of integration for library-defined types such as BigDecimal or
complex numbers as there is for the primitive types. For this purpose, C# provides the following:
• Operator overloading and indexers providing convenient syntax (see below).
• Implicit and explicit conversions; allow conversions such as exist for the built-in int type that can implicitly
convert to long.
• Valuetypes and generics based on valuetypes; in Java every custom type must be allocated on the heap, which is
detrimental for performance of both custom types and collections.
In addition to this, C# can help mathematic applications with the checked and unchecked operators that allow to
enable or disable run-time checking for arithmetic overflow for a region of code. It also offers rectangular arrays,
that have advantages over regular nested arrays for certain applications. [13]
Methods
Methods in C# are non-virtual by default, and have to be declared virtual explicitly if desired. In Java, all non-static
non-private methods are virtual. Virtuality guarantees that the most recent override for the method will always be
called, but incurs a certain runtime cost on invocation as these invocations cannot be normally inlined, and require an
indirect call via the virtual method table. However, some JVM implementations, including the Sun reference
implementation, implement inlining of the most commonly called virtual methods.
Java methods are virtual by default (although they can be "sealed" by using the final modifier to disallow
overriding). There is no way to let derived classes define a new, unrelated method with the same name.
This means that by default in C#, and only when explicitly asked in Java, you can define new methods in a derived
class with the same name and signature than the one in its base class. Which implies that when you call that method
on such an object, depending on the current knowledge of the caller (if it knows its exact subclass or not), the result
will be different.
In Java (by default), the subclass's method will be called, but you will be able to call the base class' own method if
needed. In C# (by default), the base class' method will be called, and you won't be able to intercept the call.
In very specific cases, when a base class is designed by a different person, and a new version introduces a method
with the same name and signature as some method already present in the derived class, problems can happen.
In Java, this will mean that the method in the derived class will implicitly override the method in the base class, even
though that may not be the intent of the designers of either class.
To prevent this versioning problem, C# requires that if a method should be overridden, the override keyword must be
specified. Otherwise, the method will "hide" the inherited method. A compiler warning to this effect is issued, which
can be silenced by specifying the new keyword. This avoids the problem which can arise from a base class being

Comparison of Java and C Sharp 76
extended with a protected/public method whose signature is already in use by a derived class.
Generator methods
Any C# method declared as returning IEnumerable, IEnumerator and/or the generic versions of these interfaces can
be implemented using yield syntax. This is a form of limited, compiler-generated continuations and can drastically
reduce the code required to traverse or generate sequences, although that code is just generated by the compiler
instead. The feature can also be used to implement infinite sequences, e.g. the sequence of Fibonacci numbers.
Below is an example of a C# generator method that takes an enumerable input (possibly an array of ints) and yields
the even numbers. The method will not iterate through all items on the invocation; rather it will return an iterator
which will pull items from numbers only on demand.
public static IEnumerable GetEven(IEnumerable numbers) {
}
foreach(int i in numbers) if (i % 2 == 0) yield return i;
In Java, generators can be defined only using (possibly anonymous) classes, requiring more boilerplate code.
Explicit interface implementation
In either language if a method (or property in C#) is specified with the same name and signature in multiple
interfaces, the members will clash when a class is designed which implements those interfaces. An implementation
will by default implement a common method for all of the interfaces. If separate implementations are required
(because the methods really do serve separate purposes, or because return values differ between the interfaces) C#'s
explicit interface implementation will solve the problem, though allowing different results for the same method,
depending on the current cast of the object. In Java there is no way to solve this problem other than cleaning the code
and refactoring one or more of the interfaces to avoid name clashes.
Closures
A closure is an inline function which captures variables from its lexical scope.
[14] [15]
C# supports closures as anonymous methods or lambda expressions with full-featured closure semantics.
In Java, anonymous inner classes remains the preferred way to emulate closures. Aside from being a more verbose
construction, this approach also has some drawbacks compared to real closures, such as limited access to variables
from the enclosing scopes (only final members can be referenced).
When a reference to a method can be passed around for later execution, a problem arises about what to do when the
method has references to variables/parameters in its lexical scope. C# closures can fully capture any
variable/parameter from its lexical scope. In Java's anonymous inner classes only references to final members of the
lexical scope are allowed, thus requiring the developer to artificially introduce extra levels of indirections and boxing
primitive types if he wants to reference and update those from the inner class.
While Java does not currently feature closures, it has been announced that some form of closures will be included in
JDK 7. [16]

Comparison of Java and C Sharp 77
Language integrated query
C#s Language INtegrated Query (LINQ) is not really a single feature; rather it is a number of features designed to
work together to allow for in-language querying capabilities. LINQ has emerged as one of the most distinguishing
features between Java and C#.
LINQ consists of the following features:
• Extension methods allow existing interfaces/classes to be extended with new methods. Implementations can be
shared or an interface can have a dedicated implementation.
• Lambdas allow for expression of criteria in a functional fashion.
• Expression trees allow a specific implementation to capture a lambda as a concrete syntax tree rather than an
executable block. This can be leveraged by implementations to represent criteria in a different language, e.g. in
the form of a SQL where clause as is the case with e.g. Linq#LINQ_to_SQL
• Anonymous types and type inference supports capturing and working with the result type of a query. A query
may both join and project over query sources which may lead to a result type which cannot be named.
• Query expressions to support a syntax familiar to SQL.
• Nullable (lifted) types to allow for better match with query providers which support nullable types, like e.g. SQL.
Lambdas and expression trees
C# features a special type of in-line closures called lambdas. These are anonymous methods: they have a signature
and a body, but no name. They are not methods in that they cannot form part of a class interface. They are mainly
used to specify local function-valued arguments in calls to other methods, a technique mainly associated with
functional programming. On top of that, lambda functions can double as a way to define special data structures
called expression trees. Whether they are seen as an executable function or a data structure depends on compiler type
inference and what type of variable or parameter they are assigned/cast to. Lambdas and expression trees play key
roles in LINQ. Java does not feature lambdas or expression trees; its primary mechanism for inline scope capture and
method definition is the anonymous inner class syntax.
Partial methods
Related to partial classes C# allows partial methods to be specified within partial classes. A partial method is an
intentional declaration of a method with a number of restrictions on the signature. These restrictions ensure that if a
definition is not actually provided by any class part, then the method and every call to it can be safely erased. This
feature allows code to provide a large number of interception points (like the template method GoF design pattern)
without paying any runtime overhead if these extension points are not being used by another class part at compile
time. Java has no corresponding concept.
Extension methods
Using a special this designator on the first parameter of a method, C# allows the method to act as if it were a member
method of the type of the first parameter. This extension of the foreign class is purely syntactical. The extension
method needs to be static and defined within a purely static class. It must obey any restriction on such external static
methods and thus cannot break object encapsulation. The "extension" is only active within scopes where the
namespace of the static host class has been imported. Java has no corresponding concept.

Comparison of Java and C Sharp 78
Conditional compilation
Unlike Java, C# implements conditional compilation using preprocessor directives. It also provides a Conditional
attribute to define methods that are only called when a given compilation constant is defined. This way, assertions
can be provided as a framework feature with the method Debug.Assert(), which is only evaluated when the DEBUG
constant is defined. Since version 1.4, Java provides a language feature for assertions, which are turned off at
runtime by default but can be enabled using the "-enableassertions" or "-ea" switch when invoking the JVM.
Namespaces and source files
C#'s namespaces are similar to those in C++. Unlike package names in Java, a namespace is not in any way tied to
location of the source file. While it's not strictly necessary for a Java source file location to mirror its package
directory structure, it is the conventional organization.
Both languages allow importing of classes (e.g., import java.util.* in Java), allowing a class to be referenced using
only its name. Sometimes classes with the same name exist in multiple namespaces or packages. Such classes can be
referenced by using fully qualified names, or by importing only selected classes with different names. To do this,
Java allows importing a single class (e.g., import java.util.List). C# allows importing classes under a new local name
using the following syntax: using Console = System.Console. It also allows importing specializations of classes in
the form of using IntList = System.Collections.Generic.List.
Java has a static import syntax that allows using the short name of some or all of the static methods/fields in a class
(e.g., allowing foo(bar) where foo() can be statically imported from another class). C# has a static class syntax (not
to be confused with static inner classes in Java), which restricts a class to only contain static methods. C# 3.0
introduces extension methods to allow users to statically add a method to a type (e.g., allowing foo.bar() where bar()
can be an imported extension method working on the type of foo).
The Sun Microsystems Java compiler requires that a source file name must match the only public class inside it,
while C# allows multiple public classes in the same file, and puts no restrictions on the file name. C# 2.0 and later
allows splitting a class definition into several files by using the partial keyword in the source code. In Java, a public
class will always be in its own source file. In C#, source code files and logical units separation are not tightly related.
Exception handling
Java supports checked exceptions (in addition to unchecked exceptions). C# only supports unchecked exceptions.
Checked exceptions force the programmer to either declare the exception thrown in a method, or to catch the thrown
exception using a try-catch clause.
Checked exceptions can encourage good programming practice, ensuring that all errors are dealt with. However
Anders Hejlsberg, chief C# language architect, argues that they were to some extent an experiment in Java and that
[17] [18]
they haven't been shown to be worthwhile except in small example programs.
One criticism is that checked exceptions encourage programmers to use an empty catch block (catch (Exception e)
{}), which silently eats exceptions, rather than letting the exceptions propagate to a higher-level exception-handling
routine. Another criticism of checked exceptions is that a new implementation of a method may cause unanticipated
checked exceptions to be thrown, which is a contract-breaking change. This can happen in methods implementing an
interface that only declares limited exceptions, or when the underlying implementation of a method changes. To
allow for such unanticipated exceptions to be thrown, some programmers simply declare the method can throw any
type of exception ("throws Exception"), which defeats the purpose of checked exceptions. In some cases however,
exception chaining can be applied instead; re-throwing the exception in a wrapper exception. For example, if an
object is changed to access a database instead of a file, an SQLException could be caught and re-thrown as an
IOException, since the caller may not need to know the inner workings of the object.

Comparison of Java and C Sharp 79
There are also differences between the two languages in treating the try-finally statement. The finally is always
executed, even if the try block contains control-passing statements like throw or return. In Java, this may result in
unexpected behavior if the try block is left by a return statement with some value, and then the finally block that is
executed afterwards is also left by a return statement with a different value. C# resolves this problem by prohibiting
any control-passing statements like return or break in the finally block.
A common reason for using try-finally blocks is to guard resource managing code, thus guaranteeing the release of
precious resources in the finally block. C# features the using statement as a syntactic shorthand for this common
scenario, in which the Dispose() method of the object of the using is always called.
Finally blocks
Java allows flow of control to leave the finally block of a try statement, regardless of the way it was entered. This
can cause another control flow statement (such as return) to be terminated mid-execution. For example:
int foo() {
}
try {
return 0;
} finally {
}
return 1;
In the above code, the return statement within try block causes control to leave it, and therefore finally block is
executed before the actual return happens. However, finally block itself performs a return as well; thus, the original
return that caused it to be entered is not actually executed, and the above method returns 1 rather than 0.
C# does not allow any statements which allow control flow to leave the finally block prematurely, except for throw.
In particular, return is not allowed at all, goto is not allowed if the target label is outside the finally block, and
continue and break are not allowed if the nearest enclosing loop is outside the finally block.
Lower level code
The Java Native Interface (JNI) feature allows Java programs to call non-Java code. However, JNI does require the
code being called to follow several conventions and impose restrictions on types and names used. This means that an
extra adaption layer between legacy code and Java is often needed. This adaption code must be coded in a non-Java
language, often C or C++. Java Native Access (JNA) allows easier calling of native code that only requires writing
Java code, but comes at a performance cost.
In addition, third party libraries provide for Java-COM bridging, e.g. JACOB [19] (free), and J-Integra for COM [20]
(proprietary).
.NET Platform Invoke (P/Invoke) offers the same capability by allowing calls from C# to what Microsoft refers to as
unmanaged code. Through metadata attributes the programmer can control exactly how the parameters and results
are marshalled, thus avoiding the need for extra adaption code. P/Invoke allows almost complete access to
procedural APIs (such as Win32 or POSIX), but limited access to C++ class libraries.
In addition, .NET Framework also provides a .NET-COM bridge, allowing access to COM components as if they
were native .NET objects.
C# also allows the programmer to disable the normal type-checking and other safety features of the CLR, which then
enables the use of pointer variables. When using this feature, the programmer must mark the code using the unsafe
keyword. JNI, P/Invoke, and "unsafe" code are equally risky features, exposing possible security holes and
application instability. An advantage of unsafe, managed code over P/Invoke or JNI is that it allows the programmer
to continue to work in the familiar C# environment to accomplish some tasks that otherwise would require calling

Comparison of Java and C Sharp 80
out to unmanaged code. An assembly (program or library) using unsafe code must be compiled with a special switch
and will be marked as such. This enables runtime environments to take special precautions before executing
potentially harmful code.
Runtime environments
Java (the programming language) is designed to execute on the Java platform via the Java Runtime Environment
(JRE). The Java platform includes the Java Virtual Machine (JVM) as well as a common set of libraries. The JRE
was originally designed to support interpreted execution with final compilation as an option. Most JRE environments
execute fully or at least partially compiled, possibly with adaptive optimization. The Java compiler produces Java
bytecode. Upon execution the bytecode is loaded by the Java runtime and either interpreted directly or compiled to
machine instructions and then executed.
C# is designed to execute on the Common Language Runtime (CLR). The CLR is designed to execute fully
compiled code. The C# compiler produces Common Intermediate Language instructions. Upon execution the
runtime loads this code and compiles to machine instructions on the target architecture.
Language history and evolution
Java
Java is older than C# and has built up a large and highly active user base, becoming the lingua franca in many
modern branches of computer science, particularly areas which involve networking. Java dominates programming
courses at high school and college level in the United States, and there are currently more Java than C# books. [21]
Java's maturity and popularity have ensured more third party Java API and libraries (many of them open source) than
C#.
An occasionally voiced criticism [22] of the Java language is that it evolves slowly, lacking some features which
make fashionable programming patterns and methodologies easier. Some critics suggest that the designers of C#
may pander too quickly to current trends in programming, thus lacking focus and simplicity. Java's designers seem to
have taken a more conservative stand on adding major new features to their language syntax than other current
languages, perhaps not wanting to tie the language too tightly with trends which may prove to be dead ends.
These trends have been broken with the Java 5.0 release, which introduced several new major language features: a
foreach construct, autoboxing, methods with variable number of parameters (varargs), enumerated types, generic
types, and annotations. With the exception of Generics, C# included all these features from its beginning, some
under different names. [23] Proposals and specifications for the new features had been worked on in the Java
community for considerable time before they were introduced. Indeed, some had been in gestation since before C#'s
initial release (e.g., work on Generics formally began in May 1999 [24] ) such was the Java community's conservatism
at that time.
Problem-specific language additions to Java have been considered and, for now at least, rejected. This approach,
along with a number of other new languages and technologies that address themselves specifically towards current
programming trends, has sparked a renewed debate within the Java camp about the future direction of the Java
language and whether its 'conservative evolution' is right.
As of 2008 debate continued over the inclusion of closures [25] and properties [26] into the language syntax for Java 7.

Comparison of Java and C Sharp 81
C#
By contrast, C# is a relatively new language. Microsoft has studied existing languages such as Java and Object
Pascal, and has changed some aspects of the language and runtime environment in response to perceived failures and
difficulties with its predecessors. C# accommodates constructs more commonly found in languages such as C++,
Delphi (the design of which was Anders Hejlsberg's principal job when he was at Borland), and, in recent C#
versions, borrows from dynamic scripting languages such as Ruby and Python.
C# 3.0 adds SQL-like language integrated queries suited for querying data from collections, databases or XML
documents, building upon general-purpose language features, including lambda expressions and extension methods,
to allow queries to be expressed and optimized for user types.
Before creating C#, Microsoft implemented a modified Java environment, called J++, adding new features in a
manner which was in direct contravention to the standards and conventions ensuring the platform neutrality which
lies at the heart of Java. This violated the license agreement Microsoft had signed, requiring that standards and
specifications be strictly adhered to in return for using the Java name and brand logos. Sun Microsystems sued, and
in settling the suit, Microsoft agreed to discontinue J++. (The settlement allowed other existing Java-using Microsoft
products to continue such use for seven years. [27] ) With the release of the .NET framework (and C#), the project was
revived in the form of J#.
See also
• Comparison of C# and VB.NET
• Comparison of Java and C++
• Java programming language
• Comparison of the Java and .Net platforms
External links
• C# and Java: Comparing Programming Languages [28] at MSDN
• A Comparison of C# and Java [29]
• Java vs. C# - Code for Code Comparison [30]
• Nine Language Performance Round-up [31]
• Java and C-Sharp Compared [32]
• MSDN: The C# Programming Language for Java Developers [33]
• 31 Differences between C# and Java [34]
• Standard ECMA-334 C# Language specification [35]
• Java Language Specification (Sun) [36]
References
[1] http:/ / blogs. sun. com/ javafx/ entry/ how_to_use_javafx_in
[2] August 1998 Java News (http:/ / www. cafeaulait. org/ 1998august. html)
[3] Java Language Specification Third Edition: section 15.9 Class Instance Creation Expressions (http:/ / java. sun. com/ docs/ books/ jls/
third_edition/ html/ expressions. html#41147)
[4] Goetz, Brian (26 July 2005). "Java theory and practice: Be a good (event) listener" (http:/ / www. ibm. com/ developerworks/ java/ library/
j-jtp07265/ index. html). IBM Developer Works. . Retrieved 2008-12-23.
[5] http:/ / www. angelikalanger. com/ GenericsFAQ/ JavaGenericsFAQ. html
[6] http:/ / www. angelikalanger. com/ GenericsFAQ/ FAQSections/ TechnicalDetails. html#FAQ110
[7] http:/ / www. angelikalanger. com/ GenericsFAQ/ FAQSections/ TechnicalDetails. html#FAQ302
[8] http:/ / www. angelikalanger. com/ GenericsFAQ/ FAQSections/ TechnicalDetails. html#FAQ304
[9] there one instances of a static field per instantiation of a parameterized type? (http:/ / www. angelikalanger. com/ GenericsFAQ/
FAQSections/ TypeParameters. html#Is)
[10] Generics in C#, Java, and C++ (http:/ / www. artima. com/ intv/ genericsP. html)

Comparison of Java and C Sharp 82
[11] JSR 14: http:/ / www. jcp. org/ en/ jsr/ detail?id=14
[12] http:/ / gafter. blogspot. com/ 2004/ 09/ puzzling-through-erasure-answer. html
[13] Java for Scientific Computation: Prospects and Problems (http:/ / www. pds. ewi. tudelft. nl/ pubs/ papers/ scicomp01. pdf)
[14] Richter, Jeffrey (April 2001). "An Introduction to Delegates" (http:/ / msdn. microsoft. com/ en-ca/ magazine/ cc301810. aspx). MSDN
Magazine. . Retrieved 2008-12-23.
[15] Campbell, Dustin (9 February 2007). "What's In A Closure?" (http:/ / diditwith. net/
PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b. aspx). Did it with .NET. . Retrieved 2008-12-23.
[16] Closures Coming in Java 7 (http:/ / java. dzone. com/ news/ closures-coming-java-7)
[17] The Trouble with Checked Exceptions (http:/ / www. artima. com/ intv/ handcuffs. html)
[18] Why doesn't C# have exception specifications? (http:/ / msdn2. microsoft. com/ en-us/ vcsharp/ aa336812. aspx)
[19] http:/ / jacob-project. sourceforge. net/
[20] http:/ / j-integra. intrinsyc. com/ products/ com/
[21] O'Reilly, Tim (2006-08-02). "Programming Language Trends" (http:/ / radar. oreilly. com/ archives/ 2006/ 08/
programming_language_trends_1. html). Radar. O'Reilly. .
[22] i-Technology Viewpoint: Java's Not Evolving Fast Enough (http:/ / au. sys-con. com/ node/ 163294)
[23] Java 5 catches up with C# (http:/ / www. barrycornelius. com/ papers/ java5/ )
[24] JSR 14: Add Generic Types To The JavaTM Programming Language (http:/ / jcp. org/ en/ jsr/ detail?id=014)
[25] Debate over closures for Java (http:/ / gafter. blogspot. com/ 2006/ 09/ debate-over-closures-for-java. html)
[26] Property Support in Java, the Java Way (http:/ / www. javalobby. org/ java/ forums/ t88090. html)
[27] CNET. "Sun, Microsoft settle Java suit" (http:/ / news. cnet. com/ 2100-1001-251401. html). .
[28] http:/ / msdn. microsoft. com/ en-us/ library/ ms836794. aspx
[29] http:/ / www. 25hoursaday. com/ CsharpVsJava. html
[30] http:/ / www. javacamp. org/ javavscsharp/
[31] http:/ / www. osnews. com/ story. php?news_id=5602
[32] http:/ / www. csharphelp. com/ archives/ archive96. html
[33] http:/ / msdn. microsoft. com/ en-us/ library/ ms228602. aspx
[34] http:/ / www. geeks. ltd. uk/ Knowledgebase/ Compare-c-sharp-java. html
[35] http:/ / www. ecma-international. org/ publications/ standards/ Ecma-334. htm
[36] http:/ / java. sun. com/ docs/ books/ jls/
Comparison of Java and C++
This is a comparison of the Java programming language with the C++ programming language.
Design aims
The differences between the C++ and Java programming languages can be traced to their heritage, as they have
different design goals.
• C++ was designed mainly for systems programming, extending the C programming language. To this procedural
programming language designed for efficient execution, C++ has added support for statically-typed
object-oriented programming, exception handling, scoped resource management, and generic programming, in
particular. It also added a standard library which includes generic containers and algorithms.
• Java was created initially to support network computing. It relies on a virtual machine to be secure and highly
portable. It is bundled with an extensive library designed to provide a complete abstraction of the underlying
platform. Java is a statically typed object-oriented language that uses a syntax similar to C, but is not compatible
with it. It was designed from scratch, with the goal of being easy to use and accessible to a wider audience.
The different goals in the development of C++ and Java resulted in different principles and design trade-offs between
the languages. The differences are as follows :

Comparison of Java and C++ 83
C++ Java
Compatible with C source code, except for a few corner cases. No backward compatibility with any previous language. The syntax is
however strongly influenced by C/C++.
Write once compile anywhere (WOCA) Write once run anywhere / everywhere (WORA / WORE)
Allows both procedural programming and object-oriented
programming.
Encourages an object oriented programming paradigm.
Allows direct calls to native system libraries. Call through the Java Native Interface and recently Java Native Access
Exposes low-level system facilities. Runs in a protected virtual machine.
Only provides object types and type names. Is reflective, allowing metaprogramming and dynamic code generation at
Has multiple binary compatibility standards (commonly Microsoft
and Itanium/GNU)
Optional automated bounds checking. (e.g. the at() method in
vector and string containers)
runtime.
Has a binary compatibility standard, allowing runtime check of correctness
of libraries.
Normally performs bounds checking. HotSpot can remove bounds checking.
Supports native unsigned arithmetic. No native support for unsigned arithmetic.
Standardized minimum limits for all numerical types, but the actual
sizes are implementation-defined. Standardized types are available
as typedefs (uint8_t, ..., uintptr_t).
Pointers, References, and pass by value are supported
Explicit memory management, though third party frameworks exist
to provide garbage collection. Supports destructors.
Supports class, struct, and union and can allocate them on heap or
stack
Standardized limits and sizes of all primitive types on all platforms.
Primitive data types always passed by value. Objects are passed by nullable
reference (comparable to using pointers for all class or struct parameters in
C++). [1]
Automatic garbage collection (can be triggered manually). Doesn't have the
concept of Destructor and usage of finalize() is not recommended.
Supports only class and allocates them on the heap. Java SE 6 optimizes with
escape analysis to allocate some objects on the stack.
Allows explicitly overriding types. Rigid type safety except for widening conversions. Autoboxing/Unboxing
The C++ Standard Library has a much more limited scope and
functionality than the Java standard library but includes: Language
support, Diagnostics, General Utilities, Strings, Locales, Containers,
Algorithms, Iterators, Numerics, Input/Output and Standard C
Library. The Boost library offers much more functionality including
threads and network I/O. Users must choose from a plethora of
(mostly mutually incompatible) third-party libraries for GUI and
other functionality.
added in Java 1.5.
The standard library has grown with each release. By version 1.6 the library
included support for locales, logging, containers and iterators, algorithms,
GUI programming (but not using the system GUI), graphics, multi-threading,
networking, platform security, introspection, dynamic class loading, blocking
and non-blocking I/O, and provided interfaces or support classes for XML,
XSLT, MIDI, database connectivity, naming services (e.g. LDAP),
cryptography, security services (e.g. Kerberos), print services, and web
services. SWT offers an abstraction for platform specific GUIs.
Operator overloading for most operators Meaning of operators is immutable.
Full multiple inheritance, including virtual inheritance. Single inheritance only from classes, multiple from interfaces.
Compile time Templates Run time Generics
Function pointers, function objects, lambdas (in C++0x) and
interfaces
No standard inline documentation mechanism. 3rd party software
(e.g. Doxygen) exists.
const keyword for defining immutable variables and member
functions that do not change the object.
No function pointer mechanism. Instead idioms such as Interfaces, Adapters
and Listeners are extensively used.
Javadoc standard documentation
final provides a limited version of const, equivalent to type* const pointers
for objects and plain const of primitive types only. No const member
functions, nor any equivalent to const type* pointers.
Supports the goto statement. Supports labels with loops and statement blocks.

Comparison of Java and C++ 84
Source code can be written to be platform independent (can be
compiled for Windows, BSD, Linux, Mac OS X, Solaris etc. without
needing modification) and written to take advantage of platform
specific features. Is typically compiled into native machine code.
Is compiled into byte code for the JVM. Is dependent on the Java platform
but the source code is typically written not to be dependent on operating
system specific features.
C++ is a powerful language designed for system programming. The Java language was designed to be simple and
easy to learn with a powerful cross-platform library. The Java standard library is considerably large for a standard
library. However, Java does not always provide full access to the features and performance of the platform that the
software runs on. The C++ standard libraries are simple and robust providing containers and associative arrays. [2]
Language features
Syntax
• Java syntax has a context-free grammar which can be parsed by a simple LALR parser. Parsing C++ is somewhat
more complicated; for example, Foo(3); is a sequence of comparisons if Foo is a variable, but it creates an
object if Foo is the name of a class template.
• C++ allows namespace level constants, variables, and functions. All such Java declarations must be inside a class
or interface.
• In C++ declarations, a class name declares an object of that class as a value (a.k.a. value semantics). There is no
way to do this in Java. Objects are not values in Java. In Java declarations, a class name declares a reference to an
object of that class (a.k.a. reference semantics). The equivalent way to do this in C++ is to use "*" to declare a
pointer.
• In C++, the operator "." takes an object as the left operand and accesses a member of the object. Since objects
cannot be values in Java, and all objects are accessed through references, this cannot be done in Java. In Java, the
"." operator takes a reference to an object as the left operand and access a member of that object. The equivalent
operator in C++ is "->".
e="7.71">
{ // Declares class Foo
; // Member variable
: x(0) { // Constructor for Foo,
// initializes x
ar(int i) { // Member function bar()
eturn 3*i + x;
e="7.71">
C++ Java
es a to be a Foo object value,
lized using the default constructor
wanted to use another constructor,
uld declare it as "Foo a(args);"
class Foo { // Defines class Foo
public int x = 0; // Member variable,
// with initializer
public Foo() { // Constructor for Foo
}
public int bar(int i) {// Member method bar()
return 3*i + x;
}
}
Foo a;
// declares a to be a reference to a Foo object
a = new Foo();
// initializes using the default constructor
// If you wanted to use another constructor,
// you would declare it as "Foo a = new Foo(args);

Comparison of Java and C++ 85
e="7.71">
;
the contents of a to a new Foo object b;
ative syntax is "Foo b(a)"
Foo b = a.clone();
// copies the values of all members
// of this instance if, and only if,
// Foo implements a public method called
// clone() which returns a new copy of the object
e="7.71">a.x = 5; // modifies the object a a.x = 5; // modifies the object
e="7.71">
.x
es c to be a pointer to a
ject (initially
ned; could point anywhere)
e="7.71">
oo();
c to reference a new Foo object
e="7.71">
c;
d to reference the same object as c
e="7.71">
es the object referenced by c
e="7.71">
// invokes Foo::bar() for a
; // invokes Foo::bar() for *c
e="7.71">
->x

Comparison of Java and C++ 86
C++ Java
const Foo *a; // you cannot modify the object
//pointed to by a through a
private final Foo a;//Use getA() instead of a
public Foo getA(){
return a.clone()
}
a = new Foo(); a=new Foo();//Only in constructor
a->x = 5;
// ILLEGAL
Foo *const b = new Foo();
// you can declare a "const" pointer
b = new Foo();
//ILLEGAL, you can't re-bind it
b->x = 5;
// LEGAL, you can still modify the object
getA().x=5;
//Only modifies a clone of a's x, not a.x
final Foo b = new Foo();
// you can declare a "final" reference
b = new Foo();
// ILLEGAL, you can't re-bind it
b.x = 5;
// LEGAL, you can still modify the object
• C++ supports goto statements; Java enforces structured control flow, and relies on labelled break and labelled
continue statements to provide some goto-like functionality. Some commenters point out that these labelled flow
control statements break the single point-of-exit property of structured programming. [3]
• C++ provides low-level features which Java lacks. In C++, pointers can be used to manipulate specific memory
locations, a task necessary for writing low-level operating system components. Similarly, many C++ compilers
support inline assembler. In Java, such code has to reside in external libraries, and can only be accessed through
the Java Native Interface with a significant overhead for each call.
Semantics
• C++ allows default values for arguments of a function/method, Java does not. However, method overloading can
be used to obtain similar results in Java.
• The minimal compilation unit in C++ is a function; the compilation unit in Java is a class. In C++, functions can
be compiled separately. In Java, to compile and maintain methods separately requires moving them into super and
extended classes or using some other code refactoring technique.
• C++ allows a range of implicit conversions between native types, and also allows the programmer to define
implicit conversions involving user-defined types. In Java, only widening conversions between native types are
implicit; other conversions require explicit cast syntax.
• A consequence of this is that although loop conditions (if, while and the exit condition in for) in Java and C++
both expect a boolean expression, code such as if(a = 5) will cause a compile error in Java because there is no
implicit narrowing conversion from int to boolean. This is handy if the code was a typo for if(a == 5). Yet
current C++ compilers usually generate a warning when such an assignment is performed within a conditional
expression.
• For passing parameters to functions, C++ supports both pass-by-reference and pass-by-value. In Java, parameters
are always passed by value. [4] However, in Java all non-primitive values are references to objects (in C++ terms,
they are (smart)-pointers). Objects are not values in Java and only their references can be manipulated; C++
developers who are used to having objects as values may confuse this with pass-by-reference.
• Java built-in types are of a specified size and range defined by the virtual machine; In C++, a minimal range of
values is defined for built-in types, but the exact representation (number of bits) can be mapped to whatever
native types are supported on a given platform.
• For instance, Java characters are 16-bit Unicode characters, and strings are composed of a sequence of such
characters. C++ offers both narrow and wide characters, but the actual size of each is platform dependent, as is

Comparison of Java and C++ 87
the character set used. Strings can be formed from either type.
• The rounding and precision of floating point values and operations in C++ is platform dependent. Java provides
an optional strict floating-point model that guarantees consistent results across platforms, though possibly at the
cost of slower run-time performance.
• In C++, pointers can be manipulated directly as memory address values. Java does not have pointers — it only
has object references and array references, neither of which allow direct access to memory addresses. In C++ one
can construct pointers to pointers, while Java references only access objects.
• In C++ pointers can point to functions or methods (function pointers or functors). The equivalent mechanism in
Java uses object or interface references.
• Through the use of stack-allocated objects, C++ supports scoped resource management, a technique used to
automatically manage memory and other system resources that supports deterministic object destruction. Yet,
scoped resource management in C++ cannot be guaranteed; it is only a design pattern, and hence relies on
programmers' adherence. Java supports automatic memory management using garbage collection, but other
system resources (windows, communication ports, threads) often have to be explicitly released if the garbage
collector can not determine they are no longer used.
• C++ features programmer-defined operator overloading which is not supported in Java. The only overloaded
operators in Java are the "+" and "+=" operators, which concatenate strings as well as performing addition.
• Java features standard API support for reflection and dynamic loading of arbitrary new code.
• C++ supports static and dynamic linking of binary to manage the space required for binary and performance.
• Java has generics, whose main purpose is to provide type-safe containers. C++ has templates, which provide more
extensive support for generic programming.
• Both Java and C++ distinguish between native types (these are also known as "fundamental" or "built-in" types)
and user-defined types (these are also known as "compound" types). In Java, native types have value semantics
only, and compound types have reference semantics only. In C++ all types have value semantics, but a reference
can be created to any type, which will allow the object to be manipulated via reference semantics.
• C++ supports multiple inheritance of arbitrary classes. In Java a class can derive from only one class, but a class
can implement multiple interfaces (in other words, it supports multiple inheritance of types, but only single
inheritance of implementation).
• Java explicitly distinguishes between interfaces and classes. In C++ multiple inheritance and pure virtual
functions make it possible to define classes that function almost like Java interfaces do, with a few small
differences.
• Java has both language and standard library support for multi-threading. The synchronized keyword in Java
provides simple and secure mutex locks to support multi-threaded applications, though synchronized sections
have to be left in LIFO order. Java also provides robust and complex libraries for more advanced multi-threading
synchronization. In C++ there is currently no defined memory model for multi-threading; however, third party
libraries provide support roughly equivalent to that of Java; obvious difference being the non-uniformity of these
C++ libraries.
• C++ methods can be declared as virtual functions, which means the method to be called is determined by the
run-time type of the object. By default, methods in C++ are not virtual. In Java, methods are virtual by default,
but can be made non-virtual by using the final keyword.
• C++ enumerations are primitive types and support conversion to and comparison with other integer types. Java
enumerations are actually instances of a class (they extend java.lang.Enum) and may therefore define
constructors, fields, and methods as any other class.

Comparison of Java and C++ 88
Resource management
• Java offers automatic garbage collection. Memory management in C++ is usually done through constructors,
destructors, and smart pointers. The C++ standard permits garbage collection, but does not require it; garbage
collection is rarely used in practice. The enforced use of automatic garbage collection means that writing
real-time software can be difficult in Java. [3]
• C++ can allocate arbitrary blocks of memory. Java only allocates memory through object instantiation. (Note that
in Java, the programmer can simulate allocation of arbitrary memory blocks by creating an array of bytes. Still,
Java arrays are objects.)
• Java and C++ use different idioms for resource management. Java relies mainly on garbage collection, which can
only reclaim memory and may be a last shot at other resources, while C++ relies mainly on the RAII (Resource
Acquisition Is Initialization) idiom. This is reflected in several differences between the two languages:
• In C++ it is common to allocate objects of compound types as local stack-bound variables which are destroyed
when they go out of scope. In Java compound types are always allocated on the heap and collected by the
garbage collector (except in virtual machines that use escape analysis to convert heap allocations to stack
allocations).
• C++ has destructors, while Java has finalizers. Both are invoked prior to an object's deallocation, but they
differ significantly. A C++ object's destructor must be implicitly (in the case of stack-bound variables) or
explicitly invoked to deallocate the object. The destructor executes synchronously just prior to the point in the
program at which the object is deallocated. Synchronous, coordinated uninitialization and deallocation in C++
thus satisfy the RAII idiom. In Java, object deallocation is implicitly handled by the garbage collector. A Java
object's finalizer is invoked asynchronously some time after it has been accessed for the last time and before it
is actually deallocated, which may never happen. Very few objects require finalizers; a finalizer is only
required by objects that must guarantee some clean up of the object state prior to deallocation — typically
releasing resources external to the JVM. In Java safe synchronous deallocation of resources has to be
performed explicitly using the try/finally construct.
• In C++ it is possible to have a dangling pointer – a stale reference to an object that has already been
deallocated; attempting to use a dangling pointer typically results in program failure. In Java, the garbage
collector won't destroy a referenced object.
• In C++ it is possible to have uninitialized primitive objects, Java enforces default initialization.
• In C++ it is possible to have an object that is allocated, but has no reachable reference to it. Such an
unreachable object cannot be destroyed (deallocated), and results in a memory leak. In contrast, in Java an
object will not be deallocated by the garbage collector until it becomes unreachable (by the user program).
(Note: weak references are supported, which work with the Java garbage collector to allow for different
strengths of reachability.) Garbage collection in Java prevents many memory leaks, but leaks are still possible
under some circumstances. [5]
• Java is more prone to leaking non-memory resources, while idiomatic C++ makes that much harder.
Libraries
• C++ provides cross-platform access to many features typically available in platform-specific libraries. Direct
access from Java to native operating system and hardware functions requires the use of the Java Native Interface.
Runtime
• C++ is normally compiled directly to machine code which is then executed directly by the operating system. Java
is normally compiled to byte-code which the Java virtual machine (JVM) then either interprets or JIT compiles to
machine code and then executes.

Comparison of Java and C++ 89
• Due to its unconstrained expressiveness, low level C++ language features (e.g. unchecked array access, raw
pointers, type punning) cannot be reliably checked at compile-time or without overhead at run-time. Related
programming errors can lead to low-level buffer overflows and segmentation faults. The Standard Template
Library provides higher-level abstractions (like vector, list and map) to help avoid such errors. In Java, low level
errors either cannot occur or are detected by the JVM and reported to the application in the form of an exception.
• The Java language requires specific behavior in the case of an out-of-bounds array access, which generally
requires bounds checking of array accesses. This eliminates a possible source of instability but usually at the cost
of slowing down execution. In some cases, compiler analysis can prove a bounds check unnecessary and
eliminate it. C++ has no required behavior for out-of-bounds access of native arrays, thus requiring no bounds
checking for native arrays. C++ standard library collections like std::vector, however, offer optional bounds
checking. In summary, Java arrays are "always safe; severely constrained; always have overhead" while C++
native arrays "have optional overhead; are completely unconstrained; are potentially unsafe."
Templates vs. Generics
Both C++ and Java provide facilities for generic programming, templates and generics, respectively. Although they
were created to solve similar kinds of problems, and have similar syntax, they are actually quite different.
C++ Templates Java Generics
Classes and functions can be templated. Classes and methods can be genericized.
Parameters can be any type or integral value. Parameters can only be reference types (not primitive types).
Separate copies of the class or function are likely to be generated for each type
parameter when compiled.
One version of the class or function is compiled, works for all
type parameters.
Objects of a class with different type parameters are different types at run time. Type parameters are erased when compiled; objects of a class
Implementation source code of the templated class or function must be included
in order to use it (declaration insufficient).
Templates can be specialized -- a separate implementation could be provided for
a particular template parameter.
Template parameters can have default arguments (only for template classes, not
functions).
Does not support wildcards. Instead, return types are often available as nested
typedefs.
Does not directly support bounding of type parameters, but metaprogramming
provides this [6]
with different type parameters are the same type at run time.
Signature of the class or function from a compiled class file is
sufficient to use it.
Generics cannot be specialized.
Generic type parameters cannot have default arguments.
Supports wildcard as type parameter if it is only used once.
Supports bounding of type parameters with "extends" and
"super" for upper and lower bounds, respectively; allows
enforcement of relationships between type parameters.
Allows instantiation of class of type parameter type. Does not allow instantiation of class of type parameter type
(except through reflection).
Type parameter of templated class can be used for static methods and variables. Type parameter of templated class cannot be used for static
methods and variables.
Static variables are not shared between classes of different type parameters. Static variables are shared between instances of a classes of
Templated classes and functions do not enforce type relations for type parameters
in their declaration. Use of a wrong type parameter results in the template code
"not working", usually generating an error message at a place in the template
code where an operation is not allowed for that type and not in the user's code.
Proper use of templated classes and functions is dependent on proper
documentation. Metaprogramming provides these features at the cost of
additional effort.
different type parameters.
Generic classes and functions can enforce type relationships for
type parameters in their declaration. Use of a wrong type
parameter results in a type error at the code that uses it.
Operations on parametrized types in generic code are only
allowed in ways that can be guaranteed to be safe by the
declaration. This results in greater type safety at the cost of
flexibility.

Comparison of Java and C++ 90
Templates are Turing-complete (see template metaprogramming). Generics are not Turing-complete.
Miscellaneous
• Java and C++ use different techniques for splitting up code in multiple source files. Java uses a package system
that dictates the file name and path for all program definitions. In Java, the compiler imports the executable class
files. C++ uses a header file source code inclusion system for sharing declarations between source files. (See
Comparison of imports and includes.)
• Compiled Java code files are generally smaller than code files in C++ as Java bytecode is usually more compact
than native machine code and Java programs are never statically linked.
• C++ compilation features an additional textual preprocessing phase, while Java does not. Thus some users add a
preprocessing phase to their build process for better support of conditional compilation.
• In both languages, arrays have a fixed size. In Java, arrays are first-class objects, while in C++ they are merely a
continuous run of their base objects, often referred to using a pointer to their first element and an optional length.
In Java, arrays are bounds-checked and know their length, while in C++ you can treat any subsequence as an
array in its own right. Both C++ and Java provide container classes (std::vector and java.util.ArrayList
respectively) which are resizable and store their size.
• Java's division and modulus operators are well defined to truncate to zero. C++ does not specify whether or not
these operators truncate to zero or "truncate to -infinity". -3/2 will always be -1 in Java, but a C++ compiler may
return either -1 or -2, depending on the platform. C99 defines division in the same fashion as Java. Both
languages guarantee (where a and b are integer types) that (a/b)*b + (a%b) == a for all a and b (b != 0). The C++
version will sometimes be faster, as it is allowed to pick whichever truncation mode is native to the processor.
• The sizes of integer types is defined in Java (int is 32-bit, long is 64-bit), while in C++ the size of integers and
pointers is compiler and ABI dependent within given constraints. Thus, carefully-written C++ code can take
advantage of the 64-bit processor's capabilities while still functioning properly on 32-bit processors. However,
care must be taken to write the C++ program in a portable manner. In contrast, Java's fixed integer sizes mean that
programmer error in this regard shouldn't be possible. This may incur a performance penalty since Java code
cannot run using an arbitrary processor's word size.
Performance
In addition to running a compiled Java program, computers running Java applications must also run the Java Virtual
Machine JVM, while compiled C++ programs can be run without external applications. Early versions of Java were
significantly outperformed by statically compiled languages such as C++. This is because the program statements of
these two closely related languages may compile to a few machine instructions with C++, while compiling into
several byte codes involving several machine instructions each when interpreted by a JVM. For example:
Java/C++ statement C++ generated code (x86) Java generated byte
vector[i]++; mov edx,[ebp+4h]
mov eax,[ebp+1Ch]
inc dword ptr [edx+eax*4]
aload_1
iload_2
dup2
iaload
iconst_1
While this may still be the case for embedded systems because of the requirement for a small footprint, it is
frequently argued that advances in just in time (JIT) compiler technology for long-running server and desktop Java
processes will close the performance gap.
iadd
iastore
code

Comparison of Java and C++ 91
Several studies of mostly numerical benchmarks argue that Java could potentially be faster than C++ in some
circumstances, [7] [8] [9] . However, it was shown that numerical (micro-)benchmarks are not appropriate for
evaluation of languages as compiler is able to optimize both cases equally, or eliminate benchmarked code entirely.
[10] [11] [12] If referring to a real world program, Java would suffer because of number of reasons: [13] [14] [15]
• All objects are allocated on the heap. For functions using small objects this can result in huge performance
degradation as stack allocation costs essentially zero.
• Methods are by-default virtual. This increases memory usage as much as several times for small objects because
of virtual function tables. Also, it induces performance penalty, because JIT compiler has to do additional
optimization passes even for de-virtualization of small functions.
• A lot of casting required even using standard containers induces performance penalty as it is needed to walk
through entire inheritance hierarchy.
• Virtual Java Machine Increases memory usage even further, thus reducing memory locality and increasing
chances of cache misses and therefore slowdown of the program.
• Lack of access to low level details does not allow developer to better optimize the program where the compiler is
unable to do so. [16]
It is argued, however, that compared to Java, C++ also has a number of downsides:
• Pointers make optimization difficult since they may point to arbitrary data. However this is obsoleted as new
compilers introduced strict-aliasing rule [17] and because of support of the C99 keyword restrict. [18]
• Java garbage collection may have better cache coherence than usual usage of malloc/new for memory allocation
as its allocations are generally made sequentially. Nevertheless, arguments exist that both allocators equally
fragment the heap and no one exhibits better cache locality.
• Run-time compilation can potentially use additional information available at run-time to optimise code more
effectively, such as knowing what processor the code will be executed on. However this claim is effectively made
obsolete as most state-of-the-art C++ compilers generate multiple code paths to employ full computational
abilities of the given system [19] .
Proprietary Control
C++ is not a trademark of any company or organization and is not owned by any individual. [20] Java is a trademark
of Sun Microsystems, which is now owned by Oracle. [21]
The C++ language is defined by ISO/IEC 14882, an ISO standard, which is published by the ISO/IEC
JTC1/SC22/WG21 committee. The Java language is defined by the Java Language Specification[36], a book which
is published by Sun (now Oracle).
External references
• Java and C++ Memory Management [22] — an exhaustive publication about object-oriented memory management
that compares Java and C++ in terms of Memory Modeling.
• How Java Differs from C [23] — excerpt from Java in a Nutshell by David Flanagan
• Java vs. C++ resource management comparison [24] - Comprehensive paper with examples
• Java vs C performance... again... [25] - In-depth discussion of differences between Java and C / C++ with regard to
performance

Comparison of Java and C++ 92
References
[1] Java is Pass-By-Value (http:/ / javadude. com/ articles/ passbyvalue. htm)
[2] Java and C++ Library (http:/ / en. wikibooks. org/ wiki/ C+ + _Programming/ Programming_Languages/ Comparisons/ Java#Libraries)
[3] Robert C. Martin (January 1997). "Java vs. C++: A Critical Comparison" (http:/ / www. objectmentor. com/ resources/ articles/ javacpp. pdf)
(PDF). .
[4] James Gosling, Bill Joy, Guy Steele, and Gilad Bracha, The Java language specification, third edition. Addison-Wesley, 2005. ISBN
0-321-24678-0 (see also online edition of the specification (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html)).
[5] "Java memory leaks -- Catch me if you can" (http:/ / www-128. ibm. com/ developerworks/ rational/ library/ 05/ 0816_GuptaPalanki/ ) by
Satish Chandra Gupta, Rajeev Palanki, IBM DeveloperWorks, 16 Aug 2005
[6] Boost type traits library (http:/ / www. boost. org/ libs/ type_traits/ doc/ html/ boost_typetraits/ reference. html)
[7] "Microbenchmarking C++, C# and Java" (http:/ / www. ddj. com/ 184401976) by Thomas Bruckschlegel, Dr. Dobbs, June 17, 2005
[8] "Performance of Java versus C++" (http:/ / scribblethink. org/ Computer/ javaCbenchmark. html) by J.P. Lewis and Ulrich Neuman, USC,
Jan. 2003 (updated 2004)
[9] "Java will be faster than C++" (http:/ / trs-new. jpl. nasa. gov/ dspace/ bitstream/ 2014/ 18351/ 1/ 99-1827. pdf) by Kirk Reinholtz, JPL, Apr
2001
[10] http:/ / www. ibm. com/ developerworks/ java/ library/ j-jtp02225. html#2. 0
[11] http:/ / www. irrlicht3d. org/ pivot/ entry. php?id=446
[12] "Java (not really faster) than C++ benchmark (http:/ / bruscy. republika. pl/ pages/ przemek/ java_not_really_faster_than_cpp. html)
illustrates
[13] http:/ / www. jelovic. com/ articles/ why_java_is_slow. htm
[14] http:/ / warp. povusers. org/ grrr/ java. html
[15] . p. 18. page.mi.fu-berlin.de/prechelt/Biblio//jccpprtTR.pdf.
[16] Clark, Nathan; Amir Hormati, Sami Yehia, Scott Mahlke (2007). "Liquid SIMD: Abstracting SIMD hardware using lightweight dynamic
mapping". HPCA’07: 216–227.
[17] http:/ / cellperformance. beyond3d. com/ articles/ 2006/ 06/ understanding-strict-aliasing. html
[18] Demystifying the Restrict Keyword (http:/ / www. cellperformance. com/ mike_acton/ 2006/ 05/ demystifying_the_restrict_keyw. html)
[19] www.slac.stanford.edu/comp/unix/.../icc/.../optaps_dsp_qax.htm Targeting IA-32 Architecture Processors for Run-time Performance
Checking
[20] Bjarne Stroustrup's FAQ: Do you own C++? (http:/ / www. research. att. com/ ~bs/ bs_faq. html#revenues)
[21] ZDNet: Oracle buys Sun; Now owns Java (http:/ / blogs. zdnet. com/ BTL/ ?p=16598).
[22] http:/ / task3. cc/ 289/ object-oriented-memory-management
[23] http:/ / www. ora. com/ catalog/ javanut/ excerpt/ index. html#except
[24] http:/ / www. fatalmind. com/ papers/ java_vs_cplusplus/ resource. html
[25] http:/ / www. azulsystems. com/ blog/ cliff-click/ 2009-09-06-java-vs-c-performanceagain

Comparison of the Java and .NET platforms 93
Comparison of the Java and .NET platforms
Legal issues
Standardization
The two platforms, their programming libraries, their binary formats, and their runtime environments have largely
been governed by very different means.
International standards organizations Ecma International and ISO/IEC define the standard for the .NET executable
environment (known as the Common Language Infrastructure, or CLI), and .NET executable format (known as
Common Intermediate Language, or CIL), but excluding most of the foundation classes (the Base Class Library, or
BCL). This formal committee-based standardization process is in keeping with the way very popular languages like
COBOL, Fortran and C have been standardized in the past. The standards do not include many new libraries that
Microsoft has implemented on top of the standard framework, such as those for accessing databases, or building GUI
and Web applications, such as Windows Forms, ASP.NET and ADO.NET.
To date, no part of Java has been standardized by Ecma International, ISO/IEC, ANSI, or any other third-party
standards organization. While Sun Microsystems has unlimited and exclusive legal rights to modify and license its
Java trademarks, Sun voluntarily participates in a process called the Java Community Process (JCP) that allows
interested parties to propose changes to any of Sun's Java technologies (from language and tools to API) via forums,
consultation exercises and expert groups. The JCP requires a membership fee for commercial contributors, while
non-commercial contributors and individuals can join for free.
Within the rules of the JCP anyone can bring forward a proposal for a new Platform Edition Specifications or
suggest changes to the Java language. All proposals are reviewed and voted on by interested JCP members at various
stages throughout their lifecycle, however when it comes to including changes into the standard reference
implementations (Java SE, Java EE and Java ME) modifications may be subject to rejection by Sun, who retain
ultimate power of veto.
Java standards are maintained by a suite of test applications which examine every aspect of a given Java
implementation against a rigorous specification. Only if an implementation passes the tens of thousands of individual
tests can it use the trademarked name "Java", and associated logos and brands.
License
Java
While "Java" is a Sun trademark, and only Sun can license the name "Java", numerous free software projects exist
that are compatible with Sun Java. Most notably, GNU Classpath and GCJ provide a free software class library and a
compiler that are partially compatible with the current version of Sun Java. [1] Sun announced in November 13, 2006
that all Java source code, excluding closed-source code for which they do not retain rights, will be released under a
modified version of the GPL, [2] and released two fundamental parts of the JRE and JDK: HotSpot and the javac
[3] [4]
compiler under the GPL.
Following their promise, Sun released the complete source code of the Class library under GPL on May 8, 2007,
except some limited parts that were licensed by Sun from 3rd parties who did not want their code to be released
under an open-source license [5] (see also Free Java implementations). Sun's goal is to replace the parts that remain
closed with alternative implementations and make the class library completely open.
In June 2008, Red Hat announced [6] that the IcedTea project has passed the rigorous Java TCK, indicating a fully
functional open-source implementation of the Java platform.

Comparison of the Java and .NET platforms 94
.NET
Microsoft's .NET CLI executable environment, and some of the corresponding class library, have been
standardized and can be freely implemented without a license. A few standards-compliant free software
environments have been implemented, such as the Mono Project and DotGNU. The Mono Project has also
implemented many of Microsoft's non-standard libraries by examining Microsoft materials, similar to GNU
Classpath and Java.
Microsoft is currently distributing a shared source version of its .NET runtime environment for academic use,
however it is only supported on Windows XP SP2 and has not been updated after .NET 2.0. [7]
The Mono project aims to avoid infringing on any patents or copyrights, and to the extent that they are successful,
the project can be safely distributed and used under the GPL. On November 2, 2006, Microsoft and Novell
announced a joint agreement whereby Microsoft promised not to sue Novell or its customers for patent
infringement. [8] According to a statement on the blog of Mono project leader Miguel de Icaza, this agreement only
extends to Mono for Novell developers and users. [9] Because of the possible threat of Microsoft patents, the FSF
[10] [11]
recommends that people avoid creating software that depends on Mono or C#.
The Microsoft/Novell agreement was criticized by some in the open source community because it violates the
principles of giving equal rights to all users of a particular program (see Agreement with Microsoft and Mono and
Microsoft's patents).
In response to the Microsoft/Novell agreement the Free Software Foundation revised its GNU General Public
License to close the loophole used by Microsoft and Novell to bypass the GPL's very restrictive provisions on patent
deals. [12] The FSF also stated that by selling coupons for Novell's Linux software, the mechanism by which
Microsoft circumvented the GNU license, it considers Microsoft to be a Linux vendor, and thereby subject to the full
terms and conditions laid out in the GPL. [12] (Microsoft issued the coupons because on the patent deal worked out
between the two companies Novell's network patents were considered far more profitable to Microsoft than
Microsoft's .NET patents were to Novell.)
Community
In its proprietorship of Java, Sun works with an open culture, allowing multiple parties, from organizations to
individuals, to steer the decision making process. Sun retains exclusive and unlimited legal rights to its Java
intellectual properties, and the Java community is subject to those rights.
Sun's acceptance of third-party contributions goes to solve the problem of vendor lock-in at the cost of sometimes
creating a baffling array of options for beginners wishing to choose a Java-based solution. Java has grown in
popularity to become one of the most popular languages of the early 21st century, and the pluralist nature of its
development has resulted in many different groups tackling the same (or similar) problems. This issue is particularly
acute in the Enterprise space (web/Ajax/Web2.0 applications), where one must not only be familiar with Java, but
also the various competing frameworks.
While Microsoft has developed C# and .NET without a formal community contribution system, the language and
some parts of the executable format and runtime have been standardized and freely distributed through Ecma and
ISO in an open and vendor-neutral process, rather than a process that retains veto and copy rights for Microsoft.
However, the standards do not include many new libraries that Microsoft has implemented on top of the standard
framework (see Standardization). Numerous C# and CLI community software projects, help and documentation
sites, and discussion forums are under active development and maintenance, including those focusing on Windows
development with Microsoft .NET or the Mono project, Free software Operating system development under the
Mono project, and mobile development using Microsoft's .NET compact framework..
Microsoft is distributing a shared source release (version 1.0) of the .NET virtual machine that can be compiled and
used on Windows, FreeBSD, Mac OS X, and other platforms. [13] An updated version (2.0) is currently available, but

Comparison of the Java and .NET platforms 95
the only officially supported platform is Windows. [14] A community port to Linux of the 1.0 shared source .NET
virtual machine is also available. [15] In March 2003, O'Reilly Media published a book about Microsoft's shared
source .NET runtime. [16]
Traditional computer applications
Desktop applications
Although Java's AWT (Abstract Windowing Toolkit) and Swing libraries are not shy of features, Java has struggled
to establish a foothold in the desktop market. Sun Microsystems has also been slow, in the eyes of some, to promote
Java to developers and end users alike in a way which makes it an appealing choice for desktop software. Even
technologies such as Java Web Start, which have few parallels within rival languages and platforms, have barely
been promoted.
The release of Java version 6.0 in December 11, 2006, saw a renewed focus on the desktop market with an extensive
set of new tools for closer integration with the desktop. At the 2007 JavaOne conference Sun made further desktop
related announcements, including a new language aimed at taking on Adobe Flash (JavaFX), a new lightweight way
of downloading the JRE which sees the initial footprint reduced to under 2Mb, and a renewed focus on multimedia
libraries.
An alternative to AWT and Swing is the Standard Widget Toolkit (SWT), which was originally developed by IBM
and now maintained by the Eclipse Foundation. It attempts to achieve improved performance and visualization of
Java desktop applications by relying on underlying native libraries where possible.
.NET is becoming more common in open source and free software systems due to its inclusion [17] by the GNOME
desktop environment using the Mono framework.
Server applications
This is probably the arena in which the two platforms are closest to being considered rivals. Java, through its Java
EE (a.k.a. Java Platform Enterprise Edition) platform, and .NET through ASP.NET, compete to create web-based
dynamic content and applications.
Both platforms are well used and supported in this market, with a bevy of tools and supporting products available for
Java EE and .NET. And both have high profile backers. For example, for Java: Oracle included direct support for
Java into its database, while Google has used Java to power tools like Gmail. [18]
Some of Sun's current Java-related license agreements for Java EE define aspects of the Java platform as a trade
secret, [19] and prohibit the end user from contributing to a third-party Java environment. Specifically, at least one
current license for a Sun Java EE development package contains the following terms: "You may make a single
archival copy of Software, but otherwise may not copy, modify, or distribute Software." — "Unless enforcement is
prohibited by applicable law, you may not decompile, or reverse engineer Software." — "You may not publish or
provide the results of any benchmark or comparison tests run on Software to any third party without the prior
written consent of Sun." — "Software is confidential and copyrighted." [19] However, while Sun's software is subject
to the above license terms, Sun's Java EE API reference has been implemented under an open source license by the
JBoss and JOnAS projects.
Microsoft's implementation of ASP.NET is not part of the standardized CLI, and while Microsoft's runtime
environment and development tools are not subject to comparable secrecy agreements to Java EE, the official
Microsoft tools are not open source or free software, and require Windows servers. However, a cross-platform free
software ASP.NET 2.0 implementation is part of the Mono project (minus webparts and Web Services
Enhancements). [20]

Comparison of the Java and .NET platforms 96
Embedded applications
Mobile applications
Java ME has a very large base within the mobile phone and PDA markets, with only the cheapest devices now
devoid of a KVM (a cut down Java Virtual Machine for use on devices with limited processing power). Java
software, including many games, is commonplace.
While almost every mobile phone includes a JVM, these features are not always heavily used by users (particularly
in North America). Initially Java applications on most phones typically consisted of menuing systems, small games,
or systems to download ringtones etc. However, more powerful phones are increasingly being sold with simple
applications pre-loaded, such as translation dictionaries, world clock displays (darkness/light, timezones, etc.) and
calculators. Some of these are written in Java, although how often phone owners actually use them is probably
unknown.
In January 2007 Steve Jobs suggested that Apple's iPhone would not support Java. [21] [22] Significantly, at that time
Java's mobile platform was perceived as nearly ubiquitous across the cell phone market, commonly being used by
software companies to write device-neutral mobile applications. Noted commentators argued against Jobs' stand, [23]
but when the iPhone finally appeared it did indeed lack both Java and Adobe's rival Flash technology, favoring
instead simple web applications using the phone's Safari browser.
In May 2007 Sun used the JavaOne conference to announce JavaFX Mobile, as a direct response to Adobe's attempt
to introduce Flash onto mobile devices.
In October 2007 Apple bowed to pressure and announced that by early 2008 the iPhone would be opened up to allow
development of software other than via the Safari browser. Neither Java nor Flash is supported under this plan, and
Apple does not allow interpreters for any language to run on the phone.
Home entertainment technologies
Java has found a market in digital television, where it can be used to provide software which sits alongside
programming, or extends the capabilities of a given Set Top Box. TiVo, for example, has a facility called "Home
Media Engine", which allows JavaTV software to be transmitted to an appropriate TiVo device to complement
programming or provide extra functionality (for example, personalized stock tickers on a business news program.)
A variant of Java has been accepted as the official software tool for use on the next generation optical disc
technology Blu-ray, via the BD-J interactive platform. This will mean that interactive content, such as menus, games,
downloadables, etc. on all Blu-ray optical discs will be created under a variant of the Java platform. Blu-ray
equipment first went on sale to the consumer in 2006, and is currently not widely owned. However, the release of the
Sony PlayStation 3 in late 2006 and early 2007 may give the platform a boost.
Rather than using Java, HD DVD (the defunct high definition successor to DVD) uses a technology jointly
developed by Microsoft and Disney called HDi that is based on XML, CSS, JavaScript, and other technologies that
are comparable to those used by standard web browsers.
The BD-J platform API is more extensive than its iHD rival, with an alleged 8,000 methods and interfaces, as
opposed to iHD's 400. [24] And while Microsoft is pushing iHD's XML presentation layer by including it with
Windows Vista, iHD is still a newcomer in a market sector where Java technologies are already commonplace. [25]
However, the fact that the HD DVD format has been abandoned in favor of Blu-ray means that HDi is no longer
supported on any Optical disc format, making the BD-J format a clear winner. [26]

Comparison of the Java and .NET platforms 97
Runtime inclusion in operating systems
.NET/Mono
On Windows, Microsoft is promoting .NET as its flagship development platform, [27] by including the .NET runtime
in Windows XP Service Pack 2 and 3, Windows Server 2003, Windows Vista, Windows Server 2008 and Windows
7. Microsoft also distributes the Visual C# Express development environment at no cost. [28]
.NET Framework 3.5 runtime is not pre-installed on versions of Windows prior to Vista SP1, and must be
[29] [30]
downloaded by the user, which has been criticized because of its large size (65 MB download for .NET 3.5).
While neither .NET nor Mono are installed with Mac OS X out-of-the-box, the Mono project can be downloaded and
installed separately, for free, for any Mac user who wants to build and/or run C# and .NET software. As of 13 May
2008, Mono's System.Windows.Forms 2.0 is API complete (contains 100% of classes, methods etc. in Microsoft's
System.Windows.Forms 2.0); also System.Windows.Forms 2.0 works natively on Mac OS X.
C# and the CLI are included and used in a number of Linux and BSD based operating systems by way of including
[31] [32] [33]
the free software Mono Project.
As a result of inclusion of .NET or Mono runtimes in the distributions of Windows and Linux, non-GUI applications
that utilize the programming interfaces that are common to both .NET and Mono can be developed in C# or any
other .NET language and then deployed across many operating systems and processor architectures using a runtime
environment that is available as a part of the operating system's installation. [34] [35] [36] Both Microsoft .NET and the
Mono project have complete support for the Ecma- and ISO-standardized C# language and .NET runtime, and many
of Microsoft's non-standardized .NET programming interfaces have been implemented or are under development in
Mono, [37] but each environment includes many components that have not been implemented in the other.
Java
Starting with XP SP1a, Windows does not ship with a Java runtime environment. However according to a September
2003 press release some OEMs agreed to pre-install the JRE on their desktop and laptop models. Mentioned were
Acer, Dell, Gateway, Hewlett-Packard, and Toshiba. [38] These companies combined make up a simple majority of
consumer PC's sold in the United States of America. [39]
Java comes pre-installed on all new Apple computers since Mac OS X 10.0. Because Apple maintains the Java
runtime for Mac OS X, updates are usually one or two versions behind the versions available from Sun for the other
operating systems, and versions of Java are usually tied to the specific operating system version, so newer Java
versions are usually unavailable for older versions of OS X.
Java comes pre-installed with many commercial Unix flavors, including those from Sun, IBM and Hewlett Packard.
As of June 2009, the Fedora 9, [40] Ubuntu 8.04, [41] Debian, [42] Slackware extra, [43] Mandriva [44] and OpenSUSE [45]
distributions are available with OpenJDK, based completely on free and open source code. [46] Since June 2008,
OpenJDK passed all of the compatibility tests in the Java SE 6 JCK and can claim to be a fully compatible Java 6
implementation. [47] [48] OpenJDK can run complex applications such as Netbeans, Eclipse, GlassFish, or JBoss.
The Operating System Distributor License for Java (DLJ) [49] is a Sun initiative to ease distribution issues with
operating systems based on OpenSolaris or Linux.
If Java is not installed on a computer by default, it may be downloaded by the user as a web plugin. The web plugin
process has been criticized because of the size of the Java plugin. Unlike other plugins the Java download is a full
runtime environment, capable of running not just applets, but full applications and dynamic WebStart apps. Because
of this the perceived download footprint is larger than some web plugins. However, compared to Java, other popular
browser plugins have larger sizes: Java 6 JRE is 13 MB, but Acrobat Reader is 33 MB, QuickTime 19 MB,
Windows Media Player 25 MB, the .NET Framework 3.0 runtime is 54 MB, and the .NET Framework 3.5 runtime is
197 MB (it's a united package for x86, x64 and IA-64, each part has approximately 60 MB).

Comparison of the Java and .NET platforms 98
At the JavaOne event in May 2007 Sun announced that the deployment issues with Java would be solved in two
major updates during the lifespan of Java 6 (the changes will not be held over to Java 7.) These include:
• the introduction of a new consumer JRE edition, with an initial 2Mb footprint and the ability to download the
remaining 9Mb in sections using an on-demand methodology.
• the development of drop-in cross platform JavaScript code, which can be used from a web page to install the
necessary JRE for a given applet or Rich Internet Application to run, if necessary.
• an improvement in support for automatically downloading updates to the JRE.
• support for pre-loading of the JRE, so applets and applications written in Java start up almost instantaneously.
See also
• Comparison of Java and C# languages
• Java programming language
• C#
External links
• ECMA-335 Common Language Infrastructure (CLI), 4th edition (June 2006) [50] Free download of Ecma CLI
standard
• ISO/IEC 23271:2006 Common Language Infrastructure (CLI) Partitions I to VI [51] The official ISO/IEC CLI
standard
References
[1] Results of comparison between jdk15 and classpath (http:/ / www. kaffe. org/ ~stuart/ japi/ htmlout/ h-jdk15-classpath)
[2] Free and Open Source Java - Project Overview (http:/ / www. sun. com/ software/ opensource/ java/ project_overview. jsp)
[3] Sun openjdk: Home (http:/ / openjdk. java. net/ )
[4] Sun Java 2 Runtime License Agreement (http:/ / java. sun. com/ j2se/ 1. 4. 2/ j2re-1_4_2_13-license. txt)
[5] "Open JDK is here!" (http:/ / mail. openjdk. java. net/ pipermail/ announce/ 2007-May. txt). Sun Microsystems. 2007-05-08. . Retrieved
2007-05-09.
[6] Java Finally Free and Open (http:/ / truthhappens. redhatmagazine. com/ 2008/ 06/ 19/ java-finally-free-and-open/ )
[7] Rotor: Shared Source CLI Provides Source Code for a FreeBSD Implementation of .NET (http:/ / msdn. microsoft. com/ msdnmag/ issues/
02/ 07/ SharedSourceCLI/ )
[8] Microsoft and Novell Announce Broad Collaboration on Windows and Linux Interoperability and Support (http:/ / www. novell. com/ news/
press/ item. jsp?id=1196)
[9] "Statement on the blog of Mono project leader Miguel de Icaza regarding patent protection for Mono" (http:/ / tirania. org/ blog/ archive/
2006/ Nov-04. html). 2006-11-04. . Retrieved 2006-11-06.
[10] Stallman, Richard (2009-06-26). "Why free software shouldn't depend on Mono or C#" (http:/ / www. fsf. org/ news/
dont-depend-on-mono). Free Software Foundation. . Retrieved 2009-07-02. "We should systematically arrange to depend on the free C#
implementations as little as possible. In other words, we should discourage people from writing programs in C#. Therefore, we should not
include C# implementations in the default installation of GNU/Linux distributions, and we should distribute and recommend non-C#
applications rather than comparable C# applications whenever possible."
[11] "Microsoft's Empty Promise" (http:/ / www. fsf. org/ news/ 2009-07-mscp-mono). Free Software Foundation. 2009-07-16. . Retrieved
2009-078-03. "Until that happens, free software developers still should not write software that depends on Mono. C# implementations can still
be attacked by Microsoft's patents: the Community Promise is designed to give the company several outs if it wants them. We don't want to see
developers' hard work lost to the community if we lose the ability to use Mono, and until we eliminate software patents altogether, using
another language is the best way to prevent that from happening."
[12] Microsoft takes on the free world. (http:/ / money. cnn. com/ magazines/ fortune/ fortune_archive/ 2007/ 05/ 28/ 100033867/ index. htm)
[13] Shared Source Common Language Infrastructure 1.0 Release (http:/ / www. microsoft. com/ downloads/ details.
aspx?FamilyId=3A1C93FA-7462-47D0-8E56-8DD34C6292F0& displaylang=en)
[14] Shared Source Common Language Infrastructure 2.0 Release (http:/ / www. microsoft. com/ downloads/ details.
aspx?familyid=8c09fd61-3f26-4555-ae17-3121b4f51d4d& displaylang=en)
[15] Rotor Comes to Linux (http:/ / www. ondotnet. com/ pub/ a/ dotnet/ 2002/ 07/ 01/ rotorlinux. html)
[16] oreilly.com -- Online Catalog: Shared Source CLI Essentials (http:/ / www. oreilly. com/ catalog/ sscliess/ )
[17] Mono-Applications-Aplenty!, OSNews (http:/ / www. osnews. com/ story. php/ 9780/ Mono-Applications-Aplenty!)

Comparison of the Java and .NET platforms 99
[18] Google Web Toolkit (http:/ / code. google. com/ webtoolkit/ )
[19] Java EE SDK 5 Update 2 No JDK download page (reference to license agreement) (http:/ / javashoplm. sun. com/ ECom/ docs/ Welcome.
jsp?StoreId=22& PartDetailId=java_ee_sdk-5_02-nojdk-oth-JPR& SiteId=JSC& TransactionId=noreg)
[20] Mono: ASP.NET (http:/ / www. mono-project. com/ ASP. NET)
[21] Jobs: No Java for you (http:/ / blogs. zdnet. com/ Burnette/ ?p=238)
[22] Steve Jobs on iPhone: No Java For You (http:/ / www. javalobby. org/ java/ forums/ t88464. html)
[23] Steve Jobs alert: Killer Java app for iPhone (http:/ / scobleizer. com/ 2007/ 03/ 20/ steve-jobs-alert-killer-java-app-for-iphone/ )
[24] HD-DVD vs. Blu-Ray, round 2 (http:/ / blogs. zdnet. com/ carroll/ index. php?p=1583)
[25] Format Wars - Blu-ray vs HD DVD (http:/ / www. pcauthority. com. au/ print. aspx?CIID=60242& SIID=)
[26] Zaharov-Reutt, Alex (2008-02-21). "Microsoft's HDi interactivity layer loses from HD DVD's death - but does it matter?" (http:/ / www.
itwire. com/ content/ view/ 16780/ 1154/ 1/ 0/ ). itwire.com. . Retrieved 2008-08-27. "While many claimed that creating interactivity with HDi
was much simpler than using BD-J, the fact that HD DVD will see few future releases beyond 2008 means that, whatever the enthusiasts
position on the relative merits of HDi vs BD-J, the BD-J interactivity format is now the winner"
[27] Microsoft article that refers to C# as its "flagship" language. (http:/ / www. microsoft. com/ learning/ books/ developer/ feature/ 050301.
mspx)
[28] microsoft.com: Visual C# (http:/ / msdn. microsoft. com/ vstudio/ express/ visualcsharp/ )
[29] "Dear Microsoft" (http:/ / channel9. msdn. com/ ShowPost. aspx?PageIndex=1& PostID=370737#370737). 2008-01-09. . Retrieved
2008-02-03.
[30] ".Net framework 3.5 size 166MB!" (http:/ / www. codeprof. com/ dev-archive/ 179/ 12-1020-1798773. shtm). 2007-11-10. . Retrieved
2008-02-03.
[31] Fedora embraces Mono - ZDNet UK (http:/ / news. zdnet. co. uk/ software/ 0,1000000121,39246774,00. htm)
[32] Debian Mono Packages (http:/ / packages. debian. org/ mono)
[33] Wikipedia Uses Mono; Mono Integrated into Ubuntu/Debian - OSNews.com (http:/ / www. osnews. com/ story. php?news_id=10714)
[34] Fedora Catches Mono (http:/ / www. desktoplinux. com/ news/ NS2809897659. html)
[35] SUSE 10.1 released (http:/ / www. mono-project. com/ news/ archive/ 2006/ May-11-1. html)
[36] Wikipedia Uses Mono; Mono Integrated into Ubuntu/Debian (http:/ / www. osnews. com/ story. php/ 10714/
Wikipedia-Uses-Mono-Mono-Integrated-into-UbuntuDebian)
[37] "Mono – Plans" (http:/ / www. mono-project. com/ Plans). . Retrieved 2008-12-23.
[38] Sun signs up five more OEMs for Java (http:/ / www. infoworld. com/ article/ 03/ 09/ 23/ HNsunoems_1. html)
[39] "Digitimes.com" (http:/ / www. digitimes. com/ systems/ a20070420PR208. html). . Available only for paid subscribers.
[40] Wade, Karsten (2008-03-13). "OpenJDK in Fedora 9!" (http:/ / developer. redhatmagazine. com/ 2008/ 03/ 12/
openjdk-to-replace-icedtea-in-fedora-9/ ). redhatmagazine.com. . Retrieved 2008-04-05. "Thomas Fitzsimmons updated the Fedora 9 release
notes source pages to reflect that Fedora 9 would ship with OpenJDK 6 instead of the IcedTea implementation of OpenJDK 7. Fedora 9
(Sulphur) is due to release in May 2008."
[41] "openjdk-6 in Ubuntu" (https:/ / launchpad. net/ ubuntu/ + source/ openjdk-6). . Retrieved 2008-04-19.
[42] "Package: openjdk-6-jdk" (http:/ / packages. debian. org/ stable/ openjdk-6-jdk). debian.org. 2009-02-14. . Retrieved 2009-02-16.
[43] Slackware Java package (http:/ / packages. slackware. it/ package. php?q=current/ jdk-6-i586-1)
[44] Mandriva Java package (http:/ / qa. mandriva. com/ twiki/ bin/ view/ Main/ JavaPackaging#Compati)
[45] "Package: OpenJDK" (http:/ / en. opensuse. org/ OpenJDK). opensuse.org. . Retrieved 2009-06-01.
[46] Reinhold, Mark (2008-04-24). "There's not a moment to lose!" (http:/ / blogs. sun. com/ mr/ entry/ in_hardy_heron). . Retrieved 2008-04-19.
[47] Sharples, Rich (2008-06-19). "Java is finally Free and Open" (http:/ / blog. softwhere. org/ archives/ 196). .
[48] Angel, Lillian (2008-03-13). "OpenJDK to replace IcedTea in Fedora 9" (http:/ / langel. wordpress. com/ 2008/ 03/ 13/ openjdk-in-fedora-9/
). . Retrieved 2008-04-05.
[49] Operating System Distributor License for Java (DLJ) (https:/ / jdk-distros. dev. java. net/ )
[50] http:/ / www. ecma-international. org/ publications/ standards/ ecma-335. htm
[51] http:/ / www. iso. org/ iso/ iso_catalogue/ catalogue_tc/ catalogue_detail. htm?csnumber=42927

Constant interface 100
Constant interface
In the Java programming language, the constant interface pattern describes the use of an interface solely to define
constants, and having classes implement that interface in order to achieve convenient syntactic access to those
constants. However, since the usage of constants is an implementation detail, it is considered inappropriate to define
an interface for this purpose. [1] [2] In general, collecting system constants into classes independent of behaviour,
might create a poor object-oriented design, because it is often a sign of low cohesion. It is for these reasons that
implementing constants interfaces is considered to be an anti-pattern.
Use of this anti-pattern has a few other downsides:
1. It pollutes the class namespace with read-only variables that may not be of use.
2. Contrary to the compile-time tactical utility of implementing a constants interface, the incidental run-time
artifacts have little practical purpose (cf. marker interfaces which also have no methods but are useful at
run-time).
3. If binary code compatibility is required in future releases, the constants interface must remain forever an interface
(it cannot be converted into a class), even though it has not been used as an interface in the conventional sense.
4. Without an IDE that resolves where the constant are coming from, tracking it back to its containing class or
interface can be time consuming.
5. A variable (representing an instance) of the interface is syntactically no more useful than the interface name itself
(since it has no methods).
Example
public interface Constants {
}
public static final double PI = 3.14159;
public static final double PLANCK_CONSTANT = 6.62606896e-34;
public class Calculations implements Constants {
}
public double getReducedPlanckConstant() {
}
Alternatives
return PLANCK_CONSTANT / (2 * PI);
Many of the pitfalls of the anti-pattern can be avoided by converting the constants interface to a proper class with no
instances:
public final class Constants {
private Constants() {
}
// restrict instantiation
public static final double PI = 3.14159;

Constant interface 101
}
public static final double PLANCK_CONSTANT = 6.62606896e-34;
This still leaves the original intent of the pattern mostly un-addressed (i.e. there is no syntax for accessing the
constants unqualified). However, since Java 5, consider using static import [2] to achieve the same goal:
import static Constants.PLANCK_CONSTANT;
import static Constants.PI;
public class Calculations {
}
public double getReducedPlanckConstant() {
}
return PLANCK_CONSTANT / (2 * PI);
To varying degrees, the issues listed above have now been addressed:
1. Because static members can be imported specifically, the class namespace need not be polluted with all members
of the constants interface.
2. Run-time and compile-time semantics are more closely aligned when using static imports instead of constants
interfaces.
3. The compiled code has one less binary compatibility constraint (that "class Calculations implements Constants").
4. Because static imports apply only to the current file (and not the whole class hierarchy) it is easier to discover
where each static member is declared.
5. There is less need to declare variables of the constants interface type, and it is potentially clearer that no concrete
instances actually exist.
Note however, the changes do nothing to improve the cohesion of the Constants class, so static imports should not be
considered to be a panacea.
References
[1] Bloch, Joshua, Effective Java, 2nd Edition, p. 98
[2] Sun Microsystems, Inc. (2004). "Static Import" (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ static-import. html).

Java 4K Game Programming Contest 102
Java 4K Game Programming Contest
The Java 4K Game Programming Contest (aka 'Java 4K' and 'J4K') is an informal contest that was started by the
Java Game Programming community to challenge their software development abilities. The goal of the contest is to
develop the best game possible within four kilobytes (4096 bytes) of data. While the rules originally allowed for
nearly any distribution method, recent years have required that the games be packaged as either an executable JAR
file, a Java Webstart application, or a Java Applet.
History
The Java 4K Game Programming Contest came into being on August 28, 2002 when a user by the handle of
codymanix posted the suggestion to the Sun Microsystems Java forums. After a bit of argument over how feasible a
game would be in 4K, a user by the handle of mlk officially organized the contest on August 29, 2002.
Slowly but surely, entries began to trickle in for the contest. The majority of these entries were Applets, as it was
believed that separating the images from the class files would help reduce the size of the file. Future contests would
see a reversal of this as game creators utilized compressed JAR files to reduce the size of their code.
One of the most interesting points about the first contest was that non-game applications were allowed. One
contestant produced a telnet server in 4K of Java! However, this artifact of the first competition did not survive, and
was most likely allowed because of the loose handling of the first contest. While no winner was officially declared
the first year, the 4K Racing game submitted by Robin Chaddock (aka Abuse/AbU5e) was generally agreed upon to
have "won".
Successive competitions became more and more organized, with many of the contestants pitching in to handle
administration and promotion of the contest. All contests received official judging, with the method of judging being
refined each year. By the third year, the contest was officially transitioned over to the JavaGaming.org forums. The
fourth year saw the introduction of the JavaUnlimited website as the official repository for the contest. The site had
been used the previous year to track entries that had been posted to the official threads on JavaGaming.org and
forum.java.sun.com.
Tradeoffs
Because the Java class file format incurs quite a bit of overhead, creating a complete game in 4K can be quite a
challenge. As a result, contestants must choose how much of their byte budget they wish to spend on graphics,
sound, and gameplay. Finding the best mix of these factors can be extremely difficult. Many new entrants believe
that impressive graphics alone are enough to carry a game. However, entries with more modest graphics and focus
on gameplay have regularly scored higher than such technology demonstrations.
Prizes
When first conceived, the "prize" for winning the contest was a bundle of "Duke Dollars", a virtual currency used on
Sun Microsystems' Java forums. This currency could theoretically be redeemed for physical prizes such as watches
and pens. Unfortunately, the artificial currency was being downplayed by the introduction of the 4K contest, thus
leaving no real prize at all.
While there has been some discussion of providing prizes for the contest, it has continued to thrive without them.
Most entrants seem to feel content to compete with their peers in a challenge of skill and ability. The reward has
been nothing more than praise from those who play the games.

Java 4K Game Programming Contest 103
Reasons for success
While there has been a great deal of debate on why the Java 4K contest is so successful, the consensus from the
contestants seems to be that it provides a very appealing challenge. Not only do the entrants get the chance to show
off how much they know about Java programming, but the 4K size helps "even the odds" compared to other
competitions where the use of artists and musicians can easily place an entry far ahead of the others.
This may explain why spinoff contests targeting 8K, 16K, or a specific API like LWJGL have never taken off. In
fact, the contestants seem to believe that 4K is the "sweet spot" that balances what an individual can do. Because of
the tricks developed for the 4K contest, it's believed that adding even a single kilobyte would open the doors to far
more complex games that are beyond the ability of a single developer.
Year 2 (2004)
Heavy use of pre-rendered sprites, transparency, and sound effects defined this year's entries. The strongest
contenders were Defender 4000, Abuse's Shooty-Transparenty Game, and Space Invaders. However, Space Invaders'
lack of sound caused it to fall behind the other two entries which were competing hard to pack in the most
technology and gameplay.
Of particular interest were the different tactics used by the two entries. For graphics, Abuse used precious few high
color images which he then applied transparency and rotation to at runtime. Jbanes, on the other hand, developed an
imaging packing technique that allowed him to store twenty-one single-color images. Rather than applying rotation
and transparency, he chose to use his larger number of images to produce pre-rendered animations. For sound, Abuse
used clear chimes and other instruments from the MIDI soundbank. Jbanes chose to use runtime-generated PCM
sound that sounded more like video games of the late 1970s and early 1980s.
Both approaches had their merit, so it's difficult to say what finally swayed the judge's opinion. What is known is
that Year 2 was the last year that sound would be a deciding factor in the games. In future years, the bytes allocated
to sound were reallocated to other functions such as 3D graphics, levels, and bosses.
Year 2 was the first year that official judging took place. Unlike subsequent years, the only judge was the contest
organizer, mlk. After careful consideration, the judge decided to award Prong with the Best Technical Achievement
Award, and declared Defender 4000 as the overall winner. Interestingly, he scored each game but did not use this
score in determining the winner. Abuse's Shooty-Transparenty Game actually scored one point higher than Defender
4000.
Official List of Year 2 Entries [1]
Year 3 (2005)
Year 3 was defined by a major influx of professional Java developers, 3D graphics in the games, and a gradual
transition to the JavaGaming.org forums. JavaUnlimited also began mirroring the competitors in a permanent
archive. While the mirror started as a manually edited HTML page, it eventually grew into a complete contest
management site with a database back-end.
Judging this year was handled by a panel of three volunteer, professional developers who were not participating in
the contest. One of the volunteer judges was Chris Melissinos, Sun's Chief Gaming Officer. The scoring method
used was based on the method that mlk had applied the previous year, but was updated to allow the judges to give
awards for exceptional gameplay or technological achievements.
While most of the entries were of exceptional quality, T4XI by Kevin Glass (aka kevglass) was chosen as the winner.
Besides having extremely original gameplay, it provided exceptional graphics through a pseudo-3D effect that gave
perspective to the buildings.

Java 4K Game Programming Contest 104
A minor amount of controversy erupted due to entries that judges had failed to score. Entries like JM4K and
IsOlation Net where either too complex for the judges to launch, or contained networking components that they
couldn't test. After this year's competition, the rules were changed to require that games be self-executable. In
addition, contestants were warned in advance about the difficulties in judging networked games.
List of Games [2]
List of Scores: (DHTML [3] ) (XLS [4] )
Year 4 (2006)
Year 4 marked a period of transition toward making gameplay a priority over graphics and technical
accomplishment. Many of the games were fairly simple in design, but aimed to make up for it with engrossing or
addictive gameplay.
For the first time in the contest's history, a special forum was setup on JavaGaming.org to host the contest. In
addition, the JavaUnlimited.net site became the official site for entries and judging. While judging was originally
going to be handled through JavaUnlimited by the Javagaming.org community, pushback from several members
resulted in falling back on a more traditional judging system.
After the results came back, Miners4K by Markus_Persson was declared the winner. Second place was given to
Kevin Glass's Roll4K, and third place was given to Goomba4K by Woogley.
The results of Year 4's judging were significantly better than those of Year 3, in part due to the rule changes which
forced the entries to conform to easily executable formats. However, this did not completely eliminate judging
issues. Some controversy erupted when two entries (Xero and JSquares) were given lower scores due to technical
glitches. Several recommendations were posed to prevent this from happening in future contests, including trimmed
mean scoring and verification of judge's scoring before acceptance.
List of Games & Results [5]
Year 5 (2007)
Year 5 launched in December 2006 and lasted until March 1, 2007. It saw some great games, with much less focus
on 3D and pseudo-3D graphics. Most games were 2D, with Pipe Extreme and Trailblazer being the only notable
exceptions (one could argue that a few others are 3D as well, but distinctly less so).
Just like year 4, a forum was hosted on JavaGaming.org to host the contest. JavaUnlimited's system was used for
hosting the games again, being considered the official site for the entries. A site update was planned for
JavaUnlimited, but did not occur. Originally, the plan was to have a public vote and a judging panel. One month
after the contest closing date the organizer without further explanation dropped the judging panel, which caused
some unrest in the forums, accusations of censorship, locked threads and two participants withdrawing their entries
from the contest (bringing the total down from 65 to 58) [6] . Voting was limited to javagaming.org forum
participants, and within the alloted time, 25 people voted. About two months after the contest closing date, the
official results were announced.
The winner was Metro4k by Blaine Hodge, followed by Jojoh's Roadfourk and Ulf Ochsenfahrt's aichess4k. Metro4k
is a Sim City-like city simulation game, Roadfourk a racing game, and aichess4k a chess game featuring an AI
opponent.
Unlike previous years, year 5 saw no game take the "last place", because the approval voting system used only gave
votes to around half the games.
• List of Games [7]
• Results [8]

Java 4K Game Programming Contest 105
Year 6 (2008)
Year 6 launched in December 2007 and lasted until March 1, 2008. Notably less games were submitted than in 2006
and 2007 - only 21 in total. Most of the games were 2d, with a total of 3 games using 3D or pseudo-3D graphics.
The competition was hosted on a new website, Java4k.com [9] . Games from previous years can also be found on the
new website. Before the launch of the contest, woogley had announced his withdrawal from arranging contest. The
task of administrating the contest and hosting the site was therefore taken over by Arni Arent (appel) and Joakim
Johnsson (jojoh). Just like previous years, there was also a dedicated forum [10] at JavaGaming.org [11] .
The games were then thoroughly reviewed by five judges; Arni Arent, Joakim Johnsson, Kevin Glass, Matt Hicks
and Chris Melissinos. They reviewed each game in three categories; Overall, Technical and Presentation. The results
were announced on March 28, 2008.
The top three games in each category are listed below.
Overall Score
1. Spiderball4k by Måns Olson
2. Pinball 4K by Tom-Robert Bryntesen
3. t4nks by Markus Persson
Technical Score
1. Z4rch by Simon
2. Mini Golf by Tim Foden
3. 'Pinball 4K by Tom-Robert Bryntesen
Presentation Score
1. t4nks by Markus Persson
2. Spiderball4k by Måns Olson
3. war4k by Michael Bliem
• The results of the competition [12]
• The judges' reviews of the games [13]
• List of games [14]
External links
• Web Archive of the Original Thread [15] - Actual thread was deleted by Sun during a regular system purge
• Incomplete list of first year entries [16] - Saved by Archive.org
• Year 2 Thread [17] - On Sun's Java Forums
• Java Unlimited [18] - The repository for submitted games since 2005.
• 4K Game Design Tricks [19] - A Wiki article to assist new entrants.
• 4K Tips and Sources [20] - A set of tips, tutorials and game source codes for 4K Java participants
• JavaGaming.org Contest Forums [21] - Each year (starting with year 3) has its own sub-forum.
• Why are 4K Games so much fun to write and Play? [22]
• Should there be Java game competitions without size limits? [23]

Java 4K Game Programming Contest 106
References
[1] http:/ / forum. java. sun. com/ thread. jspa?threadID=471050& start=279& tstart=0
[2] http:/ / www. javaunlimited. net/ games/ java4k_2005. php
[3] http:/ / games. datadino. com/ 4K_2005/ scores. html
[4] http:/ / games. datadino. com/ 4K_2005/ 4K%20Scores. xls
[5] http:/ / javaunlimited. net/ results/
[6] "JavaGaming Forum" (http:/ / www. javagaming. org/ forums/ index. php?topic=16357. msg129239#msg129239). . Retrieved 2007-04-30.
[7] http:/ / javaunlimited. net/ games/ java4k_2007. php
[8] http:/ / javaunlimited. net/ vote/
[9] http:/ / www. java4k. com/ index. php?action=home
[10] http:/ / www. javagaming. org/ forums/ index. php?board=56. 0
[11] http:/ / www. javagaming. org
[12] http:/ / java4k. com/ overall. html
[13] http:/ / java4k. com/ reviews. html
[14] http:/ / java4k. com/ index. php?action=games& cid=4
[15] http:/ / web. archive. org/ web/ 20021029192411/ http:/ / forum. java. sun. com/ thread. jsp?forum=406& thread=293877
[16] http:/ / web. archive. org/ web/ 20030804050840/ http:/ / www. saber-x. com/ midgarddesign/ 4k. html
[17] http:/ / forum. java. sun. com/ thread. jspa?threadID=471050& start=15& tstart=0
[18] http:/ / javaunlimited. net/
[19] http:/ / wiki. java. net/ bin/ view/ Games/ 4KGamesDesign
[20] http:/ / www. ahristov. com/ tutorial/ java4k-tips. html
[21] http:/ / www. javagaming. org/ forums/ index. php?board=46. 0
[22] http:/ / www. javagaming. org/ forums/ index. php?topic=11611. 0
[23] http:/ / www. javagaming. org/ forums/ index. php?topic=11509. 0
CookXml
CookXml is a unique XML data binding engine in Java. It is capable mapping XML documents of desired format
directly onto the corresponding object-oriented classes, essentially treating XML as a programming language rather
than merely a data storage format. Therefore, it is ideal to use CookXml to write any programs that interprets XML.
The tag library of CookXml is constructed dynamically at run time, and thus allows dynamic XML schema. The
current implementation has unmarshaling part done.
CookXml is free software, distributed under a permissive, X11 style licence.
Unmarshaling
CookXml offers the ability to directly mapping XML documents onto existing classes by breaking down the process
into three general steps. Then use a set of delegates, together forming a tag library, to handle actions performed at
these steps.
1. Object creation. Each element tag corresponds to an object instance. The action to create the object instance
corresponds to a creator in CookXml.
2. Property setting. Each attribute of the XML element corresponds to setting a property of the object instance. This
property can be handled by a setter in CookXml. For languages that offer reflection, such as Java and C#, such
property setting can be automatically detected using reflection. In these cases, to match the string attribute value
to the target property class type, a converter is necessary.
3. Add action. When CookXml obtains an object corresponding to an element tag, it is "added" to the parent object
corresponding to the parent element tag. The specific add action is handled by an adder in CookXml.
Save for CDATA nodes, the three above types of actions can handle all elements in an XML document. CDATA in
general can be handled either in the creator function or the adder function.

CookXml 107
Creators, setters, adders, and converters together form a tag library which is used by the CookXml engine to perform
the XML data binding.
Dynamic Tag Library Construction
Because CookXml tag library uses delegates, its tag library needs to be dynamically constructed. This feature is both
good and bad. It is bad because there will be a slight initiation cost when the tag library is constructed, and its
integrity may not be verified until runtime. It is also good because it allows developers to easily extend an existing
tag library at run time.
Preorder and Postorder Addition
Like any trees that can be traversed in preorder and postorder, the object corresponding to an XML element can be
added to the parent object in preorder or postorder. In the preorder addition, the object is added to the parent before
descendant XML elements get processed. In the postorder addition, the object is added to the parent after descendant
XML elements get processed.
XML Tag Inheritance
One discovery made while writing CookXml was that class inheritance of Object-oriented languages can be mirrored
into XML element tag inheritance. Semantically, tag inheritance means that the derived tag will inherit the setters
and adders of the inherited tags.
For example, javax.swing.JMenu is a child class of javax.swing.JMenuItem. Assuming that javax.swing.JMenu is
mapped to tag and javax.swing.JMenuItem is mapped to tag, then we can declare in CookXml
that tag inherits tag. tag then inherts the setters for attributes such as "text" and "icon"
of the tag.
Polymorphisms of OOP can be mirrored in XML tag inheritance as well. Class casting is similar to dynamically
renaming the current namespace and the tag of the element being processed.
XML tag inheritance is a methodology not present in any other XML data binding tools. This feature is immensely
useful in mapping XML documents to classes with deep inheritance hierarchy, typically found in GUI API. Thus
CookXml is useful in writing XUL motors. CookSwing and CookSwt are two such examples for mapping XML
documents to Swing and SWT classes.
Namespace Handling
Since version 3.0, CookXml is capable of dealing XML documents with multiple namespaces. For backward
compatibility, CookXml also parse XML documents without namespaces or partially utilizing namespaces.
Other Implementation Details
As of version 3.0, CookXml operates on top of XML DOM tree to map an XML document to objects. This feature
allows developers to utilize XML schema if such exist to verify the incoming XML documents. On the other hand,
the memory consumption for a large XML document can be problematic.

CookXml 108
Schema and Documentation Generation
Since a tag library for CookXml contains all the mappings between an XML element and its corresponding object
classes, it is entirely possible to use this map to generate documentations from this feature. The documentation
output can be HTML documents, or XML Schemas.
CookXmlDoc, a doclet API for CookXml can extract Javadoc tags and comments from the tag library source code.
The resulting information can in turn be used by an HTML doclet can then generate the appropriate tag
documentations. See CookSwing Tag Documentation [1] for an example.
Future Work
Streaming is a key feature that is under consideration. Such capability would reduce the memory consumption due to
the construction DOM tree as well as improving the overall performance.
See also
• CookSwing
External links
• CookXml Home Page [2]
• CookSwing: XML to Swing GUI [3]
• CookSwt: XML to SWT GUI [4]
References
[1] http:/ / cookxml. yuanheng. org/ cookswing/ tagdoc/
[2] http:/ / cookxml. yuanheng. org/
[3] http:/ / cookxml. yuanheng. org/ cookswing/
[4] http:/ / cookxml. yuanheng. org/ cookswt/

Cougaar 109
Cougaar
Cougaar is a Java-based architecture for the construction of large-scale distributed multi-agent systems. Cougaar is
the product of multi-year DARPA research projects ALP [1] and Ultra*Log. [2]
Cougaar is open source and includes not only the core runtime framework, but also a variety of demonstration,
visualization, and management components to simplify the development of complex, distributed applications.
Cougaar is an abbreviation, of sorts, for "Cognitive Agent Architecture".
External links
• Cougaar Project Webpage [3]
References
[1] Adalı, S. and Pigaty, L. 2003. The DARPA Advanced Logistics Project. Annals of Mathematics and Artificial Intelligence 37, 4 (Apr. 2003)
(http:/ / www. springerlink. com/ content/ r4007674t7127781)
[2] Todd Carrico and Mark Greaves "Agent Applications in Defense Logistics" Chapter in "Defence Industry Applications of Autonomous
Agents and Multi-Agent Systems", Springer 2008 (http:/ / www. springerlink. com/ content/ k6x53g3527606726)
[3] http:/ / www. cougaar. org

Deterministic Parallel Java 110
Deterministic Parallel Java
OS Cross-platform
Website http:/ / dpj. cs. uiuc. edu
Deterministic Parallel Java (DPJ) is an extension of the Java programming language which adds parallel constructs
that provide a deterministic programming model for object-oriented languages. The language extensions define a
type system that a programmer (or interactive porting tool) can use to annotate Java code with type information, and
a compiler can use to type-check that a DPJ program has deterministic semantics, i.e., produces the same visible
output for a given input, in all executions. Parallel algorithms that cannot be expressed entirely in the statically
checked type system require run-time mechanisms to enforce determinism: two key research goals are to make the
type system more expressive and to minimize the need to fall back to run-time techniques. With minor
modifications, language extensions should be applicable to other base OO languages, such as C++ and C#.
This work is funded by NSF grants CSA 07-02724 and CNS 07-20772, and by Intel and Microsoft through the
UPCRC Illinois.
External links
• The Deterministic Parallel Java Website [1]
References
[1] http:/ / dpj. cs. uiuc. edu
Devoxx
Devoxx (formerly named JavaPolis) is an annual European Java
conference organized by the Belgian Java User Group (BeJUG).
The conference takes place every year around December. [1] With
over 2,800 attendees in 2006, JavaPolis became the biggest
vendor-independent Java conference in the world. [1] In 2008, the
conference was renamed Devoxx.
Location
Devoxx takes place in the second-biggest European cinema
complex, the MetroPolis, located in Antwerp, Belgium. As a
JavaPolis 2006
result, the speakers' video and slides are projected on the huge cinema screens using the available THX audio setup.

Devoxx 111
Related links
• Devoxx home page [2]
• The JavaPolis home page [3]
• the Belgian Java User Group home page [4]
• Parleys.com hosts the JavaPolis (video) presentations [5]
References
Cinema screens
[1] Case Study: JavaPolis at atlassian.com (http:/ / www. atlassian. com/ software/ confluence/ casestudies/ javapolis. jsp)
[2] http:/ / www. devoxx. com
[3] http:/ / www. javapolis. com
[4] http:/ / www. bejug. org
[5] http:/ / www. parleys. com
Doclets
Doclet programs work with the Javadoc tool to generate documentation from code written in Java.
Doclets are written in the Java programming language and use the doclet API to:
• Select which content to include in the documentation.
• Format the presentation of the content.
• Create the file that contains the documentation.
The standard doclet included with Javadoc generates API documentation as frame-based HTML files. Many
non-standard doclets are available on the web, often for free. These can be used to:
• Create other non-API types of documentation.
• Output the documentation to other non-HTML file types such as PDF.
• Output the documentation as HTML with additional features such as a search.
External links
• http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ tooldocs/ javadoc/ overview. html

Elastic Path 112
Elastic Path
Industry Software
Founded 2000
Headquarters Vancouver, British Columbia, Canada
Area served Global
Products Enterprise Ecommerce Solutions
Website http:/ / www. elasticpath. com
Elastic Path Software is a privately-held company that provides enterprise ecommerce solutions. Founded in 2000 by
Harry Chemko [1] , Mark Williams and Jason Billinglsey [2] , the company provides a Java-based ecommerce
platform, web hosting, outsourcing, and consulting services. [3] Elastic Path is headquartered in Vancouver, Canada
with offices in Reading, UK.
Background
Elastic Path evolved from a web services business to developing an ecommerce platform. Elastic Path has a client
base of more than 200 customers worldwide and more than 100 employees at offices in Reading, UK and
Vancouver, Canada. Elastic Path grew without any outside capital [4] and earned a spot on the PROFIT 100 ranking
of "Canada's Fastest-growing Companies" two years in a row. [5]
Clients
Elastic Path has more than 200 clients worldwide including Vancouver 2010 Winter Olympics [6] and Paralympic
Games [7] , Virgin Media, Sony Ericsson, and Time Inc.
Ecommerce blog
Elastic Path hosts the Get Elastic Blog, providing ecommerce trends and best practice advice. Get Elastic was ranked
as the #1 ecommerce blog in the world by AdAge Power 150. [8]
External links
• Elastic Path Official Website [9]
• Get Elastic eCommerce blog [10]
• Elastic Path's GREP Developer Community [11]
• The Globe and Mail features Elastic Path's Founder: Harry Chemko. March 17, 2010. Retrieved March 31, 2010
[12]
• Branham Group Inc announces Elastic Path as One of the Top 10 Growth Companies of 2009. April 1, 2010.
Retrieved April 8, 2010 [13]
• The Vancouver Courier features Elastic Path as the Vancouver 2010 Olympic Online Store Operator. February
24, 2010. Retrieved April 8, 2010 [14]
• The Globe and Mail notes Elastic Path as a Creative and Effective Workplace. February 22, 2010. Retrieved April
8, 2010 [15]
• E-Commerce Times interviews Elastic Path's Director of Ecommerce Research, Linda Bustos, on Tips for
E-Commerce-Challenged Telcos. December 7, 2009. Retrieved April 8, 2010 [16]

Elastic Path 113
References
[1] http:/ / list. canadianbusiness. com/ rankings/ profit100/ 2009/ communication/ article. aspx?id=20090601_30009_30009 Profit. June 1, 2009.
retrieved March 31, 2010
[2] http:/ / www. bdc. ca/ en/ about/ mediaroom/ news_releases/ 2008/ 2008102111. htm?cookie_test=1 BDC. October 21, 2008. retrieved April
13, 2010
[3] http:/ / www. financialpost. com/ small-business/ succession/ story. html?id=1626778 Financial Post. May 25, 2009. Retrieved March 31,
2010
[4] http:/ / www. techvibes. com/ blog/ elastic-path-growing-and-hiring-despite-recession. Techvibes. May 7, 2009. Retrieved March 31, 2010
[5] http:/ / www. canadianbusiness. com/ profit_magazine/ press_room/ article. jsp?content=20090603_122513_6692 Profit. July 3, 2090.
Retrieved March 31, 2010
[6] http:/ / www. theglobeandmail. com/ report-on-business/ article977315. ece Globe and Mail. March 23, 2009. Retrieved March 31, 2010
[7] http:/ / www. bivinteractive. com/ index. php?option=com_content& task=view& id=2272& Itemid=30 Business in Vancouver. March 3,
2010. Retrieved March 31, 2010
[8] http:/ / adage. com/ power150/ AdAge Power 150. Retrieved April 8, 2010
[9] http:/ / www. elasticpath. com/
[10] http:/ / www. getelastic. com/
[11] http:/ / grep. elasticpath. com/ index. jspa
[12] http:/ / www. theglobeandmail. com/ report-on-business/ your-business/ grow/ harry-chemko/ article1502194/
[13] http:/ / www. branham300. com/ index. php?year=2010& listing=14
[14] http:/ / www2. canada. com/ vancouvercourier/ news/ story. html?id=403693d8-4ecd-419f-9013-2dc5a9bacc42
[15] http:/ / m. theglobeandmail. com/ report-on-business/ managing/ weekend-workout/ workplace-creativity-shrivels-on-the-vine/
article1474956/ ?service=mobile
[16] http:/ / www. ecommercetimes. com/ story/ Tips-for-E-Commerce-Challenged-Telcos-68822. html?wlc=1270764587
Electronic Disturbance Theater
The Electronic Disturbance Theater (EDT) formed in 1997, by performance artist and published writer Ricardo
Dominguez, is a small company of cyber activists and performance artists who engage in the development in both
the theory and practice of non-violent acts of defiance. Instead of showing their views in person on the streets, the
EDT would create a program to allow Electronic Civil Disobedience (ECD) called FloodNet a form of hacktivism
which would help create the simulation of a sit-in protest over the internet simply known as a virtual sit-in
demonstration to disrupt their oppressors, but overloading their computer networks and servers. The Electronic
Disturbance Theater group have the belief that that the Internet should not be used purely as a means for
communication and data exchange. Instead it should be a forum for direct action as well.
Richard Dominguez, Brett Stabaum, Stefan Wray, and Carmin Krarasic would be collectively known as The
Electronic Disturbance Theatre or EDT for short. Taking the idea of the American Civil Rights Movement of the
1960s, the EDT’s members would avoid using the real names and created aliases to cover their identities. As a
collective group they organise and program computer software to show their views against anti-propagandist and
military actions, and begin mobilizing micro-networks to act in solidarity by staging virtual sit-ins on-line and
allowing the emergence of a collective presence in direct digital actions.
FloodNet
Their objective was with the use of digital media and internet based technology, to cause online civil disobedience in
support of the Zapatista rebels residing in the state of Chiapas in Mexico. EDT uses both electronic mail aka e-mail
and the internet to promote their work around the world, encouraging fellow supporters to download and run a
HTML (Hyper Text Makeup Language) and Java applet, (a internet program used to help support interactive web
based features or programs that a HTML cannot provide alone), based tool called FloodNet a computer based
program, created by members of the Electronic Disturbance theater company Carmin Krarasic and Brett Stabaum.
The FloodNet program would simply reload a Uniform Resource Locator or URL for short several times; effectively
slowing the website and network server down, if a high number of protesters were to join in the sit-in at one time.

Electronic Disturbance Theater 114
The EDT would first execute the FloodNet software in what would be for them a dress rehearsal before attacking
their main targets on April 10 and a month later 1998, on both Mexican and American government websites,
representing both the Mexican President Ernesto Zedillo and American President Bill Clinton.
The Flood Net would work on this basic idea taken from street theatre practices and political rallies and protest but
instead present it on a much larger and international stage, with the facilitation of macro-networks and non-digital
forms of action.
The EDT’s mission was to allow the voices of the Zapatista to be heard, after the attack of the small remote village of
Acteal in Chiapas, Mexico. The Paramilitary a government funded military squad would surround a catholic church
during a Tsotsil Mayan, (a spoken Mexican language from around the Chiapas area of Mexico), for the next several
hours the Paramilitary would shot everyone to death. those inside the church and any which tried to escape resulting
in the death of fifteen children, nine men, and twenty one women, four of which were pregnant at the time on
December 22, 1997. This event would become known as the Acteal Massacre. Those who were convicted of this
crime were later released in the Supreme Court to the outrage of many, after ignoring eye witness reports and
allowing those that confessed to this crime on humanity. Instead the Supreme Court forcing on the mismanagement
of the investigation and the fabrication of evidence.
The Electronic Disturbance Theater took notice of these actions, when others did not and arranged their first act of
Electronic Civil Disobedience against the Mexican Government. Those that had downloaded the FloodNet program
in support of the Zapatista’s were asked the input the names repetitively of those that had lost their life’s at the hands
of the Mexican Army in military attacks. This would then target the servers to return an error message each time
these URL’s would be requested. This data request would then be stored on a server’s error log and in the eyes of the
Zapatista and the Electronic Disturbance Theater group, a symbolical list of those forty five Acteal civilians that had
died straight to their murderers. If enough people were to use the FloodNet applet, this would cause the computer
server running the website to overload, so that when a regular visitor or somebody working within the site was to try
and access the website or send company based emails and files, the pages would ether load extremely slowly or not
at all. Working off the same basis of a real sit-in demonstration, where the protestors block the entrance to a public
building of their oppressors and preventing access to the building.
With around twenty five percent of the world’s population, in one way or another connected to the World Wide Web,
with the use of dial-up internet connection, wired or wireless internet broadband connection and even mobile internet
technology, everyone of these means of communication can allow the internet to be used as a means of non-violent
action within our Human Rights, and is viewable around the world, and can be translated into different languages but
most importantly not controlled by the government. The EDT networked performances have already opened access
and communication between three unlikely micro-networks: net.art, net.activism, and net.hackers, with technology
always evolving their no telling how these areas will grow.
However June 10, 1998, the EDT would strike the Mexican Secretaria de Gobernacion, (Secretary of Government),
which is involved in immigration policies as well as Mexico’s federal public security forces working in conjunction
with the military against Zapatista communities in Chiapas unsuccessfully. The Mexican government would have a
programmed countermeasure in place. This is what the EDT believe took place. A countermeasure was built into the
operating Java script was placed in the Secretaria de Gobernacion’s website that was designed to activate whenever
FloodNet was directed toward its servers. Upon activation, the website would open window after window on the
FloodNet user’s internet browser. If the FloodNet user remained connected long enough, their browser whether it is
Netscape, Firefox or Internet Explorer, could crash the activist's computer, forcing the activist to reboot their system
stopping the FloodNet program at the source. The EDT has now since dealt with both the Mexican Government both
online and offline, and the United States Department of Defence, who has now inserted a counter attack system into
their Internet Browser based coding to prevent anymore FloodNet based attacks to the system and server.
The FloodNet system would be used again against the World Trade Organization in 1999, where the group would
release their online civil disobedience software to the public under the name ‘’Zapatista Disturbance Development’s

Electronic Disturbance Theater 115
Kit.’’
Cyber Terrorism?
The Electronic Disturbance Theater has and will remain a heated topic of debate, within its area of political up rise,
civil disobedience, hacktivism, and to a much larger scale extremes acts of cyber terrorism. Many people do have the
right and believe in free speech. The FloodNet programs does allow this in a safer way to the protestors, (as their real
identities can be hidden under their user names.), allowed people around the world to express their views on the
subject without travelling to the protest rallies and provide a non-violent way to be heard in the form of these sit-in
demonstrations, however this causes incorrect actions that block bandwidth, and the internet should be open for
everybody no matter what their political views. The Virtual Republic representatives view this blocking of
communications and data as an act of cyber terrorism. They believe the system should be open for all internet users,
and be accessible with a simple point then click and to those individuals or groups should be banned. Protestors are
asked to protest outside of their oppressors location, with signs and don’t interact with the business inside which with
the blocking of communication and data the EDT are doing. Against such self-evident truths, the digital agit-prop
actions of EDT call for the right to block data in the struggle for the development of democracy and human rights.
External links
• ECD [1]
• EDTECD [2]
• On Electronic Civil Disobedience [3]
• Digital Zapatismo [4]
• The Acteal Massacre - Chiapas Mexico - December 22, 1997 [5]
• Electronic Disturbance Theater [6]
• Electronic Disturbance Theater [7]
• The Zapatista Tactical FloodNet [8]
• FloodNet Foyer [9]
References
[1] http:/ / www. thing. net/ ~rdom/ ecd/ ecd. html
[2] http:/ / www. thing. net/ ~rdom/ ecd/ EDTECD. html
[3] http:/ / www. thing. net/ ~rdom/ ecd/ oecd. html
[4] http:/ / www. thing. net/ ~rdom/ ecd/ DigZap. html
[5] http:/ / www. libertadlatina. org/ Crisis_Mexico_Chiapas_Acteal_Massacre. htm
[6] http:/ / wiki. brown. edu/ confluence/ display/ MarkTribe/ Electronic+ Disturbance+ Theater
[7] http:/ / digitalarts. lcc. gatech. edu/ unesco/ internet/ artists/ int_a_edtheater. html
[8] http:/ / www. thing. net/ ~rdom/ ecd/ ZapTact. html
[9] http:/ / www. thing. net/ ~rdom/ zapsTactical/ foyer3. htm

Event dispatching thread 116
Event dispatching thread
The event dispatching thread (EDT) is a background thread used in Java to process events from the Abstract
Window Toolkit (AWT) graphical user interface event queue. These events are primarily update events that cause
user interface components to redraw themselves, or input events from input devices such as the mouse or keyboard.
The AWT uses a single-threaded painting model in which all screen updates must be performed from a single thread.
The event dispatching thread is the only valid thread to update the visual state of visible user interface components.
Updating visible components from other threads is the source of many common bugs in Java programs that use
Swing [1] .
Swing and thread safety
Most AWT and Swing object methods are not thread safe: invoking them from multiple threads risks thread
interference or memory consistency errors [2] [3] . To avoid these problems, Swing standards states that all user
interface components should be created and accessed only from the AWT event dispatch thread. A popular
third-party Look and Feel named Substance [4] goes as far as to refuse to instantiate any Swing component off of the
Event Dispatch Thread [5] , to prevent coders from making such a mistake.
Executing code in the EDT
Other application threads can execute code in the event dispatching thread by defining the code in a Runnable object
and pass it to the SwingUtilities helper class or to the EventQueue. Two methods of these classes allow:
• synchronous code execution (SwingUtilities.invokeAndWait(Runnable) or
EventQueue.invokeAndWait(Runnable))
• and asynchronous code execution (SwingUtilities.invokeLater(Runnable) or EventQueue.invokeLater(Runnable))
from the EDT.
The method invokeAndWait() should never be called from the event dispatching thread—it will throw an exception.
The method SwingUtilities.isEventDispatchThread() or EventQueue.isDispatchThread() can be called to determine
if the current thread is the event dispatching thread.
Another solution for executing code in the EDT is using the worker design pattern. The SwingWorker class,
developed by Sun Microsystems, is an implementation of the worker design pattern, and as of Java 6 is part of
standard Swing distribution. The open source project Foxtrot [6] provides another synchronous execution solution
similar to SwingWorker.
See also
• Abstract Window Toolkit (AWT)
• Swing (Java)
• SwingWorker
• BackgroundWorker, an equivalent .NET Framework class for SwingWorker
External links
• javax.swing (Swing API Javadoc documentation)
• java.awt (AWT API Javadoc documentation)
• Swing API documentation [7]
• AWT API documentation [8]
• The Event-Dispatching Thread [9]

Event dispatching thread 117
• SwingWorker [10] description from the Swing tutorial
• AWT/Swing event handling [11] article about event pumping, dispatch and processing, and the EDT
• Foxtrot project home page [6]
• Spin project home page [12]
References
[1] This problem is not specific to Java Swing. There is the same issue in most Widget toolkits, as for example Windows Forms, where the
BackgroundWorker class performs the same purpose as SwingWorker in Java.
[2] "The Event Dispatch Thread" (http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ concurrency/ dispatch. html). Sun Microsystems. .
Retrieved 2010-03-19.
[3] http:/ / weblogs. java. net/ blog/ alexfromsun/ archive/ 2005/ 11/ debugging_swing_1. html
[4] https:/ / substance. dev. java. net/
[5] http:/ / www. pushing-pixels. org/ ?p=368
[6] http:/ / foxtrot. sourceforge. net/
[7] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ swing
[8] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ awt
[9] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ misc/ threads. html#EDT
[10] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ misc/ threads. html#SwingWorker
[11] http:/ / tech. stolsvik. com/ 2009/ 03/ awt-swing-event-pumping-and-targeting. html
[12] http:/ / spin. sourceforge. net/

Facelets 118
Facelets
Stable release 1.1.15 / November 24, 2009
Preview release 1.2-dev / November 10, 2006
Written in Java
Operating
system
Cross-platform
Size 5.07 MB (archived)
Type Web Framework
License Apache License 2.0
Website http:/ / facelets. dev. java. net/
Facelets is an open source web framework under the Apache license and the default view handler technology (aka
view declaration language) for JavaServer Faces (JSF). The framework requires valid input XML documents to
work. Facelets supports all of the JSF UI components and focuses completely on building the JSF component tree,
reflecting the view for a JSF application.
Although both JSP and JSF technologies have been improved to work better together, Facelets eliminates the issues
noted in Hans Bergsten's article "Improving JSF by Dumping JSP" [1]
Facelets is similar enough to Apache Tapestry to draw comparison. In fact, Tapestry was well ahead of its time when
it first came out , and Facelets does draw on some of its ideas. The project is conceptually similar to Tapestry's,
which uses the jwcid attribute, while Facelets uses the jsfc attribute combined with proper namespaces to convert
HTML elements into the corresponding JSF components. Also, there are some similarities to the Tiles framework
regarding support templating as well as composition.
Initially, Facelets was available as a separate, alternative view declaration language for JSF 1.1 and JSF 1.2 which
both used JSP as the default view declaration language. Starting from JSF 2.0, Facelets has been promoted as the
default, and JSP has been deprecated as a legacy fall back [2] .
Example
The following example shows an XHTML template for taking the use of Facelets component-aliasing. The jsfc
attribute is used here, shows which tags to replace when compiling the page with the corresponding JavaServer
Faces components.

Facelets 119
The above code can be viewed in a browser, and edited with conventional WYSIWYG design tools. This is not
possible with regular JSF 1.2 pages (shown below the same functionality).
See also
• JavaServer Faces
Bibliography
• Wadia, Zubin; Marinschek, Martin; Saleh, Hazem; Byrne, Dennis (September 22, 2008), The Definitive Guide to
Apache MyFaces and Facelets [3] (1st ed.), Apress, pp. 400, ISBN 978-1590597378
• Wadia, Zubin; Aranda, Bruno (May 26, 2008), Facelets Essentials: Guide to JavaServer Faces View Definition
Framework [4] (1st ed.), Apress, pp. 84, ISBN 978-1430210498
External links
• Facelets Home Page [5]
• Facelets compared to Tiles [6]
• Facelets Developer Documentation [7]
References
[1] Hans Bergsten (June 6, 2004). "Improving JSF by Dumping JSP" (http:/ / onjava. com/ pub/ a/ onjava/ 2004/ 06/ 09/ jsf. html). O'Reilly
Media. .
[2] JavaServer Faces 2.0, The Complete Reference by Ed Burns and Chris Schal, page 55: 'The expert group decided to move forward with
Facelets as the basis for new features while letting JSP remain as a backward compatibility layer'.
[3] http:/ / www. apress. com/ book/ view/ 9781590597378
[4] http:/ / www. apress. com/ book/ view/ 9781430210498
[5] https:/ / facelets. dev. java. net/
[6] http:/ / www. ibm. com/ developerworks/ java/ library/ j-facelets/
[7] https:/ / facelets. dev. java. net/ nonav/ docs/ dev/ docbook. html

final (Java) 120
final (Java)
In the Java programming language, the final keyword is used in several different contexts to define an entity which
cannot later be changed.
Final classes
A final class cannot be subclassed. This is done for reasons of security and efficiency. Accordingly, many of the
Java standard library classes are final, for example java.lang.System and java.lang.String. All methods in a final
class are implicitly final.
Example:
public final class MyFinalClass {...}
Restricted subclassers are often referred to as "soft final" classes. [1]
Final methods
A final method cannot be overridden by subclasses. This is used to prevent unexpected behavior from a subclass
altering a method that may be crucial to the function or consistency of the class. [2]
Example:
public class MyClass {
}
public final void myFinalMethod() {...}
A common misconception is that declaring a class or method final improves efficiency by allowing the compiler to
directly insert the method inline wherever it is called. This is not completely true; the compiler is unable to do this
because the classes loaded at runtime might not be the same versions of the ones that were just compiled. Further,
the runtime environment and JIT compiler have the information about exactly what classes have been loaded, and
are able to make better decisions about when to inline, whether or not the method is final. [3]
Final variables
A final variable can only be assigned once. This assignment does not grant the variable immutable status. If the
variable is a field of a class, it must be assigned in the constructor of its class. (Note: If the variable is a reference,
this means that the variable cannot be re-bound to reference another object. But the object that it references is still
mutable, if it was originally mutable.)
Unlike the value of a constant, the value of a final variable is not necessarily known at compile time.
Example:
public class Sphere {
public static final double PI = 3.141592653589793; // this is
essentially a constant
public final double radius;
public final double xpos;
public final double ypos;
public final double zpos;

final (Java) 121
}
Sphere(double x, double y, double z, double r) {
}
[...]
radius = r;
xpos = x;
ypos = y;
zpos = z;
Any attempt to reassign radius, xpos, ypos, zpos will meet with a compile error. In fact, even if the constructor
doesn't set a final variable, attempting to set it outside the constructor will result in a compile error.
To illustrate that finality doesn't guarantee immutability: suppose we replace the three position variables with a
single one:
public final Position pos;
where pos is an object with three properties pos.x, pos.y and pos.z. Then pos cannot be assigned to, but the three
properties can, unless they are final themselves.
Like full immutability, finality of variables has great advantages, especially in optimization. For instance, Sphere
will probably have a function returning its volume; knowing that its radius is constant allows us to memoize the
computed volume. If we have relatively few Spheres and we need their volumes very often, the performance gain
might be substantial. Making the radius of a Sphere final informs developers and compilers that this sort of
optimization is possible in all code that uses Spheres.
Blank final
The blank final, which was introduced in Java 1.1, is a final variable whose declaration lacks an initializer. [4] [5] A
blank final can only be assigned to once and it must be definitely unassigned when an assignment occurs. In order to
do this, a Java compiler runs a flow analysis to ensure that, for every assignment to a blank final variable, the
variable is definitely unassigned before the assignment; otherwise a compile-time error must occur. [6]
In general, a Java compiler will ensure that the blank final is not used until is assigned a value and that once assigned
a value, the now final variable cannot be reassigned another value. [7]
Difference from the C++ "const" type qualifier
• In C++, a const field is not only protected from being reassigned, but there is the additional limitation that only
const methods can be called on it and it can only be passed as the const argument of other methods.
• Non-static inner classes can freely access any field of the enclosing class, final or not.
External links
• Its Time To Deprecate Final [8]
• The Final Word On the final Keyword by Renaud Waldura [9]

final (Java) 122
References
[1] "How to Use the Eclipse API" (http:/ / www. eclipse. org/ articles/ article. php?file=Article-API-Use/ index. html). The Eclipse Foundation..
2010. . Retrieved 23 July 2010.
[2] Writing Final Classes and Methods (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ IandI/ final. html)
[3] Java theory and practice: Is that your final answer? (http:/ / www. ibm. com/ developerworks/ java/ library/ j-jtp1029. html)
[4] Flanagan, David (May 1997). "Chapter 5 Inner Classes and Other New Language Features:5.6 Other New Features of Java 1.1" (http:/ / web.
deu. edu. tr/ doc/ oreily/ java/ javanut/ ch05_06. htm). Java in a Nutshell (2nd Edition ed.). O'Reilly. ISBN 1-56592-262-X. .
[5] "Types, Values, and Variables" (http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ typesValues. doc. html). Java Language
Specification Chapter 4. Sun Microsystems, Inc. 2000. . Retrieved 23 July 2010.
[6] "Definite Assignment" (http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ defAssign. doc. html). Java Language Specification.
Sun Microsystems, Inc.. 2000. . Retrieved 23 July 2010.
[7] Pattis, Richard E.. "More Java" (http:/ / www. cs. cmu. edu/ ~pattis/ 15-1XX/ 15-200/ lectures/ morejava/ lecture. html). Advanced
Programming/Practicum 15-200. School of Computer Science Carnegie Mellon University. . Retrieved 23 July 2010.
[8] http:/ / butunclebob. com/ ArticleS. MichaelFeathers. ItsTimeToDeprecateFinal
[9] http:/ / renaud. waldura. com/ doc/ java/ final-keyword. shtml#vars
FloodNet
The Zapatista Tactical FloodNet is a Java Applet that assists in the execution of virtual sit-ins by automatically
reloading the targeted website several times every minute. Additionally, it allows for users to post statements to the
site by sending them to the server log.
FloodNet was created by the Electronic Disturbance Theater members Carmin Karasic and Brett Stalbaum. This
activist group executed FloodNet in April and December 1998 on Mexican and American government sites,
respectively.
The FloodNet program will only cause desired effect when thousands of users are logged in simultaneously, where
all their browsers will automatically reload targeted website and cause desired effect. Desired effect being to cause
so much traffic inside the server that any other user attempting to log in will not be able to view the website.
External links
• An explanation of FloodNet [8]
• The FloodNet Foyer [9]

FormEngine 123
FormEngine
Developer(s)
imatics Software GmbH [1]
Stable release 1.6.3 / July 14, 2010
Development status Active
Written in Java
License MIT License
Website
FormEngine Home [2]
The FormEngine is a Java framework for dynamic form creation and complex form processing for web
applications.
About
The primary goal of this framework is to help application developers in two areas of interest:
1. dynamic creation of form definitions at runtime
2. a simple albeit powerful way to dynamically process complex calculations and validations of form input (user
data)
Characteristics
The FormEngine framework is build for use in available (or new) Java web application projects. It can be integrated
with a few easy steps into a servlet container.
Form processing occurs in form sessions that bind data processing abilities along with the snapshot of the current
data model to the task that's been initiated by a user/client. A form session manages a form instance that behaves just
like described in the form definition. The FormEngine relies on AJAX techniques to allow client-server
communication during a form session.
Calculations and data validation have to be implemented server-side only. Several design patterns aim for
minimizing memory needs. Renderers are implemented thread-safe and can be used simultaneously with multiple
form instances of a single form definition.
History
The FormEngine Java framework project started in 2007. It was created to overcome the shortfalls of other web form
frameworks in several areas. It is used in a business process management suite (*) as a replacement for the Chiba
Engine, a form framework to process XForms definitions. The FormEngine framework was first released for open
use under a modified MIT license in december 2009.
Articles and further information
Several articles have been posted about the FormEngine Java framework, such as "FormEngine : Multidynamische
Formulare" (german) [3] .
For further information see External links.

FormEngine 124
See also
• JavaServer Faces
• XForms
• Google Web Toolkit
External links
• form-engine.de Home [2]
• FormEngine example page [4]
• Chiba Engine Home [5]
• imatics ProcessSuite [6] - A business process management suite that makes use of the FormEngine framework
References
[1] http:/ / www. imatics. de
[2] http:/ / www. form-engine. de/ en/ index. jsp
[3] Java Magazine (2010), " it-republik.de (http:/ / it-republik. de/ jaxenter/ artikel/ FormEngine-Multidynamische-Formulare-2893. html)".
FormEngine: Multidynamische Formulare
[4] http:/ / www. form-engine. de/ en/ examples/ examples. jsp
[5] http:/ / chiba-project. org/ chiba/
[6] http:/ / www. processsuite. de/ langen/ index. html
Generics in Java
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of
J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type
safety." [1]
Hierarchy and classification
As per Java Language Specification [2] :
• A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic
interface declarations, generic method declarations, and by generic constructor declarations.
• A class is generic if it declares one or more type variables. These type variables are known as the type parameters
of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set
of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized
types share the same class at runtime.
• An interface is generic if it declares one or more type variables. These type variables are known as the type
parameters of the interface. It defines one or more type variables that act as parameters. A generic interface
declaration defines a set of types, one for each possible invocation of the type parameter section. All
parameterized types share the same interface at runtime.
• A method is generic if it declares one or more type variables. These type variables are known as the formal type
parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class
or interface.
• A constructor can be declared as generic, independently of whether the class the constructor is declared in is itself
generic. A constructor is generic if it declares one or more type variables. These type variables are known as the
formal type parameters of the constructor. The form of the formal type parameter list is identical to a type
parameter list of a generic class or interface.

Generics in Java 125
Motivation for generics
The following block of Java code illustrates a problem that exists when not using generics. First, it declares an
ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and
cast it to an Integer.
List v = new ArrayList();
v.add("test");
Integer i = (Integer)v.get(0); // Run time error
Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when
executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation
for using generics.
Using generics, the above code fragment can be rewritten as follows:
List v = new ArrayList();
v.add("test");
Integer i = v.get(0); // (type error) Compile time error
The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant
of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any
particular type, because the result of v.get(0) is defined as String by the code generated by the compiler.
Compiling the third line of this fragment with J2SE 5.0 (or later) will yield a compile-time error because the
compiler will detect that v.get(0) returns String instead of Integer. For a more elaborate example, see [3] .
Here is a small excerpt from the definitions of the interfaces List and Iterator in package java.util:
public interface List {
}
void add(E x);
Iterator iterator();
public interface Iterator {
}
E next();
boolean hasNext();
Wildcards
Generic type parameters in Java are not limited to specific classes. Java allows the use of wildcards to specify
bounds on the type of parameters a given generic object may have. Wildcards are type parameters of the form "?",
possibly annotated with a bound. Given that the exact element type of an object with a wildcard is unknown,
restrictions are placed on the type of methods that may be called on the object.
As an example of an unbounded wildcard, List indicates a list which has an unknown object type. Methods
which take such a list as an argument can take any type of list, regardless of parameter type. Reading from the list
will return objects of type Object, and writing non-null elements to the list is not allowed, since the parameter type is
not known.
To specify the upper bound of a generic element, the extends keyword is used, which indicates that the generic type
is a subtype of the bounding class. Thus it must either extend the class, or implement the interface of the bounding
class. So List

Generics in Java 126
The use of wildcards above is necessary since objects of one type parameter cannot be converted to objects of
another parameter. Neither List nor List is a subtype of the other, even though Integer is a
subtype of Number. So, code that deals with List does not work with List. If it did, it would be
possible to insert a Number that is not a Integer into it, which violates type safety. Here is a sample code that
explains the contradiction it brings if List is a subtype of List:
List ints = new ArrayList();
ints.add(2);
List nums = ints; //valid if List is a subtype of List accordin
substitution rule.
nums.add(3.14);
Integer x=ints.get(1); // now 3.14 is assigned to an Integer variable!
The solution with wildcards works because it disallows operations that would violate type safety.
To specify the lower bounding class of a generic element, the super keyword is used. This keyword indicates that the
aforementioned generic type is a super-type of said bounding class. So, List

Generics in Java 127
Pair grade440 = new Pair("mike", "A");
Pair marks440 = new Pair("mike", 100);
System.out.println("grade: " + grade440);
System.out.println("marks: " + marks440);
Generic method definitions
Here is an example of a generic method using the generic class above:
public Pair twice(T value)
{
}
return new Pair(value,value);
In many cases the user of the method need not indicate the type parameters, as they can be inferred:
Pair pair = twice("Hello");
The parameters can be explicitly added if needed:
Pair pair = this.twice("Hello");
Note that you cannot use native types, ex:
Pair pair; // this fails. You have to use Integer instead.
Generics in throws clause
Although exceptions themselves cannot be generic, generic parameters can appear in a throws clause:
public void throwMeConditional
{
}
(boolean conditional, T exception) throws T
if(conditional)
throw exception;
Type erasure
Generics are checked at compile-time for type-correctness. The generic type information is then removed in a
process called type erasure. For example, List will be converted to the non-generic type List, which can
contain arbitrary objects. The compile-time check guarantees that the resulting code is type-correct.
As a result of type erasure, type parameters cannot be determined at run-time. For example, when an ArrayList is
examined at runtime, there is no general way to determine whether, before type erasure, it was an
ArrayList or an ArrayList. Many people are dissatisfied with this restriction [5] . There are partial
approaches. For example, individual elements may be examined to determine the type they belong to; for example, if
an ArrayList contains an Integer, that ArrayList was presumably parameterized with Integer. Reflection can also
determine the type parameter. However, no approach works in all cases.
Demonstrating this point, the following code outputs "Equal":
ArrayList li = new ArrayList();
ArrayList lf = new ArrayList();
if (li.getClass() == lf.getClass()) // evaluates to true

Generics in Java 128
System.out.println("Equal");
Java generics differ from C++ templates. Java generics generate only one compiled version of a generic class or
function regardless of the number of parameterizing types used. Furthermore, the Java run-time environment does
not need to know which parameterized type is used because the type information is validated at compile-time and is
not included in the compiled code. Consequently, instantiating a Java class of a parameterized type is impossible
because instantiation requires a call to a constructor, which is unavailable if the type is unknown.
For example, the following code will not compile:
T instantiateElementType(List arg)
{
}
return new T(); //causes a compile error
Because there is only one copy per generic class at runtime, static variables are shared among all the instances of the
class, regardless of their type parameter. As a result, the type parameter cannot be used in the declaration of static
variables or in static methods. Static variables and static methods are "outside" of the scope of the class's
parameterized types.
See also
• Generic programming
• Java
• Comparison of C# and Java
• Comparison of Java and C++
External links
• Lesson: Generics [6] at The Java Tutorials
• Generics [7] by Sun Microsystems
• Wild FJ [8] by Mads Torgersen, Erik Ernst, and Christian Plesner Hansen
• Java Generics FAQ [5] by Angelika Langer
• JavaWorld Taming the Tiger [9] Excellent overview.
• Java Generics Presentation [10] by DevelopIntelligence
• Java Generics Tutorial [11] by Jakob Jenkov - jenkov.com
References
[1] Java Programming Language (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ index. html)
[2] Java Language Specification, Third Edition (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html) by James Gosling, Bill
Joy, Guy Steele, Gilad Bracha - Prentice Hall PTR 2005
[3] http:/ / java. sun. com/ j2se/ 1. 5/ pdf/ generics-tutorial. pdf - Generics in the Java Programming Language
[4] http:/ / stackoverflow. com/ questions/ 156275/ what-is-the-equivalent-of-the-c-pairl-r-in-java
[5] Gafter, Neal (2006-11-05). "Reified Generics for Java".
[6] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ generics/ index. html
[7] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ generics. html
[8] http:/ / homepages. inf. ed. ac. uk/ wadler/ fool/ program/ 14. html
[9] http:/ / www. javaworld. com/ javaworld/ jw-06-2004/ jw-0607-tiger2. html
[10] http:/ / www. developintelligence. com/ learn/ tutorials. php
[11] http:/ / tutorials. jenkov. com/ java-generics/ index. html

G-java 129
G-java
G-java 2.x was a cross-platform game/software Java-based compiler for G-Creator. It has since dissolved into
various projects such as Pineapple and Dolphin, although downloads for it are still around, but unsupported. It ran on
and created software for any Java supported operating systems such as Microsoft Windows 95+, Mac OS, Linux,
Unix and Sun Solaris. G-java is made up of two components: the IDE and the API, both of which were originally
based on Game Maker but have since been modified and became more close to Java's API.
G-Java API
The G-java API is a java API for creating games and other software based on the Game Maker Language used in
Game Maker. This allows Game Maker developers to quickly learn Java, while also giving Java programmers a lot
of useful functions for game or software development. So far, the G-java API is still in an alpha stage, but the
JavaDocs can already be viewed: G-java API javadoc [1]
History
Originally G-java was a Game Maker to Java converter application written by TGMG(lead developer), IsmAvatar
(optimization), and BZGaming (programmed some functions) in the Java programming language. It was first
released in December 2004. It is designed to allow its users to easily develop multi-platform Java computer games
without learning the Java language. However with the release of Game Maker 7 (G-java was at version 1.08 beta 8
and supported many of GM's features), Mark Overmars, the creator of Game Maker, made a public announcement
that G-Java was now officially disallowed by the new GM7 license agreement: [2], and has also encrypted the GMK
files (Game Maker 7's saved file) to discourage similar projects. Although Game Maker was originally freeware, it
switched to shareware by version 5. Conversely, TGMG hopes to improve on Game maker by making G-java2 open
source.
G-java used to use .gm6 files created in the Game Maker IDE, and converts them to .jar files which can be executed
in any Java VM within most modern graphical web browsers. For experienced users, G-java contained a built-in
scripting programming language called "EGML", or "Extended Game Maker Language". This allow users to create
programs with Java functions not available in the Game Maker Language.
G-Java 2.0 was initially supposed to implement the NetBeans source-code to save some work. However, this proved
to be extremely limited and too big.
G-Java 2.0 was then renamed to G-Creator, codenamed Aurora(Portuguese word for dawn), and started from the
beginning - the core. G-java 2.0 became the main compiler of G-Creator, before both projects dissolved altogether.
G-Java and LateralGM
The G-Java project's ancestor, Dolphin, is currently being developed as a LateralGM plugin for the same purpose.
External links
• G-java site [3] - old G-Java website; This is outdated and may be removed soon.
• G-Creator site [4] - Official G-Creator website.
• G-java/G-Creator forums [5] - official forums.
• LateralGM [6] - An open source project affiliated with and similar to G-Java, lead by IsmAvatar.

G-java 130
References
[1] http:/ / www. g-java. com/ javadoc/
[2] http:/ / forums. gamemaker. nl/ index. php?showtopic=266467& view=findpost& p=1882461
[3] http:/ / www. g-java. com
[4] http:/ / www. g-creator. org
[5] http:/ / forums. g-creator. org/
[6] http:/ / www. ismavatar. com/ lgm/
GlassFish Metro
Metro is an opensource web service stack that is a part of the GlassFish project, though it can also be used in a
stand-alone configuration. [1] Components of metro include JAXB RI, JAX-WS RI, SAAJ RI, SJSXP, and WSIT. It
is available under the CDDL and GPLv2 (with classpath exception.) [2]
It is supported by Sun Microsystems.
History
Originally, the Glassfish project developed two semi-independent project :
• JAX-WS RI, the Reference implementation of the JAX-WS specification
• WSIT, a Java implementation of some of the WS-* and an enhanced support for interoperability with the .NET
Framework. It is based on JAX-WS RI as "Web Service layer".
In June 2007, it has been decided to bundle these two components as a single component named Metro[3].
Market share
Metro is bundled with Java SE 6 in order to allow consumers of Java SE 6 to consume Web Services [4]
Metro is bundled with numerous Application Servers [5] such as :
• GlassFish
• Sun Java System Application Server Platform Edition 9.x
• Oracle WebLogic Server
• JBoss (as of version 5.x)
• TmaxSoft JEUS 6.x
The JAXB reference implementation developed for Metro is used in virtually every Java Web Services framework
(Apache Axis2, Codehaus XFire, Apache CXF) and Application Servers.

GlassFish Metro 131
Features
Metro compares well with other web service frameworks in terms of functionality. A comparison is provided by
Codehaus at [6], which compares Apache Axis 1.x, Axis 2.x, Celtix, Glue, JBossWS, Xfire 1.2 and JAX-WS RI +
WSIT (the bundle was not yet named Metro at this time).
See also
• Apache CXF
External links
• Official website [7]
References
[1] "metro: Discover Metro" (https:/ / metro. dev. java. net/ discover/ ). .
[2] "metro: Metro FAQ" (https:/ / metro. dev. java. net/ discover/ faq. html). .
[3] http:/ / blogs. sun. com/ arungupta/ entry/ announcing_metro_naming_the_web
[4] https:/ / jax-ws. dev. java. net/ faq/ index. html#different_versions
[5] http:/ / blogs. sun. com/ theaquarium/ entry/ metro_now_on_tomcat_6
[6] http:/ / xfire. codehaus. org/ Stack+ Comparison
[7] https:/ / metro. dev. java. net/

James Gosling 132
James Gosling
James Arthur Gosling
Born May 19, 1955
near Calgary, Alberta, Canada
Residence United States
Nationality Canada
Alma mater Carnegie Mellon University, University of Calgary
Occupation Computer Scientist
Employer None [1]
Known for Java programming language
Awards Officer of the Order of Canada
Website
James Gosling's weblog [2]
James A. Gosling, OC (born May 19, 1955 near Calgary, Alberta, Canada) is a software developer, best known as
the father of the Java programming language.
Education and career
In 1977, James Gosling received a B.Sc in Computer Science from the University of Calgary. In 1983, he earned a
Ph.D in Computer Science from Carnegie Mellon University, and his doctoral thesis was titled "The Algebraic
Manipulation of Constraints". While working towards his doctorate, he wrote a version of emacs (gosmacs), and
before joining Sun Microsystems he built a multi-processor version of Unix [3] while at Carnegie Mellon University,
as well as several compilers and mail systems.
Between 1984 and 2010, Gosling was with Sun Microsystems. He is known as the father of the Java programming
language.
[1] [4]
On April 2, 2010, Gosling left Sun Microsystems which had recently been acquired by the Oracle Corporation.
Regarding why he left, Gosling wrote on his blog that "Just about anything I could say that would be accurate and
honest would do more harm than good."

James Gosling 133
Contributions
He is generally credited as the inventor of the Java programming language in 1994. [5] He created the original design
of Java and implemented its original compiler and virtual machine. For this achievement he was elected to the
United States National Academy of Engineering. He has also made major contributions to several other software
systems, such as NeWS and Gosling Emacs. He co-wrote the "bundle" program, a utility thoroughly detailed in
Brian Kernighan and Rob Pike's book The Unix Programming Environment.
Honors
In 2007, he was made an Officer of the Order of Canada. [6] The Order is Canada's highest civilian honour. Officers
are the second highest grade.
Books
• Ken Arnold, James Gosling, David Holmes, The Java Programming Language, Fourth Edition, Addison-Wesley
Professional, 2005, ISBN 0-321-34980-6
• James Gosling, Bill Joy, Guy L. Steele Jr., Gilad Bracha, The Java Language Specification, Third Edition,
Addison-Wesley Professional, 2005, ISBN 0-321-24678-0
• Ken Arnold, James Gosling, David Holmes, The Java Programming Language, Third Edition, Addison-Wesley
Professional, 2000, ISBN 0-201-70433-1
• James Gosling, Bill Joy, Guy L. Steele Jr., Gilad Bracha, The Java Language Specification, Second Edition,
Addison-Wesley, 2000, ISBN 0-201-31008-2
• Gregory Bollella (Editor), Benjamin Brosgol, James Gosling, Peter Dibble, Steve Furr, David Hardin, Mark
Turnbull, The Real-Time Specification for Java, Addison Wesley Longman, 2000, ISBN 0-201-70323-8
• Ken Arnold, James Gosling, The Java programming language Second Edition, Addison-Wesley, 1997, ISBN
0-201-31006-6
• Ken Arnold, James Gosling, The Java programming language, Addison-Wesley, 1996, ISBN 0-201-63455-4
• James Gosling, Bill Joy, Guy L. Steele Jr., The Java Language Specification, Addison Wesley Publishing
Company, 1996, ISBN 0-201-63451-1
• James Gosling, Frank Yellin, The Java Team, The Java Application Programming Interface, Volume 2: Window
Toolkit and Applets, Addison-Wesley, 1996, ISBN 0-201-63459-7
• James Gosling, Frank Yellin, The Java Team, The Java Application Programming Interface, Volume 1: Core
Packages, Addison-Wesley, 1996, ISBN 0-201-63453-8
• James Gosling, Henry McGilton, The Java language Environment: A white paper [7] , Sun Microsystems, 1996
• James Gosling, David S. H. Rosenthal, Michelle J. Arden, The NeWS Book : An Introduction to the
Network/Extensible Window System (Sun Technical Reference Library), Springer, 1989, ISBN 0-387-96915-2

James Gosling 134
External links
• James Gosling's personal weblog [8]
• James Gosling's weblog at Sun [9]
• Presentation [10] by James Gosling about the origins of Java, from the JVM Languages Summit 2008
• slide show depicting Gosling's life [11]
References
[1] "Time to move on..." (http:/ / nighthacks. com/ roller/ jag/ entry/ time_to_move_on). James Gosling's personal blog. .
[2] http:/ / nighthacks. com/ roller/ jag
[3] James Gosling mentioned a multiprocessor Unix in his statement during the US vs Microsoft Antitrust DOJ trial in 1998 "DOJ/Antitrust"
(http:/ / www. usdoj. gov/ atr/ cases/ f2000/ 2049. htm). Statement in MS Antitrust case. US DOJ. . Retrieved 2007-02.
[4] Father of Java James Gosling quits Oracle (http:/ / opensource. cbronline. com/ news/ father_of_java_james_gosling_quits_oracle_120410)
[5] "Sun Labs-The First Five Years: The First Fifty Technical Reports. A Commemorative Issue" (http:/ / portal. acm. org/ citation.
cfm?id=974955& dl=GUIDE& coll=GUIDE& CFID=75229392& CFTOKEN=55758856). Ching-Chih Chang, Amy Hall, Jeanie Treichel.
Sun Microsystems, Inc.. . Retrieved 2010-02-07.
[6] Order of Canada announcement (http:/ / www. gg. ca/ media/ doc. asp?lang=e& DocID=4984)
[7] http:/ / java. sun. com/ docs/ white/ langenv/
[8] http:/ / nighthacks. com/ roller/ jag/
[9] http:/ / blogs. sun. com/ jag/
[10] http:/ / www. infoq. com/ presentations/ gosling-jvm-lang-summit-keynote
[11] http:/ / www. eweek. com/ c/ a/ Application-Development/ The-Life-and-Times-of-Java-and-James-Gosling-746438/
Gray Flimmer
Gray flimmer(ing) - The constant flashing of a Java applet, usually in animation, with the refresh() method. This
can usually be avoided by implementation of the update() method or by using the technique of double buffering. The
singular term 'gray flimmer' refers to a single flash of an image in a Java applet. When gray flimmering occurs, the
image flashes in such a way that it alternates rapidly between the actual image and a blank gray frame. This is where
the term 'gray flimmering' originates.

Todd Greanier 135
Todd Greanier
Todd Greanier is an author and software architect, widely regarded as an expert in Java programming. [1] [2] He has
written several books on the subject, including Java Foundations, which is used as a textbook in many college-level
computer science programs. It has been translated into over forty languages and is the standard text for Java
programmers in India, Russia, Germany, and South Africa.
Once a popular instructor for Sun Microsystems, Greanier now works to develop and deliver online training
programs. He was a frequent contributor to the now defunct New York Sun newspaper, [3] and was co-author (with
sportswriter Sean Lahman) of three books on professional football. [4]
Todd is currently working on a book on boxing history and is one of the founders (with Sean Lahman) of Bluebeard
Publishing. [5]
External links
• Java Foundations [6] (at Google Books)
• JavaWorld article on the Java Serialization API [7]
References
[1] From Sun Developer Network (http:/ / java. sun. com/ developer/ technicalArticles/ Programming/ serialization/ ) — "Greanier…has been
teaching and developing Java since it was introduced publicly. An expert in distributed Java technologies, he teaches classes in a wide range
of topics, including JDBC, RMI, CORBA, UML, Swing, servlets/JSP, security, JavaBeans, Enterprise Java Beans, and multithreading. He also
creates custom seminars for corporations, slanted to their specific needs."
[2] Review of Greanier's appearance at Java University. (http:/ / www. onjava. com/ pub/ a/ onjava/ 2002/ 04/ 10/ javau. html) — "Greanier, a
longtime Java developer and trainer, is an engaging instructor…"
[3] authors' archive at New York Sun website (http:/ / www. nysun. com/ authors/ Todd+ Greanier)
[4] Listing of football books at Amazon (http:/ / www. amazon. com/ s/ ref=nb_ss_b?url=search-alias=stripbooks& field-keywords=todd+
greanier+ football).
[5] Bluebeard Publishing website (http:/ / bluebeardpublishing. com/ ).
[6] http:/ / books. google. com/ books?hl=en& id=vbBXKgDJun0C& dq=todd+ greanier& printsec=frontcover& source=web&
ots=LeJJ2zpZFA& sig=N34M4CJjzy6bSwojv-Mr6qkppIE& sa=X& oi=book_result& resnum=3& ct=result
[7] http:/ / www. javaworld. com/ javaworld/ jw-07-2000/ jw-0714-flatten. html

Head First (book series) 136
Head First (book series)
Head First is a series of introductory instructional books to many topics, published by O'Reilly Media. It stresses an
unorthodox, visually intensive, reader-involving combination of puzzles, jokes, nonstandard design and layout, and
an engaging, conversational style to immerse the reader in a given topic.
Originally, the series covered programming and software engineering, but is now expanding to other topics in
science, mathematics and business, due to success[1]. The series was created by Bert Bates and Kathy Sierra, and
began with Head First Java in 2003.
Concept
The main idea of the series is to effectively stimulate the brain by: [2]
• Telling stories
• Visualizing
• Using attention-grabbing tactics: page layout, non-standard examples, puzzles, jokes, and other means.
By using metacognition [3] the series' authors and editors try to employ varied methods to present information and
accelerate the learning process.
Books
The official web site for the Head First series has forums for each book as well as code downloads and sample
chapters. They include:
• Head First Software Development (ISBN 0-596-52735-7) by Dan Pilone and Russ Miles
• Head First PMP (ISBN 0-596-10234-8) by Jennifer Greene and Andrew Stellman
• Head First Object-Oriented Analysis and Design (ISBN 0-596-00867-8) by Brett McLaughlin, Gary Pollice and
David West
• Head First Ajax (ISBN 0-596-51578-2) by Rebecca Riordan
• Head First HTML with CSS & XHTML (ISBN 0-596-10197-X) by Elisabeth Freeman and Eric Freeman
• Head First Java (ISBN 0-596-00920-8) by Kathy Sierra and Bert Bates
• Head First Design Patterns (ISBN 0-596-00712-4) by Eric Freeman, Elisabeth Freeman, Kathy Sierra and Bert
Bates
• Head First SQL (ISBN 0-596-52684-9) by Lynn Beighley
• Head First Rails (ISBN 0-596-51577-4) by David Griffiths
• Head First Servlets & JSPs (ISBN 0-596-51668-1) by Bryan Basham, Kathy Sierra and Bert Bates
• Head First JavaScript (ISBN 0-596-52774-8) by Michael Morrison
• Head First PHP & MySQL (ISBN 0-596-00630-3) by Lynn Beighley and Michael Morrison
• Head First Statistics (ISBN 0-596-52758-6) by Dawn Griffiths
• Head First iPhone Development (ISBN 0-596-80354-0) by Dan Pilone and Tracey Pilone
• Head First Programming (ISBN 0-596-80237-4) by Paul Barry and David Griffiths
The offerings in the Head First series are quickly expanding and also delving into subjects that are not directly
related to IT, such as Math (Head First Algebra, Head First Statistics), Science (Head First Physics) and project
management (Head First PMP). The books are also gaining some popularity for classroom use because of their
novel approach to their subject matters.

Head First (book series) 137
Head First Labs
O'Reilly established Head First Labs, where books of the series are presented and the main idea behind the series is
explained. The Labs also hosts blogs by some of their authors and hosts some applets that complement their books.
Awards
The books in the series have received three nominations for Product Excellence Jolt Awards, winning in 2005 for
Head First Design Patterns, and were recognized on Amazon.com's yearly top 10 list for computer books from 2003
to 2005.
External links
• Head First Labs [4]
• Blog [5] and blog archive [6] of Head First Labs
References
[1] http:/ / www. headfirstlabs. com/
[2] "How Head First Helps You Learn" (http:/ / www. headfirstlabs. com/ about. php). . Retrieved 2008-06-08.
[3] "The Head First Formula" (http:/ / www. headfirstlabs. com/ readme. php). . Retrieved 2008-06-08.
[4] http:/ / www. headfirstlabs. com/ books/
[5] http:/ / feeds. feedburner. com/ headfirst-oreillymedia
[6] http:/ / www. headfirstlabs. com/ archive. php
Jim Hugunin
Jim Hugunin is a software programmer who created the Python programming language extension Numeric
(ancestor to NumPy), and later created Python implementations for the Java Platform (Jython) and for Microsoft
.NET platform (IronPython); he has also co-designed the AspectJ extension for the Java programming language.
Since 2004 he has been working for Microsoft, mainly on IronPython and Dynamic Language Runtime [1] .
References
[1] Jim Hugunin blog (http:/ / blogs. msdn. com/ hugunin/ ) at MSDN

Inner class 138
Inner class
In object-oriented programming, an inner class (aka nested class) is a class declared entirely within the body of
another class or interface. It is distinguished from a subclass.
Inner classes became a feature of the Java programming language starting with version 1.1. They are also a feature of
the D programming language.
In Python, it is possible to nest a class within another class, method or function.
Overview
An instance of a normal or top-level class can exist on its own. By contrast, an instance of an inner class cannot be
instantiated without being bound to a top-level class.
Let us take the abstract notion of a Car with four wheels. Our wheels have a specific feature that relies on being part
of our Car. This notion does not represent the wheels as wheels in a more general form that could be part of vehicle.
Instead it represents them as specific to this one. We can model this notion using inner classes as follows:
We have the top-level class Car. Instances of Class Car are composed of four instances of the class Wheel. This
particular implementation of Wheel is specific to the car, so the code does not model the general notion of a Wheel
which would be better represented as a top-level class. Therefore, it is semantically connected to the class Car and
the code of Wheel is in some way coupled to its outer class.
Inner classes provide us with a mechanism to accurately model this connection. We say that our wheel class is
Car.Wheel, Car being the top-level class and Wheel being the inner class.
Inner classes therefore allow for the object orientation of certain parts of the program that would otherwise not be
encapsulated into class.
Larger segments of code within a class might be better modeled or refactored as a separate top-level class, rather
than an inner class. This would make the code more general in its application and therefore more re-usable but
potentially might be premature generalization. This may prove more effective if code has many inner classes with
the shared functionality .
Types of inner class
In Java there are four types of nested class:
• Static member class, also simply called nested class - They are declared static. Like other things in static scope,
they do not have an enclosing instance, and cannot access instance variables and methods of the enclosing class.
They are almost identical to non-nested classes except for scope details (they can refer to static variables and
methods of the enclosing class without qualifying the name; other classes that are not one of its enclosing classes
have to qualify its name with its enclosing class's name). Nested interfaces are implicitly static.
• Inner class - The following categories are called inner classes. Each instance of these classes has a reference to an
enclosing instance (i.e. an instance of the enclosing class), except for local and anonymous classes declared in
static context. Hence, they can implicitly refer to instance variables and methods of the enclosing class. The
enclosing instance reference can be explicitly obtained via EnclosingClassName.this. Inner classes may not have
static variables or methods, except for compile-time constant variables. When they are created, they must have a
reference to an instance of the enclosing class; which means they must either be created within an instance
method or constructor of the enclosing class, or (for member and anonymous classes) be created using the syntax
enclosingInstance.new InnerClass().
• Member class - They are declared outside a function (hence a "member") and not declared "static".

Inner class 139
• Local class - These are classes which are declared in the body of a function. They can only be referred to in the
rest of the function. They can use local variables and parameters of the function, but only ones which are
declared "final". (This is because the local class instance must maintain a separate copy of the variable, as it
may out-live the function; so as not to have the confusion of two modifiable variables with the same name in
the same scope, the variable is forced to be non-modifiable.)
• Anonymous class - These are local classes which are automatically declared and instantiated in the middle of
an expression. They can only directly extend one class or implement one interface. They can specify
arguments to the constructor of the superclass, but cannot otherwise have a constructor (however, this is not a
limitation, since it can have an instance initializer block to perform any initialization).
C++ has nested classes that are like Java's static member classes (first kind above), except that they are not declared
with "static".
GUI code
Local inner classes are often used in Java to define callbacks for GUI code. Components can then share an object
that implements an event handling interface or extends an abstract adapter class, containing the code to be executed
when a given event is triggered.
Anonymous inner classes are also used where the event handling code is only used by one component and therefore
does not need a named reference.
This avoids a large monolithic actionPerformed(ActionEvent) method with multiple if else branches to identify the
source of the event. This type of code is often considered messy and the inner class variations are considered to be
better in all regards.
External links
• So what are inner classes good for anyway? [1]
• Nested classes in D [2]
References
[1] http:/ / www. javaworld. com/ javaworld/ javaqa/ 2000-03/ 02-qa-innerclass. html
[2] http:/ / www. digitalmars. com/ d/ class. html#nested

Interface (Java) 140
Interface (Java)
An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic
sense of the term) that classes must implement. Interfaces are declared using the interface keyword, and may only
contain method signatures and constant declarations (variable declarations that are declared to be both static and
final). An interface may never contain method definitions.
As interfaces are implicitly abstract, they cannot be directly instantiated except when instantiated by a class that
implements the said interface. The class must implement all of the methods described in the interface, or be an
abstract class. Object references in Java may be specified to be of an interface type; in which case, they must either
be null, or be bound to an object that implements the interface.
One benefit of using interfaces is that they simulate multiple inheritance. All classes in Java (other than
java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of
classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of
interfaces; however an interface may not implement an interface.
Overview
Interfaces are used to encode similarities which classes of various types share, but do not necessarily constitute a
class relationship. For instance, a human and a parrot can both whistle; however, it would not make sense to
represent Humans and Parrots as subclasses of a Whistler class. Rather they would most likely be subclasses of an
Animal class (likely with intermediate classes), but both would implement the Whistler interface.
Another use of interfaces is being able to use an object without knowing its type of class, but rather only that it
implements a certain interface. For instance, if one were annoyed by a whistling noise, one may not know whether it
is a human or a parrot, because all that could be determined is that a whistler is whistling. In a more practical
example, a sorting algorithm may expect an object of type Comparable. Thus, it knows that the object's type can
somehow be sorted, but it is irrelevant what the type of the object is. The call whistler.whistle() will call the
implemented method whistle of object whistler no matter what class it has, provided it implements Whistler.
For example:
interface Bounceable
{
void setBounce(); // Note the semicolon:
implementations are allowed.
}
Usage
Defining an interface
// Interface methods are public and abstract.
// Think of them as prototypes only; no
Interfaces are defined with the following syntax (compare to Java's class definition):
[visibility] interface InterfaceName [extends other interfaces] {
}
constant declarations
member type declarations
abstract method declarations

Interface (Java) 141
The body of the interface contains abstract methods, but since all methods in an interface are, by definition, abstract,
the abstract keyword is not required. Since the interface specifies a set of exposed behaviors, all methods are
implicitly public.
Thus, a simple interface may be
public interface Predator {
}
boolean chasePrey(Prey p);
void eatPrey(Prey p);
The member type declarations in an interface are implicitly static and public, but otherwise they can be any type of
class or interface. [1]
The syntax for implementing an interface uses this formula:
... implements InterfaceName[, another interface, another, ...] ...
Classes may implement an interface. For example,
public class Lion implements Predator {
}
public boolean chasePrey(Prey p) {
}
// programming to chase prey p (specifically for a lion)
public void eatPrey (Prey p) {
}
// programming to eat prey p (specifically for a lion)
If a class implements an interface and does not implement all its methods, it must be marked as abstract. If a class is
abstract, one of its subclasses is expected to implement its unimplemented methods.
Classes can implement multiple interfaces
public class Frog implements Predator, Prey { ... }
Interfaces are commonly used in the Java language for callbacks. [2] Java does not allow the passing of methods
(procedures) as arguments. Therefore, the practice is to define an interface and use it as the argument and use the
method signature knowing that the signature will be later implemented.
Subinterfaces
Interfaces can extend several other interfaces, using the same formula as described above. For example
public interface VenomousPredator extends Predator, Venomous {
}
//interface body
is legal and defines a subinterface. Note how it allows multiple inheritance, unlike classes. Note also that Predator
and Venomous may possibly define or inherit methods with the same signature, say kill(Prey prey). When a class
implements VenomousPredator it will implement both methods simultaneously.

Interface (Java) 142
Examples
Some common Java interfaces are:
• Comparable has the method compareTo, which is used to describe two objects as equal, or to indicate one is
greater than the other. Generics allow implementing classes to specify which class instances can be compared to
them.
• Serializable is a marker interface with no methods or fields - it has an empty body. It is used to indicate that a
class can be serialized. Its Javadoc describes how it should function, although nothing is programmatically
enforced.
Java interface modifiers
Access Modifier Interface Modifier
public abstract
strictfp
Note that improper usage of modifiers of interfaces may result in unstable software behavior.
See also
• Mixin
External links
• What Is an Interface? [3]
• Interfaces and Packages [4]
• Difference between a Java interface and a Java abstract class [5]
References
[1] "The Java Language Specification" (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ interfaces. html#9. 5). .
[2] "Java World" (http:/ / www. javaworld. com/ javaworld/ javatips/ jw-javatip10. html). .
[3] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ concepts/ interface. html
[4] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ interpack/ index. html
[5] http:/ / javapapers. com/ ?p=17

Internet Foundation Classes 143
Internet Foundation Classes
The Internet Foundation Classes (IFC) were a graphics library for Java originally developed by Netcode
Corporation and first released by Netscape Corporation on December 16, 1996.
History
On April 2, 1997, Sun Microsystems and Netscape announced their intention to combine IFC with other
technologies to form the Java Foundation Classes [1] .
Ultimately, Sun merged the IFC with other technologies under the name "Swing", adding the capability for a
pluggable look and feel of the widgets.
Because its technology has been merged to constitute Swing and Java 2D, IFC is now no longer maintained.
Differences with Swing
Swing draw a lot of features from IFC:
• contrary to AWT, IFC were written in pure Java, thus being (at the time) browser-independent.
• IFC already provided two Layout managers, that would be later included in the standard JDK
• some IFC components were able to read HTML content from URLs, but the implementation was still far from
reliable.
However, Swing also improved IFC in a lot of ways:
• IFC did not have a Model-View architecture
• contrary to Swing, the Look and feel of IFC components was written in the components themselves, making it
impossible to change it easily.
• IFC components were not JavaBeans. IFC had a specific persistence mechanism [2] , but it was a bit complex, and
not compatible with the Java Serialization API.
• event mechanism was still raw [3] , and the Event loop sometimes needed to be accessed directly.
Examples
Hello World
This is the classic Hello world program in IFC:
import netscape.application.*;
import netscape.util.*;
public class HelloWorld extends Application {
public void init() {
}
super.init();
// Create a text field
TextField textField = new TextField(100, 24, 128, 24);
// Set the string to be displayed in the text field.
textField.setStringValue("Hello World");
// Add the text field to the view hierarchy.
mainRootView().addSubview(textField);

Internet Foundation Classes 144
// This method allows HelloWorld to run as a stand alone
application.
}
public static void main(String args[]) {
}
HelloWorld = new HelloWorld ();
ExternalWindow mainWindow = new ExternalWindow();
Size size;
app.setMainRootView(mainWindow.rootView());
size = mainWindow.windowSizeForContentSize(320, 200);
mainWindow.sizeTo(size.width, size.height);
mainWindow.show();
app.run();
To be compared with the equivalent Java Swing code:
import javax.swing.*;
public class HelloWorld extends JFrame {
}
public HelloWorld() {
}
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
add(new JLabel("Hello, World!"));
public static void main(String[] args) {
}
See also
• Swing
HelloWorld app = new HelloWorld();
app.pack();
External links
• IFC presentation [4]
app.setVisible(true);
• IFC runtime download [5]
• IFC programming guide [6]
• IFC class hierarchy [7]
• IFC tutorial [8]
The last places, where to download the IFC:
• ftp-Server 1 Uni-Potsdam [9]
• ftp-Server 2 Uni-Potsdam [10]
• ftp-Server 3 Uni-Potsdam [11]

Internet Foundation Classes 145
• ftp-Server Uni-Bochum [12]
• ftp-Server SunSite [13]
All find from
• FileSearching.com [14]
The web-archive where is the last place to find really all files:
• WebArchive of the IFC-side [15]
References
[1] "Sun and Netscape to jointly develop Java Foundation Classes" (http:/ / wp. netscape. com/ newsref/ pr/ newsrelease378. html). Netscape
Communications Corporation. 1997-04-02. . Retrieved 2007-07-14.
[2] "IFC 1.1 guide - Persistence" (http:/ / infodoc. unicaen. fr/ docs/ Java/ guide. IFC1. 1/ persist. mak. html#1004819). 2000-06-15. . Retrieved
2007-07-15.
[3] "IFC 1.1 guide - Targets and commands" (http:/ / infodoc. unicaen. fr/ docs/ Java/ guide. IFC1. 1/ targets. mak. html#100582). 2000-06-15. .
Retrieved 2007-07-15.
[4] http:/ / www. phdcc. com/ javaart2. html
[5] http:/ / wp. netscape. com/ eng/ ifc/ download. html
[6] http:/ / infodoc. unicaen. fr/ docs/ Java/ guide. IFC1. 1/
[7] http:/ / infodoc. unicaen. fr/ docs/ Java/ Reference. IFC1. 1/ tree. html
[8] http:/ / infodoc. unicaen. fr/ docs/ Java/ cookbook/
[9] ftp:/ / ftp. uni-potsdam. de/ pub/ WWW/ Netscape/ navigator/ plugins/ ifc/ 1. 0/
[10] ftp:/ / ftp. uni-potsdam. de/ pub/ WWW/ clients/ netscape/ plugins/ ifc/ 1. 0/
[11] ftp:/ / ftp. uni-potsdam. de/ pub/ WWW/ netscape/ navigator/ plugins/ ifc/ 1. 0/
[12] ftp:/ / ftp. ruhr-uni-bochum. de/ . subdisc1/ local/ jk. collection/
[13] ftp:/ / ftp. anu. edu. au/ sunsite/ mnt/ disk3/ WWW/ netscape/ navigator/ plugins/ ifc/ 1. 0/
[14] http:/ / www. filesearching. com/ cgi-bin/ s?q=nsifc10
[15] http:/ / web. archive. org/ web/ 20001021124345/ developer. netscape. com/ docs/ manuals/ ifc/ downloads/ downloads. html

JAD (JAva Decompiler) 146
JAD (JAva Decompiler)
Developer(s) Pavel Kouznetsov
Initial release Before 1999
Written in C++
Operating
system
Cross-platform
Available in English
Type Software engineering
License Free for non-commercial use (Copyright: Pavel Kouznetsov)
Jad (JAva Decompiler) is a decompiler for the Java programming language. Jad provides a command-line user
interface to extract source code from class files. The most popular GUI for Jad is DJ Java Decompiler http:/ /
members. fortunecity. com/ neshkov/ dj. html. According to CNET.com, in the past 8 years the various versions of
DJ Java Decompiler has been downloaded over 10 Million times. A graphical user interface for Jad is JadClipse
which is a plugin to the Eclipse IDE.
The domain name used by the official website expired on 02/25/2009.
The most recent version of JAD says it supports only Java versions 45.3, 46.0 and 47.0, not Java 5.
A similar alternative, JD-Core [1] , has emerged that supports JDK 1.1.8 to JDK 1.6.0, jrockit90_150, jikes-1.2.2,
harmony-jdk.
See also
• Mocha (decompiler)
External links
• New download site [2]
• JadClipse plugin for Eclipse IDE [3]
• JadRetro decompiler helper for Jad [4]
• uuDeJava decompiler helper for Jad [5]
• Original Jad site, including downloads [6] at the Wayback Machine (archived February 14, 2008).
• DJ Java Decompiler New homepage [7]
References
[1] http:/ / java. decompiler. free. fr/
[2] http:/ / www. varaneckas. com/ jad
[3] http:/ / jadclipse. sf. net/
[4] http:/ / jadretro. sourceforge. net/
[5] http:/ / www. uuware. com/ uudejava_en. htm
[6] http:/ / web. archive. org/ web/ 20080214075546/ http:/ / www. kpdus. com/ jad. html
[7] http:/ / www. neshkov. com/ dj. html

JAD (file format) 147
JAD (file format)
Filename extension .jad
Internet media
type
text/vnd.sun.j2me.app-descriptor
Developed by Sun Microsystems, Inc.
Type of format Descriptor file
Standard(s) Java application
Java Application Descriptor (JAD) files describe the MIDlets (Java ME applications) that are distributed as JAR
files. JAD files are commonly used to package Java applications or games that can be downloaded to mobile phones.
Java applications enable Mobile phones to interact programmatically with online web services, such as the ability to
send SMS messages via GSM mobile internet or interact in multiplayer games. Some BlackBerry devices use JAD
files for themes.
Recent midlets contain a manifest file in the JAR archive. This file contains much of the information stored in the
JAD file, rendering it unnecessary in most cases.
JAD files format
MIDlet-1: , ,
MIDlet-Jar-Size:
MIDlet-Jar-URL:
MIDlet-Name:
MIDlet-Vendor:
MIDlet-Version:
MicroEdition-Configuration:
MicroEdition-Profile:
JAD mime type
The MIDP2 specification instructs that web servers should serve JAD files with a MIME type of
"text/vnd.sun.j2me.app-descriptor". If this mime type is not correctly configured, many phones will
fail to install the midlet.
See also
• .sis
• Decompilation
• Mobile development
• Midp2

JAD (file format) 148
External links
• JADs and JARs [1]
• Retrieving MIDlet Attributes [2]
• Online check of JAD file syntax and mime type [3]
References
[1] http:/ / developers. sun. com/ mobility/ learn/ midp/ lifecycle/ #jadsnjars
[2] http:/ / developers. sun. com/ mobility/ midp/ ttips/ getAppProperty/
[3] http:/ / jadcheck. appspot. com

JAMWiki 149
JAMWiki
Developer(s) Ryan Holliday
Initial release June 30, 2006
Stable release 0.9.1 / July 26, 2010
Written in Java, servlets and JSP
Operating
system
Cross-platform
Type wiki software
License GNU Lesser General Public License
Website http:/ / www. jamwiki. org
JAMWiki is wiki software built around the standard components of Java, servlets and JSP. It was written by Ryan
Holliday and released under the LGPL. While for the user JAMWiki is highly similar to MediaWiki and even uses
the same wiki syntax (including templates, etc), it is not a MediaWiki clone but independent implementation, written
in a different language and using a different database schema.
JAMWiki internally uses Spring framework and has two code generation layers: servlets (that can be mapped to the
various special pages of the wiki) and JSP (for the final page generation). Servlet (that is similar to standard servlet
but is not exactly the same class) receives HTTP request, does all processing and puts the name-value pairs into
provided context data structure ("model"). On the next stage, JSP uses these values to build the final output. Search
is implemented using Lucene. Build system is currently powered by Maven.
JamWiki runs inside Tomcat, Glassfish or other similar server and supports a wide range of databases to store the
data.
History
Ryan Holliday started developing JAMWiki in June 2006. [1]
Features
• Wikipedia style syntax - At the present time JAMWiki supports the majority of the Mediawiki syntax including:
• User watchlists.
• Mediawiki footnotes (references).
• Mediawiki templates (recent releases also support conditional constructs)
• Mediawiki categories.
• Image support (including automatic image resizing).
• Topic delete / undelete.
• Topic versioning.
• Searching (powered by Lucene)
• Page move/redirect
• Internationalization - JAMWiki uses UTF-8 unicode as its standard encoding, making it work in languages such
as Japanese and Chinese.
• XML import / export - JAMWiki can import and export topics in Mediawiki-compatible XML format.

JAMWiki 150
External links
• Official JAMWiki wiki [2]
Sites using JAMWiki
• MathEclipse.org [3]
• linux.org.ru [4]
• WingS Framework [5]
• uniBlogger [6]
• Ultrastudio.org [7]
References
[1] Ryan Holliday's blog 2006-06 (http:/ / www. mountaininterval. org/ journal-2006-06. html#20060623)
[2] http:/ / www. jamwiki. org/
[3] http:/ / www. matheclipse. org
[4] http:/ / www. linux. org. ru/ wiki/
[5] http:/ / wingsframework. org/ wiki/
[6] http:/ / www. uniblogger. com
[7] http:/ / ultrastudio. org

JGroups 151
JGroups
Stable release 2.6.3 / June 30, 2008
Development status Active
Written in Java
Operating system Cross-platform
Type reliable multicast system
License GNU Lesser General Public License
Website http:/ / www. jgroups. org/
JGroups is a reliable multicast system that's written in the Java language.
JGroups adds a "grouping" layer over a transport protocol, internally keeping a list of participants. This list is used
to:
• Make the application aware of the listeners
• Make some or all transmissions reliable
• Allow atomic (all or none) transmissions
• Allow totally ordered transmissions
JGroups is a toolkit for reliable multicast communication. It can be used to create groups of processes whose
members can send messages to each other. JGroups enables developers to create reliable multipoint (multicast)
applications where reliability is a deployment issue. JGroups also relieves the application developer from
implementing this logic themselves. This saves significant development time and allows for the application to be
deployed in different environments without having to change code.
JGroups Features
• Group creation and deletion. Group members can be spread across LANs or WANs
• Joining and leaving of groups
• Membership detection and notification about joined/left/crashed members
• Detection and removal of crashed members
• Sending and receiving of member-to-group messages (point-to-multipoint)
• Sending and receiving of member-to-member messages (point-to-point)
Flexible Protocol Stack
The most powerful feature of JGroups is its flexible protocol stack, which allows developers to adapt it to exactly
match their application requirements and network characteristics. The benefit of this is that you only pay for what
you use. By mixing and matching protocols, various differing application requirements can be satisfied. JGroups
comes with a number of protocols (but anyone can write their own), for example
• Transport protocols: UDP (IP Multicast), TCP, JMS
• Fragmentation of large messages
• Reliable unicast and multicast message transmission. Lost messages are retransmitted
• Failure detection: crashed members are excluded from the membership
• Ordering protocols: Atomic (all-or-none message delivery), Fifo, Causal, Total Order (sequencer or token based)
• Membership
• Encryption

JGroups 152
External links
• The JGroups website [1]
• A simple request distribution example in JGroups [2]
• A slideshow presenting JGroups [3]
References
[1] http:/ / www. jgroups. org/ javagroupsnew/ docs/ index. html
[2] http:/ / www. alishomepage. com/ Scholar/ Master/ JGroups/ RequestDistributor. java
[3] http:/ / www. alishomepage. com/ Scholar/ Master/ JGroups/ Slideshow. pdf
JPicus
JPicus is a Java TM I/O analysis framework. It consists of the following major parts:
• Agent - it plugs into the Java TM Virtual Machine and collects I/O analysis data, like open file handles, byte
counters etc
• User interface - Eclipse based user interface that lets the user take a snapshot and visualise it
JPicus is similar to Java CPU and memory allocation profilers with the difference that it operates in the I/O domain.
External links
• Official site [1]
References
[1] http:/ / jpicus. com

Java Class Library 153
Java Class Library
The Java Class Library is a set of
dynamically loadable libraries that
Java 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:
Java Platform diagram
• Like other standard code libraries, they provide the programmer 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.
• 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.
Architecture
The Java Class Library is almost entirely written in Java itself, except for the parts that need direct access to the
hardware and operating system (such as for I/O, or bitmap graphics). The classes that give access to these functions
commonly use native interface wrappers to access the API of the operating system.
Almost all of the Java Class Library is stored in a single Java archive file called "rt.jar", which is provided with JRE
and JDK distributions. The Java Class Library (rt.jar) is located in the default bootstrap classpath [1] , and does not
have to be found in the classpath declared for the application.
Conformance
Any Java implementation must pass the Java Technology Compatibility Kit tests for compliance.
Main Features
Features of the Class Library are accessed through classes grouped by packages.
• java.lang contains fundamental classes and interfaces closely tied to the language and runtime system.
• I/O and networking: access to the platform file system, and more generally to networks, is provided through the
java.io, java.nio, and java.net packages.
• Mathematics package: java.math provides regular mathematical expressions, as well as arbitrary-precision
decimals and integers numbers.
• Collections and Utilities : provide built-in Collection data structures, and various utility classes, for Regular
expressions, Concurrency, logging and Data compression.

Java Class Library 154
• GUI and 2D Graphics: the java.awt package supports basic GUI operations and binds to the underlying native
system. It also contains the 2D Graphics API. The javax.swing package is built on AWT and provides a platform
independent widget toolkit, as well as a Pluggable look and feel. It also deals with editable and non-editable text
components.
• Sound: provides interfaces and classes for reading, writing, sequencing, and synthesizing of sound data.
• Text: the java.text package deals with text, dates, numbers, and messages.
• Image package: java.awt.image and javax.imageio provide APIs to write, read, and modify images.
• XML: built-in classes handle SAX, DOM, StAX, XSLT transforms, XPath, and various APIs for Web services, as
SOAP protocol and JAX-WS.
• CORBA and RMI APIs, including a built-in ORB
• Security and Cryptography
• Databases: access to SQL databases is provided through the java.sql package.
• Access to Scripting engines: the javax.script package gives access any Scripting language that conforms to this
API.
• Applets: java.applet allows applications to be downloaded over a network and run within a guarded sandbox
• Java Beans: java.beans provides ways to manipulate reusable components.
Licensing
Following their promise to release a fully buildable JDK based almost completely on free and open source code in
the first half of 2007 [2] , Sun released the complete source code of the Class Library under the GPL on May 8, 2007,
except some limited parts that were licensed by Sun from third parties who did not want their code to be released
under a free and open-source license. [3] Sun's goal is to replace the parts that remain proprietary and closed source
with alternative implementations and make the Class Library completely free and open source. [4]
As of May 2008, the only part of the Class library that remain proprietary and closed-source (4% as of May 2007 for
OpenJDK 7 [5] , and less than 1% as of May 2008 and OpenJDK 6 [6] [7] ) is [8] [9] :
• The SNMP implementation [9] .
Since the first May 2007 release, Sun Microsystems, with the help of the community, has released as Open-source or
replaced with Open-source alternatives almost all the encumbered code:
• All the audio engine code, including the software synthetizer, has been released as Open-source [9] [10] . The
closed-source software synthesizer has been replaced by a new synthesizer developed specifically for OpenJDK
called Gervill [11] ,
• All cryptography classes used in the Class library have been released as Open-source [12] ,
[13] [14] [15]
• The code that scales and rasterizes fonts has been replaced by FreeType
• The native color management system has been replaced by LittleCMS [14] . There is a pluggable layer in the JDK,
so that the commercial version can use the old color management system and OpenJDK can use LittleCMS.
• The anti-aliasing graphics rasterizer code has been replaced by the Open-sourced Pisces renderer used in the
phoneME project [14] [16] [17] . This code is fully functional, but still needs some performance enhancements [18] ,
• The Javascript plugin has been open-sourced (the JavaScript engine itself was open-sourced from the
beginning) [19] .

Java Class Library 155
Alternative implementations
GNU Classpath is the other main free software class library for Java. Contrary to other implementations, it only
implements the Class Library, and is used by many free Java runtimes (like Kaffe, SableVM, JamVM, CACAO).
Apache Harmony is another free software class library. Its aim is to also implement the other parts of the Java stack
(Virtual Machine, Compiler, and other tools required for any Java implementation).
See also
• Java Platform, Standard Edition
• List of Java APIs
• OpenJDK
• Free Java implementations
• Standard library
• Java applet
External links
• Java SE Main page [20]
• Java SE 6 API Javadocs
• Java SE API documentation [21]
• Java software development kits (status as of August 2006):
• 1.7 [22] (early development)
• 1.6 [23] (stable, current)
• 1.5 [24] (stable)
• 1.4 [25] (stable)
• 1.3 [26] (obsolete)
References
[1] How Classes are Found (http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ tools/ findingclasses. html)
[2] http:/ / www. sun. com/ software/ opensource/ java/ faq. jsp#b4
[3] "Open JDK is here!" (http:/ / mail. openjdk. java. net/ pipermail/ announce/ 2007-May. txt). Sun Microsystems. 2007-05-08. . Retrieved
2007-05-09.
[4] Since there's some encumbered code in the JDK, Sun will continue to use that code in commercial releases until it is replaced by
fully-functional free and open-source alternatives.
[5] Fitzsimmons, Thomas (2007-05-18). "Plans for OpenJDK" (http:/ / fitzsim. org/ blog/ ?p=17). . Retrieved 2007-05-22.
[6] Angel, Lillian (2008-03-13). "OpenJDK to replace IcedTea in Fedora 9" (http:/ / langel. wordpress. com/ 2008/ 03/ 13/ openjdk-in-fedora-9/
). . Retrieved 2008-04-05.
[7] Wade, Karsten (2008-03-13). "OpenJDK in Fedora 9!" (http:/ / developer. redhatmagazine. com/ 2008/ 03/ 12/
openjdk-to-replace-icedtea-in-fedora-9/ ). redhatmagazine.com. . Retrieved 2008-04-05. "Thomas Fitzsimmons updated the Fedora 9 release
notes source pages to reflect that Fedora 9 would ship with OpenJDK 6 instead of the IcedTea implementation of OpenJDK 7. Fedora 9
(Sulphur) is due to release in May 2008."
[8] Herron, David (2007-10-04). "Plans for OpenJDK" (http:/ / weblogs. java. net/ blog/ robogeek/ archive/ 2007/ 10/ openjdk_encumbr. html). .
Retrieved 2007-10-09.
[9] "OpenJDK 6 b10 source posted" (http:/ / mail. openjdk. java. net/ pipermail/ jdk6-dev/ 2008-May/ 000058. html). 2008-05-30. . Retrieved
2008-06-01.
[10] audio-engine project page (http:/ / openjdk. java. net/ projects/ audio-engine/ )
[11] "Gervill - Software Synthesizer" (https:/ / gervill. dev. java. net/ ). . Retrieved 2008-06-01.
[12] "Crypto has been added to OpenJDK" (http:/ / mail. openjdk. java. net/ pipermail/ security-dev/ 2007-September/ 000015. html).
2007-09-27. . Retrieved 2007-10-07.
[13] font-scaler projectpage (http:/ / openjdk. java. net/ projects/ font-scaler/ )
[14] Java2D project page (http:/ / openjdk. java. net/ groups/ 2d/ )

Java Class Library 156
[15] "Freetype font rasteriser" (http:/ / mail. openjdk. java. net/ pipermail/ font-scaler-dev/ 2007-August/ 000011. html). 2007-08-07. . Retrieved
2007-11-24.
[16] phoneme.dev.java.net/ (https:/ / phoneme. dev. java. net/ )
[17] graphics-rasterizer project page (http:/ / openjdk. java. net/ projects/ graphics-rasterizer/ )
[18] Graham, Jim (2007-10-03). "Open Source rasterizer" (http:/ / mail. openjdk. java. net/ pipermail/ 2d-dev/ 2007-October/ 000078. html). Sun
Microsystems. . Retrieved 2007-05-09.
[19] "Javascript is encumbered and there is no javascript plugin support." (http:/ / icedtea. classpath. org/ bugzilla/ show_bug. cgi?id=85).
IcedTea. 2008-03-11. . Retrieved 2008-06-01. "Changing Summary. JavaScript is no longer encumbered, but we still need liveconnect
support."
[20] http:/ / java. sun. com/ j2se/
[21] http:/ / java. sun. com/ reference/ api/ index. html
[22] https:/ / jdk7. dev. java. net/
[23] http:/ / java. sun. com/ javase/ 6/
[24] http:/ / java. sun. com/ j2se/ 1. 5. 0/
[25] http:/ / java. sun. com/ j2se/ 1. 4. 2/
[26] http:/ / java. sun. com/ j2se/ 1. 3/
Java Classloader
The Java Classloader is a part of the Java Runtime Environment that dynamically loads Java classes into the Java
Virtual Machine [1] . Usually classes are only loaded on demand. The Java run time system does not need to know
about files and file systems because of class loaders. Delegation is an important concept to understand when learning
about class loaders.
A software library is a collection of more or less related object code. In the Java language, libraries are typically
packaged in Jar files. Libraries can contain objects of different types. The most important type of object contained in
a Jar file is a Java class. A class can be thought of as a named unit of code. The class loader is responsible for
locating libraries, reading their contents, and loading the classes contained within the libraries. This loading is
typically done "on demand", in that it does not occur until the class is actually used by the program. A class with a
given name can only be loaded once by a given classloader.
Class loading process
Each Java class must be loaded by a class loader [2] . Furthermore, Java programs may make use of external libraries
(that is, libraries written and provided by someone other than the author of the program) or may itself be composed,
at least in part, by a number of libraries.
When the JVM is started, three class loaders are used [3] [4] :
1. Bootstrap class loader
2. Extensions class loader
3. System class loader
The bootstrap class loader loads the core Java libraries [5] (/lib directory). This class loader, which
is part of the core JVM, is written in native code.
The extensions class loader loads the code in the extensions directories (/lib/ext or any other
directory specified by the java.ext.dirs system property). It is implemented by the
sun.misc.Launcher$ExtClassLoader class.
The system class loader loads code found on java.class.path, which maps to the system CLASSPATH variable. This
is implemented by the sun.misc.Launcher$AppClassLoader class.

Java Classloader 157
User-defined class loaders
By default, all user classes are loaded by the default system class loader, but it is possible to replace it by a
user-defined ClassLoader (which defaults to the original root system class loader), and even to chain class loaders
as desired.
This makes it possible (for example):
• to load or unload classes at runtime (for example to load libraries dynamically at runtime, even from a HTTP
resource). This is an important feature for:
• implementing scripting languages,
• using bean builders,
• allowing user-defined extensibility
• allowing multiple namespaces to communicate. This is one of the foundations of CORBA / RMI protocols, for
example.
• to change the way the bytecode is loaded (for example, it is possible to use encrypted Java class bytecode [6] ).
• to modify the loaded bytecode (for example, for load-time weaving of aspects when using Aspect Oriented
Programming).
Class Loaders in JEE
Java Platform, Enterprise Edition (JEE) application servers typically load classes from a deployed WAR or EAR
archive by a tree of Classloaders, isolating the application from other applications, but sharing classes between
[2] [7]
deployed modules. So-called "servlet containers" are typically implemented in terms of multiple classloaders
JAR hell
JAR hell is a term similar to DLL hell used to describe all the various ways in which the classloading process can
end up not working. [8] Three ways JAR hell can occur are explained below:
• The first case is when a developer or deployer of a Java application has accidentally made two different versions
of a library available to the system. This will not be considered an error by the system. Rather, the system will
load classes from one or the other library. Adding the new library to the list of available libraries instead of
replacing it, may see the application still behaving as though the old library is in use, which it may well be.
• Another version of the problem arises when two libraries (or a library and the application) require different
versions of the same third library. If both versions of the third library use the same class names, there is no way to
load both versions of the third library with the same classloader.
• The most complex JAR hell problems arise in circumstances that take advantage of the full complexity of the
classloading system. A Java program is not required to use only a single "flat" classloader, but instead may be
composed of several (or, in fact, an indefinite number of) nested, cooperating classloaders. Classes loaded by
different classloaders may interact in complex ways not fully comprehended by a developer, leading to
inexplicable errors or bugs.
The OSGi Alliance specified (starting as JSR 8 in 1998) a modularity framework that solved JAR hell for current
and future VMs both in ME, SE, and EE that is widely adopted. Using metadata in the JAR manifest, JAR files
(called bundles) are wired on a per-package basis. Bundles can export packages, import packages and keep packages
private, providing the basic constructs of modularity and versioned dependency management.
To remedy the JAR hell problems a Java Community Process — JSR 277 was initiated in 2005. The resolution —
Java Module System — intended to introduce a new distribution format, modules versioning scheme and a common
modules repository (similar in purpose to Microsoft .NET's Global Assembly Cache). In December 2008 Sun
announced that JSR 277 was put on hold [9] .

Java Classloader 158
See also
• Loader (computing)
• Dynamic loading
• DLL hell
• OSGi
• Apache Maven, automated software build tool with dependency management
External links
• Brandon E. Taylor, "Java Class Loading: The Basics [10] ", 2003
• Jeff Hanson, "Take Control of Class Loading in Java [11] ", 2006-06-01
• Andreas Schaefer, "Inside Class Loaders [12] ", 2003-11-12
• Sheng Liang and Gilad Bracha, "Dynamic class loading in the Java virtual machine [13] ", In Proceedings of the
13 th ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA'98),
ACM SIGPLAN Notices, vol. 33, no. 10, ACM Press, 1998, pp. 36–44
• Dr. Christoph G. Jung, "Classloaders Revisited Hotdeploy [14] ", Java Specialist Newsletter, 2001-06-07
• Don Schwarz, "Managing Component Dependencies Using ClassLoaders [15] ", 2005-04-13
References
[1] "The basics of Java class loaders" (http:/ / www. javaworld. com/ javaworld/ jw-10-1996/ jw-10-indepth. html). JavaWorld. 1996-10-01. .
Retrieved 2008-01-26.
[2] Christudas, Binildas (2005-01-26). "Internals of Java Class Loading" (http:/ / www. onjava. com/ pub/ a/ onjava/ 2005/ 01/ 26/ classloading.
html). onjava.com. . Retrieved 2009-10-02.
[3] "Understanding Extension Class Loading" (http:/ / java. sun. com/ docs/ books/ tutorial/ ext/ basics/ load. html). java.sun.com. 2008-02-14. .
Retrieved 2009-12-08.
[4] Sosnoski, Dennis (2003-04-29). "Classes and class loading" (http:/ / www. ibm. com/ developerworks/ java/ library/ j-dyn0429/ ). ibm.com. .
Retrieved 2008-01-26.
[5] These libraries are stored in Jar files called rt.jar, core.jar, server.jar, etc.
[6] Roubtsov, Vladimir (2003-05-09). "Cracking Java byte-code encryption" (http:/ / www. javaworld. com/ javaworld/ javaqa/ 2003-05/
01-qa-0509-jcrypt. html?page=1). javaworld.com. . Retrieved 2008-01-26.
[7] deBoer, Tim; Karasiuk, Gary (2002-08-21). "J2EE Class Loading Demystified" (http:/ / www-128. ibm. com/ developerworks/ websphere/
library/ techarticles/ 0112_deboer/ deboer. html). ibm.com. . Retrieved 2008-01-26.
[8] http:/ / incubator. apache. org/ depot/ version/ jar-hell. html
[9] http:/ / www. osgi. org/ News/ 20081217
[10] http:/ / www. developer. com/ java/ other/ article. php/ 2248831
[11] http:/ / www. devx. com/ Java/ Article/ 31614
[12] http:/ / www. onjava. com/ pub/ a/ onjava/ 2003/ 11/ 12/ classloader. html
[13] http:/ / citeseer. ist. psu. edu/ liang98dynamic. html
[14] http:/ / www. roseindia. net/ javatutorials/ hotdeploy. shtml
[15] http:/ / www. onjava. com/ pub/ a/ onjava/ 2005/ 04/ 13/ dependencies. html?page=1

Java compiler 159
Java compiler
A Java compiler is a compiler for the Java programming language. The most common form of output from a Java
compiler are Java class files containing platform-neutral Java bytecode. There exist also compilers emitting
optimized native machine code for a particular hardware/operating system combination.
Most Java-to-bytecode compilers, Jikes being a well known exception, do virtually no optimization, leaving this
until runtime to be done by the JRE.
The Java Virtual Machine (JVM) loads the class files and either interprets the bytecode or just-in-time compiles it to
machine code and then possibly optimizes it using dynamic compilation.
The very first Java compiler developed by Sun Microsystems was written in C using some libraries from C++.
Major Java compilers
As of 2010, the following are major Java compilers:
• javac, included in JDK from Sun Microsystems, open-sourced since 13 November 2006.
• GCJ, a part of gcc which compiles C, Fortran, Pascal and other programming languages besides Java. It can also
generate native code using the back-end of gcc.
• ECJ, the Eclipse Compiler for Java, is an open source incremental compiler used by the Eclipse JDT.
Java decompilers
A Java decompiler tries to reverse the process of compiling, that is it tries to decompile Java bytecode files (*.class)
back to Java source files (*.java).
• DJ Java Decompiler [1] (Uses JAD) 10 use trial version
• JAD, written in C++, free for non-commercial use.
• JD [1], younger project, includes GUI, optional Eclipse-plugin.
• JODE [2], decompiler and optimizer, open-source.
• Mocha, one of the first decompilers for Java.
External links
• Sun's OpenJDK javac page [3]
• Jikes homepage [4]
• JSR 199 [5] Java Compiler API Java Specification Request for invoking the Java compiler from a Java program
References
[1] http:/ / www. neshkov. com/
[2] http:/ / jode. sourceforge. net/
[3] http:/ / openjdk. java. net/ groups/ compiler/
[4] http:/ / jikes. sourceforge. net/
[5] http:/ / www. jcp. org/ en/ jsr/ detail?id=199

Java Development Kit 160
Java Development Kit
Developer(s) Sun Microsystems (Owned by Oracle Corporation)
Stable release
Preview release
Operating
system
6 Update 21 [1] / July 7, 2010
JDK 7 Preview Release, Build b101 / July 15, 2010 [2]
Cross-platform
Type Software development kit
License Sun License (most of it also under GPL)
Website http:/ / java. sun. com/ javase/
The Java Development Kit (JDK) is a Sun Microsystems product aimed at Java developers. Since the introduction
of Java, it has been by far the most widely used Java SDK. On 17 November 2006, Sun announced that it would be
released under the GNU General Public License (GPL), thus making it free software. This happened in large part on
8 May 2007 [3] ; Sun contributed the source code to the OpenJDK.
JDK contents
The JDK has as its primary components a collection of programming tools, including:
• java – the loader for Java applications. This tool is an interpreter and can interpret the class files generated by the
javac compiler. Now a single launcher is used for both development and deployment. The old deployment
launcher, jre, no longer comes with Sun JDK.
• javac – the compiler, which converts source code into Java bytecode
• jar – the archiver, which packages related class libraries into a single JAR file. This tool also helps manage JAR
files.
• javadoc – the documentation generator, which automatically generates documentation from source code
comments
• jdb – the debugger
• jps – the process status tool, which displays process information for current Java processes
• javap – the class file disassembler
• appletviewer – this tool can be used to run and debug Java applets without a web browser.
• javah – the C header and stub generator, used to write native methods
• javaws – the Java Web Start launcher for JNLP applications
• extcheck – a utility which can detect JAR-file conflicts.
• apt – the annotation-processing tool
• jhat – (experimental) Java heap analysis tool

Java Development Kit 161
• jstack – (experimental) utility which prints Java stack traces of Java threads
• jstat – (experimental) Java Virtual Machine statistics monitoring tool
• jstatd – (experimental) jstat daemon
• jinfo – (experimental) This utility gets configuration information from a running Java process or crash dump.
• jmap – (experimental) This utility outputs the memory map for Java and can print shared object memory maps or
heap memory details of a given process or core dump.
• idlj – the IDL-to-Java compiler. This utility generates Java bindings from a given IDL file.
• policytool – the policy creation and management tool, which can determine policy for a Java runtime, specifying
which permissions are available for code from various sources
• VisualVM – visual tool integrating several commandline JDK tools and lightweight performance and memory
profiling capabilities
• wsimport – generates portable JAX-WS artifacts for invoking a web service.
• jrunscript – Java command-line script shell.
The JDK also comes with a complete Java Runtime Environment, usually called a private runtime. It consists of a
Java Virtual Machine and all of the class libraries present in the production environment, as well as additional
libraries only useful to developers, such as the internationalization libraries and the IDL libraries.
Copies of the JDK also include a wide selection of example programs demonstrating the use of almost all portions of
the Java API.
Ambiguity between a JDK and an SDK
The JDK forms an extended subset of a software development kit (SDK). In the descriptions which accompany its
recent releases for Java SE, EE, and ME, Sun acknowledges that under its terminology, the JDK forms the subset of
the SDK which has the responsibility for the writing and running of Java programs. The remainder of the SDK
comprises extra software, such as application servers, debuggers, and documentation.
Other JDKs
There are other JDKs commonly available for a variety of platforms, some of which started from the Sun JDK
source and some which did not. All of them adhere to the basic Java specifications, but they often differ in explicitly
unspecified areas, such as garbage collection, compilation strategies, and optimization techniques. They include:
• GNU's GCJ (The GNU Compiler for Java)
• IBM's J9 JDK, for AIX, Linux, Windows, MVS, OS/400, Pocket PC, z/OS [4]
• Oracle Corporation's JRockit JDK, for Windows, Linux and Solaris [5]
• Blackdown Java – The Blackdown Group's port of Sun's JDK for Linux
• Apple's Mac OS Runtime for Java JVM/JDK for Mac OS [6]

Java Development Kit 162
See also
• Classpath (Java)
• Java platform
• Java version history
External links
• Sun Java SE [7] – Sun's current stable release (6).
• IBM Java technology JDK [8]
• Oracle's JRockit JDK [5]
• Open source JDK 7 project [22]
• Open source JDK project [9]
• Community support [10]
• GNU Classpath [11] – a Free software JDK alternative
• Apache Harmony [38] – an Open source JDK alternative
• Javadoc Developer Kit (JDK) Search Engine [12]
• Developer Support Services from Sun Microsystems [13]
References
[1] "Java SE Downloads - Sun Developer Network (SDN)" (http:/ / java. sun. com/ javase/ downloads/ widget/ jdk6. jsp). .
[2] http:/ / dlc. sun. com. edgesuite. net/ jdk7/ binaries/ index. html
[3] "Sun's May 8th announcement of source code for JDK" (http:/ / www. prnewswire. com/ cgi-bin/ stories. pl?ACCT=104& STORY=/ www/
story/ 05-08-2007/ 0004583482). .
[4] http:/ / www-128. ibm. com/ developerworks/ java/ jdk/
[5] http:/ / www. oracle. com/ appserver/ jrockit/ index. html
[6] http:/ / docs. info. apple. com/ article. html?artnum=120209
[7] http:/ / java. sun. com/ javase/
[8] http:/ / www. ibm. com/ developerworks/ java/ jdk/
[9] http:/ / openjdk. java. net/
[10] http:/ / community. java. net/ jdk/
[11] http:/ / www. gnu. org/ software/ classpath/
[12] http:/ / javadoc. ankerl. com/
[13] http:/ / www. sun. com/ service/ developer/ index. jsp

Java Interface Definition Language 163
Java Interface Definition Language
In software development, Java Interface Definition Language, or Java IDL, is an implementation of the CORBA
specification and enables interoperability and connectivity with heterogeneous objects. It is basically an Object
Request Broker provided with JDK. The Java IDL enables distributed Web applications to transparently invoke
operations on remote network services using the industry standards IDL and IIOP from OMG.
External links
• Sun Developer Network: Core Java: Java IDL [1]
References
[1] http:/ / java. sun. com/ products/ jdk/ idl/
Java resource bundle
A resource bundle is a Java .properties file that contains locale-specific data [1] . It is a way of internationalising a
Java application by making the code locale-independent.
Naming a resource bundle
Resource bundles have a naming convention to identify them when they deal with different languages. The file name
is followed by an underscore and a two-letter language code (ISO 639-2 code) that specifies the language that the
resource bundle deals with. So, for example, an application that supports Spanish and French can have these resource
bundles, respectively:
resbund_es.properties
resbund_fr.properties
This can also be followed by another underscore and a two-letter country code (ISO 3166-1). In this case, an
application that supports British English and US English respectively will have the following files:
resbund_en_GB.properties
resbund_en_US.properties
Content of a resource bundle
Resource bundles are essentially text files. The most common type of content in a resource bundle is a list of strings.
Each string has a “key” to identify it, which is the same in all the different resource bundles. When writing the code
for the application, only the key is mentioned (this is why we say that the code is locale-independent). Using the
methods provided in the Java API for the ResourceBundle class [2] , we can access the string (i.e. the "value")
associated with the key. Depending on which locale the application is handling, it will call the adequate resource
bundle at runtime [3] .
For instance, our resource bundle for the UK English locale can contain “firstKey = Localisation” and our US
English one can contain “firstKey = Localization”. We will refer only to “firstKey” in the code and, according to the
current locale settings, the application will use either “Localization” or “Localisation”.

Java resource bundle 164
Benefits of using resource bundles
Extracting locale-sensitive objects such as strings from the code (as opposed to hard-coding them) means that the
application can handle multiple locales without having to write different code for each locale. It also means that
translators can deal with just the translatable text and not the programming code. Therefore, using resource bundles
improves the internationalisation and the localisation process of a software product.
Translating a resource bundle
Some CAT tools like OmegaT, OmegaT+ [4] or Sun's Open language tools can specifically handle resource bundles.
In addition to these, translators can use any text editor to create new resource bundles or to modify existing ones.
References
[1] O'Conner, B. Java Internationalization: Localization with ResourceBundles, Sun Developer Network. (http:/ / java. sun. com/ developer/
technicalArticles/ Intl/ ResourceBundles/ )
[2] Java API ResourceBundle Class (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ )
[3] Esselink, B. A Practical Guide to Software Localisation, John Benjamins Publishing (1998).
[4] OmegaT+ (http:/ / omegatplus. sourceforge. net/ )
Java TV
Java TV is a Java-based software framework designed for use on TV set-top boxes, based around components called
Xlets. It is currently used only on the Connected Device Configuration, specifically for iTV applications
development.
The API includes the Xlet classes in the package javax.tv.xlet. Other packages of the public API include
1. javax.tv.graphics - provides a simple rendering canvas
2. javax.tv.locator - provides a locator in the style of a URL for services and media, such as service:/SERV1
3. javax.tv.service - defines a mechanism for service information (SI) databases and APIs representing the SI
elements, such as the TV channels and media available for playback.
Criticisms
While the framework is general, Sun currently provides support only on Java ME. For some subjects, such as media
locators, it is in effect superseded by other locator standards on platforms such as BD-J.
A point of confusion is that in platforms supported as of 2008, examples such as the SvcDispXlet example from the
introduction to the API, written circa 2001, are not deployable because it uses AWT widgets such as java.awt.Button
[1] . Most iTV platforms, along with BD-J, implement Personal Basis Profile with no AWT widgets, as opposed to
Personal Profile which includes the widgets. [2]
Sun's reference implementation for Java TV attempts to limit its exposure to support issues to the full Java Media
Framework by having its own small version of JMF that is internally referred to as "jmflite". As with the limitations
of the MIDP emulators that Sun provides, the Java TV reference implementation provided by Sun has not been
updated to make provisions for later JDK's such as removing calls to Thread.stop(). The Thread.stop() method was
made a "final" method in Java 1.5 (meaning that classes which extend Thread and override stop() will fail at runtime
under JRE 1.5 when the class is loaded). This implies that Sun has not yet committed to public plans or a roadmap
for taking Java ME beyond JRE 1.3. If such an upgrade were to take place, it would require significant work on the
[3] [4]
part of all vendors of Java ME-enabled devices.

Java TV 165
See also
• Xlet
External links
• Java ME Technology - Java TV API [5] - includes Sun's Reference Implementation
• Java TV API 1.1 (JSR-927) online Javadocs [6]
• The JavaTV tutorial [7]
References
[1] http:/ / java. sun. com/ javase/ 6/ docs/ api/ java/ awt/ Button. html
[2] Introduction to Digital TV Applications Programming (http:/ / java. sun. com/ developer/ technicalArticles/ javatv/ apiintro/ ) By Monica
Pawlan, February 2001
[3] JRE 1.5 Thread.stop() javadoc (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ Thread. html#stop())
[4] Why Are Thread.stop, Thread.suspend, Thread.resume and Runtime.runFinalizersOnExit Deprecated? (http:/ / java. sun. com/ j2se/ 1. 5. 0/
docs/ guide/ misc/ threadPrimitiveDeprecation. html)
[5] http:/ / java. sun. com/ javame/ technology/ javatv/
[6] http:/ / java. sun. com/ javame/ reference/ apis/ jsr927/
[7] http:/ / www. mhp-interactive. org/ tutorials/ javatv/

Java Work Framework 166
Java Work Framework
Stable release 1.0.1 / February 18, 2009
Operating
system
Cross-platform
Type Java Network Framework
License MIT license
Website http:/ / javawork. org/
Java Work Framework is a simple, but powerful Java framework providing Network(New I/O Socket), Database,
Exception handling and System functionality. It is open source, object-oriented and event driven.
History
It was originally designed and implemented by Ivan Penev back in 2005 as a network layer capable to handle around
10,000 socket connections. Then it gradually included the most common functionality a programmer may need -
socket communication, simple database access, reading external resources as files, URLs, etc.
Features
Its main focus is to hide behind simple wrappers existing Java functionality and to provide general application
exception handling mechanism. In short it supports:
• Java NIO Socket Framework
• 15,000+ socket connections. Sending/receiving 5000 java objects per second between 2 computers works great.
• Multicast
• Unicast(UDP) support
• Pluggable protocols through in and out filters
• Easy-to-use database layer
• Custom JAR files loader
Security
• Securing socket communication through SSL
• Exchanging data encrypted through XXTEA, XOR algorithms
Code snippets
Multicast:
Multicast.listen( "230.0.0.1", 35098, new IEventListener() { public void onEvent( IEvent evt ) {
} } );
MulticastDataEvent dataEvt = (MulticastDataEvent)evt;
System.out.println( "data-bytes:" + DebugUtil.toString(dataEvt.asByteArray()) );
Multicast.send( "Lorem ipsum dolor ...", "230.0.0.1", 35098 );
Database:

Java Work Framework 167
Database db = Database.createInstance();
db.setUrl("jdbc:postgresql://localhost/testdb");
db.setUsername("testuser");
db.setPassword("test123");
SQLInsert insertOp = new SQLInsert("persons");
insertOp.addData("person_fname", "Mike",
"person_lname", "Johnson",
"birthday", Convert.toDate("1971-08-01"),
"country_id", "de",
"single", true);
int affectedRows = insertOp.execute();
System.out.println("Affected rows = " + affectedRows);
Requirements
• JDK 1.6 (Mustang)
External links
• Official website [1]
• Demo [2]
References
[1] http:/ / javawork. org/
[2] http:/ / javawork. org/ examples/

Java annotation 168
Java annotation
An annotation, in the Java computer programming language, is a special form of syntactic metadata that can be
added to Java source code. [1] Classes, methods, variables, parameters and packages may be annotated. Unlike
Javadoc tags, Java annotations can be reflective in that they can be embedded in class files generated by the compiler
and may be retained by the Java VM to be made retrievable at run-time. [2]
Examples
// @Twizzle is an annotation to method toggle().
@Twizzle
public void toggle() {
}
// Declares the annotation Twizzle.
public @interface Twizzle {
}
Annotations may include an optional list of key-value pairs:
// Same as: @Edible(value = true)
@Edible(true)
Item item = new Carrot();
public @interface Edible {
}
boolean value() default false;
@Author(first = "Oompah", last = "Loompah")
Book book = new Book();
public @interface Author {
}
String first();
String last();
Annotations themselves may be annotated to indicate where and when they can be used:
@Retention(RetentionPolicy.RUNTIME) // Make this annotation
accessible at runtime via reflection.
@Target({ElementType.METHOD}) // This annotation can only be
applied to class methods.
public @interface Tweezable {
}
The compiler reserves a set of special annotations (including @Deprecated, @Override and
@SuppressWarnings) for syntactic purposes.
Annotations are often used by frameworks as a way of conveniently applying behaviours to user-defined classes and
methods that must otherwise be declared in some external source (such as an XML configuration file) or

Java annotation 169
programmatically (with API calls). The following, for example, is an annotated EJB 3.0 data class:
@Entity // Declares this an
entity bean
@Table(name = "people") // Maps the bean to
SQL table "people"
class Person implements Serializable {
@Id // Map this to the
primary key column.
@GeneratedValue(strategy = GenerationType.AUTO) // Database will
generate new primary keys, not us.
private Integer id;
@Column(length = 32) // Truncate column
values to 32 characters.
}
private String name;
public Integer getId() {
}
return id;
public void setId(Integer id) {
}
this.id = id;
public String getName() {
}
return name;
public void setName(String name) {
}
this.name = name;
A complete example is given below:
package com.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD,

Java annotation 170
ElementType.CONSTRUCTOR,ElementType.ANNOTATION_TYPE,
ElementType.PACKAGE,ElementType.FIELD,ElementType.LOCAL_VARIABLE})
@Inherited
public @interface Unfinished {
}
public enum Priority { LOW, MEDIUM, HIGH }
String value();
String[] changedBy() default "";
String[] lastChangedBy() default "";
Priority priority() default Priority.MEDIUM;
String createdBy() default "prabir karmakar";
String lastChanged() default "01/01/2009";
package com.annotation;
public @interface UnderConstruction {
}
String owner() default "PrabirK";
String value() default "Object is Under Construction.";
String createdBy() default "Prabir Karmakar";
String lastChanged() default "01/01/2009";
package com.validators;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
import com.annotation.UnderConstruction;
import com.annotation.Unfinished;
import com.annotation.Unfinished.Priority;
import com.util.Util;
@UnderConstruction(owner="Prabir Karmakar")
public class DateValidator implements Validator{
public void validate(FacesContext context, UIComponent component,
Object value)
{
throws ValidatorException
String date = (String) value;
String errorLabel = "Please enter a valid date.";
if(!component.getAttributes().isEmpty())
{
errorLabel = (String)

Java annotation 171
component.getAttributes().get("errordisplayval");
}
if(!Util.validateAGivenDate(date))
{
not, confirm"
}
}
}
@Unfinished(changedBy = "prabirk"
)
,value="whether to add message to context or
,priority=Priority.HIGH
FacesMessage message = new FacesMessage();
message.setSeverity(FacesMessage.SEVERITY_ERROR);
message.setSummary(errorLabel);
message.setDetail(errorLabel);
throw new ValidatorException(message);
The annotations are not method calls and will not, by themselves, do anything. Rather, the class object is passed to
the EJB implementation at run-time, which then extracts the annotations to generate an ORM.
Processing
When Java source code is compiled, annotations can be processed by compiler plug-ins called annotation processors.
Processors can produce informational messages or create additional Java source files or resources, which in turn may
be compiled and processed, but annotation processors cannot modify the annotated code itself. The Java compiler
conditionally stores annotation metadata in the class files if the annotation has a RetentionPolicy of CLASS or
RUNTIME. Later, the JVM or other programs can look for the metadata to determine how to interact with the
program elements or change their behavior.
History
The Java platform has had various ad-hoc annotation mechanisms—for example, the transient modifier, or the
@deprecated javadoc tag. The general purpose annotation (also known as metadata) facility was introduced to the
Java Community Process as JSR-175 in 2002 and approved in September 2004. [3] Annotations became available in
the language itself beginning with version 1.5 of the JDK. A provisional interface for compile-time annotation
processing was provided by the apt tool in JDK version 1.5, and was formalized through JSR-269 and integrated into
the javac compiler in version 1.6.

Java annotation 172
See also
• Java programming
• Model-driven architecture
• Java virtual machine
• .NET Attributes
External links
• Introduction to Java 5.0 Annotations by Joy Christy [4]
• Of Java Annotations by John Hunt [5]
• An Introduction to Java Annotations by M. M. Islam Chisty [6]
• Introduction to Java 6 Annotations at Sun Developer Network Site [7]
References
[1] "JDK 5.0 Developer's Guide: Annotations" (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ annotations. html). Sun Microsystems.
2007-12-18. . Retrieved 2008-03-05..
[2] Sun Microsystems (2005). Java(TM) Language Specification (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html) (3rd
ed.). Prentice Hall. ISBN 0321246780. .
[3] Coward, Danny (2006-11-02). "JSR 175: A Metadata Facility for the JavaTM Programming Language" (http:/ / www. jcp. org/ en/ jsr/
detail?id=175#2). Java Community Process. . Retrieved 2008-03-05.
[4] http:/ / www. javabeat. net/ articles/ java-5-0/ 2007/ 08/ annotations/
[5] http:/ / www. regdeveloper. co. uk/ 2006/ 02/ 24/ java_annotations/
[6] http:/ / www. developer. com/ java/ other/ article. php/ 3556176
[7] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ language/ annotations. html
Java collections framework
JCF redirects here and can also stand for Jordan canonical form in Linear Algebra or Juan Carlos Ferrero, the
Spanish tennis player
The Java collections framework is a coupled set of classes and interfaces that implement commonly reusable
collection data structures. It was designed and developed primarily by Joshua Bloch.
Although it is a framework, it works in a manner of a library.
See also
• Container (data structure)
• Standard Template Library
External links
• 'The Java Tutorials - Collections' by Josh Bloch [1]
• 'The Collections Framework' [2] (Sun Java SE 6 documentation)
• Generic Types [3]
• Java Generics and Collections [4]
• Taming Tiger: The Collections Framework [5]
• Collections Lessons [6]
• CollectionSpy [7] — A profiler for Java's Collections Framework.
• Java 6 Collection Tutorial [8] — By Jakob Jenkov, Kadafi Kamphulusa

Java collections framework 173
References
[1] http:/ / java. sun. com/ docs/ books/ tutorial/ collections/
[2] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ collections/ index. html
[3] http:/ / www. onjava. com/ pub/ a/ onjava/ excerpt/ javaian5_chap04/
[4] http:/ / www. onjava. com/ pub/ a/ onjava/ excerpt/ javagenerics_chap05/
[5] http:/ / www-128. ibm. com/ developerworks/ java/ library/ j-tiger07195/
[6] http:/ / javalessons. com/ cgi-bin/ fun/ java-tutorials-main. cgi?sub=adv& ses=ao789
[7] http:/ / www. collectionspy. com
[8] http:/ / tutorials. jenkov. com/ java-collections/ index. html
Java concurrency
Java is a programming language (and API) which has been designed to support concurrent programming, and all
execution in the language takes place in the context of a thread. It is important for a Java programmer to understand
both the power and limitations of Java threads.
In the JVM (Java Virtual Machine), objects and resources can be accessed by many separate threads; each thread has
its own path of execution but can potentially access any object in the program. The programmer must ensure that
threads do not interfere with each other, and that resources are properly coordinated (or "synchronized") during both
read and write access. The Java language has built-in constructs to support this coordination.
The Java Language Specification does not say how the JVM designer should implement the multithreading
primitives specified, because there is so much variation among the various operating systems and hardware on which
the JVM is expected to run.
Monitor synchronization in Java
The key synchronization concept in Java is the monitor. Every object in a JVM has a monitor associated with it.
Such monitor-based concurrency was originally introduced with the Mesa programming language.
Changes in Java 5
Java 5 incorporated many additions and clarifications to the Java concurrency model. JSR 133 provided support for
well-defined atomic operations in a multithreaded/multiprocessor environment, opening the door to JSR 166, a large
battery of concurrent programming APIs.
See also
• Monitor (synchronization)
• Concurrency (computer science)
• Concurrency pattern
• Doug Lea
• Thread (computer science)

Java concurrency 174
References
• Goetz, Brian; Joshua Bloch, Joseph Bowbeer, Doug Lea, David Holmes, Tim Peierls (2006). Java Concurrency
in Practice. Addison Wesley. ISBN 0-321-34960-1.
• Lea, Doug (1999). Concurrent Programming in Java: Design Principles and Patterns. Addison Wesley.
ISBN 0-201-31009-0.
External links
• JDK 5.0 concurrency utilities [1]
• Podcast from JavaPolis - 'Concurrency Utilities in JDK 5.0 by Brian Goetz' [2]
• JavaOne 2005 - Concurrency Utilities in Practice [3]
• JavaOne 2005 - Brian Goetz - Simpler, Faster, Better: Concurrency Utilities in JDK Software Version 5.0 [4]
• Podcast from JavaPosse - Interview with Brian Goetz on Concurrency in Java 5 [5]
• William Pugh's Java Memory Model page [6]
• Java Concurrency Tutorial by Jakob Jenkov [7]
• Thread Safe Java Programming by Vadym Ustymenko [8]
References
[1] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ concurrency/ index. html
[2] http:/ / www. javapolis. com/ confluence/ display/ JP05/ 2006/ 05/ 23/ Concurrency+ Utilities+ in+ JDK+ 5. 0+ talk+ by+ Brian+ Goetz
[3] http:/ / developers. sun. com/ learning/ javaoneonline/ 2005/ coreplatform/ TS-3423. pdf
[4] http:/ / developers. sun. com/ learning/ javaoneonline/ 2005/ coreplatform/ TS-5807. pdf
[5] http:/ / javaposse. com/ index. php?post_id=95780
[6] http:/ / www. cs. umd. edu/ ~pugh/ java/ memoryModel/
[7] http:/ / tutorials. jenkov. com/ java-concurrency/ index. html
[8] http:/ / javatip. com/ 2010/ 07/ core-java/ concurrency/ thread-safe-without-synchronization/

Java syntax 175
Java syntax
The syntax of the Java programming language
is a set of rules which defines how a Java
program is written and interpreted.
The syntax is mostly derived from C and C++.
Unlike C++, Java is almost exclusively an
object-oriented language. There are no global
functions or variables, all code belongs to
classes and all values are objects. The only
exception is the primitive types, which are not
represented by a class instance due to
performance reasons (though can be
automatically converted to objects and
vice-versa via autoboxing). Some features like
operator overloading or unsigned integer types
are omitted to simplify the language and to
avoid possible programming mistakes.
A snippet of Java code with keywords highlighted in blue and bold font
Java syntax is constantly improved in major JDK releases. The last significant addition happened in J2SE 5.0,
which introduced such features as generics and annotations.
Basics
Identifier
An identifier is the name of an element in the code. There are certain standard naming conventions to follow when
selecting names for elements. Identifiers in Java are case-sensitive.
An identifier can contain:
• Any Unicode character that is a letter (including numeric letters like Roman numerals) or digit.
• Currency sign (such as $).
• Connecting punctuation character (such as _).
An identifier cannot:
• start with a digit.
• be equal to a reserved keyword, null literal or boolean literal.
Keywords

Java syntax 176
[1] Keyword was introduced in J2SE 1.4
[2] Keyword is not used
[3] Keyword was introduced in J2SE 5.0
[4] Keyword was introduced in J2SE 1.2
Literals
abstract continue for new switch
assert [1] default
goto [2] package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case
enum [3] instanceof return transient
catch extends int short try
char final interface static void
class finally long
strictfp [4] volatile
const [2] float native super while
octal 0365, 0[0..7]*
Integers
hexadecimal 0xF5, 0x[0..9, A..F, a..f]*
decimal 245, [1..9][0..9]*
Floating-point values
float 23.5F, 23.5f; 1.72E3F, 1.72E3f, 1.72e3F, 1.72e3f
double 23.5, 23.5D, 23.5d; 1.72E3, 1.72E3D, ...
Character literals
char 'a', 'Z', '\u0231'
boolean true, false
null reference null
String "Hello, world"
Boolean literals
null literal
String literals
Characters escapes in strings
Unicode character \u followed by the hexadecimal unicode code point (up to \uFFFF)
Octal escape Octal number not exceeding 377, preceded by backslash (e.g. \352)
Line feed \n
Carriage return \r
Form feed \f
Backslash \\
Single quote \'

Java syntax 177
Double quote \"
Tab \t
Backspace \b
Integer literals are of int type by default unless long type is specified by appending L or l suffix to the literal, e.g.
367L.
Variables
Variables are identifiers associated with values. They are declared by writing the variable's type and name, and are
optionally initialized in the same statement by assigning a value.
int myInt; /* Declaring an uninitialized variable called 'myInt',
of type 'int' */
myInt = 35; // Initializing the variable
int myInt = 35; // Declaring and initializing the variable at the same time
Multiple variables of the same type can be declared and initialized in one statement using comma as a delimiter.
int a, b; // Declaring multiple variable of the same type
int a = 2, b = 3; // Declaring and initializing multiple variables of the same type
Code blocks
The operators { ... } are used to signify a code block and a new scope. Class members and the body of a method are
examples of what can live inside these braces in various contexts.
Inside of method bodies you can use the braces to create new scopes like so:
void doSomething() {
}
int a;
{
}
a = 2;
int b;
a = 1;
b = 3; // Will fail because the variable is declared in an inner scope.
Comments
Java has three kinds of comments: traditional comments, end-of-line comments and documentation comments.
Traditional comments start with /* and end with */, they may span across multiple lines. This type of comments was
derived from C and C++.
/* This is a multi-line comment.
It may occupy more than one line. */
End-of-line comments start with // and extend to the end of the current line. This comment type is also present in
C++ and in modern C.

Java syntax 178
// This is an end-of-line comment
Documentation comments are processed by Javadoc tool to generate documentation from source files. This type of
comments is identical to traditional comments, except it starts with /** and follows conventions defined by the
Javadoc tool. Technically these comments are a special kind of traditional comments and they are not specifically
defined in the language specification.
/**
* This is a documentation comment.
*
* @author John Doe
*/
Program structure
A Java application consists of classes and their members. Classes exist in packages but can also be nested inside
other classes.
main method
Whether it is a console or a graphical interface application the program must have an entrypoint of some sort. The
entrypoint of the Java application is the main method. There can be more than one class with main method, but the
main class is always defined externally (e.g. in a manifest file). The method must be static and is passed
command-line arguments as an array of strings. Unlike C++ or C# it never returns a value and must return void.
public static void main(String[] args) {
}
Packages
Packages are a part of a class name and they are used to group and/or distinguish named entities from other ones.
Another purpose of packages is to govern code access together with access modifiers.
java.lang.InputStream // InputStream is a class in java.lang package
A package is declared at the start of the file like this:
package myapplication.mylibrary;
public class MyClass {
}
Classes must be placed in the files with the same name and java extension and put into nested folders
corresponding to the package name. The above class myapplication.mylibrary.MyClass will have the following path:
"myapplication/mylibrary/MyClass.java".

Java syntax 179
import statement
The import statement loads a specific class or classes from a referenced package. It must be placed at the top of a
code file after the package declaration.
import java.io.InputStream; /*Now it is allowed to use InputStream
class without referencing its full name including the package*/
import java.util.*; /*This is a star import which loads all
classes contained in java.util package*/
Since J2SE 5.0 it is allowed to do static imports, which allows to access members (fields and methods) defined in the
imported class as public static without specifying the class name:
import static java.lang.System.out;
public class HelloWorld {
}
public static void main(String[] args) {
}
Operators
out.println("Hello World!"); /*Without the static import it would
be required to write "System.out" instead of just "out".*/
Operators in Java are mostly similar to those in C++. There's no delete operator due to garbage collection
mechanisms in Java and no operations on pointers since Java does not support them, another difference is that Java
has unsigned right shift operator (>>>). Operators in Java cannot be overloaded.
Precedence Operator Description Associativity
1 () Method invocation Left-to-right
[] Array access
. Class member selection
2 ++ -- Postfix increment and decrement
3 ++ -- Prefix increment and decrement Right-to-left
+ - Unary plus and minus
! ~ Logical NOT and bitwise NOT
(type) Type cast
new Class instance or array creation

Java syntax 180
Control structures
4 * / % Multiplication, division, and modulus (remainder) Left-to-right
5 + - Addition and subtraction
+ String concatenation
6 > >>> Bitwise left shift, signed right shift and unsigned right shift
7 < >= Relational “greater than” and “greater than or equal to”
instanceof Type comparison
8 == != Relational “equal to” and “not equal to”
9 & Bitwise and logical AND
10 ^ Bitwise and logical XOR (exclusive or)
11 | Bitwise and logical OR (inclusive or)
12 && Logical conditional-AND
13 || Logical conditional-OR
14 c ? t : f Ternary conditional (see ?:) Right-to-left
15 = Simple assignment
Conditional statements
if statement
+= -= Assignment by sum and difference
*= /= %= Assignment by product, quotient, and remainder
= >>>= Assignment by bitwise left shift, signed right shift and unsigned right shift
&= ^= |= Assignment by bitwise AND, XOR, and OR
if statements in Java are similar to those in C and use the same syntax:
if (i == 3) doSomething();
if statement may include optional else block, in which case it becomes an if-then-else statement:
if (i == 2)
else
doSomething();
doSomethingElse();
Like C, else-if construction does not involve any special keywords, it is formed as a sequence of separate if-then-else
statements:
if (i == 3) {
doSomething();
} else if (i == 2) {
doSomethingElse();
} else {
}
doSomethingDifferent();

Java syntax 181
switch statement
Switch statements in Java can use byte, short, char, and int primitive data types or their corresponding wrapper types.
It is also possible to use enum types. Strings or other objects cannot be used in switch statements.
Possible values are listed using case labels. These labels in Java may contain only constants (including enum
constants). Execution will start after the label corresponding to the expression inside the brackets. An optional
default label may be present to declare that the following it code will be executed if none of the case labels
correspond to the expression.
Code for each label ends with the break keyword. It is possible to omit it causing the execution to proceed to the next
label, however, a warning will be usually reported during compilation.
switch (ch) {
}
case 'A':
doSomething(); // Triggered if ch == 'A'
break;
case 'B':
case 'C':
doSomethingElse(); // Triggered if ch == 'B' or ch == 'C'
break;
default:
doSomethingDifferent(); // Triggered in any other case
break;
Iteration statements
Iteration statements are statements that are repeatedly executed when a given condition is evaluated as true. Since
J2SE 5.0 Java has four forms of such statements.
while loop
In the while loop the test is done before each iteration.
while (i < 10) {
}
doSomething();
do ... while loop
In the do ... while loop the test is done after each iteration. Consequently, the code is always executed at least once.
// doSomething() is called at least once
do {
doSomething();
} while (i < 10);

Java syntax 182
for loop
for loops in Java include an initializer, a condition and a counter expression. It is possible to include several
expressions of the same kind using comma as delimiter. However, unlike C, comma is just a delimiter and not an
operator.
for (int i = 0; i < 10; i++) {
}
doSomething();
// A more complex loop using two variables
for (int i = 0, j = 9; i < 10; i++, j -= 3) {
}
doSomething();
Like C, all three expressions are optional, the following loop will be infinite:
for (;;) {
}
doSomething();
Enhanced for loop
Enhanced for loops have been available since J2SE 5.0. This type of loop uses built-in iterators over arrays and
collections to return each item in the given collection. Every element will be returned and reachable in the context of
the code block. When the block has been executed the next item will be returned until there are no items remaining.
Unlike C# this kind of loop does not involve a special keyword but instead uses a different notation style.
for (int i : intArray) {
}
doSomething(i);
Jump statements
Labels
Labels are given points in code used by break and continue statements. Despite the presence of the goto keyword, it
cannot be used to jump to specific points in the code.
start:
someMethod();
break statement
The break statement breaks out of the closest loop or switch statement. Execution continues in the statement after the
terminated statement, if any.
for (int i = 0; i < 10; i++) {
}
while (true) {
}
break;
// Will break to this point
It is possible to break out of the outer loop using labels:

Java syntax 183
outer:
for (int i = 0; i < 10; i++) {
}
while (true) {
}
break outer;
// Will break to this point
continue statement
The continue statement discontinues the current iteration of the current control statement and begins the next
iteration. The following while loop in the code above reads characters by calling getChar(), skipping the statements
in the body of the loop if the characters are spaces:
int ch;
while (ch = getChar()) {
}
if (ch == ' ')
continue; // Skips the rest of the while-loop
// Rest of the while-loop, will not be reached if ch == ' '
doSomething();
Labels can be specified in continue statements, as they can in break statements:
outer:
for (String str : stringsArr) {
}
char[] strChars = str.toCharArray();
for (char ch : strChars) {
}
if (ch == ' ') {
}
return statement
/* Continues the outer cycle and the next
string is retrieved from stringsArr */
continue outer;
doSomething(ch);
The return statement is used to end method execution and to return a value. A value returned by the method is
written after the return keyword. If the method returns anything but void, it must use the return statement to return
some value.
void doSomething(boolean streamClosed) {
}
// If streamClosed is true, execution is stopped
if (streamClosed) {
}
return;
readFromStream();

Java syntax 184
int calculateSum(int a, int b) {
}
int result = a + b;
return result;
return statement ends execution immediately, except for one case: if the statement is encountered within a try block
and it is complemented by a finally, control is passed to the finally block.
void doSomething(boolean streamClosed) {
}
try {
if (streamClosed) {
}
return;
readFromStream();
} finally {
}
/* Will be called last even if
readFromStream() was not called */
freeResources();
Exception handling statements
try ... catch ... finally statements
Exceptions are managed within try ... catch blocks.
try {
// Statements which may throw exceptions
methodThrowingExceptions();
} catch (Exception ex) {
// Exception caught and handled here
reportException(ex);
} finally {
}
// Statements always executed after the try/catch blocks
freeResources();
The statements within the try block are executed, and if any of them throws an exception, execution of the block is
discontinued and the exception is handled by the catch block. There may be multiple catch blocks, in which case the
first block with an exception variable whose type matches the type of the thrown exception is executed.
If no catch block matches the type of the thrown exception, the execution of the outer block (or method) containing
the try ... catch statement is discontinued, and the exception is passed up and outside the containing block (or
method). The exception is propagated upwards through the call stack until a matching catch block is found within
one of the currently active methods. If the exception propagates all the way up to the top-most main method without
a matching catch block being found, a textual description of the exception is written to the standard output stream.
The statements within the finally block are always executed after the try and catch blocks, whether or not an
exception was thrown and even if a return statement was reached. Such blocks are useful for providing clean-up code
that is guaranteed to always be executed.

Java syntax 185
The catch and finally blocks are optional, but at least one or the other must be present following the try block.
throw statement
throw statement is used to throw an exception and end method execution. Thrown exception instance is written after
the throw statement.
void methodThrowingExceptions(Object obj) {
}
if (obj == null) {
}
// Throws exception of NullPointerException type
throw new NullPointerException();
// Will not be called if obj was null
doSomethingWithObject(obj);
Thread concurrency control
Unlike C++, Java has built-in tools for multi-thread programming. For the purposes of thread synchronization the
synchronized statement is included in Java language.
To make a code block synchronized, it is preceded by the synchronized keyword followed by the lock object inside
the brackets. When the executing thread reaches the synchronized block, it acquires a mutual exclusion lock,
executes the block, then releases the lock. No threads may enter this block until the lock is released. Any non-null
reference type may be used as the lock.
/* Acquires lock on someObject. It must be of
a reference type and must be non-null */
synchronized(someObject) {
}
// Synchronized statements
assert statement
assert statements have been available since J2SE 1.4. This type of statements is used to make assertions in the source
code, which can be turned on and off during execution for specific classes or packages. To declare an assertion the
assert keyword is used followed by a conditional expression. If it evaluates to false during when the statement is
executed, an exception is thrown. This statement may include a colon followed by another expression, which will act
as the exception's detail message.
// If n equals 0, AssertionError is thrown
assert n != 0;
/* If n equals 0, AssertionError will be thrown
with the message after the colon */
assert n != 0 : "n was equal to zero";

Java syntax 186
Primitive types
Primitive types in Java include integer types, floating-point numbers, UTF-16 code units and a boolean type. There
are no unsigned types in Java except char type, which is used to represent UTF-16 code units. The lack of unsigned
types is offset by introducing unsigned right shift operation (>>>), which is not present in C++. Nevertheless,
criticisms have been levelled about the lack of compatibility with C and C++ this causes. [1]
Primitive Types
Type Name Wrapper class Value Range Size Default
byte java.lang.Byte integer −128 through +127 8-bit (1-byte) 0
short java.lang.Short integer −32,768 through +32,767 16-bit
int java.lang.Integer integer −2,147,483,648 through +2,147,483,647 32-bit
long java.lang.Long integer −9,223,372,036,854,775,808 through
+9,223,372,036,854,775,807
float java.lang.Float floating point number ±1.401298E−45 through ±3.402823E+38 32-bit
double java.lang.Double floating point number ±4.94065645841246E−324 through
±1.79769313486232E+308
(2-byte)
(4-byte)
64-bit
(8-byte)
(4-byte)
64-bit
(8-byte)
boolean java.lang.Boolean Boolean true or false 8-bit (1-byte) false
char java.lang.Character UTF-16 code unit (BMP
character
or a part of a surrogate pair)
'\u0000' through '\uFFFF' 16-bit
(2-byte)
0
0
0
0.0
0.0
Value
'\u0000'
char does not necessarily correspond to a single character. It may represent a part of a surrogate pair, in which case
Unicode code point is represented by a sequence of two char values.
Boxing and unboxing
This language feature was introduced in J2SE 5.0. Boxing is the operation of converting a value of a primitive type
into a value of a corresponding reference type, which serves as a wrapper for this particular primitive type. Unboxing
is the reverse operation of converting a value of a reference type (previously boxed) into a value of a corresponding
primitive type. Neither operation requires an explicit type cast.
Example:
int foo = 42; // Primitive type
Integer bar = foo; /* foo is boxed to bar, bar is of Integer type,
which serves as a wrapper for int */
int foo2 = bar; // Unboxed back to primitive type

Java syntax 187
Reference types
Reference types include class types, interface types, and array types. When the constructor is called an object is
created on the heap and a reference is assigned to the variable. When a variable of an object gets out of scope the
reference is broken and when there are no references left the object gets marked as garbage. The garbage collector
will then soon collect and destroy it.
A reference variable is null when it does not reference any object.
Arrays
Arrays in Java are created at runtime, just like class instances. Array length is defined at creation and cannot be
changed.
int[] numbers = new int[5];
numbers[0] = 2;
numbers[1] = 5;
int x = numbers[0];
Initializers
// Long syntax
int[] numbers = new int[5] {20, 1, 42, 15, 34};
// Short syntax
int[] numbers2 = {20, 1, 42, 15, 34};
Multi-dimensional arrays
In Java multi-dimensional arrays are represented as arrays of arrays. Technically they are represented by arrays of
references to another arrays.
int[][] numbers = new int[3][3];
number[1][2] = 2;
int[][] numbers2 = {{2, 3, 2}, {1, 2, 6}, {2, 4, 5}};
Due to the nature of the multi-dimensional arrays, sub-arrays may vary in length, so multi-dimensional arrays are not
bound to be rectangular unlike C:
int[][] numbers = new int[2][]; //Initialization of the first dimension
only
numbers[0] = new int[3];
numbers[1] = new int[2];

Java syntax 188
Classes
Classes are fundamentals of an object-oriented language such as Java. They contain members that store and
manipulate data in real-life-like way. Classes are divided into top-level and nested. Nested classes include member
classes, local classes and anonymous classes.
Declaration
Top-level class class Foo {
// Class members
}
Member class class Foo { // Top-level class
Local class class Foo {
}
class Bar { // Nested class
}
void bar() {
Anonymous class class Foo {
Initialization
}
}
}
class Foobar {// Local class within a method
}
void bar() {
}
new Object() {// Creation of a new anonymous class extending Object
};
To use non-static members of the class it must be instantiated. It is done by using the new keyword and calling the
class constructor.
Foo foo = new Foo();
Accessing members
Members of both instances and static classes are accessed with the . operator.
Accessing an instance member
Instance members can be accessed through the name of a variable.
String foo = "Hello";
String bar = foo.toUpperCase();
Accessing a static class member
Static members are accessed by using the name of the class or any other type. This does not require the creation of a
class instance. Static members are declared using the static modifier.
public class Foo {
}
public static void doSomething() {
}
// Calling the static method

Java syntax 189
Foo.doSomething();
Modifiers
Modifiers are keywords used to modify declarations of types and type members. Most notably there is a sub-group
containing the access modifiers.
• abstract - Specifies that a class only serves as a base class and cannot be instantiated.
• static - Used only for member classes, specifies that the member class does not belong to a specific instance of
the containing class.
• final - Classes marked as final cannot be extended from and cannot have any subclasses.
• strictfp - Specifies that all floating-point operations must be carried out conforming to IEEE 754 and forbids
using enhanced precision to store intermediate results.
Access modifiers
The access modifiers, or inheritance modifiers, set the accessibility of classes, methods, and other members.
Members marked as public can be reached from anywhere. If a class or its member does not have any modifiers,
default access is assumed.
public class Foo {
}
int do() {
}
return 0;
private class Bar {
}
The following table shows whether code within a class has access to the class or method depending on the accessing
class location and the modifier for the accessed class or class member:
Modifier Same
class
Other class inside the same
package
Subclass inside another
package
Non-subclass inside another
private yes no no no
default (package
private)
package
yes yes no no
protected yes yes yes no
public yes yes yes yes
Constructors
A constructor is a special method that is called when an object is initialized. Its purpose is to initialize the members
of the object. The main differences between constructors and ordinary methods are that constructors are named after
the class and never return anything. They may take parameters as any common method.
class Foo {
}
Foo() {
}
//Initialization

Java syntax 190
There are also static constructors, whose purpose is to initialize static fields when the class is initialized. They are
declared using static keyword:
class Foo {
}
static {
}
//Initialization
Since Java has a garbage collection mechanism, there are no destructors. However, every object has a finalize()
method called prior to garbage collection which could be overridden to implement finalization.
Methods
All the statements in Java must reside within methods. Methods are similar to functions except they belong to
classes. A method has a return value, a name and usually some parameters initialized when it is called with some
arguments. Similar to C++, methods which return nothing have return type declared as void. Unlike in C++, methods
in Java are not allowed to have default argument values and methods are usually overloaded instead.
class Foo {
}
int bar(int a, int b) {
}
return (a * 2) + b;
int bar(int a) { /* Overloaded method with the same name but
}
return a * 2;
different set of arguments */
A method is called using . notation on a specific variable, or as in the case of static methods, the name of a type.
Foo foo = new Foo();
int result = foo.bar(7, 2); // Non-static method is called on foo
int finalResult = Math.abs(result); // Static method call
Methods throwing exceptions use throws keyword to indicate that. All checked exceptions are mandatory to be
declared.
void openStream() throws IOException { // Indicates that IOException may be thrown
}

Java syntax 191
Modifiers
• abstract - Abstract methods can be present only in abstract classes, such methods have no body and must be
overridden in a subclass unless it is abstract itself.
• static - Makes the method static and accessible without creation of a class instance. However static methods
cannot access non-static members in the same class.
• final - Declares that the method cannot be overridden in a subclass.
• native - Indicates that this method is implemented through JNI in platform-dependent code. Actual
implementation happens outside Java code, and such methods have no body.
• strictfp - Declares strict conformance to IEEE 754 in carrying out floating-point operations.
• synchronized - Declares that a thread executing this method must acquire monitor. For synchronized methods the
monitor is the class instance or java.lang.Class if the method is static.
• Access modifiers - Identical to those used with classes.
Varargs
This language feature was introduced in J2SE 5.0. The last argument of the method may be declared as a variable
arity parameter, in which case the method becomes a variable arity method (as opposed to fixed arity methods) or
simply varargs method. This allows to pass a variable number of value of declared type to the method as parameters.
These values will be available inside the method as an array.
void printReport(String header, int... numbers) { //numbers represents varargs
}
System.out.println(header);
for (int num : numbers) {
}
System.out.println(num);
// Calling varargs method
printReport("Report data", 74, 83, 25, 96);
Fields
Fields, or class variables, can be declared inside the class body to store data.
class Foo {
}
double bar;
Fields can be initialized directly when declared.
class Foo {
}
double bar = 2.3;

Java syntax 192
Modifiers
• static - Makes the field a static member.
• final - Allows the field to be initialized only once in a constructor.
• transient - Indicates that this field will not be stored during serialization.
• volatile - If a field is declared volatile, it is ensured that all threads see a consistent value for the variable.
• Access modifiers - Identical to those used with classes
Inheritance
Classes in Java may only inherit from one class. A class may derive from any class that is not marked as final.
Inheritance is declared using extends keyword. A class may reference itself using this keyword and its direct
superclass using super keyword.
class Foo {
}
class Foobar extends Foo {
}
If a class does not specify the superclass, it implicitly inherits from java.lang.Object class. Thus all classes in Java
are subclasses of Object class.
Overriding methods
Unlike C++, all non-final methods in Java are virtual and can be overridden by the inheriting classes.
class Operation {
}
public int do() {
}
return 0;
class NewOperation extends Operation {
}
public int do() {
}
Abstract classes
return 1;
Abstract classes are classes that only serve as templates and cannot be instantiated. Otherwise it is just like an
ordinary class.
Only abstract classes are allowed to have abstract methods. Abstract methods do not have any implementation and
must be overridden by a subclass unless it is not abstract itself.
abstract class Mammal {
}
public abstract void walk();
class Human extends Mammal {

Java syntax 193
}
public void walk() {
}
final classes
The final modifier can be an optional modifier for classes to make them uninheritable.
final class Foo { // This class cannot be extended by any other class
}
Enumerations
This language feature was introduced in J2SE 5.0. Technically enumerations are a kind of class which contains enum
constants in its body. Each enum constant defines an instance of the enum type. Enumeration classes cannot be
instantiated anywhere except in the enumeration class itself.
enum Season {
}
WINTER, SPRING, SUMMER, AUTUMN
Enum constants are allowed to have constructors, which are called when the class is loaded:
public enum Season {
}
WINTER("Cold"), SPRING("Warmer"), SUMMER("Hot"), AUTUMN("Cooler");
Season(String description) {
}
this.description = description;
private final String description;
public String getDescription() {
}
return description;
Enumerations can have class bodies, in which case they are treated like anonymous classes extending the enum
class:
public enum Season {
WINTER {
},
String getDescription() {return "cold";}
SPRING {
},
String getDescription() {return "warmer";}
SUMMER {
},
String getDescription() {return "hot";}

Java syntax 194
}
AUTUMN {
};
Interfaces
String getDescription() {return "cooler";}
Interfaces are data structures that contain member definitions and not actual implementation. They are useful to
define a contract between members in different types that have different implementations. Every interface is
implicitly abstract. The only modifier allowed to use with interfaces apart from access modifiers is strictfp, which
has the same effect as for classes.
interface ActionListener {
}
int ACTION_ADD = 0;
int ACTION_REMOVE = 1;
void actionSelected(int action);
Implementing an interface
An interface is implemented by a class using the implements keyword. It is allowed to implement more than one
interface, in which case they are written after implements keyword in a comma-separated list. Class implementing an
interface must override all its methods, otherwise it must be declared as abstract.
interface RequestListener {
}
int requestReceived();
class ActionHandler implements ActionListener, RequestListener {
}
void actionSelected(int action) {
}
public int requestReceived() {
}
//Calling method defined by interface
RequestListener listener = new ActionHandler(); /*ActionHandler can be
represented as RequestListener...*/
listener.requestReceived(); /*...and thus is known to implement
requestReceived() method*/

Java syntax 195
Inheritance
Interfaces can inherit from other interfaces just like classes. Unlike classes it is allowed to inherit from multiple
interfaces. However, it is possible that several interfaces have a field with the same name, in which case it becomes a
single ambiguous member, which cannot be accessed.
/* Class implementing this interface must implement methods of both
ActionListener and RequestListener */
interface EventListener extends ActionListener, RequestListener {
}
Annotations
Annotations in Java are a way to embed metadata into code. This language feature was introduced in J2SE 5.0.
Annotation types
Java has a set of predefined annotation types, but it is allowed to define new ones. An annotation type declaration is
a special type of an interface declaration. They are declared in the same way as the interfaces, except the interface
keyword is preceded by the @ sign. All annotations are implicitly extended from java.lang.annotation.Annotation
and cannot be extended from anything else.
@interface BlockingOperations {
}
Annotations may have the same declarations in the body as the common interfaces, in addition they are allowed to
include enums and annotations. The main difference is that abstract methods declarations must not have any
parameters or throw any exceptions. Also they may have a default value, which is declared using the default
keyword after the method name:
@interface BlockingOperations {
}
boolean fileSystemOperations();
boolean networkOperations() default false;
Usage of annotations
Annotations may be used in any kind of declaration, whether it is package, class (including enums), interface
(including annotations), field, method, parameter, constructor, or local variable. Also they can be used with enum
constants. Annotations are declared using the @ sign preceding annotation type name, after which element-value
pairs are written inside brackets. All elements with no default value must be assigned a value.
@BlockingOperations(/*mandatory*/ fileSystemOperations = true,
/*optional*/ networkOperationsPresent = true)
void openOutputStream() { //Annotated method
}
Besides the generic form, there are two other forms to declare an annotation, which are shorthands. Marker
annotation is a short form, it is used when no values are assigned to elements:
@Unused // Shorthand for @Unused()
void travelToJupiter() {
}

Java syntax 196
The other short form is called single element annotation. It is used with annotations types containing only one
element or in the case when multiple elements are present, but only one elements lacks a default value. In single
element annotation form the element name is omitted and only value is written instead:
/* Equivalent for @BlockingOperations(fileSystemOperations = true).
networkOperations has a default value and
does not have to be assigned a value */
@BlockingOperations(true)
void openOutputStream() {
}
Generics
Generics, or parameterized types, or parametric polymorphism is one of the major features introduced in J2SE 5.0.
Before generics were introduced, it was required to declare all the types explicitly. With generics it became possible
to work in a similar manner with different types without declaring the exact types. The main purpose of generics is to
ensure type safety and to detect runtime errors during compilation. Unlike C#, information on the used parameters is
not available at runtime due to type erasure.
Generic classes
Classes can be parameterized by adding a type variable inside angle brackets (< and >) following the class name. It
makes possible the use of this type variable in class members instead of actual types. There can be more than one
type variable, in which case they are declared in a comma-separated list.
It is possible to limit a type variable to a subtype of some specific class or declare an interface that must be
implemented by the type. In this case the type variable is appended by the extends keyword followed by a name of
the class or the interface. If the variable is constrained by both class and interface or if there are several interfaces,
the class name is written first, followed by interface names with & sign used as the delimiter.
/* This class has two type variables, T and V. T must be
a subtype of ArrayList and implement Formattable interface */
public class Mapper {
}
public void add(T array, V item) {
}
// array has add method because it is an ArrayList subclass
array.add(item);
When a variable of a parametrized type is declared or an instance is created, its type is written exactly in the same
format as in the class header, except actual type is written in the place of the type variable declaration.
/* Mapper is created for CustomList as T and Integer as V.
CustomList must be a subclass of ArrayList and implement Formattable */
Mapper mapper = new Mapper();
When declaring a variable for a parametrized type, it is possible to use wildcards instead of explicit type names.
Wildcards are expressed by writing ? sign instead of the actual type. It is possible to limit possible types to the
subclasses or superclasses of some specific class by writing the extends keyword or the super keyword
correspondingly followed by the class name.

Java syntax 197
/* Any Mapper instance with CustomList as the first parameter
may be used regardless of the second one.*/
Mapper mapper;
mapper = new Mapper();
mapper = new Mapper();
/* Will not accept types that use anything but
a subclass of Number as the second parameter */
void addMapper(Mapper

Java syntax 198
}
void addItem(Integer item) {
}
See also
• Java Platform, Standard Edition
References
[1] Owens, Sean. "Java and unsigned int, unsigned short, unsigned byte, unsigned long, etc. (Or rather, the lack thereof)" (http:/ / darksleep. com/
player/ JavaAndUnsignedTypes. html). .
• Patrick Naughton, Herbert Schildt. Java 2: The Complete Reference, third edition. The McGraw-Hill Companies,
1999. ISBN 0-07-211976-4
• Vermeulen, Ambler, Bumgardner, Metz, Misfeldt, Shur, Thompson. The Elements of Java Style. Cambridge
University Press, 2000. ISBN 0-521-77768-2
• Gosling, James; Joy Bill; Steele, Guy; and Bracha, Gillad (2005). Java Language Specification (http:/ / java. sun.
com/ docs/ books/ jls/ index. html) (3rd ed.). Addison-Wesley Professional. Retrieved 2008-12-03.
External links
• The Java Language Specification, Third edition (http:/ / java. sun. com/ docs/ books/ jls/ ) Authoritative
description of the Java language
• Java SE 6 API Javadocs
Java: View Technologies and Frameworks
Various Java Web frameworks have appeared in recent years. Some of them are in direct competition, while others
are complementary technologies. It is therefore necessary to understand where exactly each technology/framework
fits into the J2EE scheme of things. This page lists the View technologies. These are the frameworks which are used
for defining the web pages and the server-side programs which handle the requests (clicks) generated by the web
pages.
At a glance
HTTP Paradigm Component Paradigm Templating
Struts Wicket Tiles
Tapestry SiteMesh
JSF Facelets
• Struts is relatively easier to use for beginners because it contains the familiar HTTP paradigm of
Request/Response. However, the Component based frameworks are architecturally superior, and usually
recommended for creating more complex web applications.
• Wicket, Tapestry and JSF are competing technologies.
• Tiles is a templating framework which is designed to work with Struts.
• SiteMesh can be used with any JSP.
Click

Java: View Technologies and Frameworks 199
• Facelets is designed to work with JSF.
• Wicket and Tapestry have their own native templating.
• Click uses HTML based velocity templates and plain old Java objects. JSP is optional.
Servlet API
• This is the foundation of almost all Java View technologies.
• It provides the basic framework for writing Java classes, called 'Servlets' that can respond to HTTP Requests,
JSP
create Cookies and maintain Sessions.
• Built on top of the Servlet API, JSP provides for a HTML centric Server programming model.
• Java code is embedded in the JSP files and is executed when a request is received.
Struts
• Built on top of the Servlet API, Struts provides for decoupling between the Controller and the View.
• Requests are received by a Java Class (Controller) which can decide which View to display.
• The actual View is written as a JSP page.
• An XML configuration file is used to specify the "Page Navigation", i.e. the flow of the request to the appropriate
Controller, and which View to display based on the outcome of the Controller.
• Competitor: Though Struts does not have any direct competitor in its league, Component View Technologies
(like Wicket, Tapestry) are generally accepted as superior.
Tiles
• This is a HTML templating framework based on the "Composite" model.
• It allows for the HTML page to be broken up into multiple pagelets, called Templates, Definitions and
Composing pages.
• At run time the pagelets are stitched together to generate the final HTML. Pages are written in JSP.
• Competitor: SiteMesh
SiteMesh
• SiteMesh is a HTML templating framework based on the "Decoration" model.
• It allows for the creation of a 'decoration' template which is then applied to any other HTML to generate a new
HTML.
• The newly generated HTML contains elements from the original HTML blended into the template.
• This allows for the original HTML to be very simple and devoid of any formatting or layout specification. The
template, in turn, is devoid of any actual information.
• Blending the two allows for a consistent look and feel for all web pages.
• Competitor: Tiles

Java: View Technologies and Frameworks 200
Wicket
• Wicket provides a 'Component' view technology - meaning the Request-Response Stateless paradigm of HTTP is
abstracted away to give rise to an Object Oriented Stateful paradigm.
• Pages now directly interact with Stateful Java Components on the server.
• Components and their State are managed by the Wicket framework, freeing the application developer from having
to use HttpSession directly to manage state themselves.
• Further, Wicket provides for a clear separation of HTML markup from code, and there are no XML configuration
files to manage.
• Web page components are 'pushed' into the HTML markup from the code.
• Competitor: Tapestry, JSF
Tapestry
• Tapestry provides a 'Component' view technology.
• Classes are written as POJOs and Annotations are used to configure them as Tapestry components.
• HTML components can directly refer to the component methods and attributes.
• Competitor: Wicket, JSF
References
• Java Servlet Technology (http:/ / java. sun. com/ products/ servlet/ )
• JavaServer Pages Technology (http:/ / java. sun. com/ products/ jsp/ )
• Apache Struts 2 Documentation (http:/ / struts. apache. org/ 2. 1. 6/ docs/ home. html)
• Apache Struts Tiles (http:/ / struts. apache. org/ 1. x/ struts-tiles/ )
• Click Framework Project Documentation (http:/ / incubator. apache. org/ click/ )

JavaBeans Activation Framework 201
JavaBeans Activation Framework
JavaBeans Activation Framework, or JAF, enables developers to: [1]
determine the type of an arbitrary piece of data; encapsulate access to it; discover the operations available on
it; and instantiate the appropriate bean to perform the operation(s).
It also enables you to dynamically register types of arbitrary data and actions associated with particular kinds of data.
Additionally, it enables a program to dynamically provide or retrieve JavaBeans that implement actions associated
with some kind of data.
External links
• Java Technologies [2]
References
[1] JavaBeans Activation Framework (http:/ / java. sun. com/ javase/ technologies/ desktop/ javabeans/ jaf/ ). Retrieved 2010-07-06.
[2] http:/ / java. sun. com/ javase/ technologies/ desktop/ javabeans/ jaf/ downloads/ index. html
JavaThreads
Simply put, a thread is a program's path of execution. Most programs written today run as a single thread, causing
problems when multiple events or actions need to occur at the same time. Let's say, for example, a program is not
capable of drawing pictures while reading keystrokes. The program must give its full attention to the keyboard input
lacking the ability to handle more than one event at a time. The ideal solution to this problem is the seamless
execution of two or more sections of a program at the same time. Threads allows us to do this.
Multithreaded applications deliver their potent power by running many threads concurrently within a single program.
From a logical point of view, multithreading means multiple lines of a single program can be executed at the same
time, however, it is not the same as starting a program twice and saying that there are multiple lines of a program
being executed at the same time. In this case, the operating system is treating the programs as two separate and
distinct processes. Under Unix, forking a process creates a child process with a different address space for both code
and data. However, fork() creates a lot of overhead for the operating system, making it a very CPU-intensive
operation. By starting a thread instead, an efficient path of execution is created while still sharing the original data
area from the parent. The idea of sharing the data area is very beneficial, but brings up some areas of concern that
we'll discuss later.
Creating threads
Java's creators have graciously designed two ways of creating threads: implementing an interface and extending a
class. Extending a class is the way Java inherits methods and variables from a parent class. In this case, one can only
extend or inherit from a single parent class. This limitation within Java can be overcome by implementing interfaces,
which is the most common way to create threads. (Note that the act of inheriting merely allows the class to be run as
a thread. It is up to the class to start() execution, etc.)
Interfaces provide a way for programmers to lay the groundwork of a class. They are used to design the requirements
for a set of classes to implement. The interface sets everything up, and the class or classes that implement the
interface do all the work. The different set of classes that implement the interface have to follow the same rules.
There are a few differences between a class and an interface. First, an interface can only contain abstract methods
and/or static final variables (constants). Classes, on the other hand, can implement methods and contain variables

JavaThreads 202
that are not constants. Second, an interface cannot implement any methods. A class that implements an interface
must implement all methods defined in that interface. An interface has the ability to extend from other interfaces,
and (unlike classes) can extend from multiple interfaces. Furthermore, an interface cannot be instantiated with the
new operator; for example, Runnable a=new Runnable(); is not allowed.
javac
Developer(s) Sun Microsystems
Stable release 1.6.0_14 / May 28, 2009
Operating
system
Cross-platform
Type Compiler
License GNU General Public License
Website [1]
javac (pronounced "java-see") is the primary Java compiler, included in the Java Development Kit (JDK) from Sun
Microsystems.
The compiler accepts source code conforming to the Java language specification (JLS) and produces bytecode
conforming to the Java Virtual Machine Specification (JVMS).
javac is itself written in Java. The compiler can also be invoked programmatically. [2]
History
On 13 November 2006, Sun's Java Virtual Machine (JVM) and Java Development Kit (JDK) were made available [3]
under the GPL license (see Sun's OpenJDK Hotspot page [4] ).
Since version 0.95, GNU Classpath, a free implementation of the standard class library for Java, supports compiling
and running javac using the Classpath runtime (GIJ) and compiler (GCJ), and also allows one to compile the GNU
Classpath class library, tools and examples with javac itself [5] .
See also
• Java compiler for a general presentation of Java compilers, and a list of other existing alternative compilers.
• Java (programming language)
• Java Platform
• OpenJDK
External links
• Sun's OpenJDK javac page [6]
• The Java Virtual Machine Specification [7]
• JSR 199 [5] Java Compiler API Java Specification Request for invoking the Java compiler from a Java program

javac 203
References
[1] http:/ / java. sun. com/ javase/ downloads/ index. jsp
[2] "[...]an application can access javac programmatically." Shawn Silverman (2002-08-30). JavaWorld - Java tip 131 "Java Tip 131: Make a
statement with javac!" (http:/ / www. javaworld. com/ javatips/ jw-javatip131. html?page=1). JavaWorld.com. JavaWorld - Java tip 131.
Retrieved 2008-08-09.
[3] Sun opens Java (feature story) (http:/ / www. sun. com/ 2006-1113/ feature/ story. jsp)
[4] https:/ / openjdk. dev. java. net/ hotspot/
[5] "This release supports compiling and running the GPL OpenJDK javac compiler lala kamina[...]" "GNU Classpath 0.95 Announcement"
(http:/ / www. gnu. org/ software/ classpath/ announce/ 20070423. html). .
[6] https:/ / openjdk. dev. java. net/ compiler/
[7] http:/ / java. sun. com/ docs/ books/ vmspec/

JavaFX 204
JavaFX
Developer(s) Sun Microsystems
Stable release 1.3 / April 22, 2010
Operating
system
Java Runtime Environment
Platform Cross-platform
Available in JavaFX Script
Type Rich Internet applications
License EULA
Website http:/ / javafx. com/
JavaFX is a Java platform for creating and delivering rich Internet applications that can run across a wide variety of
connected devices. The current release (JavaFX 1.3, April 2010) enables building applications for desktop, browser
and mobile phones. TV set-top boxes, gaming consoles, Blu-ray players and other platforms are planned.
JavaFX builds on Java technology. To build JavaFX apps developers use a statically typed, declarative language
called JavaFX Script; Java code can be integrated into JavaFX programs. JavaFX is compiled to Java bytecode, so
JavaFX applications run on any desktop and browser that runs the Java Runtime Environment (JRE) and on top of
mobile phones running Java ME.
On desktop, the current release supports Windows XP, Windows Vista and Mac OS X operating systems. Beginning
with JavaFX 1.2 Sun has released beta-releases for Linux and OpenSolaris. [1]
On mobile, JavaFX is capable of running on multiple mobile operating systems, including Symbian OS, Windows
Mobile, and proprietary real-time operating systems.
Current release of JavaFX platform includes the following components:
1. The JavaFX SDK: JavaFX compiler and runtime tools. Graphics, media web services, and rich text libraries
2. NetBeans IDE for JavaFX: NetBeans with drag-and-drop palette to add objects with transformations, effects and
animations plus set of samples and best practices. For Eclipse users there is a community-supported plugin hosted
on Project Kenai
3. Tools and plugins for creative tools (a.k.a. Production Suite): Plugins for Adobe Photoshop and Adobe Illustrator
that can export graphics assets to JavaFX Script code, tools to convert SVG graphics into JavaFX Script code and
preview assets converted to JavaFX from other tools
Commentators have speculated JavaFX will compete on the desktop with Adobe Flash Player, Adobe AIR,
OpenLaszlo, and Microsoft Silverlight.
Technical highlights
Common profile. JavaFX is based on the concept of a “Common profile” that is intended to span across all devices
supported by JavaFX. This approach makes it possible for developers to use a common programming model while
building an application targeted for both desktop and mobile devices and to share much of the code, graphics assets
and content between desktop and mobile versions. To address the need for tuning applications on a specific class of
devices, the JavaFX 1.1 platform includes APIs that are desktop or mobile-specific. For example JavaFX Desktop

JavaFX 205
profile includes Swing and advanced visual effects.
Drag-to-Install. From the point of view of the end user “Drag-to-Install” allows them to drag a JavaFX widget (or
application residing in a website and is visible within the browser window) and drop it onto their desktop. The
application will not lose its state or context even after the browser is closed. An application can also be re-launched
by clicking on a shortcut that gets created automatically on the user's desktop. This behavior is enabled
out-of-the-box by the Java applet mechanism and is leveraged by JavaFX from the underlying Java layer. Sun touts
“Drag-to-Install” as opening up of a new distribution model and allowing developers to “break away from the
browser”.
Integrating graphics created with third-party tools. JavaFX includes a set of plug-ins for Adobe Photoshop and
Illustrator that enable advanced graphics to be integrated directly into JavaFX applications. The plug-ins generate
JavaFX Script code that preserves layers and structure of the graphics. Developers can then easily add animation or
effects to the static graphics imported. There is also an SVG graphics converter tool (a.k.a. Media Factory) that
allows for importing graphics and previewing assets after the conversion to JavaFX format.
History
JavaFX Script, the scripting component of JavaFX, began life as a project by Chris Oliver called F3. [2]
Sun Microsystems first announced JavaFX at the JavaOne Worldwide Java Developer conference on May 2007.
In May 2008 Sun Microsystems announced plans to deliver JavaFX for the browser and desktop by the third quarter
of 2008, and JavaFX for mobile devices in the second quarter of 2009. Sun also announced a multi-year agreement
with On2 Technologies to bring comprehensive video capabilities to the JavaFX product family using the company's
TrueMotion Video codec.
Since end of July 2008, developers could download a preview of the JavaFX SDK for Windows and Macintosh, as
well as the JavaFX plugin for NetBeans 6.1. On December 4, 2008 Sun released JavaFX 1.0.
JavaFX 1.1
JavaFX for mobile development was finally made available as part of the JavaFX 1.1 release announced officially on
February 12, 2009.
JavaFX 1.2
JavaFX 1.2 was released at JavaOne on June 2, 2009. This release introduced: [3]
• Beta support for Linux and Solaris,
• Built-in controls and layouts,
• Skinnable CSS controls,
• Built-in chart widgets,
• JavaFX I/O management, masking differences between desktop and mobile devices,
• Speed improvements.

JavaFX 206
JavaFX 1.3
JavaFX 1.3 was released on April 22, 2010. This release introduces [4] :
• Performance improvements
• Support of additional platforms
• Improved support for user interface controls
License
There are currently various licenses for the modules that compose the JavaFX runtime:
• The core JavaFX runtime is still proprietary software and its code has not yet been released to the public, [5]
• The JavaFX compiler [6] and an older version of the 2D Scene graph [7] are released under a GPL v2 license,
• The NetBeans plugin for JavaFX is dual licensed under GPL v2 and CDDL. [5]
During development, Sun explained they will roll out their strategy for the JavaFX licensing model for JavaFX first
release. [8] After the release, Jeet Kaul, Sun's Vice president for Client Software, explained that they will soon publish
a specification for JavaFX and its associated file formats, and will continue to open source the JavaFX runtime, and
decouple this core from the proprietary parts licensed by external parties. [9]
See also
• JavaFX Script
• JavaFX Mobile
• Lobo Web Browser, with JavaFX support
• Curl RIA platform, a declarative programming language for web applications
• UltraLightClient, a Java based approach for Rich Internet Applications
Bibliography
• Weaver, James L.; Gao, Weiqi; Chin, Stephen; Iverson, Dean (January 11, 2010). Pro JavaFX 2 Platform: A
Definitive Guide to Script, Desktop, and Mobile RIA with Java Technology [10] . Apress. pp. 500.
ISBN 1430268727.
• Jordan, Lucas (December 17, 2009). JavaFX Special Effects: Taking Java RIA to the Extreme with Animation,
Multimedia, and Game Elements [11] . Apress. pp. 300. ISBN 1430226234.
• Morris, Simon (November 23, 2009). JavaFX in Action [12] . Manning. pp. 375. ISBN 1933988991.
• Topley, Kim (October 12, 2009). JavaFX Developer's Guide [13] . Addison-Wesley Professional. pp. 640.
ISBN 0321601653.
• Weaver, James L.; Gao, Weiqi; Chin, Stephen; Iverson, Dean (June 22, 2009). Pro JavaFX Platform: Script,
Desktop and Mobile RIA with Java Technology [14] . Apress. pp. 500. ISBN 1430218754.
• Clarke, Jim; Connors, Jim; J. Bruno, Eric (June 15, 2009). JavaFX: Developing Rich Internet Applications [15] .
Prentice Hall. pp. 384. ISBN 013701287X.
• Anderson, Gail; Anderson, Paul (June 15, 2009). Essential JavaFX [16] . Prentice Hall. pp. 360.
ISBN 0137042795.
• Weaver, James L. (May 4, 2009). JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-side
Applications [17] . Apress. pp. 200. ISBN 1590599454.

JavaFX 207
External links
• Official website [18]
• Official JavaFX blog website [19]
• java.sun.com website [20]
• Sun.com - JavaFX [21]
• OpenJFX website [22]
• Sun.com - Learning JavaFX Script: An Introduction for Java Programmers [23]
• Crash Course in Next-Gen RIA: AIR, Silverlight, and JavaFX [24]
• Ellison at JavaOne: Myths About JavaFX, Android, and J2ME [25]
• James Weaver's JavaFX blog [26]
• A JavaOne 2009 talk about JavaFx + Groovy [27]
• fxexperience.com - A blog on JavaFX with insights from core engineers on the JavaFX team and weekly news
posts [28]
• javaontop.com - JavaFx code examples [29]
References
[1] "Software and System Requirements for JavaFX Technology" (http:/ / java. sun. com/ javafx/ 1/ reference/ system-requirements-1-2.
html#javafxsdk). .
[2] Project name F3 (http:/ / blogs. sun. com/ chrisoliver/ entry/ f3)
[3] Marinacci, Joshua (2009-06-09). "Top 5 Most Important Features in JavaFX 1.2" (http:/ / weblogs. java. net/ blog/ joshy/ archive/ 2009/ 06/
top_5_most_impo. html). . Retrieved 2009-06-12.
[4] "JavaFX 1.3 Released, Improves User Experiences" (http:/ / blogs. sun. com/ javafx/ entry/ javafx_1_3_released_delivers). 2010-04-22. .
Retrieved 2010-04-25.
[5] "JavaFX Downloads" (https:/ / openjfx. dev. java. net/ downloads. html). . Retrieved 2008-06-07.
[6] "OpenJFX Compiler Project" (https:/ / openjfx-compiler. dev. java. net/ ). . Retrieved 2008-06-07.
[7] "Project Scene Graph home" (https:/ / scenegraph. dev. java. net/ ). . Retrieved 2008-06-07.
[8] "Will JavaFX technology be released in open source?" (http:/ / java. sun. com/ javafx/ faqs. jsp#2). . Retrieved 2008-06-07. "Sun will continue
to engage the OpenJFX community as we release JavaFX products. This fall we will be rolling out our open source strategy for JavaFX
technology concurrent with the release of version 1 of JavaFX Desktop"
[9] Kaul, Jeet (2008-12-16). "JavaFX - the road ahead" (http:/ / blogs. sun. com/ meetjeet/ entry/ javafx_the_road_ahead). . Retrieved
2009-01-03. "Sun is committed to open standards and open source, and specifications are coming soon(...)There are some dependencies on
licensed code that cannot be open sourced. We are working towards decoupling the dependencies so that the non-proprietary portions can be
open sourced. Currently the JavaFX compiler, Netbeans JavaFX plugin and Eclipse JavaFX plugin are already being developed in the open
source. The scene graph is out in the open. We will put the core runtime out in the open over time."
[10] http:/ / www. apress. com/ book/ view/ 1430268727
[11] http:/ / www. apress. com/ book/ view/ 9781430226239
[12] http:/ / www. manning. com/ morris
[13] http:/ / www. informit. com/ store/ product. aspx?isbn=0321648978
[14] http:/ / www. apress. com/ book/ view/ 1430218754
[15] http:/ / www. informit. com/ store/ product. aspx?isbn=0137013531
[16] http:/ / www. informit. com/ store/ product. aspx?isbn=0137042795
[17] http:/ / www. apress. com/ book/ view/ 1590599454
[18] http:/ / www. javafx. com/
[19] http:/ / blogs. sun. com/ javafx
[20] http:/ / java. sun. com/ javafx/ index. jsp
[21] http:/ / www. sun. com/ software/ javafx/
[22] https:/ / openjfx. dev. java. net/
[23] http:/ / java. sun. com/ developer/ technicalArticles/ scripting/ javafxpart1/
[24] http:/ / www. devx. com/ RichInternetApps/ Article/ 35208/ 1954?pf=true
[25] http:/ / java. sys-con. com/ node/ 994363
[26] http:/ / learnjavafx. typepad. com/
[27] http:/ / canoo. com/ blog/ 2009/ 06/ 04/ dierks-talk-at-j1-javafx-groovy-beauty-productivity/
[28] http:/ / fxexperience. com/
[29] http:/ / www. javaontop. com/ index. php?option=com_content& view=article& id=66& Itemid=17/

Jawin 208
Jawin
Jawin is the abbreviation for the Java/Win32 integration project. It is a free, open source architecture for
interoperation between Java and components exposed through Microsoft's Component Object Model (COM) or
through Win32 Dynamic Link Libraries (DLLs).
Jawin includes a code generator, Jawin Type Browser, supporting generation of stub code for scriptable as well as
non-scriptable COM components. The code generator reads one or more type libraries, and automatically emits the
Java stubs needed to call the component(s). The Jawin Type Browser is not (yet) able to generate code for DLL entry
points, and not all parameter types are supported for COM components.

JExamples 209
JExamples
Industry Computer
software
Headquarters Oakland, CA
Key people Pete Eakle
Chris Webster
Website
jexamples.com [1]
JExamples is a web-based, source code search engine for the Java language. It provides the ability to search the
JExamples database for Java examples. The JExamples database contains the source code of Java open source
projects. The search engine understands the semantics of Java, so the search yields more accurate results than a text
search. JExamples also provides the ability to rate examples and the highest rated examples are shown first.
Available since March, 2005, JExamples was the first public web site to allow searching of open source code.
Products & services
In addition to the web-based search engine, JExamples provides a plug-in for the firefox web browser.
References
• List of search engines
• The JExamples About [2] page describes other advantages of JExamples compared to other source code search
engines.
External links
• JExamples.com [3]
References
[1] http:/ / jexamples. com/
[2] http:/ / www. jexamples. com/ about. html
[3] http:/ / www. jexamples. com

Jfig 210
Jfig
Developer(s) The jfig Team
Operating
system
Cross-platform
Type Vector graphics
editor
License shareware
Website [1]
Jfig is a 2D graphics and diagram editor based on the FIG file format. The user-interface of jfig is based on xfig, a
popular graphics editor for the X11 window system.
The jfig software is written in the Java programming language and can be used on notebooks, PCs, and workstations
running Windows 2000/XP, Mac OS X, OS/2, and most versions of Linux and Unix. Due to the support of
LaTeX-formatted text objects, jfig and xfig are often used to create diagrams for LaTeX and pdflatex documents.
See also
• List of vector graphics editors
• Comparison of vector graphics editors
• xfig
External links
• JFig homepage [1]
• Fig file format [2]
References
[1] http:/ / tams-www. informatik. uni-hamburg. de/ applets/ jfig/
[2] http:/ / epb. lbl. gov/ xfig/ fig-format. html

Jikes 211
Jikes
Developer(s) IBM
Stable release 1.22 / October 3, 2004
Development status Unmaintained
Operating system Cross-platform
Type Java compiler
License IBM Public License
Website http:/ / jikes. sourceforge.
net
Jikes is an open source Java compiler written in C++. It is no longer being updated.
The original version was developed by David L. "Dave" Shields and Philippe Charles at IBM but was quickly
transformed into an open source project contributed to by an active community of developers. Initially hosted by
IBM, the project has subsequently been transferred to SourceForge. Among its accomplishments, it was much faster
in compiling small projects than Sun's own compiler, and provided more helpful warnings and errors.
While the free software community needed free Java implementations, the GNU Compiler for Java became the most
commonly used compiler.
Project Status
As of 2010 the project is no longer being actively developed [1] . The last 1.22 version was released in October 2004
and partially supports Java 5.0 (with respect to new classes, but not new language features) [2] [3] . As no further
versions were released since, Java SE 6 is not supported.
See also
• JikesRVM
• Free Java implementations
• Java compiler
External links
• Jikes Homepage [4]
• Jikes RVM Homepage [4]
• Jikes Archives, hosted by David Shields [5]
References
[1] No project CVS writes for the last 12 months (http:/ / sourceforge. net/ project/ stats/ detail. php?group_id=128803& ugn=jikes& type=cvs&
mode=12months)
[2] http:/ / sourceforge. net/ forum/ forum. php?forum_id=446830
[3] http:/ / sourceforge. net/ project/ showfiles. php?group_id=128803
[4] http:/ / jikesrvm. sourceforge. net/
[5] http:/ / daveshields. wordpress. com/ jikes-archives/

jnSynch 212
jnSynch
jnSynch is a light-weight file synchronization engine written in Java, and released as open source through GPL
license.
jnSynch was inspired in rsync and aims to provide an easy way to perform incremental/differential backups that are
gentle to computer resources such as CPU usage, memory footprint and network bandwidth usage.
As in PGP (Pretty Good Privacy) toolset, jnSynch can be thought as a Pretty Good Incremental File Sychronization
Solution.
It recursively synchronizes a source folder to a target folder. For that, it uses a very simple algorithm of comparing
file's "last change date" attribute, between source and target folders, when the attribute is different between source
and target, the engine replaces the target file with a fresh copy from the source and updates its "last changed date"
attribute to exactly that of the source file.
It was first released to public on September 6, 2008. It is actively hosted in SourceForge.net and code.google.com. It
was later scheduled for deletion in code.google.com, so that it is centralized hosted in Sourceforge.Net.
External links
• jnSynch @ Sourceforge.Net [1]
References
[1] http:/ / sourceforge. net/ projects/ jnsynch/
Michael Kölling
Michael Kölling is a professor and software developer currently with the Department of Computer Science at the
University of Kent. Originally from Bremen, Germany, he is also a key member of the team that developed the BlueJ
and Greenfoot Java learning environments. BlueJ is used in over 780 institutions world wide. [1] Kölling was also
involved in the development of the Blue programming language [2] which was an object-oriented programming
language that was developed especially for teaching. This lead on to what is now BlueJ. [3] BlueJ is currently being
maintained by a joint team at the University of Kent at Canterbury and Deakin University in Melbourne, Australia.
Launched in 2006, Greenfoot is an environment created for teaching programming and computer science concepts
and is targeted for a demographic of 15 years old and up. The software is available in both English and German.
Kölling co-wrote Objects First with Java (4th edition), with David J. Barnes, which has been translated into six
languages, including German, Italian, French and Dutch. BlueJ is available in over a dozen languages.
At the Association of Computing Machinery (ACM) Special Interest Group of Computer Science Education
(SIGCSE) 2010 conference, held in Milwaukee, WI, his work was referenced as one of the most influential tools in
the history of computer science education. This paper described Kölling's work on the Blue programming language,
which preceded BlueJ. [4]

Michael Kölling 213
Microsoft Patent issue
On the 22nd May 2005 Kölling made an entry to the BlueJ website [5] in response to a post on Dan Fernandez's blog
(Lead Product Manager - Visual Studio Express). Fernandez described a new feature of Visual Studio 2005 that
"helps you understand objects at Design Time, rather than runtime." [6] This feature had striking similarities to the
way the object test bench functions within BlueJ.
Kölling did not act on the discovery. However, on May 11, 2006 Microsoft attempted to patent [7] the idea. As the
object test bench is essential to the way it functions, had Microsoft's patent been granted, it was likely that BlueJ
would have had to have been discontinued.
Kölling spoke to Microsoft, namely Jane Prey, and eventually the patent was dropped. [8]
Fernandez posted a response on his blog where he says "the patent application was a mistake and one that should not
have happened. To fix this, Microsoft will be removing the patent application in question. Our sincere apologies to
Michael Kölling and the BlueJ community." [9]
Miscellany
• Kölling received a "Best PhD Thesis Award" in 2000 from The Computing Research and Education Association
of Australasia [10]
• Kölling was awarded the first Victorian Pearcey Award for his development of BlueJ. [11]
• Kölling holds an honorary research position at Deakin University.
• Kölling took part in a debate titled "Resolved: Objects First has failed" at SIGCSE in 2005. He believes that
"Objects First has not failed. We have failed to do it". [12]
Books
• Michael Kölling, Introduction to Programming with Greenfoot: Object-Oriented Programming in Java with
Games and Simulations, Pearson Education, August 2009, ISBN 978-0-13-603753-8.
• David J. Barnes & Michael Kölling, Objects First with Java: A Practical Introduction using BlueJ, Prentice Hall /
Pearson Education, 2008, ISBN 0-13-606086-2.
• Bennedsen, Jens; Caspersen, Michael E.; Kölling, Michael (Eds.), Reflections on the Teaching of Programming
Series: Lecture Notes in Computer Science , Vol. 4821. Springer, 2008, ISBN 978-3-540-77933-9.
See also
• BlueJ
• Greenfoot
• Blue programming language
External links
• Michael Kölling Professor of Computer Science [13] University of Kent
References
[1] "List of BlueJ users" (http:/ / www. bluej. org/ about/ users. html). .
[2] "Blue website" (http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ blue/ ). .
[3] "Blue status page (19 March 1999)" (http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ blue/ status. html). .
[4] "SIGCSE2010 Influential Papers website" (http:/ / www. ics. uci. edu/ ~kay/ SIGCSE/ influential/ / ). .
[5] "Comparison between VS and BlueJ's implementation of the object bench concept" (http:/ / www. bluej. org/ vs/ vs-bj. html). .
[6] "Fernandez blog entry on the VS object test bench" (http:/ / blogs. msdn. com/ danielfe/ archive/ 2005/ 01/ 26/ 361375. aspx). .

Michael Kölling 214
[7] "Microsoft patent request" (http:/ / appft1. uspto. gov/ netacgi/ nph-Parser?Sect1=PTO2& Sect2=HITOFF& p=1& u=/ netahtml/ PTO/
search-bool. html& r=1& f=G& l=50& co1=AND& d=PG01& s1=20060101406. PGNR. & OS=DN/ 20060101406& RS=DN/
20060101406). .
[8] "Blog article on Microsoft retraction of the patent" (http:/ / www. bluej. org/ mrt/ ?p=23). .
[9] "Fernandez blog apology" (http:/ / blogs. msdn. com/ danielfe/ archive/ 2007/ 01/ 28/ update-response-to-bluej-patent-issues. aspx). .
[10] "Best PhD Thesis Award" (http:/ / www. core. edu. au/ awards/ Prize Winners. html). .
[11] "Victorian Pearcey Award" (http:/ / www. pearcey. org. au/ index. php/ 1999_Winner_Michael_Kolling). .
[12] "Position summary from SIGCSE debate" (http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ presentations/
2005-SIGCSE-debate-position-summary. pdf) (PDF). .
[13] http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/
List of Java keywords
In the Java programming language, a keyword is one of 50 reserved
words [1] which have a predefined meaning in the language; because of
this, programmers cannot use keywords as names for variables,
methods, classes, or as any other identifier [2] . Due to their special
functions in the language, most integrated development environments
for Java use syntax highlighting to display keywords in a different
color for easy identification.
List
The following is a list of the keywords in Java, along with brief
descriptions of their functions: [2]
abstract
assert
boolean
break
byte
A snippet of Java code with keywords
highlighted in blue and bold font
The abstract keyword is used to declare a class or method to be abstract [3] . An abstract method has no
implementation; all classes containing abstract methods must themselves be abstract, although not all abstract
classes have abstract methods. Objects of a class which is abstract cannot be instantiated, but can be extended
by other classes. All subclasses of an abstract class must either provide implementations for all abstract
methods, or must also be abstract [4] .
The assert keyword, which was added in J2SE 1.4 [2] [1] , is used to make an assertion—a statement which the
programmer believes is always true at that point in the program. If assertions are enabled when the program is
run and it turns out that an assertion is false, an AssertionError is thrown and the program terminates. This
keyword is intended to aid in debugging [5] [6] .
The boolean keyword is used to declare a field that can store a boolean value; that is, either true or false [7] [8] .
This keyword is also used to declare that a method returns a value of type boolean [9] [3] .
Used to resume program execution at the statement immediately following the current enclosing block or
statement. If followed by a label, the program resumes execution at the statement immediately following the
enclosing labeled statement or block.
The byte keyword is used to declare a field that can store an 8-bit signed two's complement integer. [7] [8] This
keyword is also used to declare that a method returns a value of type byte [9] [3] .

List of Java keywords 215
case
catch
char
class
const
continue
default
do
double
else
The case keyword is used to create individual cases in a switch statement; see switch [10] [11] .
Defines an exception handler—a group of statements that are executed if an exception is thrown in the block
defined by a preceding try keyword. The code is executed only if the class of the thrown exception is
assignment compatible with the exception class declared by the catch clause.
The char keyword is used to declare a field that can store a 16-bit Unicode character [7] [8] . This keyword is
also used to declare that a method returns a value of type char [9] [3] .
A type that defines the implementation of a particular kind of object. A class definition defines instance and
class fields, methods, and inner classes as well as specifying the interfaces the class implements and the
immediate superclass of the class. If the superclass is not explicitly specified, the superclass is implicitly
Object.
Although reserved as a keyword in Java, const is not used and has no function [2] [1] .
Used to resume program execution at the end of the current loop body. If followed by a label, continue
resumes execution at the end of the enclosing labeled loop body.
The default can optionally be used in a switch statement to label a block of statements to be executed if no
case matches the specified value; see switch [10] [11] .
The do keyword is used in conjunction with while to create a do-while loop, which executes a block of
statements associated with the loop and then tests a boolean expression associated with the while. If the
expression evaluates to true, the block is executed again; this continues until the expression evaluates to
false [12] [13] .
The double keyword is used to declare a field that can hold a 64-bit double precision IEEE 754 floating-point
number. [7] [8] This keyword is also used to declare that a method returns a value of type double [9] [3] .
The else keyword is used in conjunction with if to create an if-else statement, which tests a boolean
expression; if the expression evaluates to true, the block of statements associated with the if are evaluated; if it
evaluates to false, the block of statements associated with the else are evaluated [14] [15] .
enum (as of J2SE 5.0)
extends
A Java keyword used to declare an enumerated type. Enumerations extend the base class Enum.
Used in a class declaration to specify the superclass; used in an interface declaration to specify one or more
superinterfaces. Class X extends class Y to add functionality, either by adding fields or methods to class Y, or
by overriding methods of class Y. An interface Z extends one or more interfaces by adding methods. Class X
is said to be a subclass of class Y; Interface Z is said to be a subinterface of the interfaces it extends.
Also used to specify an upper bound on a type parameter in Generics.

List of Java keywords 216
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
Define an entity once that cannot be changed nor derived from later. More specifically: a final class cannot be
subclassed, a final method cannot be overridden, and a final variable can occur at most once as a left-hand
expression. All methods in a final class are implicitly final.
Used to define a block of statements for a block defined previously by the try keyword. The finally block is
executed after execution exits the try block and any associated catch clauses regardless of whether an
exception was thrown or caught, or execution left method in the middle of the try or catch blocks using the
return keyword.
The float keyword is used to declare a field that can hold a 32-bit single precision IEEE 754 floating-point
number. [7] [8] This keyword is also used to declare that a method returns a value of type float [9] [3] .
The for keyword is used to create a for loop, which specifies a variable initialization, a boolean expression,
and an incrementation. The variable initialization is performed first, and then the boolean expression is
evaluated. If the expression evaluates to true, the block of statements associated with the loop are executed,
and then the incrementation is performed. The boolean expression is then evaluated again; this continues until
the expression evaluates to false [16] .
As of J2SE 5.0, the for keyword can also be used to create a so-called "enhanced for loop" [17] , which specifies
an array or Iterable object; each iteration of the loop executes the associated block of statements using a
different element in the array or Iterable [16] .
Although reserved as a keyword in Java, goto is not used and has no function [2] [1] .
The if keyword is used to create an if statement, which tests a boolean expression; if the expression evaluates
to true, the block of statements associated with the if statement is executed. This keyword can also be used to
create an if-else statement; see else [14] [15] .
Included in a class declaration to specify one or more interfaces that are implemented by the current class. A
class inherits the types and abstract methods declared by the interfaces.
Used at the beginning of a source file to specify classes or entire Java packages to be referred to later without
including their package names in the reference. Since J2SE 5.0, import statements can import static members
of a class.
A binary operator that takes an object reference as its first operand and a class or interface as its second
operand and produces a boolean result. The instanceof operator evaluates to true if and only if the runtime type
of the object is assignment compatible with the class or interface.
The int keyword is used to declare a field that can hold a 32-bit signed two's complement integer [7] [8] . This
keyword is also used to declare that a method returns a value of type int [9] [3] .

List of Java keywords 217
long
native
new
package
private
protected
public
return
short
static
Used to declare a special type of class that only contains abstract methods, constant (static final) fields and
static interfaces. It can later be implemented by classes that declare the interface with the implements
keyword.
The long keyword is used to declare a field that can hold a 64-bit signed two's complement integer [7] [8] . This
keyword is also used to declare that a method returns a value of type long [9] [3] .
Used in method declarations to specify that the method is not implemented in the same Java source file, but
rather in another language [3] .
Used to create an instance of a class or array.
A group of types. Packages are declared with the package keyword.
The private keyword is used in the declaration of a method, field, or inner class; private members can only be
accessed by other members of their own class [18] .
The protected keyword is used in the declaration of a method, field, or inner class; protected members can
only be accessed by members of their own class, that class's subclasses or classes from the same package [18] .
The public keyword is used in the declaration of a class, method, or field; public classes, methods, and fields
can be accessed by the members of any class [18] .
Used to finish the execution of a method. It can be followed by a value required by the method definition that
is returned to the caller.
The short keyword is used to declare a field that can hold a 16-bit signed two's complement integer [7] [8] . This
keyword is also used to declare that a method returns a value of type short [9] [3] .
Used to declare a field, method or inner class as a class field. Classes maintain one copy of class fields
regardless of how many instances exist of that class. static also is used to define a method as a class method.
Class methods are bound to the class instead of to a specific instance, and can only operate on class fields.
(Classes and interfaces declared as static members of another class or interface are actually top-level classes
and are not inner classes.)
strictfp (as of J2SE 1.2)
super
A Java keyword used to restrict the precision and rounding of floating point calculations to ensure
portability [3] .
Used to access members of a class inherited by the class in which it appears. Allows a subclass to access
overridden methods and hidden members of its superclass. The super keyword is also used to forward a call
from a constructor to a constructor in the superclass.
Also used to specify a lower bound on a type parameter in Generics.

List of Java keywords 218
switch
The switch keyword is used in conjunction with case and default to create a switch statement, which evaluates
a variable, matches its value to a specific case, and executes the block of statements associated with that case.
If no case matches the value, the optional block labelled by default is executed, if included [10] [11] .
synchronized
this
throw
throws
transient
try
void
volatile
while
Used in the declaration of a method or code block to acquire the mutex lock for an object while the current
thread executes the code [3] . For static methods, the object locked is the class' Class. Guarantees that at most
one thread at a time operating on the same object executes that code. The mutex lock is automatically released
when execution exits the synchronized code. Fields, classes and interfaces cannot be declared as synchronized.
Used to represent an instance of the class in which it appears. this can be used to access class members and as
a reference to the current instance. The this keyword is also used to forward a call from one constructor in a
class to another constructor in the same class.
Causes the declared exception instance to be thrown. This causes execution to continue with the first enclosing
exception handler declared by the catch keyword to handle an assignment compatible exception type. If no
such exception handler is found in the current method, then the method returns and the process is repeated in
the calling method. If no exception handler is found in any method call on the stack, then the exception is
passed to the thread's uncaught exception handler.
Used in method declarations to specify which exceptions are not handled within the method but rather passed
to the next higher level of the program. All uncaught exceptions in a method that are not instances of
RuntimeException must be declared using the throws keyword.
Declares that an instance field is not part of the default serialized form of an object. When an object is
serialized, only the values of its non-transient instance fields are included in the default serial representation.
When an object is deserialized, transient fields are initialized only to their default value.
Defines a block of statements that have exception handling. If an exception is thrown inside the try block, an
optional catch block can handle declared exception types. Also, an optional finally block can be declared that
will be executed when execution exits the try block and catch clauses, regardless of whether an exception is
thrown or not. A try block must have at least one catch clause or a finally block.
The void keyword is used to declare that a method does not return any value [9] .
Used in field declarations to specify that the variable is modified asynchronously by concurrently running
threads. Methods, classes and interfaces thus cannot be declared volatile.
The while keyword is used to create a while loop, which tests a boolean expression and executes the block of
statements associated with the loop if the expression evaluates to true; this continues until the expression
evaluates to false. This keyword can also be used to create a do-while loop; see do [12] [13] .

List of Java keywords 219
Reserved words for literal values
false
null
true
See also
A boolean literal value.
A reference literal value.
A boolean literal value.
• Java annotation
References
• Gosling, James; Joy, Bill; Steele, Guy; and Bracha, Gillad (June 2005). Java Language Specification [47] (Third
ed.). Addison-Wesley Professional. ISBN 978-0321246783. Retrieved 2008-12-03.
• Flanagan, David (March 2005). Java in a Nutshell [19] (Fifth ed.). O'Reilly Media. ISBN 978-0-596-00773-7.
Retrieved 2010-03-03.
References
[1] Flanagan 2005, p. 20.
[2] "Java Language Keywords" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ _keywords. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-02.
[3] Flanagan 2005, pp. 66-67.
[4] "Abstract Methods and Classes" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ IandI/ abstract. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-06.
[5] "Programming With Assertions" (http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ guide/ lang/ assert. html). Java 2 SDK, Standard Edition
Documentation. Sun Microsystems, Inc.. 2002. . Retrieved 2008-12-06.
[6] Flanagan 2005, pp. 60-64.
[7] "Primitive Data Types" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ datatypes. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03.
[8] Flanagan 2005, p. 22.
[9] "Returning a Value from a Method" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ javaOO/ returnvalue. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03.
[10] "The switch Statement" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ switch. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03.
[11] Flanagan 2005, pp. 46-48.
[12] "The while and do-while Statements" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ while. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03.
[13] Flanagan 2005, pp. 48-49.
[14] "The if-then and if-then-else Statements" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ if. html). The Java Tutorials. Sun
Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03.
[15] Flanagan 2005, pp. 44-46.
[16] "The for Statement" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ for. html). The Java Tutorials. Sun Microsystems, Inc..
February 14, 2008. . Retrieved 2008-12-03.
[17] Flanagan 2005, pp. 50-54.
[18] "Controlling Access to Members of a Class" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ javaOO/ accesscontrol. html). The Java
Tutorials. Sun Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03.
[19] http:/ / oreilly. com/ catalog/ 9780596007737

Marker interface pattern 220
Marker interface pattern
The marker interface pattern is a design pattern in computer science, used with languages that provide run-time
type information about objects. It provides a means to associate metadata with a class where the language does not
have explicit support for such metadata.
To use this pattern, a class implements a marker interface, and methods that interact with instances of that class test
for the existence of the interface. Whereas a typical interface specifies functionality (in the form of method
declarations) that an implementing class must support, a marker interface need not do so. The mere presence of such
an interface indicates specific behavior on the part of the implementing class. Hybrid interfaces, which both act as
markers and specify required methods, are possible but may prove confusing if improperly used.
An example of the application of marker interfaces from the Java programming language is the Serializable
interface. A class implements this interface to indicate that its non-transient data members can be written to an
ObjectOutputStream. The ObjectOutputStream private method writeObject() contains a series of instanceof tests to
determine writeability, one of which looks for the Serializable interface. If none of these tests pass, the method
throws a NotSerializableException.
Critique
A major problem with marker interfaces is that an interface defines a contract for implementing classes, and that
contract is inherited by all subclasses. This means that you cannot "unimplement" a marker. In the example given, if
you create a subclass that you do not want to serialize (perhaps because it depends on transient state), you must
resort to explicitly throwing NotSerializableException (per ObjectOutputStream docs).
A better solution is for the language to support metadata directly:
• Both the .NET framework and Java (as of Java 5 (1.5)) provide support for such metadata. In .NET, they are
called "custom attributes", in Java they are called "annotations". Despite the different name, they are conceptually
the same thing. They can be defined on classes, member variables, methods, and method parameters and may be
accessed using reflection.
• In Python, the term "marker interface" is common in Zope and Plone. Interfaces are declared as metadata and
subclasses can use implementsOnly to declare they do not implement everything from their super classes.
See also
• Design markers for an expansion of this pattern.

Name mangling 221
Name mangling
In software compiler engineering, name mangling (sometimes called name decoration) is a technique used to solve
various problems caused by the need to resolve unique names for programming entities in many modern
programming languages.
It provides a way of encoding additional information in the name of a function, structure, class or another datatype in
order to pass more semantic information from the compilers to linkers.
The need arises where the language allows different entities to be named with the same identifier as long as they
occupy a different namespace (where a namespace is typically defined by a module, class, or explicit namespace
directive).
Any object code produced by compilers is usually linked with other pieces of object code (produced by the same or
another compiler) by a type of program called a linker. The linker needs a great deal of information on each program
entity. For example, to correctly link a function it needs its name, the number of arguments and their types, and so
on.
C name decoration in Microsoft Windows
Although name mangling is not generally required or used by languages that do not support function overloading
(such as C and classic Pascal), they use it in some cases to provide additional information about a function. For
example, compilers targeted at Microsoft Windows platforms support a variety of calling conventions, which
determine the manner in which parameters are sent to subroutines and results returned. Because the different calling
conventions are not compatible with one another, compilers mangle symbols with codes detailing which convention
should be used.
The mangling scheme was established by Microsoft, and has been informally followed by other compilers including
Digital Mars, Borland, and GNU gcc, when compiling code for the Windows platforms. The scheme even applies to
other languages, such as Pascal, D, Delphi, Fortran, and C#. This allows subroutines written in those languages to
call, or be called by, existing Windows libraries using a calling convention different from their default.
When compiling the following C examples:
int _cdecl f (int x) { return 0; }
int _stdcall g (int y) { return 0; }
int _fastcall h (int z) { return 0; }
32 bit compilers emit, respectively:
_f
_g@4
@h@4
In the stdcall and fastcall mangling schemes, the function is encoded as _name@X and @name@X
respectively, where X is the number of bytes, in decimal, of the argument(s) in the parameter list (including those
passed in registers, for fastcall). In the case of cdecl, the function name is merely prefixed by an underscore.

Name mangling 222
Name mangling in C++
C++ compilers are the most widespread and yet least standard users of name mangling. The first C++ compilers
were implemented as translators to C source code, which would then be compiled by a C compiler to object code;
because of this, symbol names had to conform to C identifier rules. Even later, with the emergence of compilers
which produced machine code or assembly directly, the system's linker generally did not support C++ symbols, and
mangling was still required.
The C++ language does not define a standard decoration scheme, so each compiler uses its own. C++ also has
complex language features, such as classes, templates, namespaces, and operator overloading, that alter the meaning
of specific symbols based on context or usage. Meta-data about these features can be disambiguated by mangling
(decorating) the name of a symbol. Because the name-mangling systems for such features are not standardized across
compilers, few linkers can link object code that was produced by different compilers.
Simple example
Consider the following two definitions of f() in a C++ program:
int f (void) { return 1; }
int f (int) { return 0; }
void g (void) { int i = f(), j = f(0); }
These are distinct functions, with no relation to each other apart from the name. If they were natively translated into
C with no changes, the result would be an error — C does not permit two functions with the same name. The C++
compiler therefore will encode the type information in the symbol name, the result being something resembling:
int __f_v (void) { return 1; }
int __f_i (int) { return 0; }
void __g_v (void) { int i = __f_v(), j = __f_i(0); }
Notice that g() is mangled even though there is no conflict; name mangling applies to all symbols.
Complex example
For a more complex example, we'll consider an example of a real-world name mangling implementation: that used
by GNU GCC 3.x, and how it mangles the following example class. The mangled symbol is shown below the
respective identifier name.
namespace wikipedia
{
class article
{
public:
std::string format (void);
/* = _ZN9wikipedia7article6formatEv */
bool print_to (std::ostream&);
/* = _ZN9wikipedia7article8print_toERSo */
class wikilink
{
public:
wikilink (std::string const& name);

Name mangling 223
}
};
};
/* = _ZN9wikipedia7article8wikilinkC1ERKSs */
All mangled symbols begin with _Z (note that an underscore followed by a capital is a reserved identifier in C and
C++, so conflict with user identifiers is avoided); for nested names (including both namespaces and classes), this is
followed by N, then a series of pairs (the length being the length of the next identifier), and finally E.
For example, wikipedia::article::format becomes
_ZN·9wikipedia·7article·6format·E
For functions, this is then followed by the type information; as format() is a void function, this is simply v;
hence:
_ZN·9wikipedia·7article·6format·E·v
For print_to, a standard type std::ostream (or more properly std::basic_ostream) is used, which has the special alias So; a reference to this type is therefore RSo, with
the complete name for the function being:
_ZN·9wikipedia·7article·8print_to·E·RSo
How different compilers mangle the same functions
There isn't a standard scheme by which even trivial C++ identifiers are mangled, and consequently different
compiler vendors (or even different versions of the same compiler, or the same compiler on different platforms)
mangle public symbols in radically different (and thus totally incompatible) ways. Consider how different C++
compilers mangle the same functions:
Notes:
Compiler void h(int) void h(int, char) void h(void)
Intel C++ 8.0 for Linux _Z1hi _Z1hic _Z1hv
HP aC++ A.05.55 IA-64 _Z1hi _Z1hic _Z1hv
GNU GCC 3.x and 4.x _Z1hi _Z1hic _Z1hv
HP aC++ A.03.45 PA-RISC h__Fi h__Fic h__Fv
GNU GCC 2.9x h__Fi h__Fic h__Fv
Microsoft VC++ v6/v7 ?h@@YAXH@Z ?h@@YAXHD@Z ?h@@YAXXZ
Digital Mars C++ ?h@@YAXH@Z ?h@@YAXHD@Z ?h@@YAXXZ
Borland C++ v3.1 @h$qi @h$qizc @h$qv
OpenVMS C++ V6.5 (ARM mode) H__XI H__XIC H__XV
OpenVMS C++ V6.5 (ANSI
mode)
CXX$__7H__FI0ARG51T CXX$__7H__FIC26CDH77 CXX$__7H__FV2CB06E8
OpenVMS C++ X7.1 IA-64 CXX$_Z1HI2DSQ26A CXX$_Z1HIC2NP3LI4 CXX$_Z1HV0BCA19V
SunPro CC __1cBh6Fi_v_ __1cBh6Fic_v_ __1cBh6F_v_
Tru64 C++ V6.5 (ARM mode) h__Xi h__Xic h__Xv
Tru64 C++ V6.5 (ANSI mode) __7h__Fi __7h__Fic __7h__Fv
Watcom C++ 10.6 W?h$n(i)v W?h$n(ia)v W?h$n()v

Name mangling 224
• The Compaq C++ compiler on OpenVMS VAX and Alpha (but not IA-64) and Tru64 has two name mangling
schemes. The original, pre-standard scheme is known as ARM model, and is based on the name mangling
described in the C++ Annotated Reference Manual (ARM). With the advent of new features in standard C++,
particularly templates, the ARM scheme became more and more unsuitable — it could not encode certain
function types, or produced identical mangled names for different functions. It was therefore replaced by the
newer "ANSI" model, which supported all ANSI template features, but was not backwards compatible.
• On IA-64, a standard ABI exists (see external links), which defines (among other things) a standard
name-mangling scheme, and which is used by all the IA-64 compilers. GNU GCC 3.x, in addition, has adopted
the name mangling scheme defined in this standard for use on other, non-Intel platforms.
Handling of C symbols when linking from C++
The job of the common C++ idiom:
#ifdef __cplusplus
extern "C" {
#endif
/* ... */
#ifdef __cplusplus
}
#endif
is to ensure that the symbols following are "unmangled" – that the compiler emits a binary file with their names
undecorated, as a C compiler would do. As C language definitions are unmangled, the C++ compiler needs to avoid
mangling references to these identifiers.
For example, the standard strings library, usually contains something resembling:
#ifdef __cplusplus
extern "C" {
#endif
void *memset (void *, int, size_t);
char *strcat (char *, const char *);
int strcmp (const char *, const char *);
char *strcpy (char *, const char *);
#ifdef __cplusplus
}
#endif
Thus, code such as:
if (strcmp(argv[1], "-x") == 0)
else
strcpy(a, argv[2]);
memset (a, 0, sizeof(a));
uses the correct, unmangled strcmp and memset. If the extern had not been used, the (SunPro) C++ compiler
would produce code equivalent to:

Name mangling 225
if (__1cGstrcmp6Fpkc1_i_(argv[1], "-x") == 0)
else
__1cGstrcpy6Fpcpkc_0_(a, argv[2]);
__1cGmemset6FpviI_0_ (a, 0, sizeof(a));
Since those symbols do not exist in the C runtime library (e.g. libc), link errors would result.
Standardised name mangling in C++
While it is a relatively common belief that standardised name mangling in the C++ language would lead to greater
interoperability between implementations, this is not really the case. Name mangling is only one of several
application binary interface issues in a C++ implementation. Other ABI issues like exception handling, virtual table
layout, structure padding, etc. cause differing C++ implementations to be incompatible. Further, requiring a
particular form of mangling would cause issues for systems where implementation limits (e.g. length of symbols)
dictate a particular mangling scheme. A standardised requirement for name mangling would also prevent an
implementation where mangling was not required at all — for example, a linker which understood the C++
language.
The C++ standard therefore does not attempt to standardise name mangling. On the contrary, the Annotated C++
Reference Manual (also known as ARM, ISBN 0-201-51459-1, section 7.2.1c) actively encourages the use of
different mangling schemes to prevent linking when other aspects of the ABI, such as exception handling and virtual
table layout, are incompatible.
Real-world effects of C++ name mangling
Because C++ symbols are routinely exported from DLL and shared object files, the name mangling scheme is not
merely a compiler-internal matter. Different compilers (or different versions of the same compiler, in many cases)
produce such binaries under different name decoration schemes, meaning that symbols are frequently unresolved if
the compilers used to create the library and the program using it employed different schemes. For example, if a
system with multiple C++ compilers installed (e.g. GNU GCC and the OS vendor's compiler) wished to install the
Boost library, it would have to be compiled twice — once for the vendor compiler and once for GCC.
It is good for safety purposes that compilers producing incompatible object codes (codes based on different ABIs,
regarding e.g. classes and exceptions) use different name mangling schemes. This guarantees that these
incompatibilities are detected at the linking phase, not when executing the software.
For this reason name decoration is an important aspect of any C++-related ABI.
Name mangling in Java
The language, compiler, and .class file format were all designed together (and had object-orientation in mind from
the start), so the primary problem solved by name mangling doesn't exist in implementations of the Java runtime.
There are, however, cases where an analogous transformation and qualification of names is necessary.
Creating unique names for inner and anonymous classes
The scope of anonymous classes is confined to their parent class, so the compiler must produce a "qualified" public
name for the inner class, to avoid conflict where other classes (inner or not) exist in the same namespace. Similarly,
anonymous classes must have "fake" public names generated for them (as the concept of anonymous classes exists
only in the compiler, not the runtime). So, compiling the following java program
public class foo {
class bar {

Name mangling 226
}
}
public int x;
public void zark () {
}
Object f = new Object () {
};
will produce three .class files:
public String toString() {
}
return "hello";
• foo.class, containing the main (outer) class foo
• foo$bar.class, containing the named inner class foo.bar
• foo$1.class, containing the anonymous inner class (local to method foo.zark)
All of these class names are valid (as $ symbols are permitted in the JVM specification) and these names are "safe"
for the compiler to generate, as the Java language definition prohibits $ symbols in normal java class definitions.
Name resolution in Java is further complicated at runtime, as fully qualified class names are unique only inside a
specific classloader instance. Classloaders are ordered hierarchically and each Thread in the JVM has a so called
context class loader, so in cases where two different classloader instances contain classes with the same name, the
system first tries to load the class using the root (or system) classloader and then goes down the hierarchy to the
context class loader.
Handling issues with the java to native interface
Java's native method support allows java language programs to call out to programs written in another language
(generally either C or C++). There are two name-resolution concerns here, neither of which is implemented in a
particularly standard manner.
Name mangling in Python
A Python programmer can explicitly designate that an identifier is a "private name" (its scope is confined to the
class) by setting the first two characters of the identifier to be underscores. Mangling will not be performed if the
identifier ends with more than one underscore, for example, __thing will be mangled, as will ___thing and __thing_,
but __thing__ and __thing___ will not. On encountering these, the Python compiler or interpreter turns these private
names into global symbols by prepending a string consisting of a single underscore and the name of the enclosing
class.
So, for example,
class Test:
def __private_symbol(self):
pass
def normal_symbol(self):
pass
print dir(Test)
will output:

Name mangling 227
['_Test__private_symbol',
'__doc__',
'__module__',
'normal_symbol']
Name mangling in Borland's Turbo Pascal / Delphi range
To avoid name mangling in Pascal, use:
exports
myFunc name 'myFunc', myProc name 'myProc';
Name mangling in Objective-C
Essentially two forms of method exist in Objective-C, the class ("static") method, and the instance method. A
method declaration in Objective-C is of the following form
+ method name: argument name 1 :parameter 1 ...
- method name: argument name 1 :parameter 1 ...
Class methods are signified by +, instance methods use -. A typical class method declaration may then look like:
+ (id) initWithX: (int) number andY: (int) number;
+ (id) new;
with instance methods looking like
- (id) value;
- (id) setValue: (id) new_value;
Each of these method declarations have a specific internal representation. When compiled, each method is named
according to the following scheme for class methods:
_c_Class_methodname_name 1 _name 2 _ ...
and this for instance methods:
_i_Class_methodname_name 1 _name 2 _ ...
The colons in the Objective-C syntax are translated to underscores. So, the Objective-C class method + (id)
initWithX: (int) number andY: (int) number;, if belonging to the Point class would translate as
_c_Point_initWithX_andY_, and the instance method (belonging to the same class) - (id) value;
would translate to _i_Point_value.
Each of the methods of a class are labeled in this way. However, in order to look up a method that a class may
respond to would be tedious if all methods are represented in this fashion. Each of the methods is assigned a unique
symbol (such as an integer). Such a symbol is known as a selector. In Objective-C, one can manage selectors directly
— they have a specific type in Objective-C — SEL.
During compilation, a table is built that maps the textual representation (such as _i_Point_value) to selectors
(which are given a type SEL). Managing selectors is more efficient than manipulating the textual representation of a
method. Note that a selector only matches a method's name, not the class it belongs to — different classes can have
different implementations of a method with the same name. Because of this, implementations of a method are given
a specific identifier too — these are known as implementation pointers, and are given a type also, IMP.

Name mangling 228
Message sends are encoded by the compiler as calls to the id objc_msgSend (id receiver, SEL
selector, ...) function, or one of its cousins, where receiver is the receiver of the message, and SEL
determines the method to call. Each class has its own table that maps selectors to their implementations — the
implementation pointer specifies where in memory the actual implementation of the method resides. There are
separate tables for class and instance methods. Apart from being stored in the SEL to IMP lookup tables, the
functions are essentially anonymous.
The SEL value for a selector does not vary between classes. This enables polymorphism.
The Objective-C runtime maintains information about the argument and return types of methods. However, this
information is not part of the name of the method, and can vary from class to class.
Since Objective-C does not support namespaces, there is no need for mangling of class names (that do appear as
symbols in generated binaries).
Name mangling in Fortran
Name mangling is also necessary in Fortran compilers, originally because the language is case insensitive. Further
mangling requirements were imposed later in the evolution of the language because of the addition of modules and
other features in the Fortran 90 standard. The case mangling, especially, is a common issue that must be dealt with in
order to call Fortran libraries (such as LAPACK) from other languages (such as C).
Because of the case insensitivity, the name of a subroutine or function "FOO" must be converted to a canonical case
and format by the Fortran compiler so that it will be linked in the same way regardless of case. Different compilers
have implemented this in various ways, and no standardization has occurred. The AIX and HP-UX Fortran compilers
convert all identifiers to lower case ("foo"), while the Cray Unicos Fortran compilers converted identifiers all upper
case ("FOO"). The GNU g77 compiler converts identifiers to lower case plus an underscore ("foo_"), except that
identifiers already containing an underscore ("FOO_BAR") have two underscores appended ("foo_bar__"),
following a convention established by f2c. Many other compilers, including SGI's IRIX compilers, gfortran, and
Intel's Fortran compiler, convert all identifiers to lower case plus an underscore ("foo_" and "foo_bar_").
Identifiers in Fortran 90 modules must be further mangled, because the same subroutine name may apply to different
routines in different modules.
See also
• Language binding
• Foreign function interface
• Calling convention
• Application programming interface - API
• Application Binary Interface - ABI
• Comparison of application virtual machines
• Java Native Interface
• SWIG - opensource interfaces bindings generator from many languages to many languages

Name mangling 229
External links
• Linux Itanium ABI for C++ [1] , including name mangling scheme.
• c++filt [2] — filter to demangle encoded C++ symbols
• undname [3] — msvc tool to demangle names.
• The Objective-C Runtime System [4] — From Apple's The Objective-C Programming Language 1.0 [5]
• C++ Name Mangling/Demangling [6] Quite detailed explanation of Visual C++ compiler name mangling scheme
• PHP UnDecorateSymbolName [7] a php script that demangles Microsoft Visual C's function names.
• Calling conventions for different C++ compilers [8] contains detailed description of name mangling schemes for
various x86 C++ compilers
• Macintosh C/C++ ABI Standard Specification [9]
• Mixing C and C++ Code [10]
• Symbol management – 'Linkers and Loaders' by John R. Levine [11]
References
[1] http:/ / www. codesourcery. com/ cxx-abi/ abi. html#mangling
[2] http:/ / sources. redhat. com/ binutils/ docs-2. 15/ binutils/ c--filt. html
[3] http:/ / msdn2. microsoft. com/ en-us/ library/ 5x49w699. aspx
[4] http:/ / developer. apple. com/ legacy/ mac/ library/ documentation/ Cocoa/ Conceptual/ OOPandObjC1/ Articles/ ocRuntimeSystem. html#/ /
apple_ref/ doc/ uid/ TP40005191-CH9-CJBBBCHG
[5] http:/ / developer. apple. com/ legacy/ mac/ library/ documentation/ Cocoa/ Conceptual/ OOPandObjC1/ Introduction/ introObjectiveC. html
[6] http:/ / www. kegel. com/ mangle. html#operators
[7] http:/ / sourceforge. net/ projects/ php-ms-demangle/
[8] http:/ / www. agner. org/ optimize/ calling_conventions. pdf
[9] http:/ / developer. apple. com/ tools/ mpw-tools/ compilers/ docs/ abi_spec. pdf
[10] http:/ / www. parashift. com/ c+ + -faq-lite/ mixing-c-and-cpp. html
[11] http:/ / www. iecc. com/ linker/ linker05. html

Patrick Naughton 230
Patrick Naughton
Patrick Naughton (born in 1965) is an American software developer, best known as being one of the original
creators of the Java programming language.
Career
Working for Sun
As a Sun engineer, Patrick Naughton had become increasingly frustrated with the state of Sun's C++ and C APIs
(application programming interfaces) and tools. While considering moving to NeXT, Naughton was offered a chance
to work on new technology and thus the Stealth Project was started.
The Stealth Project was soon renamed to the Green Project with James Gosling and Mike Sheridan joining
Naughton. Together with other engineers, they began work in a small office on Sand Hill Road in Menlo Park,
California. They were attempting to develop a new technology for programming next generation smart appliances,
[1] [2]
which Sun expected to be a major new opportunity.
In June and July 1994, after three days of brainstorming with John Gage, the Director of Science for Sun, James
Gosling, Bill Joy, Naughton, Wayne Rosing, and Eric Schmidt, the team re-targeted the platform for the World Wide
Web. They felt that with the advent of the first graphical web browser, Mosaic, the Internet was on its way to
evolving into the same highly interactive medium that they had envisioned for cable TV. As a prototype, Naughton
wrote a small browser, WebRunner, later renamed HotJava. [3]
After Sun
In 1994, Naughton quit Sun for Starwave (then a property of Paul Allen) to develop server Java applications for high
profile web sites (in times when J2EE frameworks did not exist yet) [3] . They developed ESPN.com,
ABCNEWS.com, Outside Online, and Mr. Showbiz.com among other groundbreaking sites, setting the standard for
much of the commercial Internet explosion of the late 1990s.
In 1998, Walt Disney Internet Group acquired Starwave and amalgamated it with Infoseek in the Go Network
company. As a result, Naughton became executive vice president of Infoseek.
After his arrest in 1999, Naughton was fired from Infoseek. [4] He is currently employed by the Seattle hedge fund L1
Partners.
Arrest for sex crimes
Patrick Naughton was arrested by the FBI on 16 September 1999 and was prosecuted for traveling in interstate
commerce with the intent to have sex with a minor, in violation of 18 U.S.C. §2423(b). [4] [5] [6] After the trial ended
in a hung jury, the government moved for a new trial, then struck a plea agreement where he took a reduced
sentence, serving no prison time, in exchange for working for the FBI for free for a year. [7] [8] His line of defense
was that he claimed he was persuaded to participate online in a ritualized sexual role-playing exercise, dealing with a
mature woman acting as a girl. [8]

Patrick Naughton 231
See also
• History of Java
• Online identity
References
[1] Patrick Naughton. "Java Was Strongly Influenced by Objective-C" (http:/ / cs. gmu. edu/ ~sean/ stuff/ java-objc. html). . Retrieved
2009-08-02.
[2] "Java Technology: The Early Years" (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html). Sun Microsystems. . Retrieved 2009-08-02.
[3] "Le cadre, le piège et la loi" (http:/ / www. cyberie. qc. ca/ chronik/ 990928. html#b) (in French). cyberie.qc.ca. . Retrieved 2009-08-02.
[4] "Patrick Doesn't Work Here Anymore" (http:/ / www. wired. com/ wired/ archive/ 7. 12/ mustread. html?pg=5). Wired News. December
1999. . Retrieved 2009-08-02.
[5] "CEO: Naughton said 'I did it'" (http:/ / news. zdnet. co. uk/ security/ 0,1000000189,2075734,00. htm). zdnet.co.uk. 1999-12-09. . Retrieved
2009-08-02.
[6] "The Fantasy Defense" (http:/ / www. cbsnews. com/ stories/ 2000/ 05/ 24/ eveningnews/ main199192. shtml). CBS News. 2000-05-31. .
Retrieved 2009-08-02.
[7] "Patrick Naughton faces retrial" (http:/ / www. zdnet. com. au/ news/ soa/ Patrick-Naughton-faces-retrial-/ 0,139023165,120104206,00. htm).
zdnet.co.uk. 2000-10-13. . Retrieved 2009-08-02.
[8] "Paper 2: Legal Treatment Of Online Identity" (http:/ / emoglen. law. columbia. edu/ CPC/ discuss/ 383. html). emoglen.law.columbia.edu.
2006-04-29. . Retrieved 2009-08-02. "At his criminal trial, Naughton employed what has come to be known as the "fantasy defense": citing his
technical sophistication and the adult tone of his interlocutor's conversation, he claimed that he believed her to be an adult woman playing the
role of a teenage girl; which, indeed, she was, although for different reasons from those Naughton claimed to have believed."
New I/O
New I/O or Non-blocking I/O, usually called NIO, is a collection of Java programming language APIs that offer
features for intensive I/O operations. It was introduced with the J2SE 1.4 release of Java by Sun Microsystems to
complement an existing standard I/O. NIO was developed under the Java Community Process as JSR 51. [1] As of
2006, an extension to NIO, called NIO2, is being developed under JSR 203; JSR 203 is scheduled to be included in
Java SE 7 ("Dolphin"). [2]
Features and organization.
The APIs of NIO were designed to provide access to the low-level I/O operations of modern operating systems.
Although the APIs are themselves relatively high-level, the intent is to facilitate an implementation that can directly
use the most efficient operations of the underlying platform.
The Java NIO APIs are provided in the java.nio package and its subpackages. The documentation by Sun
Microsystems identifies these features.
• Buffers for data of primitive types
• Character set encoders and decoders
• A pattern-matching facility based on Perl-style regular expressions (in package java.util.regex)
• Channels, a new primitive I/O abstraction
• A file interface that supports locks and memory mapping of files up to Integer.MAX_VALUE bytes (2 GiB)
• A multiplexed, non-blocking I/O facility for writing scalable servers

New I/O 232
NIO buffers
NIO data transfer is based on buffers (java.nio.Buffer and related classes). These classes represent a contiguous
extent of memory, together with a small number of data transfer operations. Although theoretically these are
general-purpose data structures, the implementation may select memory for alignment or paging characteristics,
which are not otherwise accessible in Java. Typically, this would be used to allow the buffer contents to occupy the
same physical memory used by the underlying operating system for its native I/O operations, thus allowing the most
direct transfer mechanism, and eliminating the need for any additional copying. In most operating systems, provided
the particular area of memory has the right properties, transfer can take place without using the CPU at all. The NIO
buffer is intentionally limited in features in order to support these goals.
There are buffer classes for all of Java's primitive types except boolean, which can share memory with byte buffers
and allow arbitrary interpretation of the underlying bytes.
Usage
NIO buffers maintain several pointers that dictate the function of its accessor methods. The NIO buffer
implementation contains a rich set of methods for modifying these pointers:
• The flip() method, rather than performing a "flip" or paging function in the canonical sense, moves the position
pointer to the origin of the underlying array (if any) and the limit pointer to the former position of the position
pointer.
• Three get() methods are supplied for transferring data out of a NIO buffer. The bulk implementation, rather than
performing a "get" in the traditional sense, "puts" the data into a specified array. The "offset" argument supplied
to this method refers not to the offset from within the buffer from which to read, nor an offset from the position
pointer, but rather the offset from 0 within the target array.
• Unless using the absolute get() and put() methods, any get() or put() is conducted from the position pointer.
Should one need to read from a different position within the underlying array, whilst not adjusting the writing
position, the mark() and reset() methods have been supplied.
• The mark() method effectively stores the position of the position pointer by setting the mark pointer to the
position of the position pointer. The reset() method causes the position pointer to move to the mark pointer's
position.
• Upon invocation of the clear() method or the flip() method the mark pointer is discarded.
• The clear() method does not ensure zero-ing of the buffer, but does return the limit pointer to the upper boundary
of the underlying array, and the position pointer to zero.
• put() and get() operations for NIO buffers are not thread safe.
• You can only map() a java.nio.MappedByteBuffer from a java.nio.channels.FileChannel up to
Integer.MAX_VALUE in size (2GiB); regions beyond this limit can be accessed using an offset greater than zero.
Channels
Channels (classes implementing the interface java.nio.channels.Channel) are designed to provide for bulk data
transfers to and from NIO buffers. This is a low-level data transfer mechanism that exists in parallel with the classes
of the higher-level I/O library (packages java.io and java.net). A channel implementation can be obtained from a
high-level data transfer class such as java.io.File, java.net.ServerSocket, or java.net.Socket, and vice versa. Channels
are analogous to "file descriptors" found in Unix-like operating systems.
File channels (java.nio.channels.FileChannel) can use arbitrary buffers but can also establish a buffer directly
mapped to file contents using memory-mapped I/O. They can also interact with file system locks. Similarly, socket
channels (java.nio.channels.SocketChannel and java.nio.channels.ServerSocketChannel) allow for data transfer
between sockets and NIO buffers.

New I/O 233
FileChannel can be used to do a file copy, which is potentially far more efficient than using old read/write with a
byte array. The typical code for this is:
// Getting file channels
FileChannel in = new FileInputStream(source).getChannel();
FileChannel out = new FileOutputStream(target).getChannel();
// JavaVM does its best to do this as native I/O operations.
in.transferTo (0, in.size(), out);
// Closing file channels will close corresponding stream objects as
well.
out.close();
in.close();
Selectors
A selector (java.nio.channels.Selector and subclasses) provides a mechanism for waiting on channels and
recognizing when one or more become available for data transfer. When a number of channels are registered with the
selector, it enables blocking of the program flow until at least one channel is ready for use, or until an interruption
condition occurs.
Although this multiplexing behavior could be implemented with Java threads, the selector can provide a significantly
more efficient implementation using native platform threads or, more likely, even lower-level operating system
constructs. A POSIX-compliant operating system, for example, would have direct representations of these concepts,
select(). A notable application of this design would be the common paradigm in server software which involves
simultaneously waiting for responses on a number of sessions.
Character sets
In Java, a character set is a mapping between Unicode characters (or a subset of them) and bytes. The
java.nio.charset package of NIO provides facilities for identifying character sets and providing encoding and
decoding algorithms for new mappings.
Regular expressions
The regular expression library in the java.util.regex package provides a powerful search facility for character data
based on regular expression matching.
The following example was adopted from the NIO API guide examples [3] , where there are more examples.
/*
* @(#)Grep.java 1.3 01/12/13
* Search a list of files for lines that match a given
regular-expression
* pattern. Demonstrates NIO mapped byte buffers, charsets, and
regular
* expressions.
*
* Copyright 2001-2002 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or

New I/O 234
* without modification, are permitted provided that the following
* conditions are met:
*
* -Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduct the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any
* kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
* EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY
* DAMAGES OR LIABILITIES SUFFERED BY LICENSEE AS A RESULT OF OR
* RELATING TO USE, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
* ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE
* FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT,
* SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
* CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF
* THE USE OF OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that Software is not designed, licensed or
* intended for use in the design, construction, operation or
* maintenance of any nuclear facility.
*/
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.regex.*;
public class Grep {
// Charset and decoder for ISO-8859-15
private static Charset charset = Charset.forName("ISO-8859-15");
private static CharsetDecoder decoder = charset.newDecoder();

New I/O 235
// Pattern used to parse lines
private static Pattern linePattern = Pattern.compile(".*\r?\n");
// The input pattern that we're looking for
private static Pattern pattern;
// Compile the pattern from the command line
private static void compile(String pat) {
}
applying
try {
pattern = Pattern.compile(pat);
} catch (PatternSyntaxException x) {
}
System.err.println(x.getMessage());
System.exit(1);
// Use the linePattern to break the given CharBuffer into lines,
// the input pattern to each line to see if we have a match
private static void grep(File f, CharBuffer cb) {
}
Matcher lm = linePattern.matcher(cb); // Line matcher
Matcher pm = null; // Pattern matcher
int lines = 0;
while (lm.find()) {
}
lines++;
CharSequence cs = lm.group(); // The current line
if (pm == null)
else
pm = pattern.matcher(cs);
pm.reset(cs);
if (pm.find())
System.out.print(f + ":" + lines + ":" + cs);
if (lm.end() == cb.limit())
break;
// Search for occurrences of the input pattern in the given file
private static void grep(File f) throws IOException {
// Open the file and then get a channel from the stream
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
// Get the file's size and then map it into memory
int sz = (int)fc.size();
MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0,

New I/O 236
sz);
}
}
// Decode the file into a char buffer
CharBuffer cb = decoder.decode(bb);
// Perform the search
grep(f, cb);
// Close the channel and the stream
fc.close();
public static void main(String[] args) {
}
if (args.length < 2) {
}
System.err.println("Usage: java Grep pattern file...");
return;
compile(args[0]);
for (int i = 1; i < args.length; i++) {
}
File f = new File(args[i]);
try {
grep(f);
} catch (IOException x) {
}
JDK 7 and NIO.2
System.err.println(f + ": " + x);
JDK 7 includes a java.nio.file package which, with the java.io.file.Path class (also new to JDK 7), among other
features, provides extended capabilities for filesystem tasks, e.g. can work with symbolic/hard links and dump big
directory listings into buffers more quickly than the old File class does.
External links
• Java SE 6 API Javadocs
• JDK 5.0 New I/O-related APIs & Developer Guides [4] - description of New I/O by Sun Microsystems
• JSR 51 [5] (NIO)
• JSR 203 [6] (NIO2)
• Architecture of a Highly Scalable NIO-Based Server [7] - discussion on Java NIO and patterns of usage

New I/O 237
References
[1] "JSR 51: New I/O APIs for the JavaTM Platform" (http:/ / www. jcp. org/ en/ jsr/ detail?id=51). The Java Community Process(SM) Program
- JSRs: Java Specification Requests. . Retrieved 2009-05-23.
[2] "This JSR will be delivered as part of Java SE 7 "Dolphin"." "JSR 203: More New I/O APIs for the JavaTM Platform ("NIO.2")" (http:/ /
www. jcp. org/ en/ jsr/ detail?id=203). The Java Community Process(SM) Program - JSRs: Java Specification Requests. 2006-01-30. .
Retrieved 2009-05-23.
[3] http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ guide/ nio/ example/ index. html
[4] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ nio/ index. html
[5] http:/ / www. jcp. org/ en/ jsr/ detail?id=51
[6] http:/ / www. jcp. org/ en/ jsr/ detail?id=203
[7] http:/ / today. java. net/ pub/ a/ today/ 2007/ 02/ 13/ architecture-of-highly-scalable-nio-server. html
Object type (object-oriented programming)
In computer science, an object type (a.k.a. wrapping object) is a datatype which is used in object-oriented
programming to wrap a non-object type to make it look like a dynamic object.
Some object-oriented programming languages make a distinction between reference and value types, often referred
to as objects and non-objects on platforms where complex value types don't exist, for reasons such as runtime
efficiency and syntax or semantic issues. For example, Java has primitive wrapper classes corresponding to each
primitive type: Integer and int, Character and char, Float and float, etc. Languages like C++ have little or no notion
of reference type; thus, the use of object type is of little interest.
Boxing
Boxing is the process of placing a primitive type within an object so that the primitive can be used as a reference
object. For example, lists may have certain methods which arrays might not, but the list might also require that all of
its members be dynamic objects. In this case, the added functionality of the list might be unavailable to a simple
array of numbers. For a more concrete example, in Java, a LinkedList can change its size, but an array must have a
fixed size. One might desire to have a LinkedList of ints, but the LinkedList class only lists references to dynamic
objects — it cannot list primitive types, which are value types.
To get around this, ints can be boxed into Integers, which are dynamic objects, and then added to a LinkedList of
Integers. (Using generic parameterized types introduced in J2SE 5.0, this type is represented as
LinkedList.) On the other hand, C# has no primitive wrapper classes, but allows boxing of any value type,
returning a generic Object reference.
The boxed object is always a copy of the value object, and is usually immutable. Unboxing the object also returns a
copy of the stored value. Note that repeated boxing and unboxing of objects can have a severe performance impact,
since it dynamically allocates new objects and then makes them eligible for Garbage collection.
Autoboxing
Autoboxing is the term for treating a value type as a reference type without any extra source code. The compiler
automatically supplies the extra code needed to perform the type conversion.
For example, J2SE 5.0 allows the programmer to create a LinkedList of ints. This does not contradict what was said
above: the LinkedList still only lists references to dynamic objects, and it cannot list primitive types. But now, when
Java expects a reference but receives a primitive type, it immediately converts that primitive type to a dynamic
object. Note that the declaration List is illegal in Java, but List is not, and autoboxing will allow
adding of primitive ints to the collection.
For example, in versions of Java prior to J2SE 5.0, the following code did not compile:

Object type (object-oriented programming) 238
Integer i = new Integer(9);
Integer j = new Integer(13);
int k = 9 + 13; // always OK
Integer l = i + j; // error in versions prior to 5.0!
Compilers prior to 5.0 would not accept the last line. Integers are reference objects, on the surface no different from
List, Object, and so forth; mathematical operators such as + were not meaningfully defined for references. As of
J2SE 5.0, the Integers i and j are unboxed into ints, the two are added, and then the sum is autoboxed into a new
Integer. [1]
Unboxing
Unboxing refers to a boxed value type which has been broken down and the value type retrieved for a process of
some kind such as a mathematical operation.
For example, in versions of Java prior to J2SE 5.0, the following code did not compile:
int i = 4;
int j = 5;
Integer k = new Integer(i + j); // always OK
Integer l = i + j; // would have been an error, but okay now -
equivalent to previous line
C# does not support automatic unboxing. A boxed object must be explicitly unboxed with a typecasting operator:
int i = 42;
object o = i; //box
int j = (int)o; //unbox
Console.Writeline(j); //outputs "42"
References
[1] java.sun.com Java language guide entry on autoboxing (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ autoboxing. html)

Omniscient Debugger 239
Omniscient Debugger
The Omniscient Debugger, or ODB for short, is a Java programming language debugger which lets users step
backwards in time. It allows this by keeping track of all changes to objects and variables made as a program runs. [1]
It is free open source software, released under the GPL license.
[1] Lewis, Bil (2003), "Debugging Backwards in Time" (http:/ / www. citebase. org/ abstract?id=oai:arXiv. org:cs/ 0310016), in Ronsse, M.; De
Bosschere, K., Proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003) (http:/ / arxiv. org/ abs/ cs. SE/
0309027), Ghent, September 2003,
External links
• ODB home page (http:/ / www. lambdacs. com/ debugger/ )
• Debugging Backwards in Time (http:/ / video. google. com/ videoplay?docid=3897010229726822034) video,
hosted by Google Video
• Dr. Dobb's Journal article about ODB (http:/ / www. ddj. com/ article/ printableArticle.
jhtml?articleID=184406101& dept_url=/ dept/ debug/ )
OpenJDK
Developer(s) Sun Microsystems
Initial release
Stable release
Written in C++ and Java
Operating
system
Type Library
openJDK6 Build b05 February 12, 2008 [1]
OpenJDK6 Build b20 [2] / June 21, 2010
Cross-platform
License GPL+linking exception
Website [3]
Developer(s) Sun Microsystems
Preview release
Written in C++ and Java
Operating
system
Type Library
OpenJDK7 Build b105 [4] / August 13,
2010
Cross-platform
License GPL+linking exception
Website [5]
OpenJDK (aka Open Java Development Kit) is a Free and open source implementation of the Java programming
language. It is the result of an effort Sun Microsystems began in 2006. The implementation is licensed under the
GNU General Public License (GPL) with a linking exception, which exempts components of the Java class library
from the GPL licensing terms.

OpenJDK 240
History
Sun's promise and initial release
Sun announced in JavaOne 2006 that Java would become open source software, [6] [7] and on October 25, 2006, at
the Oracle OpenWorld conference, Jonathan Schwartz said that the company was set to announce the open-sourcing
of the core Java Platform within 30 to 60 days.
Sun released the Java HotSpot virtual machine and compiler as free software under the GNU General Public License
on 13 November 2006, with a promise that the rest of the JDK (which includes the Java Runtime Environment)
would be placed under the GPL by March 2007, "except for a few components that Sun does not have the right to
publish in source form under the GPL". [8] According to computer scientist and Free software advocate Richard
Stallman, this would end the "Java trap", the Vendor lock-in that he argues applies to Java and programs written in
Java. [9] Software entrepreneur Mark Shuttleworth called the initial press announcement "A real milestone for the free
software community". [10]
Release of the class library
Following their promise to release a Java Development Kit (JDK) based almost completely on Free and open source
code in the first half of 2007 [11], Sun released the complete source code of the Java Class Library under the GPL on
May 8, 2007, except for some limited parts that some third parties licensed to Sun that rejected the terms of the
GPL. [12] Included in the list of encumbered parts were several major components of the Java Graphical User
Interface (GUI). Sun stated that it planned to replace the remaining proprietary and closed source components with
alternative implementations and to make the class library completely Free. [13]
Community improvements
On 2007-11-05, Red Hat announced an agreement with Sun, signing Sun's broad contributor agreement (which
covers participation in all Sun-led free and open source software projects by all Red Hat engineers) and Sun's
OpenJDK Community TCK License Agreement (which gives the company access to the test suite that determines
whether a project based on openJDK complies with the Java SE 6 specification). [14]
Also on November 2007, the porters group was created on OpenJDK [15] to aid in efforts to port OpenJDK to
different processor architectures and operating systems. The BSD porting projects [16], led by Kurt Miller and Greg
Lewis and the Mac OS X porting project (based on the BSD one) SoyLatte [17] led by Landon Fuller [18] have
expressed interest in joining OpenJDK via the porters group and as of January 2008 are part of the mailing list
discussions. Another project pending formalization on the porters group is the Haiku Java Team, led by Bryan
Varner. [19]
On December 2007, Sun moved the revision control of OpenJDK from TeamWare to Mercurial, as part of the
[20] [21]
process of releasing it to open source communities.
OpenJDK has comparatively strict procedures of accepting code contributions: every proposed contribution must be
reviewed by two of Sun's engineers and have the automatic test demonstrating that feature has been fixed. [22]
However, although initially the fixes proposed by the community were committed by Sun in the codebase,
September 2008 saw the first (significant) patches directly committed by a non-Sun or ex-Sun employee. [23]

OpenJDK 241
Inclusion in software distributions
As of May 2008, the Fedora 9 [24] [25] and Ubuntu 8.04 [26] distributions were released with OpenJDK, based
completely on free and open source code. [27]
In June 2008, it was announced that IcedTea 6 (as the packaged version of OpenJDK on Fedora 9) has passed the
Technology Compatibility Kit tests and can claim to be a fully compatible Java 6 implementation. [28]
On July 12, 2008, Debian accepted OpenJDK-6 in unstable [29] [30] , and it is now in stable [31] . OpenJDK is also
available on openSUSE [32] , and also Red Hat Enterprise Linux and its derivatives such as CentOS [33] .
Since August 2008, OpenJDK 7 is runnable on Mac OS X and other BSD distributions. [34]
In July 2009, OpenJDK binary build for Ubuntu 9.04 passed all of the compatibility tests in the Java SE 6 JCK. [35]
Status
Supported JDK versions
OpenJDK was initially based only on the JDK 7.0 version of the Java platform. [36]
Since February 15, 2008, there are two separate OpenJDK projects:
• The main OpenJDK [9] project, which is based on the JDK 7.0 version of the Java platform,
• The JDK 6 [3] project, which provides an Open-source version of Java 6.0. [37]
Compiler and Virtual Machine
Sun's Java compiler, javac, and HotSpot (the virtual machine), are now under a GPL license.
Class library
As of May 2008, the only part of the Class library that remains proprietary and closed-source (4% as of May 2007
for OpenJDK 7 [38] , and less than 1% as of May 2008 and OpenJDK 6 [24] ) is [39] [40] the SNMP implementation [40] .
Since the first May 2007 release, Sun Microsystems, with the help of the community, has released as free and
open-source software or replaced with free and open-source alternatives almost all the encumbered code:
• All the audio engine code, including the software synthesizer, has been released as Open-source. [40] [41] The
closed-source software synthesizer has been replaced by a new synthesizer developed specifically for OpenJDK
called Gervill [42] ,
• All cryptography classes used in the Class library have been released as Open-source [43] ,
[44] [45] [46]
• The code that scales and rasterizes fonts has been replaced by FreeType
• The native color management system has been replaced by LittleCMS. [45] There is a pluggable layer in the JDK,
so that the commercial version can use the old color management system and OpenJDK can use LittleCMS.
• The anti-aliasing graphics rasterizer code has been replaced by the Open-sourced Pisces renderer used in the
phoneME project. [45] [47] [48] This code is fully functional, but still needs some performance enhancements [49] ,
• The JavaScript plugin has been open-sourced (the Rhino JavaScript engine itself was open-sourced from the
beginning). [50]

OpenJDK 242
IcedTea
Because of the encumbered components in the Class library, it was not possible to build OpenJDK only with free
software components. In order to be able to do this before the whole class library is made free, and to be able to
bundle OpenJDK in Fedora and other free Linux distributions, a project called IcedTea has been started by Red Hat.
It is basically an OpenJDK/GNU Classpath hybrid that can be used to bootstrap OpenJDK using only free
[51] [52]
software.
IcedTea is a software development and integration project launched by Red Hat in June 2007. [53] The goal is to make
the OpenJDK software which Sun Microsystems released as free software in 2007 usable without requiring any other
software that is not free software. For Red Hat, this would make it possible to add OpenJDK to the Fedora Linux
distribution, as well as other distributions.
On November 5, 2007, Red Hat has signed both the Sun Contributor Agreement and the OpenJDK Community TCK
License. [54] One of the first benefits of this agreement is tighter alignment with the IcedTea project, which brings
together Fedora, the Linux distribution, and JBoss, the application server, technologies in a Linux environment.
IcedTea is providing free software alternatives for the few remaining proprietary sections in the OpenJDK project.
Fedora 9 was the first version to ship with IcedTea6, based on the OpenJDK6 sources from Sun rather than
OpenJDK7. It was also the first to use OpenJDK for the package name (via the OpenJDK trademark agreement [55] )
instead of IcedTea. [24]
Ubuntu also first packaged IcedTea7 [56] before later moving to IcedTea6. Packages for IcedTea6 were also created
for Debian and included in lenny.
See also
• javac, Sun's java compiler, now under a GPL license
• HotSpot, Sun's Virtual Machine, now under a GPL license
• Java Class Library
• Free Java implementations
• Java Platform, Standard Edition
• Apache Harmony
External links
• Main site [9]
• OpenJDK FAQ [57]
• OpenJDK - The First Year [58] by Mark Reinhold
References
[1] http:/ / download. java. net/ openjdk/ jdk6/ promoted/ b05/
[2] http:/ / download. java. net/ openjdk/ jdk6/
[3] http:/ / openjdk. java. net/ projects/ jdk6/
[4] http:/ / download. java. net/ openjdk/ jdk7/
[5] http:/ / openjdk. java. net/ projects/ jdk7/
[6] Schwartz, Jonathan (23 May 2006). "Busy Week..." (http:/ / blogs. sun. com/ roller/ page/ jonathan/ 200605#busy_week1). Sun
Microsystems. . Retrieved 2007-05-09.
[7] "Sun Opens Java" (http:/ / mediacast. sun. com/ share/ tmarble/ Sun_Opens_Java. ogg) (OGG Theora). Sun Microsystems. .
[8] "Sun Opens Java" (http:/ / www. sun. com/ 2006-1113/ feature/ index. jsp). Sun Microsystems. 13 November 2006. . Retrieved 2007-05-09.
[9] Stallman, Richard. "Free But Shackled—The Java Trap" (http:/ / www. gnu. org/ philosophy/ java-trap. html). . Retrieved 2007-12-04.
[10] "Sun 'releases' Java to the world" (http:/ / news. bbc. co. uk/ 1/ hi/ technology/ 6144748. stm). BBC News. 13 November 2006. . Retrieved
2007-05-09.
[11] http:/ / www. sun. com/ software/ opensource/ java/ faq. jsp#b4

OpenJDK 243
[12] "Open JDK is here!" (http:/ / mail. openjdk. java. net/ pipermail/ announce/ 2007-May. txt). Sun Microsystems. 8 May 2007. . Retrieved
2007-05-09.
[13] Some encumbered code remains in the JDK; Sun stated that it will continue to use such code in commercial releases until fully functional
free and open source alternatives replace it.
[14] Broad contributor agreement and TCK License pave way for a fully compatible, free and open source Java Development Kit for Red Hat
Enterprise Linux (http:/ / www. businesswire. com/ portal/ site/ google/ index. jsp?ndmViewId=news_view& newsId=20071105005882&
newsLang=en)
[15] Porters Group (http:/ / openjdk. java. net/ groups/ porters/ )
[16] http:/ / www. eyesbeyond. com/ freebsddom/ java/ jdk16. html
[17] http:/ / landonf. bikemonkey. org/ static/ soylatte
[18] http:/ / landonf. bikemonkey. org/ code/ macosx/
[19] New java for haiku team formed (http:/ / haiku-os. org/ news/ 2008-01-03/ new_java_for_haiku_team_formed)
[20] James Gosling. Interview with Robert Eckstein. James Gosling on Open Sourcing Sun's Java Platform Implementations, Part 1 (http:/ / java.
sun. com/ developer/ technicalArticles/ Interviews/ gosling_os1_qa. html). October 2006.
[21] O'Hair, Kelly (2007-12-12). "Mercurial OpenJDK Questions" (http:/ / blogs. sun. com/ kto/ entry/ mercurial_openjdk_questions). .
[22] Tripp, Andy (2007-07-16). "Classpath hackers frustrated with slow OpenJDK process" (http:/ / www. javalobby. org/ java/ forums/ t98834.
html). . Retrieved 2008-04-20.
[23] Kennke, Roman (2008-09-29). "A small step for me" (http:/ / kennke. org/ blog/ 2008/ 09/ 29/ a-small-step-for-me/ ). . Retrieved
2008-10-19.
[24] Wade, Karsten (2008-03-13). "OpenJDK in Fedora 9!" (http:/ / developer. redhatmagazine. com/ 2008/ 03/ 12/
openjdk-to-replace-icedtea-in-fedora-9/ ). redhatmagazine.com. . Retrieved 2008-04-05. "Thomas Fitzsimmons updated the Fedora 9 release
notes source pages to reflect that Fedora 9 would ship with OpenJDK 6 instead of the IcedTea implementation of OpenJDK 7. Fedora 9
(Sulphur) is due to release in May 2008."
[25] "Open Source Java Technology Debuts In GNU/Linux Distributions" (http:/ / www. sun. com/ aboutsun/ pr/ 2008-04/ sunflash. 20080430.
1. xml). Sun Microsystems. . Retrieved 2008-05-02.
[26] "openjdk-6 in Ubuntu" (https:/ / launchpad. net/ ubuntu/ + source/ openjdk-6). . Retrieved 2008-04-19.
[27] Reinhold, Mark (2008-04-24). "There’s not a moment to lose!" (http:/ / blogs. sun. com/ mr/ entry/ in_hardy_heron). . Retrieved 2008-04-19.
[28] Sharples, Rich (2008-06-19). "Java is finally Free and Open" (http:/ / blog. softwhere. org/ archives/ 196). .
[29] Topic, Dalibor (2008-07-14). "QotD: Debian Overview of openjdk-6 source package" (http:/ / robilad. livejournal. com/ 33750. html). .
Retrieved 2008-07-15.
[30] "Overview of openjdk-6 source package" (http:/ / packages. qa. debian. org/ o/ openjdk-6. html). debian.org. . Retrieved 2008-07-15.
[31] "Package: openjdk-6-jdk" (http:/ / packages. debian. org/ stable/ openjdk-6-jdk). debian.org. 2009-02-14. . Retrieved 2009-02-16.
[32] "Package: OpenJDK" (http:/ / en. opensuse. org/ OpenJDK). opensuse.org. . Retrieved 2009-06-01.
[33] "How to download and install prebuilt OpenJDK packages" (http:/ / openjdk. java. net/ install/ #epel). . Retrieved 2010-03-03.
[34] Fuller, Landon (2008-08-19). "SoyLatte, Meet OpenJDK: OpenJDK 7 for Mac OS X" (http:/ / landonf. bikemonkey. org/ code/ java/
SoyLatte_Meets_OpenJDK. 20080819. html). . Retrieved 2008-08-22.
[35] Announcing OpenJDK 6 Certification for Ubuntu 9.04 (jaunty) (https:/ / lists. ubuntu. com/ archives/ ubuntu-devel-announce/ 2009-July/
000587. html)
[36] "Didn't you promise to open source both JDK 6 and JDK 7 last November? What happened to JDK 6?" (http:/ / www. sun. com/ software/
opensource/ java/ faq. jsp#b10). Sun Microsystems. . Retrieved 2007-10-14. "Sun did make that promise, and we plan to keep it. But in the six
months since the November 2006 announcement, it has become clear that doing this is far more complex than just changing the license and
publishing the source code."
[37] Darcy, Joe (2008-02-11). "The code is coming! The code is coming!" (http:/ / mail. openjdk. java. net/ pipermail/ jdk6-dev/ 2008-February/
000001. html). . Retrieved 2008-02-16. "At Sun we're making final preparations for the first source release for the OpenJDK 6 project. We
plan to release a tarball of the source, along with matching binary plugs, by February 15, 2008."
[38] Fitzsimmons, Thomas (2007-05-18). "Plans for OpenJDK" (http:/ / fitzsim. org/ blog/ ?p=17). . Retrieved 2007-05-22.
[39] Herron, David (2007-10-04). "Plans for OpenJDK" (http:/ / weblogs. java. net/ blog/ robogeek/ archive/ 2007/ 10/ openjdk_encumbr. html). .
Retrieved 2007-10-09.
[40] "OpenJDK 6 b10 source posted" (http:/ / mail. openjdk. java. net/ pipermail/ jdk6-dev/ 2008-May/ 000058. html). 2008-05-30. . Retrieved
2008-06-01.
[41] audio-engine project page (http:/ / openjdk. java. net/ projects/ audio-engine/ )
[42] "Gervill - Software Synthesizer" (https:/ / gervill. dev. java. net/ ). . Retrieved 2008-06-01.
[43] "Crypto has been added to OpenJDK" (http:/ / mail. openjdk. java. net/ pipermail/ security-dev/ 2007-September/ 000015. html).
2007-09-27. . Retrieved 2007-10-07.
[44] font-scaler projectpage (http:/ / openjdk. java. net/ projects/ font-scaler/ )
[45] Java2D project page (http:/ / openjdk. java. net/ groups/ 2d/ )
[46] "Freetype font rasteriser" (http:/ / mail. openjdk. java. net/ pipermail/ font-scaler-dev/ 2007-August/ 000011. html). 2007-08-07. . Retrieved
2007-11-24.
[47] phoneme.dev.java.net/ (https:/ / phoneme. dev. java. net/ )

OpenJDK 244
[48] graphics-rasterizer project page (http:/ / openjdk. java. net/ projects/ graphics-rasterizer/ )
[49] Graham, Jim (2007-10-03). "Open Source rasterizer" (http:/ / mail. openjdk. java. net/ pipermail/ 2d-dev/ 2007-October/ 000078. html). Sun
Microsystems. . Retrieved 2007-05-09.
[50] "Javascript is encumbered and there is no javascript plugin support." (http:/ / icedtea. classpath. org/ bugzilla/ show_bug. cgi?id=85).
IcedTea. 2008-03-11. . Retrieved 2008-06-01. "Changing Summary. JavaScript is no longer encumbered, but we still need liveconnect
support."
[51] Andrew, Haley (2007-06-07). "Experimental Build Repository at icedtea.classpath.org" (http:/ / article. gmane. org/ gmane. comp. java.
openjdk. distro-packaging. devel/ 5). . Retrieved 2007-06-09.
[52] Mark, Wielaard (2007-06-07). "Experimental Build Repository at icedtea.classpath.org" (http:/ / developer. classpath. org/ pipermail/
classpath/ 2007-June/ 002109. html). . Retrieved 2007-06-09.
[53] Fitzsimmons, Thomas (2007-06-08). "Credits" (http:/ / mail. openjdk. java. net/ pipermail/ distro-pkg-dev/ 2007-June/ 000032. html). .
Retrieved 2007-06-08.
[54] "Red Hat and Sun Collaborate to Advance Open Source Java Technology" (http:/ / home. businesswire. com/ portal/ site/ google/ index.
jsp?ndmViewId=news_view& newsId=20071105005882& newsLang=en). Red Hat. 2007-11-05. . Retrieved 2007-11-06.
[55] http:/ / openjdk. java. net/ legal/ openjdk-trademark-notice. html
[56] "icedtea-java7 in Ubuntu" (https:/ / launchpad. net/ ubuntu/ + source/ icedtea-java7). . Retrieved 2008-04-19.
[57] http:/ / www. sun. com/ software/ opensource/ java/ faq. jsp
[58] http:/ / parleys. com/ display/ PARLEYS/ OpenJDK+ -+ The+ First+ Year?showComments=true
PHP/Java Bridge
There are three well known implementations of the PHP scripting language:
• The original implementation of PHP and the de facto standard is the open source PHP distribution.
• Project Zero has a PHP runtime written in Java. It also distributes extensions from the open source
implementation of PHP.
• Quercus is an open-source pure Java implementation of the PHP scripting language.
To bridge between PHP scripts and Java libraries all three implementations provide a PHP/Java bridge.
The de facto implementation of PHP has a PHP/Java Bridge separately available from SourceForge. This uses a dual
process model where the Java libraries are run in a separate process from the PHP runtime. Interactions with Java
objects are marshalled across to the Java process using an XML [1] protocol.
Quercus and Project Zero implement PHP on top of the Java Virtual Machine and so can run the Java libraries in the
same process as the PHP runtime. This reduces the overhead of interacting with Java libraries when compared with
the dual process model.
See also
• Quercus (software)
External links
• Open source PHP homepage [2]
• SourceForge PHP/Java Bridge homepage [3]
• Project Zero homepage [4]
• Quercus homepage [5]

PHP/Java Bridge 245
References
[1] http:/ / php-java-bridge. sourceforge. net/ pjb/ PROTOCOL. TXT
[2] http:/ / www. php. net/
[3] http:/ / php-java-bridge. sourceforge. net/
[4] http:/ / www. projectzero. org/ documentation/
[5] http:/ / quercus. caucho. com/
Java package
A Java package is a mechanism for organizing Java classes into namespaces similar to the modules of Modula. Java
packages can be stored in compressed files called JAR files, allowing classes to download faster as a group rather
than one at a time. Programmers also typically use packages to organize classes belonging to the same category or
providing similar functionality.
• A package provides a unique namespace for the types it contains.
• Classes in the same package can access each other's package-access members.
Overview
In general, a package can contain the following kinds of types.
• Classes
• Interfaces
• Enumerated types
• Annotations
Using packages
In a Java source file, the package that this file's class or classes belong to is specified with the package keyword. This
keyword is usually the first keyword in source file. [1]
package java.awt.event;
To use a package's classes inside a Java source file, it is convenient to import the classes from the package with an
import declaration. The following declaration
import java.awt.event.*;
imports all classes from the java.awt.event package, while the next declaration
import java.awt.event.ActionEvent;
imports only the ActionEvent class from the package. After either of these import declarations, the ActionEvent
class can be referenced using its simple class name:
ActionEvent myEvent = new ActionEvent();
Classes can also be used directly without an import declaration by using the fully-qualified name of the class. For
example,
java.awt.event.ActionEvent myEvent = new java.awt.event.ActionEvent();
does not require a preceding import declaration.
[2] [3]
Note that if you do not use a package declaration, your class ends up in an unnamed package.

Java package 246
Package access protection
Classes within a package can access classes and members declared with default access and class members declared
with the protected access modifier. Default access is enforced when neither the public, protected nor private access
modifier is specified in the declaration. By contrast, classes in other packages cannot access classes and members
declared with default access. Class members declared as protected can be accessed from the classes in the same
package as well as classes in other packages that are subclasses of the declaring class.
Creation of JAR files
JAR Files are created with the jar command-line utility. The command
jar cf myPackage.jar *.class
compresses all .class files into the JAR file myPackage.jar. The ' c ' option on the command line tells the jar
command to "create new archive." The ' f ' option tells it to create a file. The file's name comes next before the
contents of the JAR file.
Package naming conventions
Packages are usually defined using a hierarchical naming pattern, with levels in the hierarchy separated by periods (.)
(pronounced "dot"). Although packages lower in the naming hierarchy are often referred to as "subpackages" of the
corresponding packages higher in the hierarchy, there is no semantic relationship between packages. The Java
Language Specification establishes package naming conventions to avoid the possibility of two published packages
having the same name. The naming conventions describe how to create unique package names, so that packages that
are widely distributed will have unique namespaces. This allows packages to be separately, easily and automatically
installed and catalogued.
In general, a package name begins with the top level domain name of the organization and then the organization's
domain and then any subdomains listed in reverse order. The organization can then choose a specific name for their
package. Package names should be all lowercase characters whenever possible.
For example, if an organization in Canada called MySoft creates a package to deal with fractions, naming the
package ca.mysoft.fractions distinguishes the fractions package from another similar package created by
another company. If a US company named MySoft also creates a fractions package, but names it
us.mysoft.fractions, then the classes in these two packages are defined in a unique and separate namespace.
Complete conventions for disambiguating package names and rules for naming packages when the Internet domain
name cannot be directly used as a package name are described in section 7.7 of the Java Language Specification.
Core packages in Java SE 6

Java package 247
External links
java.lang — basic language functionality and fundamental types
java.util — collection data structure classes
java.io — file operations
java.math — multiprecision arithmetics
java.nio — the New I/O framework for Java
java.net — networking operations, sockets, DNS lookups, ...
java.security — key generation, encryption and decryption
java.sql — Java Database Connectivity (JDBC) to access databases
java.awt — basic hierarchy of packages for native GUI components
javax.swing — hierarchy of packages for platform-independent rich GUI components
java.applet — classes for creating and implementing applets
• Java SE 6 API Javadocs
• Java Language Specification, 3rd Edition, Chapter 7: Packages [4]
• Code Conventions for the Java Programming Language, Chapter 9: Naming conventions [5] (mentions packages)
• Sun's "Java Tutorials" Lesson: Packages [6]
References
[1] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ package/ managingfiles. html
[2] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ package/ createpkgs. html
[3] http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ packages. doc. html#26639
[4] http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ packages. html
[5] http:/ / java. sun. com/ docs/ codeconv/ html/ CodeConventions. doc8. html
[6] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ package/ index. html

Parboiled (Java) 248
Parboiled (Java)
Developer(s) Mathias Doenitz
Initial release November 12, 2009
Development status Active
Written in Java
Operating system Cross-platform
License Apache License 2.0
Website http:/ / www. parboiled. org/
parboiled is an open-source Java library released under an Apache License. It provides support for defining PEG
parsers directly in Java source code.
parboiled is commonly used as an alternative for regular expressions or parser generators (like ANTLR or JavaCC),
especially for smaller and medium-size applications.
Apart from providing the constructs for grammar definition parboiled implements a complete recursive descent
parser with support for abstract syntax tree construction, parse error reporting and parse error recovery.
Example
Since parsing with parboiled does not require a separate lexing phase and there is no special syntax to learn for
grammar definition parboiled makes it comparatively easy to build custom parsers quickly.
Consider this the following classic “calculator” example, with these rules in a simple pseudo notation
Expression ← Term ((‘+’ / ‘-’) Term)*
Term ← Factor (('*' / '/') Factor)*
Factor ← Number / '(' Expression ')'
Number ← [0-9]+
With parboiled this rule description can be translated directly into the following Java code:
import org.parboiled.BaseParser;
public class CalculatorParser extends BaseParser {
public Rule expression() {
}
return sequence(
);
term(),
zeroOrMore(
public Rule term() {
)
sequence(
)
firstOf('+', '-'),
term()

Parboiled (Java) 249
}
}
return sequence(
);
factor(),
zeroOrMore(
public Rule factor() {
}
)
return firstOf(
);
sequence(
)
number(),
public Rule number() {
}
firstOf('*', '/'),
factor()
sequence('(', expression(), ')')
return oneOrMore(charRange('0', '9'));
The class defines the parser rules for the language (yet without any actions), which could be used to parse actual
input with code such as this:
String input = "1+2";
CalculatorParser parser =
Parboiled.createParser(CalculatorParser.class);
ParsingResult result = ReportingParseRunner.run(parser.expression(),
input);
String parseTreePrintOut = ParseTreeUtils.printNodeTree(result);
System.out.println(parseTreePrintOut);
See also
• Parsing expression grammars
• Regular expressions
• ANTLR
• JavaCC
External links
• Official parboiled web site [1]
• Example of a complete Java 5 parser written with parboiled [2]

Parboiled (Java) 250
References
[1] http:/ / www. parboiled. org/
[2] http:/ / github. com/ sirthias/ parboiled/ blob/ master/ examples/ org/ parboiled/ examples/ java/ JavaParser. java
Plain Old Java Object
In computing software, POJO is an acronym for Plain Old Java Object. The name is used to emphasize that a
given object is an ordinary Java Object, not a special object, and in particular not an Enterprise JavaBean. The term
was coined by Martin Fowler, Rebecca Parsons and Josh MacKenzie in September 2000:
"We wondered why people were so against using regular objects in their systems and concluded that it
was because simple objects lacked a fancy name. So we gave them one, and it's caught on very
nicely." [1]
The term "POJO" is mainly used to denote a Java object which does not follow any of the major Java object models,
conventions, or frameworks such as EJB. The term continues the pattern of older terms for technologies that do not
use fancy new features, such as POTS (Plain Old Telephone Service) in telephony, and PODS (Plain Old Data
Structures) that are defined in C++ but use only C language features, and POD (Plain Old Documentation) in Perl.
The equivalent to POJO on the .NET framework is Plain Old CLR Object.
Contextual variations
The POJO phenomenon has most likely gained widespread acceptance because of the need for a common and easily
understood term that contrasts with complicated object frameworks. A JavaBean is a POJO that is serializable, has a
no-argument constructor, and allows access to properties using getter and setter methods. An Enterprise JavaBean is
not a single class but an entire component model (again, EJB 3 reduces the complexity of Enterprise JavaBeans). As
designs using POJOs have become more commonly-used, systems have arisen that give POJOs some of the
functionality used in frameworks and more choice about which areas of functionality are actually needed. Hibernate
and Spring are examples.
Ideally speaking, a POJO is a Java object not bound by any restriction other than those forced by the Java Language
Specification. I.e., a POJO should not have to
1. Extend prespecified classes, as in
public class Foo extends javax.servlet.http.HttpServlet { ...
2. Implement prespecified interfaces, as in
public class Bar implements javax.ejb.EntityBean { ...
3. Contain prespecified annotations, as in
@javax.ejb.Entity public class Baz{ ...
However, due to technical difficulties and other reasons, many software products or frameworks described as
POJO-compliant actually still require the use of prespecified annotations for features such as persistence to work
properly.

Plain Old Java Object 251
POJO generation projects
Prevayler [2]
an open source system prevalence layer that transparently persists POJOs.
BeanExaminer [3]
framework to present any java objects in an interactive surface to browse and edit them. A generator is
included to create the desired pojo's through a given db connection.
Roma Meta Framework [4]
DDD centric framework. The innovative holistic approach lets the designer/developer to view anything as a
POJO: GUI, I18N, Persistence, etc.
OpenXava [5]
Framework to develop J2EE business applications rapidly and easily. It's based in business components
defined with XML. Feature rich and flexible since it's used for years to create business applications. Generates
POJO Hibernate EJB2 and EJB3 JPA ...
PlainXML [6]
PAT [7]
Generating POJO by DTD; XML-POJO mapping via Java5 annotations or DTD; XML manipulations using
POJO without SAX/DOM; Preprocessing of XML documents using expression language; Binary XML; RMI
friendly XML; Exporting to JSON; XML marshall/unmarshall ...
AOP (JBossAOP) persistence library (aspect library). Provides persistence layer with underlying Prevayler
(1.02). Allows users to write their code without worrying about persistence code (POJO). Uses annotations.
Java O/RM [8]
This is a Java Object Relational mapping tool that is very simple to use. It works with all major databases and
requires only minimal coding effort. JOR strictly follows the POJO / POJI (Plain Old Java Objects / Plain Old
Java Interfaces) model.
AutoPersistJ [9]
This project aims to assist developers in developing java EE persistence layer for existing database tables. It
gets metadata of selected database tables and generates classes for them. it uses and extends the ideas of
DbGen project to EJB 3.0 POJO.
PojoGen [10]
Pojodbc [11]
It is a small tool to generate Java Code (a POJO) for an APPFUSE-based project from a DDL file, which is
created from an ER diagram by Microsoft VISIO. It makes an APPFUSE-based project more easy to use.
An easy-to-use Java Object Relation mapping library without configurations file or annotations. Built on top
of JDBC, you still use your optimized native SQL and get POJOs.
Apache Felix iPOJO [12]
A new type of dynamic service-oriented component runtime that runs pure POJO applications on the top of
OSGi platforms. Non-functional (extra-functional) services can be added and removed at runtime.
JBoss Microcontainer [13]
The JBoss Microcontainer is a refactoring of JBoss's JMX Microkernel to support direct POJO deployment
and standalone use outside the JBoss application server.
Naked Objects [14]

Plain Old Java Object 252
An open source framework that auto-creates an object-oriented user interface from POJOs using the naked
objects pattern.
Metawidget [15]
A 'smart User Interface widget' that populates itself, at runtime, with UI components to match the properties of
POJOs.
fbDaoGenerator [16]
Fbdaogenerator connects to a Firebird Database, reads the metadata of the Database by querying the
system-tables, and generates POJOs and Data Access Objects.
Pojo Testing Projects
• OpenPojo [17] a pluggable testing framework
See also
• Data Transfer Object
• Anemic Domain Model
References
[1] MF Bliki: POJO (http:/ / www. martinfowler. com/ bliki/ POJO. html) from MartinFowler.com
[2] http:/ / prevayler. org
[3] https:/ / sourceforge. net/ projects/ beanexaminer
[4] http:/ / www. romaframework. org
[5] http:/ / sourceforge. net/ projects/ openxava
[6] http:/ / sourceforge. net/ projects/ plainxml
[7] http:/ / sourceforge. net/ projects/ patsystem
[8] http:/ / sourceforge. net/ projects/ jor
[9] http:/ / sourceforge. net/ projects/ auto-persist-j
[10] http:/ / sourceforge. net/ projects/ pojogen
[11] http:/ / sourceforge. net/ projects/ pojodbc
[12] http:/ / cwiki. apache. org/ FELIX/ ipojo. html
[13] http:/ / labs. jboss. com/ jbossmc/
[14] http:/ / www. nakedobjects. org/ home/ index. shtml
[15] http:/ / www. metawidget. org
[16] http:/ / code. google. com/ p/ fbdaogenerator
[17] http:/ / code. google. com/ p/ openpojo

Pluggable look and feel 253
Pluggable look and feel
Pluggable look and feel is a mechanism used in the Java Swing widget toolkit allowing to change the look and feel
of the graphical user interface at runtime.
Swing allows an application to specialize the look and feel of widgets, by modifying the default (via runtime
parameters), deriving from an existing one, by creating one from scratch, or, beginning with J2SE 5.0, by using the
skinnable synth look and feel, which is configured with an XML property file. The look and feel can be changed at
runtime.
Architecture
The corresponding API includes:
• Hooks in Swing widgets to interact with their look and feel. Each widget defined in Swing can delegate its
"painting" to its associated user interface classes called UI delegates.
• An API to manage existing look and feel definitions. This API allow to set the look and feel or switch from look
and feels at runtime.
• Another API to define a specific look and feel, or derive a look and feel from an existing one.
Examples of look and feels
Platform look and feels
The Java platform comes with several bundled look and feels [1] :
• A default cross-platform look and feel, called Metal (see MetalLookAndFeel). This look and feel comes with
several themes:
• The DefaultMetalTheme, which was historically the first Swing default theme.
• The smoother OceanTheme, which became the default theme for Java 5.0.
• Other cross-platform look and feels:
• A skinnable look and feel called synth (see synth), which is configured with an XML property file.
• The Nimbus look and feel (based on synth), which is added for the Java SE 6 Update 10 [2] [3] .
• Platform dependent look and feels [4] : Look and feels that aim to be the closest as possible to the platform native
GUI. The fidelity to the native look and feel theming has been improved in recent Java versions by leveraging the
[5] [6]
platform native GUI theming library when possible
• A Windows look and feel (this look and feel depends on the version of the Windows Operating System),
• A Motif or GTK+ (for newer distributions) look and feel on Linux or Solaris,
• A specific vendor look and feel for IBM AIX, HP-UX, and Mac OS X.

Pluggable look and feel 254
Third-party look and feels
Numerous other look and feels have been developed by third parties, such as:
• Substance [4] , a skinnable look and feel,
• Napkin [7] , which can be used to make GUI work look provisional,
• Synthetica [8] , which is based on synth,
• Liquid [9] , which aim to look like the Liquid theme for KDE,
• JGoodies [10] Windows and plastic look and feels.
See also
• Look and feel
• Swing
External links
• a list of Java look and feels [11]
• Sun's tutorial overview of the pluggable look and feel mechanism [12]
• Swing pluggable look and feel architecture [13]
• Sun's tutorial on setting the look and feel in Java [14]
References
[1] "Java Tutorials: Available Look and Feels" (http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ lookandfeel/ plaf. html#available). Sun
Microsystems. 2008-02-14. . Retrieved 2008-05-25.
[2] Potts, Jasper (2007-12-07). "Nimbus Category" (http:/ / www. jasperpotts. com/ blog/ category/ nimbus/ ). . Retrieved 2008-05-25.
[3] "Nimbus" (http:/ / java. sun. com/ javase/ downloads/ ea/ 6u10/ nimbus. jsp). Sun Microsystems. . Retrieved 2008-05-25.
[4] "Available Look and Feels" (http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ lookandfeel/ plaf. html#available). Sun Microsystems. .
Retrieved 2008-05-25.
[5] "GTK Native L&F Fidelity" (http:/ / bugs. sun. com/ bugdatabase/ view_bug. do?bug_id=6185456). Sun Microsystems. . Retrieved
2008-05-25.
[6] "XP L&F does not work on Windows Vista (Longhorn) - needs to use uxtheme api" (http:/ / bugs. sun. com/ bugdatabase/ view_bug.
do?bug_id=5106661). Sun Microsystems. . Retrieved 2008-05-25.
[7] http:/ / napkinlaf. sourceforge. net/
[8] http:/ / www. javasoft. de/ jsf/ public/ products/ synthetica
[9] https:/ / liquidlnf. dev. java. net/
[10] http:/ / www. jgoodies. com/ freeware/ looks/ index. html
[11] http:/ / www. java2s. com/ Product/ Java/ Swing/ Look-And-Feel-LaF. htm
[12] http:/ / java. sun. com/ docs/ books/ tutorial/ ui/ features/ plaf. html
[13] http:/ / java. sun. com/ products/ jfc/ tsc/ articles/ architecture/ index. html#pluggable
[14] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ lookandfeel/ plaf. html

Primitive wrapper class 255
Primitive wrapper class
A primitive wrapper class in the Java programming language is one of eight classes provided in the java.lang
package to provide object methods for the eight primitive types. All of the primitive wrapper classes in Java are
immutable. J2SE 5.0 introduced autoboxing of primitive types into their wrapper object, and automatic unboxing of
the wrapper objects into their primitive value—the implicit conversion between the wrapper objects and primitive
values.
Wrapper classes are used to represent primitive values when an Object is required. The wrapper classes are used
extensively with Collection classes in the java.util package and with the classes in the java.lang.reflect reflection
package.
The primitive wrapper classes and their corresponding primitive types are:
Primitive type Wrapper class Constructor
Arguments
byte Byte byte or String
short Short short or String
int Integer int or String
long Long long or String
float Float float, double or String
double Double double or String
char Character char
boolean Boolean boolean or String
The Byte, Short, Integer, Long, Float, and Double wrapper classes are all subclasses of the Number class.
Void
Although it is not a wrapper class, the Void class is similar in that it provides an object representation of the void
return type. The Void class is an uninstantiable placeholder class used by the java.lang.reflect API to hold a
reference to the Class object representing the Java keyword void..
Atomic wrapper classes
With Java 5.0, additional wrapper classes were introduced in the java.util.concurrent.atomic package. These classes
are mutable and cannot be used as a replacement for the regular wrapper classes. Instead, they provide atomic
operations for addition, increment and assignment.
The atomic wrapper classes and their corresponding types are:

Primitive wrapper class 256
Primitive type Wrapper class
int AtomicInteger
long AtomicLong
boolean AtomicBoolean
V AtomicReference
The AtomicInteger and AtomicLong classes are subclasses of the Number class. The AtomicReference class accepts
the type parameter V that specifies the type of the object reference. (See "Generics in Java" for a description of type
parameters in Java).
See also
• java.lang
• java.lang.reflect
• Java programming language
• Java syntax
Project Semplice
Ģ Project Semplice is a project announced at the 2006 JavaOne conference to develop tools to allow Visual Basic
6.0 source code to be compiled into Java applications.
What the project does is develop a script engine for BASIC, which would then be interpreted by the Java Virtual
Machine.
As to this point, the project is still being developed and that it is not yet available to the public. Although, IDEs like
NetBeans is already available for Java Developers, the capability of Visual Basic's Rapid Application Development
is also to be developed.
The project's main goal is to provide VB6 Developer's a free solution of building Web/Desktop Application which
would be system independent.
UPDATE: This project appears to be dead at the moment. 2 of its 3 main developers have left Sun* [1] . No code has
been publicly released.
External links
• Project Semplice on Herbert Czymontek's blog [2]
• Project Semplice on Tor Norbye's blog [3]
• JavaOne Project Semplice presentation [4]
References
[1] http:/ / blogs. sun. com/ tor/ entry/ semplice_update
[2] http:/ / blogs. sun. com/ herbertc/ entry/ project_semplice_visual_basic_for
[3] http:/ / blogs. sun. com/ tor/ entry/ semplice_keynote_demo
[4] https:/ / www28. cplan. com/ javaone06_cv_124_1/ sessions_catalog. jsp?ilc=124-1& ilg=english& isort=1& is=%3CISEARCH%3E&
ip=yes& itrack=+ & isession_type=+ & isession_id=TS-3576& iabstract=& ispeaker=& ispk_company=

Quark Framework 257
Quark Framework
Paradigm functional, non-strict, modular
Appeared in 2004
Designed by Luke Evans, Bo Ilic (Business
Objects)
Typing discipline static, strong, inferred
Major implementations Open Quark Framework for Java [1]
Dialects --
Influenced by Haskell, Clean, Java
Influenced --
The Quark Framework (Open Quark) consists of a non-strict functional language and runtime for the Java
platform. The framework allows the compilation and evaluation of functional logic on the Java Virtual Machine
(JVM), directly or under the control of a regular Java application. The native language (syntax) for the Quark
Framework is called CAL. A full range of Java APIs provides the means to invoke the CAL compiler, manipulate
workspaces of modules, add metadata and evaluate functional logic. Functional logic is usually dynamically
compiled to Java bytecodes and executed directly on the JVM (with some small kernel logic controlling the normal
evaluation order). However, an interpreter (G-machine) is also available.
Motivation, History and Concept
CAL, and the associated tools and APIs forming the Quark Framework, was conceived in 1998 within Seagate
Software (later Crystal Decisions, now Business Objects) as a way to enable a common framework for sharing
business logic across business intelligence products. A framework was desired that would allow data behaviour to be
captured, at all levels of abstraction, and for these components to be composable into the actual data flows that
individual products required. In general terms, such a system had to provide a way to express data behaviour
declaratively, with universal composition and typing laws. In essence, this places the problem firmly in the domain
of functional languages, and the desire to allow machine compositions of functions without incurring increasing
efficiency penalties strongly suggested a non-strict evaluation semantic.
As well as the operational requirements, it was envisaged that future application logic would likely be written for a
dynamic platform (such as Java or .Net), and therefore it was determined that the Quark Framework should be native
to Java (initially) with considerable emphasis on performance and interoperability with application logic written on
that platform. In 1999, work began in Crystal's Research Group on an implementation of this framework. Many of
the original insights into lazy functional systems were drawn from implementations of Haskell. Early on, Haskell
(HUGS, GHC) was even considered as a starting point for the implementation itself, but a number of requirements
made this impractical, so it was decided to let the project emerge and evolve freely following its own design criteria.
For the first few years of development, the CAL source language itself was not a primary motivator, but the
operational semantics were of primary concern. At this time, CAL was merely a convenient script for expressing
functions rather than composing them programmatically through Java APIs, or using a graphical language native to a
tool called the Gem Cutter, which began to be implemented in mid-2000 as a way to author systems of functions that

Quark Framework 258
could be used in applications. From about 2002 onward, the CAL language became rather more central to the Quark
Framework, especially once programmers began to create usable libraries of functions for real applications. As the
language evolved, so did the demand for tools, and so a range of tools and utilities were created in parallel to
language development to support those doing real work with the platform.
While the Gem Cutter remained the main development environment in the initial years, since late 2005 there has
been an intention to produce Eclipse-based tools, and the emphasis has shifted to activities advancing the state of
Eclipse integration.
The motivations for the Quark Framework appear to be similar to those driving Microsoft's LINQ project, in
particular the desire for a declarative style and some lazy evaluation for certain kinds of logic, hosted within
applications coded in an Object Oriented language. While CAL cannot yet be embedded inline within Java source,
generated functions are fully compiled and the system can efficiently share data between CAL and Java sourced
logic. For instance, CAL lists can be marshalled dynamically to and from Java data structures that implement the
Iterator interface.
In 2007, the Quark Framework is an advanced and well tested framework for integrating non-strict functional logic
into Java programs. It can be used as a standalone functional language too, that happens to compile to Java
bytecodes. The framework was offered as open source under a BSD-style license in January 2007, and continues to
be used and developed within Business Objects.
CAL
CAL is the name of a programming language originally developed by Business Objects and now released as "Open
Quark", with sources, under a BSD-style license. It is a lazy functional programming language similar to the Haskell
programming language. An implementation is available from the Business Objects Labs [2] site. CAL forms part of
the Quark Framework which includes a visual programming tool, Gem Cutter.
One of the main objectives of the Quark Framework is to allow logic expressed in a declarative, lazy functional style
to be easily and efficiently integrated into Java applications. CAL source is typically compiled directly to byte codes
(though an interpreter is also available), and can be called from regular OO code. In turn CAL code can call any Java
code. Evaluation of CAL programs, and exploration of results can be completely controlled by procedural code,
allowing data transformation logic (for which CAL is ideally suited) to be flexibly integrated into Java applications.
A Java program can also easily build new functions on-the-fly, to describe transient data flows, or to create persisted
logic. This form of 'functional metaprogramming' is common in real-world deployments of the Quark Framework.
The CAL language borrows much from Haskell syntax, but also eschews some Haskell features. As such, CAL is a
strongly typed, lazily evaluated functional language, supporting algebraic functions and data types with parametric
polymorphism and type inferencing. CAL has special syntax for strings, tuples, characters, numbers, lists and
records. Single parameter type classes are supported, with superclasses, derived instances, deriving clauses for
common classes, default class methods and higher-kinded type variables. While doubtless a subjective measure,
CAL's developers have tried to keep the language simple. In particular, only the expression style is supported
(Haskell's equation based style with argument pattern matching is not supported), and CAL does not make use of
layout (semicolons are required to terminate definitions). CAL also makes certain syntactic choices to align it more
strongly with Java. For instance, Java's syntax for comments is used, and CAL's inline documentation comments are
close to JavaDoc.
One of the main differences between Haskell and CAL is in the area of interfacing with the 'real world'. Whereas
Haskell goes to great lengths to validate the purity of functions, CAL relies on the programmer to hide 'imported
impurity', exposing pure functions from a module where impure imports are made. CAL has a range of mechanisms
for controlling evaluation order and laziness. These are often essential tools in the creation of effective solutions with
native functions, but are also important in the aforementioned interface with the stateful world. The choice to
de-emphasise formal tracking of purity, in favour of mechanisms to allow the programmer to express the right logic,

Quark Framework 259
has proven to provide a good balance of flexibility and 'directness' when interfacing with external operations.
One of the main design goals for CAL was to make the language as comfortable as possible for mainstream
developers to pick up and use effectively. This is reflected in choices for syntax, but also in conventions and patterns
used within the standard libraries. For example, libraries use longer, descriptive names and are commented to explain
the implementations and best practices for use.
To see some CAL language source code click here [3] . This tutorial CAL module is designed as a top-to-bottom
'feature parade' to showcase basic syntax with examples of some built-in and user defined data structures.
Here are a few examples, derived from the tutorial module linked to in the preceding paragraph:
1. Quicksort
/**
* Here is a simple implementation of the quicksort algorithm for lists in
* CAL.
*
* Note: it is not the most efficient implementation, since it filters the
* list twice to partition.
*
* It is used here as an illustration. The production implementation of
* sorting on lists is
* {@link List.sort@}.
*
* The type of quicksort is constrained by the {@link Ord@} type class. This
* means that quicksort can sort list of any orderable type.
*/
quicksort :: Ord a => [a] -> [a];
quicksort list =
let
in
//partition_min is a local function of 1 argument
partition_min pivot = filter (\x -> x < pivot);
partition_max pivot = filter (\x -> x >= pivot);
case list of
[] -> [];
pivot : tail ->
;
quicksort (partition_min pivot tail)
++ (pivot : (quicksort (partition_max pivot tail)));
Note that CAL supports inline documentation comments, with embedded tags. Function type declarations
immediately precede the function definition. CAL supports type classes (e.g. Ord). Two local functions are declared
in the let block. Quicksort has a recursive definition, building up the output list at each level of recursion from the
sorts applied to the list of values either side of the pivot item.

Quark Framework 260
2. Data Declarations
In common with other functional languages, CAL provides a way to declare new types using data declarations. Here
is an example of declaring a new data type for 'Employee':
/**
* The Employee data type is an example of a CAL algebraic data type. It
* has one data constructor, RegularEmployee. The RegularEmployee data
* constructor has 3 fields: name, manager and directReports.
*
* The firstName and lastName fields have type String. The manager field
* has type Maybe Employee. This reflects the fact that an employee may
* have one manager or no managers (in the case fo the CEO), and that
* manager is also an Employee. directReports has type [Employee] i.e. a
* list of 0 or more employees. Note that the manager and directReports
* fields have types that recursively refer to the Employee type. In other
* words, Employee is a recursive algebraic data type.
*/
data Employee =
RegularEmployee
name :: String
//the employeeID field is a potential future addition to the
//Employee data type. Notice below that case expressions using
//field-name based extraction would not need to be updated due
//to this change, but case expressions using positional based
//extraction would need updating.
//employeeID :: Int
manager :: (Maybe Employee)
directReports :: [Employee]
//This deriving clause provides a default instance implementation for
//the Show type class for the Employee type. Essentially what this
//means is that the Debug.show function will work with Employee
//values to display a String representation of the value suitable for
//debugging purposes.
deriving Show;
Note that fields (data constructor arguments) must have names in CAL, as well as their type. The deriving clause
makes the data type work with functions defined in certain type classes. Here we ensure that CAL automatically adds
the requisite logic to make values of Employee be renderable as strings for the purposes of tracing.
Fields can be extracted in a variety of ways:
a) Positionally in a case expression:
/**
* @arg employee
* @return the employee's name
*/
employeeName :: Employee -> String;
employeeName employee =
case employee of

Quark Framework 261
//illustrates positionally based case expression extraction of the
//"name" field of the RegularEmployee data constructor
RegularEmployee empname _ _ -> empname;
;
b) By field name in a case expression:
/**
* @arg employee
* @return the employee's name
*/
employeeName :: Employee -> String;
employeeName employee =
case employee of
//illustrates field-name based case expression extraction of the
//"name" field of the RegularEmployee data constructor
RegularEmployee {name} -> name;
;
This method is obviously more stable with respect to changes in data constructor arguments than the positional
version
c) By a selector expression
/**
* @arg employee
* @return the employee's name
*/
employeeName :: Employee -> String;
employeeName employee =
//illustrates data constructor field selection of the directReports
//field
employee.RegularEmployee.name;
Note that CAL allows multiple constructor arguments to be cited in a case extractor, along with multiple constructors
to match on (so long as they all have the named arguments). So, the following scenario is possible (assuming the
data declaration includes the employeeID field and new constructors for Contractor and Associate):
// ...snip...
case employee of
//illustrates multiple field case expression extraction over multiple
//data constructors. Note the local renaming of the employeeID field
//to 'id'
(RegularEmployee | Contractor | Associate) {name, employeeID = id } -> (name, id);
;
// ...snip...

Quark Framework 262
3. Records
CAL unifies tuples and records, which can be used as containers for heterogeneously typed values (as compared to
lists, which are sequences of values of the same type). Records are extensible and can be convenient for passing
collections of values where the formality of a new data definition is not necessary. Records can have textual or
numeric (ordinal) indexed fields. Traditional tuples are simply records with exclusively ordinal fields and tuple
constructors (parentheses) simply generate ordinal fields in sequence up from #1.
Here are three examples of records: a tuple (demonstrating its simpler constructor syntax), a record with ordinal
fields (fully equivalent to the first tuple) and a record with mixed ordinal and named fields:
/**
* A record with 3 fields: field #1 has type String, field #2 has type Maybe
* Boolean and field #3 has type [Double].
* It is expressed using tuple notation.
*/
tupleRecord1 :: (String, Maybe Boolean, [Double]);
tupleRecord1 = ("apple", Just True, [2.0, 3.0, -5]);
/**
* This record actually has the same value as tupleRecord1, but it includes
* field names explicitly, and thus uses braces rather than parentheses.
* When using explicit field names, the ordering of the fields does not
* matter.
*/
tupleRecord2 :: {#1 :: String, #3 :: [Double], #2 :: Maybe Boolean};
tupleRecord2 = {#3 = [2.0, 3.0, -5], #1 = "apple", #2 = Just True};
/**
* Here is a record with both textual and ordinal fields.
*/
mixedRecord1 :: {#1 :: Maybe [Int], #2 :: Boolean, age :: Double, name :: String};
mixedRecord1 = {name = "Anton", age = 3.0, #1 = Just [10 :: Int, 20], #2 = False};
CAL on Java
The CAL compiler takes CAL source, as text or as a source model (Java object model). This is processed by the
early compiler stages to desugar and analyse the source. The intermediate form, plus metadata from analysis, is
processed by a number of optimisers, optionally including a full rewrite optimiser capable of function fusion,
deforestation and other major optimisations that preserve semantics but improve a program operationally.
The compiler supports plugable back-ends. First amongst these is LECC (Lazily Evaluating CAL Compiler). This
back-end generates Java classes and byte codes directly, emitting methods according to compiler schemes that take
account of context metadata derived in the compiler, such as strictness of function arguments. LECC can package
generated code in a number of ways, including as a CAL Archive (CAR), or a Java JAR. At runtime, a class loader
can load an entire corpus of functions, or the Quark Framework loader can load closely connected functions
according to prior dependency analysis. This latter feature is important to minimise start up times, whereby only the
functions actually required by an application incur loading overhead.
The LECC back-end can also generate Java source code, which is then compiled by the regular JDK Java compiler
to produce class files. Amongst other things, this is very useful when validating compiler schemes during compiler
development, and provides a way to reason about the operational behaviour of CAL on the Java platform.

Quark Framework 263
As well as LECC, Open Quark includes a G-machine interpreter and a compiler back-end that generates G-machine
code. While considerably slower than LECC, this option is useful for experiments and may be a better fit for some
deployments.
While many deployments of CAL may use the language standalone, the Quark Framework is fundamentally
designed to be used within regular Java applications to provide a hybrid/multi-paradigm system. The intent is to
allow transformational logic, which benefits from more algebraic representation, to be embeddable within Java OO
logic handling regular (stateful) aspects of the application. To this end, CAL supports a very powerful and easy to
use interface to Java, and the Quark Framework SDK allows Java code considerable control over how functions are
evaluated and results produced. Java code can issue new functions to the Quark Framework for compilation, which
can be immediately available for evaluation. Thus, Java can use the Quark Framework as a functional
meta-programming environment. This has been a common use case for the framework, and is supported efficiently
(low latency, with concurrent compilation and evaluation). On the consumption side, results can be presented to Java
as lazy suspensions, so that minimal functional evaluation is performed and only when Java logic requests the 'next'
output value. This feature allows data-flow logic to be constructed on-the-fly within a Java application, used
on-demand and then disposed of if necessary. Both the LECC and G-machine runtimes are able to load and unload
functions from memory to support a fully dynamic environment.
The 'foreign' interface between CAL and Java is able to import any Java entity into CAL and make calls on Java
methods. Values are passed efficiently between the two environments, without unnecessary boxing/unboxing
operations. A powerful feature called "I/O policies" allows values to be lazily marshalled between structures if
required (for instance, if you have a particular Java class or data structure that you wish to produce to represent a
CAL value). These policies are declared completely on the CAL side, leaving the Java side 'natural'. The default
policies are usually quite sufficient to share values, so usually nothing special must be done to exchange values.
Here are some examples of CAL code that declares interfaces to Java entities:
1. Importing a Java type, a constructor and a method
The following code imports the "java.util.LinkedList" class (which becomes the CAL 'opaque' data type
"JLinkedList"). The fragment then imports the default constructor for this class, and the instance method 'add'. All of
these imports are marked private, which means that they would only be usable within the importing CAL module.
This is quite common, as its usually good practise to export public functions from modules that behave as pure
functions.
data foreign unsafe import jvm "java.util.LinkedList"
private JLinkedList deriving Inputable, Outputable;
foreign unsafe import jvm "constructor"
private linkedList_new :: JLinkedList;
foreign unsafe import jvm "method add"
private linkedList_add :: JLinkedList -> JObject -> Boolean;

Quark Framework 264
2. Fields can be imported too
foreign unsafe import jvm "static field java.lang.Float.NEGATIVE_INFINITY" floatNegativeInfinity :: Float;
This is especially useful for constants, per the example.
3. Casts for Java types
Occasionally, it is necessary to cast between Java types that have been imported. For instance, JObject and JList are
imported in the Prelude. If you needed to cast between them in CAL, then you could declare the appropriate casting
functions. These declarations are properly checked for validity.
foreign unsafe import jvm "cast" castObjectToList :: JObject -> JList;
foreign unsafe import jvm "cast" castListToObject :: JList -> JObject;
Of course, with casting, there's always the potential for runtime class cast exceptions, so it's a good thing that CAL's
exception features are fully integrated with Java too, e.g. ...
4. Java Exceptions
The following fragment shows a CAL exception type being declared and a function that can demonstrate the
throwing in CAL of this exception, or a Java NullPointerException depending on the argument it is passed. Note that
CAL exceptions can have any payload. The definition of nullPointerException_make is not shown for brevity.
data MyExceptionType a =
MyExceptionType
message :: String
someOtherStuff :: a
list :: [a]
deriving Show
;
instance Exception Double where;
instance Exception a => Exception (MyExceptionType a) where;
//this is an interesting example because the JNullPointerException is not
//caught by the JThrowable catch clause. exceptions thrown by CAL (with
//CAL types) must be caught using their CAL type.
calThrownException1 :: Int -> String;
calThrownException1 n =
(
)
if n < 0 then
throw (MyExceptionType "spinach salad" 10.0 [20, 30, 40])
else if n > 0 then
else
`catch`
throw (nullPointerException_make "a new NullPointerException")
"all OK"
(\ex -> "caught MyExceptionType: " ++ show (ex :: MyExceptionType Double))
`catch`
(\ex -> "caught Throwable: " ++ show (ex :: JThrowable))

Quark Framework 265
`catch`
(\ex -> "caught NullPointerException: " ++ show (ex :: JNullPointerException))
;
If you want, you can make any type an Exception. See the following fragment:
instance Exception String where;
instance Exception Int where;
instance Exception Integer where;
instance Exception a => Exception (Maybe a) where;
instance Exception a => Exception [a] where;
instance Exception r => Exception {r} where;
//tests using various Cal types as Exception types, including the interesting
//case of records
calThrownException5 =
throw ("abc", 1 :: Int, 2 :: Integer, ["abc", "def"], Just (20 :: Int))
`catch`
(
);
let
in
handler :: (String, Int, Integer, [String], Maybe Int) -> String;
handler r = show (r.#5, r.#4, r.#3, r.#2, r.#1);
handler
Finally, and just for fun, we show how you can map an exception handler over a list!
handleAnyThrowableWithDefault :: a -> JThrowable -> a;
handleAnyThrowableWithDefault def throwable = def;
exceptionTest1 :: Boolean;
exceptionTest1 =
List.map (\x -> x `catch` handleAnyThrowableWithDefault (-999))
[(4 :: Int) / 1, 10 /2, 5 / 0, (1 - 1) / 0, 2 / 2, 5 / (2 -2)]
== [4, 5, -999, -999, 1, -999]
;
The three arithmetic exceptions (divide by zero) are converted to the default value (-999) by the exception handler.
External references
Downloads of Open Quark (with and without sources) and collateral are currently hosted at the Open Quark [1] site.
The following documents are available:
• The CAL Users Guide [4] - The main reference for the CAL language
• CAL for Haskell Programmers [5] - A comparison of CAL with Haskell for those with familiarity of the latter
• Effective CAL [6] - A discussion of best practices when programming in CAL
• Open Quark Library documentation [7] - The HTML docs generated from library CAL Doc
• The Gem Cutter Manual [8] - The main reference for the Graphical Language and its tool, the Gem Cutter
• Open Quark Java SDK documentation [9] - The HTML docs generated from SDK JavaDoc
• Java meets Quark [10] - A discussion and tutorial for using the SDK to embed Open Quark in Java applications

Quark Framework 266
• Using JFit [11] - The reference for the JFit tool, a batch generator for foreign function declarations in CAL
• Business Activity Monitor Sample [12] - A case study of embedding Open Quark in a Java app
References
[1] http:/ / openquark. org
[2] http:/ / labs. businessobjects. com/ cal
[3] http:/ / openquark. org/ Documents/ tutorial_calintro. html
[4] http:/ / openquark. org/ Documents/ cal_users_guide. pdf
[5] http:/ / openquark. org/ Documents/ cal_for_haskell_programmers. pdf
[6] http:/ / openquark. org/ Documents/ effective_cal. pdf
[7] http:/ / openquark. org/ Documents/ open_quark_cal_doc. zip
[8] http:/ / openquark. org/ Documents/ gem_cutter_manual. pdf
[9] http:/ / openquark. org/ Documents/ open_quark_javadoc. zip
[10] http:/ / openquark. org/ Documents/ java_meets_quark. pdf
[11] http:/ / openquark. org/ Documents/ using_jfit. pdf
[12] http:/ / openquark. org/ Documents/ business_activity_monitor_overview. pdf
REPLAY (software)
REPLAY is a management system for audiovisual content developed at ETH Zurich.
Background
REPLAY was developed as the future Multimedia Portal of ETH Zurich within the scope of the ICT strategy
2006-2009 and got branded „REPLAY“ in 2007. It is to manage the audiovisual content of ETH Zurich from
production to distribution in an automated manner.
Application area
The main focus of REPLAY is the quasi automated handling of large number of lecture recordings (>150 per week)
and to provide an integrated management solution for other video objects (films, digitization results etc.). Thus, it
covers all the audiovisual material usually to be found in academic and other institutions (museums, companies etc.).
Workflow
REPLAY covers the complete lifecycle of the audiovisual objects: In the classroom / lecture hall, the Linux-based
Playmobil as an additional hardware component automatically captures audio, video, and VGA (for
slides/presentations/computer display/other devices). After the lecture, these sources are bundled with metadata and
proceeded into the REPLAY backend. Other video material can be ingested through an inbox. All bundles are then -
archived, - indexed (based on slide content, using Optical Character Recognition), - encoded according to settings
and - distributed in various channels (RSS, streaming, download etc.) One of the distribution channels is Interplay, a
user interface designed for interactive consumption of video.
Much of the indexing and searching functionalites comes from Yovisto, a German metadata search engine for
academic content.

REPLAY (software) 267
Qualities
REPLAY is written in Java, Open Source and oriented towards standards wherever possible. It is modular in design
and envisaged to run on a singular machine as well as in a distributed environment.
License
REPLAY is Open Source under GNU LGPL license version 2.
Development
Development website [1] . Replay has been developed towards release 0.7 (March 2009); as of June 2009 the project
has ended and support was suspended by the end of 2009. Efforts around REPLAY and its technology are beinge
transferred to the Opencast Matterhorn project.
External links
• Official website [2]
• Project website [3]
• Article from the proceedings of the 36th annual ACM SIGUCCS conference [4]
• The WSU eLearner blog on REPLAY [5]
• The ICT en Onderwijs blog on REPLAY (Dutch) [6]
• Presentation of REPLAY at EDUCAUSE 2008 [7]
• Article on REPLAY (German) [8]
• Presentation of REPLAY (German, video) [9]
References
[1] http:/ / replay. origo. ethz. ch/
[2] http:/ / www. replay. ethz. ch
[3] http:/ / www. project-replay. ethz. ch/
[4] http:/ / portal. acm. org/ citation. cfm?doid=1449956. 1450016
[5] http:/ / wsuelearner. wordpress. com/ 2008/ 11/ 18/ educause-2008-replay-for-audiovisual-lecture-recordings/
[6] http:/ / www. gorissen. info/ Pierre/ item/ 2008/ 10/ 31/ replay-opern-source-lecture-capturing
[7] http:/ / www. replay. ethz. ch/ docs/ educause
[8] http:/ / www. workshop. ch/ openmind/ 2008/ 12/ 20/
replay-gesamtloesung-zur-aufzeichnung-und-verbreitung-von-vorlesungen-der-eth-zuerich/
[9] http:/ / www. tele-task. de/ lectures/ view/ 3910/ real/

Real time Java 268
Real time Java
Real time Java is a catch-all term for a combination of technologies that allows programmers to write programs that
meet the demands of Real time systems in the Java programming language.
Java's sophisticated memory management, native support for threading and concurrency, type safety, and relative
simplicity have created a demand for its use in many domains. Its capabilities have been enhanced to support real
time computational needs:
• Java supports a strict priority based threading model.
• Because Java threads support priorities, Java locking mechanisms support priority inversion avoidance
techniques, such as priority inheritance or the priority ceiling protocol.
To overcome typical real time difficulties, the Java Community introduced a specification for real-time Java,
JSR001. A number of implementations of the resulting Real-Time Specification for Java (RTSJ) have emerged,
including a reference implementation from Timesys, IBM's WebSphere Real Time, Sun Microsystems's Java SE
Real-Time Systems [1] , Aonix PERC or JamaicaVM from aicas.
The RTSJ addressed the critical issues by mandating a minimum specification for the threading model (and allowing
other models to be plugged into the VM) and by providing for areas of memory that are not subject to garbage
collection, along with threads that are not preemptable by the garbage collector. These areas are instead managed
using region-based memory management.
Real-Time Specification for Java
The Real-Time Specification for Java (RTSJ) is a set of interfaces and behavioral specifications that allow for
real-time programming in the Java programming language. RTSJ 1.0 was developed as JSR 1 under the Java
Community Process, which approved the new standard in November, 2001. As of 2006, RTSJ 1.1 is being developed
under JSR 282.
See also
• Functional specification
• Javolution - RTSJ Compliant Java Library (open-source)
External links
• Real-Time Specification for Java (RTSJ) [2]
• JSR-1 [3]
• IBM WebSphere Real Time [4] a fully conformant RTSJ SE VM
• JamaicaVM [5] an RTSJ SE implementation with deterministic garbage collection
• PERC [6] a real-time VM based on Java Standard Edition rather than RTSJ
• Sun Java SE Real-Time System [7]
• Apogee real-time Java with real-time GC [8]
• Timesys RTSJ implementation and testing toolkit [9]
• jRate (Java Real-Time Extension) [10] an open-source extension of the GNU GCJ compiler front-end and runtime
system which adds support for most of the features required by the RTSJ.
• DDC-I Scorpion Java [11] real-time Java SE, with safety-critical and secure versions.
• International Workshop on Java Technologies for Real-time and Embedded Systems (JTRES 2006) [12] JTRES
2007 [13] JTRES 2008 [14]

Real time Java 269
References
[1] Java SE Real-Time Systems (http:/ / java. sun. com/ javase/ technologies/ realtime/ index. jsp)
[2] http:/ / www. rtsj. org/
[3] http:/ / jcp. org/ en/ jsr/ detail?id=1
[4] http:/ / www-03. ibm. com/ linux/ realtime. html
[5] http:/ / www. aicas. com/ jamaica. html
[6] http:/ / www. aonix. com/
[7] http:/ / java. sun. com/ javase/ technologies/ realtime. jsp
[8] http:/ / www. apogee. com/
[9] http:/ / www. timesys. com/ java/
[10] http:/ / jrate. sourceforge. net/
[11] http:/ / www. ddci. com/ products_scorpion. php
[12] http:/ / www-users. cs. york. ac. uk/ ~andy/ JTRES06/
[13] http:/ / www. vmars. tuwien. ac. at/ jtres2007/
[14] http:/ / jtres. java. sun. com/ 2008/
Resource (Java)
In the Java programming language a resource is a piece of data that can be accessed by the code of an application.
An application can access its resources through Uniform Resource Locators, like web resources, but the resources
are usually contained within the JAR file(s) of the application.
A resource bundle is a set of key and value pairs, stored as a resource, that is commonly used to allow the
localization of an application. For this purpose different resource bundles with a common set of keys are used to
store translations for the messages and user interface texts of an application.
References
Campione, Mary; Kathy Walrath, Alison Huml (2004). "Internationalization" [1] . The Java Tutorial Continued [2] (6
print. ed.). Addison-Wesley. ISBN 0-201-48558-3. Retrieved April 2006.
References
[1] http:/ / java. sun. com/ docs/ books/ tutorial/ i18n/ TOC. html
[2] http:/ / java. sun. com/ docs/ books/ tutorial/ books/ continued/ index. html

Restlet 270
Restlet
Stable release 2.0.0 / July 19, 2010
Development status Active
Written in Java
Operating system Cross-platform
Website http:/ / www. restlet.
org/
Restlet is a lightweight, comprehensive, open source REST framework for the Java platform. Restlet is suitable for
both server and client Web applications. It supports major Internet transport, data format, and service description
standards like HTTP and HTTPS, SMTP, XML, JSON, Atom, and WADL. A GWT port of the client-side library is
also available.
Licenses
Restlet is available under four different licenses: [1]
• CDDL ver 1.0
• LGPL ver 2.1
• LGPL ver 3.0
• EPL ver 1.0
Architecture
Restlet directly models the concepts (Resource, Representation, Connector, Component, etc.) from Roy T. Fielding's
original dissertation on the architecture of the Web, Architectural Styles and the Design of Network-based Software
Architectures [2] .
The Restlet framework is composed of two main parts. First, there is the "Restlet API", a neutral API supporting the
concepts of REST and facilitating the handling of calls for both client-side and server-side applications. This API
must be supported by a Restlet implementation before it can effectively be used. Multiple implementations could be
provided (open source projects or commercial products).
It is available in five consistent editions. Each edition targets a special development environment:
• Google Web Toolkit (GWT) for AJAX applications deployed in desktop browsers, without any plugin required;
• Google App Engine (GAE/J) for deployment on Google’s cloud computing infrastructure;
• Android for deployment on compatible smartphones;
• Java SE for standalone deployments in regular Java Virtual Machines;
• Java EE for deployment in Servlet engines.

Restlet 271
Connectors
The list of available connectors splits into:
• Server connectors: Servlet, Spring, Jetty, Grizzly, Simple, JAXB, JAX-RS, JiBX, Velocity;
• Client connectors: Internal, Apache HTTP Client, Net (JDK's HttpURLConnection), JavaMail, JDBC.
History
Founder Jerome Louvel of Noelios Consulting began the Restlet project in December 2005, and was the primary
developer and committer through the project's 1.0 release in April, 2007. [3] He was subsequently joined by Thierry
Boileau, also of Noelios, and an expanding list of extension developers from the Restlet community.
The May, 2007 publication of the O'Reilly book RESTful Web Services featured Restlet alongside Django and
Rails. [4]
Restlet 1.1 was released October 28, 2008 [5] , and included support for GWT and the then-emerging JAX-RS
standard.
On May 6, 2009, Jerome Louvel announced that the planned 1.2 release of Restlet would be renamed 2.0, mainly
due to significant changes in the modeling of resources. The 2.0 release is targeted for the second half of 2009. [6]
Features exposed in 2.0 milestone builds include specific support for Google App Engine and Android.
An upcoming Restlet book ("Restlet In Action") has been announced by Noelios and Manning Press, planned to
cover Restlet version 2.0.
External links
• Restlet - Lightweight REST framework for Java [7]
• JavaWorld article on Restlet [8]
References
[1] Restlet - Legal terms (http:/ / www. restlet. org/ about/ legal)
[2] http:/ / www. ics. uci. edu/ ~fielding/ pubs/ dissertation/ top. htm
[3] http:/ / www. eweek. com/ c/ a/ Application-Development/ Java-Project-Founder-Outlines-Benefits-of-Restlet/
[4] Richardson, Leonard; Ruby, Sam (2007), RESTful Web Services, O'Reilly (published (May 8, 2007)), ISBN 0596529260
[5] http:/ / blog. noelios. com/ 2008/ 10/ 28/ restlet-110-released/
[6] http:/ / restlet. tigris. org/ ds/ viewMessage. do?dsMessageId=2078602& dsForumId=4447
[7] http:/ / www. restlet. org/
[8] http:/ / www. javaworld. com/ javaworld/ jw-12-2008/ jw-12-rest-series-2. html

Retrotranslator 272
Retrotranslator
Stable release 1.2.6 / February 29, 2008
Written in Java
Operating
system
Cross-platform
Platform Java Virtual Machine
License BSD-like License
Website [1]
Retrotranslator is a program written in Java that converts Java classes (bytecode). The source classes may use Java
1.5 and Java 1.6 features, whereas the target will be compatible with Java 1.4 and older environments.
Retrotranslator supports all Java 5 language features and part of the Java 5 API on both J2SE 1.4 and J2SE 1.3. On
older Java environments only the Java 5 features that don't depend on the new API are supported. Retrotranslator is
based on the ASM bytecode manipulation framework and the backport of the Java 5.0 concurrency utilities (see
http:/ / backport-jsr166. sourceforge. net/ )
The Stripes Framework developers suggest to use Retrotranslator in order to use Stripes (which extensively use Java
1.5 features) on a Java 1.4 environment [2]
Alternative tools
• Retroweaver
• Declawer
• JBossRetro
External links
• Java backporting tools
References
[1] http:/ / retrotranslator. sourceforge. net/
[2] http:/ / www. stripesframework. org/ display/ stripes/ Java+ 1. 4+ and+ Stripes

SLAMD 273
SLAMD
The SLAMD Distributed Load Generation Engine (SLAMD) is a Java-based application designed for stress testing
and performance analysis of network-based applications. Initial development of SLAMD was performed at Sun
Microsystems, with recent development sponsored primarily by UnboundID Corp. [1] .
SLAMD is available under the terms of the Sun Public License, which is an OSI-approved open source license. The
main site for obtaining information about SLAMD is available at its main web site [2] , and it is available as a java.net
[3] project.
SLAMD was originally developed for the purpose of benchmarking and analyzing the performance of LDAP
directory servers, and it is the most powerful and flexible tool available for this task. However, it is also well-suited
for testing other kinds of network applications and has been used for things like Web servers and Web-based
applications, relational databases, and mail servers. It can also be used for non-network based applications (and in
fact, it is used for comparing things like CPU power and memory latency across a number of different kinds of
systems), although its distributed nature makes it ideal for systems that can be accessed remotely.
Architecture
SLAMD uses a distributed model consisting of a server (SLAMD is distributed with Apache Tomcat) and clients.
The operator schedules a new job using a browser, and submits the job for execution. The server sends the scheduled
job to selected clients, these clients then generate load based on parameters defined in the SLAMD job class and
report results back to the SLAMD Server. SLAMD 2.0.0-alpha1 uses the Berkeley DB Java Edition. [4]
Extensibility
"SLAMD provides a Java-based API to make it possible to quickly develop custom workloads, and it also
contains an embedded scripting engine that can make it easy to stress applications using protocols like LDAP,
HTTP, SMTP, IMAP, and POP, or any database that can be accessed via JDBC. It also includes tools for
recording and playing back TCP traffic, and a utility for intercepting LDAP communication and writing it as a
script that may be executed in the SLAMD scripting engine." [5]
SLAMD jobs are managed by Java classes. New SLAMD job classes can be created by writing Java code using a
well-defined API[6], compiling the Java code, and installing the Job Class (the class is installed on the servers and
the server pushes it out to the clients).
Installation
Supported Systems
SLAMD is supported on any computer operating system that supports Java, such as Solaris, Linux, AIX, HPUX, and
Windows. SLAMD version 2 or greater requires Java 5 or greater.
Jobs
Benchmarking campaigns are a series of SLAMD jobs. SLAMD jobs are created by filling in the forms in the
Schedule a New Job page. The operator sets up a job via a browser, then submits the job. The Server sends the job to
SLAMD Clients.
The SLAMD Clients generate load based on parameters in the SLAMD job class. Parameters can be items such as
duration, ramp-up and ramp-down, and any other parameter defined in the Job Class.

SLAMD 274
Reporting
SLAMD generates reports in the following formats:
• HTML
• Portable Document Format
• Text file
See also
• Benchmarking
External links
• SLAMD at java.net [3]
• SLAMD website [7]
• Benchmarking at about.com [8]
• Six Sigma [9]
• MrBenchmark blog at Sun Microsystems [10]
References
[1] http:/ / www. unboundid. com
[2] http:/ / www. slamd. com/
[3] http:/ / slamd2. dev. java. net
[4] http:/ / www. slamd. com/ downloads/ slamd-2. 0. 0-alpha1-release-notes. pdf
[5] SLAMD Distributed Load Generation Engine - Home (http:/ / www. slamd. com)
[6] http:/ / www. slamd. com/ docs/ slamd_job_developers_guide. pdf
[7] http:/ / www. slamd. com
[8] http:/ / management. about. com/ cs/ benchmarking/ a/ Benchmarking. htm
[9] http:/ / www. isixsigma. com/ me/ benchmarking/
[10] http:/ / blogs. sun. com/ MrBenchmark

SLAMD Server 275
SLAMD Server
A SLAMD Server is a server supported by an application server that services SLAMD clients and SLAMD jobs.
SLF4J
Developer(s) Ceki Gülcü
Stable release 1.6.1 / July 5, 2010
Written in Java
Operating
system
Cross-platform
Type Logging Tool
License MIT License
Website http:/ / www. slf4j. org/
Simple Logging Facade for Java (SLF4J) provides a Java logging API by means of a simple facade pattern. The
underlying logging backend is determined at deployment time and includes java.util.logging [1] , log4j and logback.
The separation of the client API from the logging backend reduces the coupling between an application and any
particular logging framework. This can make it easier to integrate with existing or third-party code or to deliver code
into other projects that have already made a choice of logging backend.
SLF4J was created by Ceki Gülcü as a more reliable alternative to Jakarta Commons Logging framework.
Similarities and Differences with Log4j
• Five of Log4j's six logging levels are used. FATAL has been dropped on the basis that inside the logging
framework is not the place to decide when an application should terminate and therefore there is no difference
between ERROR and FATAL from the logger's point of view.
• Logger instances are created via the LoggerFactory, which is very similar in Log4j. For example,
private static final Logger LOG =
LoggerFactory.getLogger(Wombat.class);
• In Logger [2] , the logging methods are overloaded with forms that accept one, two or more values. Occurrences of
the simple pattern {} in the log message is replaced in turn with the values. This is simple to use yet provides a
performance benefit when the values have expensive toString() methods. When logging is disabled at the
DEBUG level, the logging framework does not need to evaluate the string representation of the values. In the
following example, the values count or userAccountList only need to be evaluated when DEBUG is
enabled; otherwise the overhead of the debug call is trivial.
LOG.debug("There are now " + count + " user accounts: " +
userAccountList); // slow
LOG.debug("There are now {} user accounts: {}", count,
userAccountList); // faster
• Similar methods exist in Logger [2] for isDebugEnabled() etc to allow more complex logging calls to be
wrapped so that they are disabled when the corresponding level is disabled, avoiding unnecessary processing.

SLF4J 276
• Unlike Log4j, SLF4J offers logging methods that accept markers. These are special objects that enrich the log
messages and are an idea that SLF4J has borrowed from logback.
See also
• log4j
• Java Logging Frameworks
External links
• Official slf4j Homepage [3]
References
[1] http:/ / java. sun. com/ javase/ 6/ docs/ api/ java/ util/ logging/ package-summary. html
[2] http:/ / slf4j. org/ apidocs/ org/ slf4j/ Logger. html
[3] http:/ / slf4j. org/

Bruno Souza 277
Bruno Souza
Born
Nationality Brazilian
Bruno Souza
Bruno Peres Ferreira de Souza [1]
Known for Self-promotion
Website
www.javaman.com.br [2]
Bruno Souza is the President of SOUJava [3] , a Brazilian Java User Group. He promotes himself as the
"JavaMan" [1]
Javali, a project owned by SOUJava, is focused in increasing Java usage in Brazil [4] . This project has the support
from ITI [5] [6] [7] .
From 2007 [8] to 2009 [9] , Bruno was on the Board of Directors at the Open Source Initiative, where he currently
holds an Emeritus status. [9]
External links
• Bruno Souza´s homepage [10] and weblog [11]
• Bruno Souza´s Interview in Netbeans.tv [12]
References
[1] Souza, Bruno. "Site do JavaMan" (http:/ / www. javaman. com. br/ ) (in Portuguese). Bruno's own homepage. . Retrieved 2009-01-13.
[2] http:/ / www. javaman. com. br
[3] "Organização - SOUJava" (http:/ / www. soujava. org. br/ pages/ viewpage. action?pageId=1835023) (in Portuguese). SOUJava. . Retrieved
2009-01-13.
[4] "Javali" (https:/ / javali. dev. java. net/ ). . Retrieved 2008-10-19.
[5] Instituto Nacional de Tecnologia da Informação (2004-07-01). "ITI apóia projeto Javali" (http:/ / www. iti. gov. br/ twiki/ bin/ view/ Noticias/
PressRelease2004Jul01A) (in Portuguese). Press release. . Retrieved 2009-01-13.
[6] Instituto Nacional de Tecnologia da Informação (2006-05-24). "Governo Federal recebe apoio de empresa na adoção de Software Livre"
(http:/ / www. iti. gov. br/ twiki/ bin/ view/ Noticias/ PressRelease2006May24A) (in Portuguese). Press release. . Retrieved 2009-01-13.
[7] "Apresentação" (http:/ / www. iti. gov. br/ twiki/ bin/ view/ ITI/ Apresentacao) (in Portuguese). Instituto Nacional de Tecnologia da
Informação. . Retrieved 2009-01-13.
[8] "OSI Board of Directors" (http:/ / www. opensource. org/ docs/ board-annotated#BrunoDeSouza). . Retrieved 2008-10-19.
[9] OSI (http:/ / www. opensource. org) (2009-05-11). "2009 OSI Board Elections held in April" (http:/ / www. opensource. org/ node/ 431).
Press release. .
[10] http:/ / www. javaman. com. br/
[11] http:/ / today. java. net/ pub/ au/ 88
[12] http:/ / www. netbeans. tv/ interviews/ Bruno-Souza-215/

Static import 278
Static import
Static import is a feature introduced in the Java programming language that allows members (fields and methods)
defined in a class as public static to be used in Java code without specifying the class in which the field is defined.
This feature was introduced into the language in version 5.0.
The feature provides a typesafe mechanism to include constants into code without having to reference the class that
originally defined the field. It also helps to deprecate the practice of creating a constant interface: an interface that
only defines constants then writing a class implementing that interface, which is considered an inappropriate use of
interfaces [1] .
The mechanism can be used to reference individual members of a class:
import static java.lang.Math.PI;
import static java.lang.Math.pow;
or all the static members of a class:
import static java.lang.Math.*;
For example, this class:
public class HelloWorld {
public static void main(String[] args) {
cm, it has:");
"cm");
System.out.println("Hello World!");
System.out.println("Considering a circle with a diameter of 5
System.out.println("A circumference of " + (Math.PI * 5) +
System.out.println("And an area of " + (Math.PI *
Math.pow(5,2)) + "sq. cm");
}
}
Can be shortened to:
import static java.lang.Math.*;
import static java.lang.System.out;
public class HelloWorld {
has:");
}
public static void main(String[] args) {
}
out.println("Hello World!");
out.println("Considering a circle with a diameter of 5 cm, it
out.println("A circumference of " + (PI * 5) + "cm");
out.println("And an area of " + (PI * pow(5,2)) + "sq. cm");

Static import 279
References
[1] Java Practices (http:/ / www. javapractices. com/ topic/ TopicAction. do;jsessionid=8DE0FD351E0CF7378452E4E1001FCDDA?Id=32)
StormMQ
Developer(s) StormMQ Limited
Stable release 2010.05.20.1859.RC / May 20, 2010
Written in Java
Operating
system
Cross-platform
Type AMQP, Message Queuing Service, message oriented middleware
License Client downloads Mozilla Public License
Website
StormMQ.com [1]
In computing, StormMQ is a Message Queuing Service (a form of message-oriented middleware that provides a
message broker), using the standard Advanced Message Queuing Protocol (AMQP). StormMQ is the first Hosted,
On-Premise or Cloud solution for Machine-to-Machine Message Queuing using AMQP. StormMQ Limited provides
an open, secure platform and the necessary legal protections for data moved through the cloud. The platform
interoperates with clients from RabbitMQ and Apache Qpid, with additional clients developed by StormMQ with
third parties available as open source with code released under the Mozilla Public License.
See also
• Advanced Message Queuing Protocol
• Message Queuing Service
• message oriented middleware
References
[1] http:/ / stormmq. com/
• Ross Cooney (2010-03-20). "StormMQ at CloudStorm" (http:/ / www. spoutingshite. com/ 2010/ 03/ 20/
cloudstorm-london/ ). SpoutingShite.
• Tony Byrne (2010-05-01). "StormMQ-Ruby-Client" (http:/ / github. com/ tonybyrne/ StormMQ-Ruby-Client/
tree/ l). GitHub.
External links
• StormMQ web site (http:/ / stormmq. com/ )
• StormMQ touts data-protection compliance for secure messaging service in the cloud (http:/ / www. the451group.
com/ report_view/ report_view. php?entity_id=62762)

strictfp 280
strictfp
strictfp is a keyword in the Java programming language that restricts floating-point calculations to ensure
portability. It was introduced into Java with the Java virtual machine (JVM) version 1.2.
Basis
The IEEE standard, IEEE 754, specifies a standard method for both floating-point calculations and storage of
floating-point values in either single (32-bit, used in Java floats) or double (64-bit, used in Java doubles) precision.
Prior to JVM 1.2, floating-point calculations were strict; that is, all intermediate floating-point results were
represented as IEEE single or double precisions. As a consequence, errors of calculation, overflows and underflows,
could occur. Whether or not an error had occurred, the calculation would always return a valid number; if an
overflow or underflow had occurred, that number would be incorrect. Hence, whether an error had occurred was
typically not obvious. Since JVM 1.2, intermediate computations are not limited to the standard 32- and 64- bit
precisions. On platforms that can handle other representations, those representations can be used, preventing
overflows and underflows, thereby increasing precision. For some applications, a programmer might need every
platform to have precisely the same floating-point behavior, even on platforms that could handle greater precision.
The strictfp modifier accomplishes this by truncating all intermediate values to IEEE single- and double- precision,
as occurred in earlier versions of the JVM [1] .
Usage
Programmers can use the modifier strictfp to ensure that calculations are performed as in the earlier versions; that is,
only with IEEE single and double precision types used. Using strictfp guarantees that results of floating-point
calculations are identical on all platforms. This can be extremely useful when comparing floating-point numbers.
It can be used on classes, interfaces and non-abstract methods. [2] When applied to a method, it causes all calculations
inside the method to use strict floating-point math. When applied to a class, all calculations inside the class use strict
floating-point math. Compile-time constant expressions must always use strict floating-point behavior
Examples
public strictfp class MyFPclass {
}
// ... contents of class here ...
The Java package java.lang.Math class contains these strictfp methods:
public static strictfp double abs(double);
public static strictfp int max(int, int);
public static strictfp long max(long, long);
public static strictfp float max(float, float);
public static strictfp double max(double, double);
public static strictfp int min(int, int);

strictfp 281
Behaviors and restrictions
Strictfp is sometimes viewed as a problem of Java [3] [4] .
References
• http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ html/ Concepts. doc. html#24465
[1] Flanagan, David (March 2005). Java in a Nutshell (http:/ / oreilly. com/ catalog/ 9780596007737) (Fifth ed.). O'Reilly Media.
ISBN 978-0-596-00773-7. . Retrieved 2010-03-03.
[2] Schildt, Herbert (2007). Java: A Beginner's Guide (4 ed.). McGraw-Hill Companies. ISBN 978-0-07-226384-8.
[3] Kahan, W.; Joseph D. Darcy (1998-03-01). "How Java's Floating-Point Hurts Everyone Everywhere" (http:/ / www. cs. berkeley. edu/
~wkahan/ JAVAhurt. pdf) (PDF). . Retrieved 2006-12-09.
[4] "Types, Values, and Variables" (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ typesValues. html#4. 2. 3). Sun Microsystems. .
Retrieved 2006-12-09.
String Buffer
In object-oriented programming, a String Buffer is an alternative to a String. It has the ability to be altered through
adding or appending, whereas a String is normally fixed or unchangeable.
In Java
Theory
Java's standard way to handle text is to use its String class. Any given String in Java is an immutable object, which
means its state cannot be changed. A String has an array of characters. Whenever a String must be manipulated, any
changes require the creation of a new String (which, turn, involves the creation of a new array of characters, and
copying of the original array). This happens even if the original String's value or intermediate Strings used for the
manipulation are not kept.
Java provides an alternate class for string manipulation, called a StringBuffer [1] . A StringBuffer, like a String, has
an array to hold characters. It, however, is mutable (its state can be altered). Its array of characters is not necessarily
completely filled (as oppose to a String, whose array is always the exact required length for its contents). Thus, it has
the capability to add, remove, or change its state without creating a new object (and without the creation of a new
array, and array copying). The exception to this is when its array is no longer of suitable length to hold its content. In
this case, it is required to create a new array, and copy contents.
For these reasons, Java would handle an expression like
String newString = aString + anInt + aChar + aDouble;
like this:
String newString = (new StringBuffer(aString)).append(anInt).append(aChar).append(aDouble)).toString();
Implications
Generally, a StringBuffer is more efficient than a String in string handling. However, this is not necessarily the case,
since a StringBuffer will be required to recreate its character array when it runs out of space. Theoretically, this is
possible to happen the same number of times as a new String would be required, although this is unlikely (and the
programmer can provide length hints to prevent this). Either way, the effect is not noticeable in modern desktop
computers.

String Buffer 282
As well, the shortcomings of arrays are inherent in a StringBuffer. In order to insert or remove characters are
arbitrary positions, whole sections of arrays must be moved.
The method by which a StringBuffer is attractive in an environment with low processing power takes this ability by
using too much memory, which is likely also at a premium in this environment. This point, however, is trivial,
considering the space required for creating many instances of Strings in order to process them. As well, the
StringBuffer can be optimized to "waste" as little memory as possible.
The StringBuilder class, introduced in J2SE 5.0, differs from StringBuffer in that it is unsynchronized. When only a
single thread at a time will access the object, using a StringBuilder is more efficient than using a StringBuffer.
StringBuffer and StringBuilder are included in the java.lang package.
In .NET
Microsoft's .NET Framework has a StringBuilder class in its Base Class Library.
See also
• Analysis of algorithms
Links
• The JavaDocs of StringBuffer [1] , StringBuilder [2] and String [3] , as well as the article StringBuffer and
StringBuilder.
• The source code of these classes [4]
• Urban Performance Legends [5] - An article which involves a discussion of immutable objects with respect to
object-oriented design
References
[1] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ StringBuffer. html
[2] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ StringBuilder. html
[3] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ String. html
[4] http:/ / www. java2s. com/ Code/ JavaAPI/ java. lang/ StringBuffer. htm
[5] http:/ / www-128. ibm. com/ developerworks/ java/ library/ j-jtp04223. html?ca=dgr-lnxw01JavaUrbanLegends

Sun Web Developer Pack 283
Sun Web Developer Pack
The Sun Web Developer Pack (SWDP) is a collection of open source software released by Sun Microsystems for
developing web applications that run on Java EE application servers. The SWDP is targeted at software developers
interested in writing web applications that use Web 2.0 technologies such as Ajax, REST, Atom, and JavaScript.
Software Included in the SWDP
The SWDP consists of the following software:
• Scripting language support
• Project Phobos, a project that allows you to write web applications in JavaScript or other scripting languages
• Ajax technologies
• Project jMaki, a framework for creating Ajax-enabled web applications in Java, PHP, or Phobos
• Project Dynamic Faces, a framework for creating Ajax-enabled JavaServer Faces applications
• REST
• RESTful web services, an API for creating REST web services in Java
• WADL
• ROME, a Java API for parsing and generating RSS and Atom web feeds
• Atom Server (The ROME Propono subproject), a prototype Java API and framework for creating a web feed
server for Atom feeds
Release history
Release 1 of the SWDP was made public on March 12, 2007.
External links
• Sun Web Developer Pack home page [1]
• Documentation
• Online SWDP Tutorial [2]
• SWDP Tutorial bundle download [3]
• Getting Started with the SWDP [4]
• java.net project pages
• Project jMaki [5]
• Project Dynamic Faces [6]
• Project Phobos [7]
• WADL [8]
• ROME API [9]

Sun Web Developer Pack 284
References
[1] http:/ / developers. sun. com/ web/ swdp/ index. jsp
[2] http:/ / developers. sun. com/ web/ swdp/ docs/ tutorial/ doc/ toc. html
[3] http:/ / developers. sun. com/ web/ swdp/ docs/ tutorial/ download. html
[4] http:/ / developers. sun. com/ web/ swdp/ docs/ GettingStarted. html
[5] https:/ / ajax. dev. java. net
[6] https:/ / jsf-extensions. dev. java. net
[7] https:/ / phobos. dev. java. net
[8] https:/ / wadl. dev. java. net
[9] https:/ / rome. dev. java. net
Swing (Java)
Swing is a widget toolkit for Java. It is part
of Sun Microsystems' Java Foundation
Classes (JFC) — an API for providing a
graphical user interface (GUI) for Java
programs.
Swing was developed to provide a more
sophisticated set of GUI components than
the earlier Abstract Window Toolkit. Swing
provides a native look and feel that emulates
the look and feel of several platforms, and
also supports a pluggable look and feel that
allows applications to have a look and feel
unrelated to the underlying platform.
History
The Internet Foundation Classes (IFC) were
Example Swing widgets in Java 5 for the X Window System
a graphics library for Java originally developed by Netscape Communications Corporation and first released on
December 16, 1996. On April 2, 1997, Sun Microsystems and Netscape Communications Corporation announced
their intention to incorporate IFC with other technologies to form the Java Foundation Classes.
Swing introduced a mechanism that allowed the look and feel of every component in an application to be altered
without making substantial changes to the application code. The introduction of support for a pluggable look and feel
allows Swing components to emulate the appearance of native components while still retaining the benefits of
platform independence. This feature also makes it easy to make an application written in Swing look very different
from native programs if desired.
Originally distributed as a separately downloadable library, Swing has been included as part of the Java Standard
Edition since release 1.2. The Swing classes and components are contained in the javax.swing package hierarchy.

Swing (Java) 285
The Swing Architecture
Swing is a platform-independent, Model-View-Controller GUI framework for Java. It follows a single-threaded
programming model, and possesses the following traits:
Foundations
Swing is platform independent both in terms of expression (Java) and implementation (Look-and-Feel).
Extensible
Swing is a highly partitioned architecture, which allows for the "plugging" of various custom implementations of
specified framework interfaces: Users can provide their own custom implementation(s) of these components to
override the default implementations. In general, Swing users can extend the framework by extending existing
(framework) classes and/or providing alternative implementations of core components.
Swing is a component-based framework. The distinction between objects and components is a fairly subtle point:
concisely, a component is a well-behaved object with a known/specified characteristic pattern of behaviour. Swing
objects asynchronously fire events, have "bound" properties, and respond to a well-known set of commands (specific
to the component.) Specifically, Swing components are Java Beans components, compliant with the Java Beans
Component Architecture specifications.
Customizable
Given the programmatic rendering model of the Swing framework, fine control over the details of rendering of a
component is possible in Swing. As a general pattern, the visual representation of a Swing component is a
composition of a standard set of elements, such as a "border", "inset", decorations, etc. Typically, users will
programmaticaly customize a standard Swing component (such as a JTable) by assigning specific Borders, Colors,
Backgrounds, opacities, etc., as the properties of that component. The core component will then use these properties
(settings) to determine the appropriate renderers to use in painting its various aspects. However, it is also completely
possible to create unique GUI controls with highly customized visual representation.
Configurable
Swing's heavy reliance on runtime mechanisms and indirect composition patterns allows it to respond at runtime to
fundamental changes in its settings. For example, a Swing-based application can change its look and feel at runtime.
Further, users can provide their own look and feel implementation, which allows for uniform changes in the look and
feel of existing Swing applications without any programmatic change to the application code.
Lightweight UI
Swing's configurability is a result of a choice not to use the native host OS's GUI controls for displaying itself.
Swing "paints" its controls programmatically through the use of Java 2D APIs, rather than calling into a native user
interface toolkit. Thus, a Swing component does not have a corresponding native OS GUI component, and is free to
render itself in any way that is possible with the underlying graphics APIs.
However, at its core every Swing component relies on an AWT container, since (Swing's) JComponent extends
(AWT's) Container. This allows Swing to plug into the host OS's GUI management framework, including the crucial
device/screen mappings and user interactions, such as key presses or mouse movements. Swing simply "transposes"
its own (OS agnostic) semantics over the underlying (OS specific) components. So, for example, every Swing
component paints its rendition on the graphic device in response to a call to component.paint(), which is defined in
(AWT) Container. But unlike AWT components, which delegated the painting to their OS-native "heavyweight"
widget, Swing components are responsible for their own rendering.
This transposition and decoupling is not merely visual, and extends to Swing's management and application of its
own OS-independent semantics for events fired within its component containment hierarchies. Generally speaking,

Swing (Java) 286
the Swing Architecture delegates the task of mapping the various flavors of OS GUI semantics onto a simple, but
generalized, pattern to the AWT container. Building on that generalized platform, it establishes its own rich and
complex GUI semantics in the form of the JComponent model.
Loosely-Coupled and MVC
The Swing library makes heavy use of the Model/View/Controller software design pattern [1] , which conceptually
decouples the data being viewed from the user interface controls through which it is viewed. Because of this, most
Swing components have associated models (which are specified in terms of Java interfaces), and the programmer can
use various default implementations or provide their own. The framework provides default implementations of
model interfaces for all of its concrete components. The typical use of the Swing framework does not require the
creation of custom models, as the framework provides a set of default implementations that are transparently, by
default, associated with the corresponding JComponent child class in the Swing library. In general, only complex
components, such as tables, trees and sometimes lists, may require the custom model implementations around the
application-specific data structures. To get a good sense of the potential that the Swing architecture makes possible,
consider the hypothetical situation where custom models for tables and lists are wrappers over DAO and/or EJB
services.
Typically, Swing component model objects are responsible for providing a concise interface defining events fired,
and accessible properties for the (conceptual) data model for use by the associated JComponent. Given that the
overall MVC pattern is a loosely-coupled collaborative object relationship pattern, the model provides the
programmatic means for attaching event listeners to the data model object. Typically, these events are model centric
(ex: a "row inserted" event in a table model) and are mapped by the JComponent specialization into a meaningful
event for the GUI component.
For example, the JTable has a model called TableModel that describes an interface for how a table would access
tabular data. A default implementation of this operates on a two-dimensional array.
The view component of a Swing JComponent is the object used to graphically "represent" the conceptual GUI
control. A distinction of Swing, as a GUI framework, is in its reliance on programmatically-rendered GUI controls
(as opposed to the use of the native host OS's GUI controls). Prior to Java 6 Update 10, this distinction was a source
of complications when mixing AWT controls, which use native controls, with Swing controls in a GUI (see Mixing
AWT and Swing components).
Finally, in terms of visual composition and management, Swing favors relative layouts (which specify the positional
relationships between components) as opposed to absolute layouts (which specify the exact location and size of
components). This bias towards "fluid"' visual ordering is due to its origins in the applet operating environment that
framed the design and development of the original Java GUI toolkit. (Conceptually, this view of the layout
management is quite similar to that which informs the rendering of HTML content in browsers, and addresses the
same set of concerns that motivated the former.)

Swing (Java) 287
Relationship to AWT
Since early versions of Java, a portion of the Abstract Window Toolkit
(AWT) has provided platform-independent APIs for user interface
components. In AWT, each component is rendered and controlled by a
native peer component specific to the underlying windowing system.
By contrast, Swing components are often described as lightweight
because they do not require allocation of native resources in the
operating system's windowing toolkit. The AWT components are
referred to as heavyweight components.
Much of the Swing API is generally a complementary extension of the
AWT rather than a direct replacement. In fact, every Swing lightweight
interface ultimately exists within an AWT heavyweight component
because all of the top-level components in Swing (JApplet, JDialog,
JFrame, and JWindow) extend an AWT top-level container. Prior to
Java 6 Update 10, the use of both lightweight and heavyweight
AWT and Swing class hierarchy
components within the same window was generally discouraged due to Z-order incompatibilities. However, later
version of Java have fixed these issues, and both Swing and AWT components can now be used in one GUI without
Z-order issues.
The core rendering functionality used by Swing to draw its lightweight components is provided by Java 2D, another
part of JFC.
Relationship to SWT
The Standard Widget Toolkit (SWT) is a competing toolkit originally developed by IBM and now maintained by the
Eclipse community. SWT's implementation has more in common with the heavyweight components of AWT. This
confers benefits such as more accurate fidelity with the underlying native windowing toolkit, at the cost of an
increased exposure to the native platform in the programming model.
The advent of SWT has given rise to a great deal of division among Java desktop developers, with many strongly
favoring either SWT or Swing. Sun's development on Swing continues to focus on platform look and feel (PLAF)
fidelity with each platform's windowing toolkit in the approaching Java SE 7 release (as of December 2006).
There has been significant debate and speculation about the performance of SWT versus Swing; some hinted that
SWT's heavy dependence on JNI would make it slower when the GUI component and Java need to communicate
data, but faster at rendering when the data model has been loaded into the GUI, but this has not been confirmed
either way [2] . A fairly thorough set of benchmarks concluded that neither Swing nor SWT clearly outperformed the
other in the general case [3] .
SWT serves the Windows platform very well but is considered by some to be less effective as a technology for
cross-platform development. By using the high-level features of each native windowing toolkit, SWT returns to the
issues seen in the mid 90's (with toolkits like zApp, Zinc, XVT and IBM/Smalltalk) where toolkits attempted to
mask differences in focus behaviour, event triggering and graphical layout. Failure to match behavior on each
platform can cause subtle but difficult-to-resolve bugs that impact user interaction and the appearance of the GUI.

Swing (Java) 288
Examples
A basic example
The following is a rather simple Swing-based program. It displays a window (a JFrame) containing a label and a
button.
Notice how all instantiation and handling of all Swing components are done on the Event Dispatch Thread by use of
the method EventQueue.invokeLater(Runnable)) and an anonymous Runnable class (see Swing and thread safety).
// Import the swing and AWT classes needed
import java.awt.EventQueue;
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
/**
* Basic Swing example.
*/
public class SwingExample {
public static void main(String[] args) {
on the
// Make sure all Swing/AWT instantiations and accesses are done
// Event Dispatch Thread (EDT)
EventQueue.invokeLater(new Runnable() {
@Override
"decorations", i.e.
contained
else the
public void run() {
// Create a JFrame, which is a Window with
// title, border and close-button
JFrame f = new JFrame("Swing Example Window");
// Set a simple Layout Manager that arranges the
// Components
f.setLayout(new FlowLayout());
// Add some Components
f.add(new JLabel("Hello, world!"));
f.add(new JButton("Press me!"));
// "Pack" the window, making it "just big enough".
f.pack();
// Set the default close operation for the window, or

Swing (Java) 289
}
window
}
See also
});
}
• Abstract Window Toolkit
• Layout manager
// program won't exit when clicking close button
// (The default is HIDE_ON_CLOSE, which just makes the
// invisible, and thus doesn't exit the app)
f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
// Set the visibility as true, thereby displaying it
f.setVisible(true);
• SwingLabs - Extensions to Swing that might be included in Swing in the future
• Standard Widget Toolkit A third party competing widget toolkit resembling the Abstract Window Toolkit in
function.
References
• Matthew Robinson, Pavel Vorobiev: Swing, Second Edition, Manning, ISBN 1-930110-88-X
• David M. Geary: Graphic Java 2, Volume 2: Swing, Prentice Hall, ISBN 0-13-079667-0
• John Zukowski: The Definitive Guide to Java Swing, Third Edition, Apress, ISBN 1-590-59447-9
• James Elliott, Robert Eckstein, Marc Loy, David Wood, Brian Cole: Java Swing, O'Reilly, ISBN 0-596-00408-7
• Kathy Walrath, Mary Campione, Alison Huml, Sharon Zakhour: The JFC Swing Tutorial: A Guide to
Constructing GUIs, Addison-Wesley Professional, ISBN 0-201-91467-0
• Joshua Marinacci, Chris Adamson: Swing Hacks, O'Reilly, ISBN 0-596-00907-0
External links
• The Swing API documentation [7]
• The Swing architecture [4]
References
[1] Swing as MVC (http:/ / java. sun. com/ products/ jfc/ tsc/ articles/ architecture/ )
[2] Swing vs. SWT Performance - Have a Look at the Call Stacks (http:/ / www. javalobby. org/ java/ forums/ t65168. html)
[3] Igor, Križnar (2005-05-10). "SWT Vs. Swing Performance Comparison" (http:/ / cosylib. cosylab. com/ pub/ CSS/ DOC-SWT_Vs.
_Swing_Performance_Comparison. pdf). cosylab.com. . Retrieved 2008-05-24. "It is hard to give a rule-of-thumb where SWT would
outperform Swing, or vice versa. In some environments (e.g., Windows), SWT is a winner. In others (Linux, VMware hosting Windows), Swing
and its redraw optimization outperform SWT significantly. Differences in performance are significant: factors of 2 and more are common, in
either direction."
[4] http:/ / java. sun. com/ products/ jfc/ tsc/ articles/ architecture/

SwingLabs 290
SwingLabs
Developer(s) Sun
Operating
system
Cross-platform
Type Widget library
License LGPL
Website
swinglabs.dev.java.net [1]
swingLabs is a Sun Open source project proposing extensions to the Java Swing GUI toolkit. Available components
include:
• Sorting, filtering, highlighting for tables, trees, and lists
• Find/search
• Auto-completion
• Login/authentication framework
• TreeTable component
• Collapsible panel component
• Date picker component
• Tip-of-the-Day component
The aim of the project is to experiment new or enhanced GUI functionalities that are required by Rich client
applications. It acts as a testbed for ideas related to client side technologies.
Integration into Java API
Successful project components are eventually incorporated into the core Swing toolkit for future Java versions,
although API compatibility is not guaranteed. Examples of these are:
• the GroupLayout manager in Java SE 6 [2] .
• incorporation of the SystemTray in Java SE 6.
• the new Desktop class in Java SE 6, which allows to launch easily associated applications registered on the native
desktop, as for example : launching the user-default browser, launching the user-default mail client, launching a
registered application to open, edit or print a specified file.
License
The project is distributed under a LGPL license.
Sub-projects
The swingLabs project [1] is divided into several sub-projects. For example :
• swingX [3] : provides extensions to the Java Swing GUI toolkit.
• JDIC [4] : as for JDesktop Integration Components, a project aims to make Java applications first-class citizens of
current desktop platforms without sacrificing platform independence. Its mission is to enable seamless
desktop/Java integration.
• nimbus [5] : a Look and feel using synth, the Java skinnable look and feel.
• swingLayout [6] : the home of the GroupLayout manager, before inclusion in Java SE 6.

SwingLabs 291
• JDNC [7] : Contained components that allow to build easily Swing-based rich-client Java applications. The project
is no more actively maintained. It has been replaced by Swing Application Framework (JSR 296)
• scenegraph [8] : A library that provide 2D Scene graph functionality to Java 2D, including Swing widgets. This
library is used internally by the JavaFX Script language.
• PDFRenderer [9] : A 100% pure Java PDF viewer library.
See also
• Swing (Java)
• Swing Application Framework
• SwingWorker
External links
• swingLabs project home page [1]
• swingx project home page [3]
• swingx project tutorials and documents [10]
• swingx 0.7 version javadoc [11]
References
[1] https:/ / swinglabs. dev. java. net/
[2] GroupLayout was initially developed in conjunction with Matisse, the GUI builder of NetBeans.
[3] https:/ / swingx. dev. java. net/
[4] https:/ / jdic. dev. java. net/
[5] https:/ / nimbus. dev. java. net/
[6] https:/ / swing-layout. dev. java. net/
[7] https:/ / jdnc. dev. java. net/
[8] https:/ / scenegraph. dev. java. net/
[9] https:/ / pdf-renderer. dev. java. net/
[10] http:/ / swinglabs. org/ docs. jsp
[11] http:/ / www. javadesktop. org/ swinglabs/ build/ weekly/ latest/ swingx-HEAD/ javadoc/ index. html

Synth Look and Feel 292
Synth Look and Feel
synth is a skinnable Java look and feel, which is configured with an XML property file.
According to Sun, goals for synth were:
• Enable to create custom look without writing any code.
• Allow appearance to be configured from images.
• Provide the ability to customize the look of a component based on its named properties.
• Provide a centralized point for overriding the look of all components.
• Enable custom rendering based on images, or user-defined SynthPainters.
History
synth is available beginning with version J2SE 5.0 of Java (see Java version history).
Java SE 6 Update 10 release and newer contain Nimbus, a cross-platform Look and Feel implemented with Synth.
However, for backwards compatibility, Metal is still the default Swing look and feel. [1]
Architecture
Synth is a skinnable look and feel in which all painting is delegated to the components, without having to write any
code (see Synth Look and Feel).
However synth does not provide a default look, and components that are not defined in the synth XML file will not
be painted. It is however possible to assign a default style to all other widgets, and customize styles for some specific
widgets only.
Example
The following XML declaration defines a style named textfield and binds it to all text fields. The defaultStyle allows
to set a default font, foreground and background colors to all other widgets.

Synth Look and Feel 293
Supposing that the XML declaration is defined in a file named synthExample.xml, the following code loads the XML
definition file and sets the current look and feel to synth (loading a synth Look and Feel is done using the load
method of the SynthLookAndFeel class):
SynthLookAndFeel laf = new SynthLookAndFeel();
laf.load(new File("synthExample.xml").toURL());
UIManager.setLookAndFeel(laf);
See also
• Swing, the standard cross-platform widget toolkit for Java
• Pluggable look and feel
• Look and Feel in Widget Toolkits
External links
• Synth Look and Feel API documentation
• synth file format [2]
• synth tutorial [3]
• another synth tutorial [4]
• nimbus home page [5]
• Synthetica - commercial Synth Look and Feel with many different themes [8]
• EaSynth Look And Feel Designer - commercial IDE for Synth based look and feel [5]
References
[1] "Nimbus Look and Feel (The Java Tutorials > Creating a GUI With JFC/Swing > Modifying the Look and Feel)" (http:/ / java. sun. com/
docs/ books/ tutorial/ uiswing/ lookandfeel/ nimbus. html). Sun Microsystems. . Retrieved 2010-07-01.
[2] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ javax/ swing/ plaf/ synth/ doc-files/ synthFileFormat. html
[3] http:/ / javadesktop. org/ articles/ synth/
[4] http:/ / www. ibm. com/ developerworks/ java/ library/ j-synth/
[5] http:/ / www. easynth. com/ products/ EaSynthLookAndFeelDesigner. html

TeachScheme! 294
TeachScheme!
The TeachScheme! project is an outreach effort of the PLT research group. The goal is to train college faculty, high
school teachers and possibly even middle school teachers in programming and computing.
History
Matthias Felleisen and PLT started the effort in 1995 (January, one day after the POPL symposium) in response to
observations of his Rice freshmen students and the algebra curriculum of local public schools. His objective was to
use functional programming to bring mathematics alive and to help inject design knowledge into the introductory
computer science curriculum.
The group raised funds from several private foundations, the US Department of Education, and the National Science
Foundation to create
• software appropriate for novices in functional programming
• courseware (curricula, lecture notes, exercises, mini-projects)
• teacher training camps.
Over ten years, it ran several dozen one-week workshops for some 550 teachers. In 2005, the TeachScheme! project
ran an Anniversary workshop where two dozen teachers presented their work with students.
In 2010, PLT renamed its major programming language Racket. The name for DrScheme, the IDE, was changed to
DrRacket.
Functional Programming, Computing and Algebra
The starting point of TeachScheme! is the observation that students are computers in grade school courses on
arithmetic and middle/high school courses on pre/algebra. Teachers program them with rules and run specific
problems via exercises. The key is that students execute purely functional programs.
If we can turn students into teachers that create functional programs and run them on computers, we can reinforce
this content and show students how writing down mathematics and how writing down functional programs creates
lively animated scenes and even computer games.
Here is an example:
(require 2htdp/universe)
(require 2htdp/image)
;; create an image from the current time
(define (create-image t)
(place-image APPLE 50 (* 1/10 t t) SPACE))
;; names for basic images
(define APPLE (circle 3 "solid" "red"))
(define SPACE (empty-scene 100 100))
(animate create-image)
This short program simulates an apple falling from the top to the bottom of a small white canvas. It consists of three
parts:

TeachScheme! 295
• a function definition for create-image, which is a one-line function in mathematics, assuming an algebra of
images with place-image, circle, and empty-scene have been introduced;
• two abbreviations, where names are equated with some value, just as in "let x be 5" in an algebra text; and
• one line for running the program.
A teacher can explain create-image as easily as any ordinary function in an algebra course. For example, one can
first draw a table with two rows and n columns where each column contains t at the top and an appropriate image at
the bottom. That is, if the numbers increase from left to right, then on each image the red dot is a little bit lower.
Finally the animate line applies the given function, create-image, at the rate of 28 ticks per second to 0, 1, 2, 3, and
so on. The resulting images are displayed on the computer monitor at the same pace. That's how movies are made.
The background needed for such an example is little more than knowledge about making movies, about the algebra
of pictures in DrRacket (which is like the one for numbers), and minimal pre-algebra. The TeachScheme! project
claims, however, that children would have more fun with such "live" functions than with algebraic expressions that
count the number of garden tiles [see Prentice Hall books for grades 8-9].
The TeachScheme! project proposes that both traditional mathematics as well as science courses could benefit from
an integration of this form of programming. In contrast to the traditional Basic or Visual Basic blocks in such books,
a Racket program consists of as many lines as the mathematics. Moving between the mathematics and the program is
thus straightforward. Better still, the meaning of the two are the same. DrRacket's algebraic stepper can illustrate
how Racket evaluates the program as if it were a sixth or seventh grade student, step by step, using plain algebra.
Functional Programming, Computing and Design in Programming 101
For the introductory curriculum on programming, the TeachScheme! project emphasizes that courses should focus
on the role of systematic design. Even if students never program again, they should see how helpful a systematic
approach to problem solving is. This should help them whether they become programmers or doctors or journalists
or photographers. Thus, an introductory course in programming would not be perceived as a place where students
learn about the syntax of the currently fashionable (and soon-to-be-obsolete) programming languages, but a place
where they can learn something widely applicable.
The key design element of the TeachScheme! curriculum is the design recipe. It has two dimensions: the process
dimension and the data dimension.
Along the process dimension students learn that there are six steps to designing a (simple) program, before they can
run it and others can use it:
• problem analysis with the goal of describing the classes of data that go into the program and come out;
• the reformulation of the problem statement as a concise purpose statement;
• the creation of examples that illustrate the purpose statement and that serve as criteria for success;
• the organization of givens, also called a template or inventory;
• coding;
• and the creation of a test suite from examples to ensure the program works properly on small inputs.
Note that, as in test-driven development, test cases are written before coding, as part of requirements analysis, rather
than afterward as part of testing.
Almost any human endeavour can benefit from clearly understanding the problem, defining criteria for success,
analyzing the available resources/givens, developing a proposed solution, and checking it against the criteria, in that
order. A journalist, for example, benefits from a similar process: figuring out the major concepts in a story; coining a
headline; lining up examples and specific data; organizing the article about the story around the givens and how the
story unfolded; writing; and fact checking.
The data dimension can be summarized by the maxim the shape of the data determines the shape of the code and
tests. For example, if the input or output data type has three variants, a test suite should have at least one test case

TeachScheme! 296
from each variant, and program code will probably contain a three-way conditional (whether explicit or hidden in a
polymorphic dispatch). If the input or output data type has three fields, a test suite will have to specify values for
those three fields, and program code will have to refer to those three fields. If the input or output data type has a
simple base case and one or more self-referential variants, the test suite should include a base case and one or more
non-base cases, and the program code will probably have a base case and one or more self-referential cases,
isomorphic to the data type. The technique of recursion, rather than being scary and mysterious, is simply the
application of already-learned techniques to a self-referential data type.
Organizing the givens is the task of translating the descriptions of data into a program skeleton. Each form of
description determines a specific form of program organization. The transformation is nearly mechanical and helps
the students focus on the creative part of the task.
How to Design Programs is the text book authored by the core of the TeachScheme! group.
TeachScheme! and choice of programming language
The name TeachScheme! appears to imply that this design recipe requires Scheme (now Racket) and is only
teachable with DrRacket. Neither conclusion is true, however. The TeachScheme! members and their students have
successfully applied the design recipe in Assembly, C, Java, ML, Python, and other programming languages, not to
speak of poetry, geometry, and biology courses.
To get started the TeachScheme! project has produced three essential elements:
• a series of successively more powerful and permissive teaching languages, which are dialects of Racket, matched
to the design recipe but with error reporting matched to the student's level (for example, many things that are legal
in standard Racket, but which a beginning student doesn't need, are flagged as errors in the Beginning Student
level);
• a beginner-friendly, freely-downloadable, pedagogic programming environment, DrRacket, that enforces these
language levels;
• a curriculum, encoded mostly in the book HTDP and its (draft) successor HtDP 2nd Edition [1]
Their choice of Racket reflects their belief that Racket is a good language for a small team with little funding (in
comparison to Java) to validate their conjectures. The PLT group has always tried to ensure, however, that the ideas
remain portable to other contexts.
From TeachScheme! to ReachJava
Over the past few years, the team has also created a second part of the curriculum. It demonstrates how the same
design recipe ideas apply to a complex object-oriented programming language, such as Java. This phase of the
curriculum applies the same design recipe to Java, initially in a functional paradigm, then introducing object-oriented
concepts such as polymorphism and inheritance, and then introducing the imperative techniques that are idiomatic in
mainstream Java.
A part of the team has a grant from the National Science Foundation for conducting field tests in colleges and high
schools. Professional-development workshops took place in the summer of 2007, 2008, 2009, and 2010. This part of
the project is dubbed ReachJava; the accompanying book is tentatively titled "How to Design Classes."

TeachScheme! 297
TeachScheme! and Bootstrap
Recently PLT at Northeastern University and Citizen Schools from Boston [2] have joint efforts to reach out to inner
city students with after-school programs. Citizen Schools is a nation-wide organization that matches volunteers with
after-school program sites and gets them started with scripted curricula. They have translated the TeachScheme!
material into a sixth-grade curriculum and tested it with great success in Boston. [3] The effect on the mathematics
courses of this program has encouraged Microsoft to fund a national scale-up effort, developing materials for
training teachers and creating sites in Texas, California, and other volunteer cities.
External links
• TeachScheme! [4]
• Racket [5]
• How to Design Programs [6]
• Bootstrap [7]
References
[1] http:/ / www. ccs. neu. edu/ home/ matthias/ HtDP2e/
[2] http:/ / www. citizenschools. org/ boston/
[3] http:/ / www. cs. brown. edu/ ~sk/ Publications/ Talks/ Moby-Bootstrap/
[4] http:/ / www. teach-scheme. org/
[5] http:/ / www. racket-lang. org/
[6] http:/ / www. htdp. org/
[7] http:/ / www. bootstrapworld. org/
The Java Posse
The Java Posse is a podcast of news,
discussion, and interviews about the
Java programming language and
associated Java technologies. The four
regular contributors are Tor Norbye
(Sun Microsystems), Carl Quinn
(Google), Dick Wall (Google) and Joe
Nuxoll (Apple Inc.). [1] By January
2007, the estimated listenership was
between 7- and 10,000 people. [2]
The podcast was begun in September
2005 and was a successor to an earlier
short-lived Java podcast produced by
Wall called "JavaCast", cohosted with
Brandon Werner. [1] As of December
2007, over 150 episodes of The Java
(Left to right) Tor Norbye, Joe Nuxoll, Carl Quinn and Dick Wall recording Java Posse
episode #96 in December 2006
Posse have been recorded. The group has also organized the "Java Posse Roundup", an unconference held in Crested
Butte, Colorado in 2007 and organized by Bruce Eckel. Sessions from the roundup have been published as episodes
of the podcast.
Quinn and Wall also co-host the Google developer podcast.

The Java Posse 298
External links
• The Java Posse web site [3] .
References
[1] Chris Adamson, "The Java Podcasters" (http:/ / www. onjava. com/ pub/ a/ onjava/ 2006/ 01/ 25/ java-podcasters. html), 25 January 2006
[2] Chris Adamson, Editor's Daily Blog (http:/ / weblogs. java. net/ blog/ editors/ archives/ 2007/ 01/ hold_on. html), java.net, 25 January 2007
[3] http:/ / javaposse. com/
Unified Expression Language
The Java Unified Expression Language is a special purpose programming language mostly used in Java web
applications for embedding expressions into web pages. The Java specification writers and expert groups of the Java
web-tier technologies have worked on a unified expression language which is now part of the JSP 2.1 specification
(JSR-245). While the expression language is part of the JSP specification, it does not depend on the JSP specification
and therefore it is available for a variety of technologies.
History
The expression language started out as part of the JavaServer Pages Standard Tag Library (JSTL) and was originally
called SPEL (Simplest Possible Expression Language). It offered a simple way to access data objects. Over the
years, the expression language has evolved to include more advanced functionality and it was included in the JSP 2.0
specification, because of the popularity and success in the community.
During the development of JSP 2.0, the JavaServer Faces technology was released which also needed an expression
language, but the expression language defined in the JSP 2.0 specification didn't satisfy all the needs for
development with JSF technology. The most obvious limitation is that its expressions are evaluated immediately.
And also, the JSF components need a way to invoke methods on server-side objects. A more powerful language was
created with the following new features:
• Deferred expressions, which are not immediately evaluated
• Expressions that can set as well as get data
• Method expressions, which can invoke methods
The new expression language worked well for the purposes of JSF. But developers had problems when integrating
the JSP EL with the JSF EL because of conflicts. Because of these incompatibilities, the unified expression language
initiative was started to unify these expression languages. As of JSP 2.1, the expression languages of JSP 2.0 and JSF
1.1 have been merged into a single unified expression language (EL 2.1).
Features
The new unified EL is a union of the JSP and JSF expression languages. In addition to the features already available
in the JSP EL, the unified EL has the following features:
• Deferred evaluation
• Support for expressions that can set values and expressions that can invoke methods
• A pluggable API for resolving expressions

Unified Expression Language 299
Implementations
JUEL is an open-source implementation of the Unified Expression Language. It is considered stable and feature
complete and is licensed under the Apache License 2.0. JUEL is also suitable for use in non-JSP applications.
External links
• JSR 245: JavaServer Pages 2.1 [1]
• Unified Expression Language [2] (article at Sun Developer Network (SDN)
• Unified Expression Language for JSP and JSF [3] (article at java.net)
• JUEL [4] is an implementation of the Unified Expression Language (EL), specified as part of the JSP 2.1 standard
(JSR-245).
References
[1] http:/ / www. jcp. org/ en/ jsr/ detail?id=245
[2] http:/ / java. sun. com/ products/ jsp/ reference/ techart/ unifiedEL. html
[3] http:/ / today. java. net/ pub/ a/ today/ 2006/ 03/ 07/ unified-jsp-jsf-expression-language. html
[4] http:/ / juel. sourceforge. net
Java Virtual Machine
A Java Virtual Machine (JVM) enables a set of computer software programs and data structures to use a virtual
machine model for the execution of other computer programs and scripts. The model used by a JVM accepts a form
of computer intermediate language commonly referred to as Java bytecode. This language conceptually represents
the instruction set of a stack-oriented, capability architecture. Sun has claimed there are over 4.5 billion
JVM-enabled devices. [1]
Overview
A JVM can also be used to implement programming languages other than Java. For example, Ada source code can
be compiled to Java bytecode, which may then be executed by a JVM. JVMs can also be released by other
companies besides Sun (the developer of Java) — JVMs using the "Java" trademark may be developed by other
companies as long as they adhere to the JVM specification published by Sun (and related contractual obligations).
Java was conceived keeping in mind the concept of WORA ‘write once and run anywhere’. This is possible using the
Java Virtual Machine. The JVM is the environment in which java programs execute. It is software that is
implemented on top of real hardware and operating system.
JVM is a crucial component of the Java Platform, and because JVMs are available for many hardware and software
platforms, Java can be both middleware and a platform in its own right — hence the trademark write once, run
anywhere. The use of the same bytecode for all platforms allows Java to be described as "compile once, run
anywhere", as opposed to "write once, compile anywhere", which describes cross-platform compiled languages. A
JVM also enables such features as Automated Exception Handling, which provides 'root-cause' debugging
information for every software error (exception), independent of the source code.
A JVM is distributed along with a set of standard class libraries that implement the Java API (Application
Programming Interface). An API is provided by a computer system, library, or application in order to allow data
exchange between them. APIs are bundled together as the Java Runtime Environment.

Java Virtual Machine 300
Execution environment
Programs intended to run on a JVM must be compiled into a standardized portable binary format, which typically
comes in the form of .class files. A program may consist of many classes in different files. For easier distribution of
large programs, multiple class files may be packaged together in a .jar file (short for Java archive).
The JVM runtime executes .class or .jar files, emulating the JVM instruction set by interpreting it, or using a
just-in-time compiler (JIT) such as Sun's HotSpot. JIT compiling, not interpreting, is used in most JVMs today to
achieve greater speed. Ahead-of-time compilers that enable the developer to precompile class files into native code
for a particular platforms also exist.
Like most virtual machines, the Java Virtual Machine has a stack-based architecture akin to a
microcontroller/microprocessor. However, the JVM also has low-level support for Java-like classes and methods,
which amounts to a highly idiosyncratic memory model and capability-based architecture.
The JVM, which is the instance of the 'JRE' (Java Runtime Environment), comes into action when a Java program is
executed. When execution is complete, this instance is garbage collected. JIT is the part of the JVM that is used to
speed up the execution time. JIT compiles parts of the byte code that have similar functionality at the same time, and
hence reduces the amount of time needed for compilation.
JVM languages
Versions of non-JVM languages
Language On JVM
Erlang Erjang
JavaScript Rhino
PHP Quercus
Python Jython
REXX
NetRexx [2]
Ruby JRuby
Tcl Jacl
Languages designed expressly for JVM
MIDletPascal
Clojure
Groovy
Scala
Although the JVM was primarily aimed at running compiled Java programs, many other languages can now run on
top of it [3] . The JVM has currently no built-in support for dynamically typed languages: the existing JVM
instruction set is statically typed, [4] although the JVM can be used to implement interpreters for dynamic languages.
The JVM has a limited support for dynamically modifying existing classes and methods; this currently only works in
a debugging environment. However, new classes and methods can be added dynamically. Built-in support for
dynamic languages is currently planned for Java 7. [5]

Java Virtual Machine 301
Bytecode verifier
A basic philosophy of Java is that it is inherently "safe" from the standpoint that no user program can "crash" the
host machine or otherwise interfere inappropriately with other operations on the host machine, and that it is possible
to protect certain functions and data structures belonging to "trusted" code from access or corruption by "untrusted"
code executing within the same JVM. Furthermore, common programmer errors that often lead to data corruption or
unpredictable behavior such as accessing off the end of an array or using an uninitialized pointer are not allowed to
occur. Several features of Java combine to provide this safety, including the class model, the garbage-collected heap,
and the verifier.
The JVM verifies all bytecode before it is executed. This verification consists primarily of three types of checks:
• Branches are always to valid locations
• Data is always initialized and references are always type-safe
• Access to "private" or "package private" data and methods is rigidly controlled.
The first two of these checks take place primarily during the "verification" step that occurs when a class is loaded
and made eligible for use. The third is primarily performed dynamically, when data items or methods of a class are
first accessed by another class.
The verifier permits only some bytecode sequences in valid programs, e.g. a jump (branch) instruction can only
target an instruction within the same function or method. Furthermore, the verifier ensures that any given instruction
operates on a fixed stack location [6] , allowing the JIT compiler to transform stack accesses into fixed register
accesses. Because of this, the fact that JVM is a stack architecture does not imply a speed penalty for emulation on
register-based architectures when using a JIT compiler. In the face of the code-verified JVM architecture, it makes
no difference to a JIT compiler whether it gets named imaginary registers or imaginary stack positions that need to
be allocated to the target architecture's registers. In fact, code verification makes the JVM different from a classic
stack architecture whose efficient emulation with a JIT compiler is more complicated and typically carried out by a
slower interpreter.
Code verification also ensures that arbitrary bit patterns cannot get used as an address. Memory protection is
achieved without the need for a Memory management unit (MMU). Thus, JVM is an efficient way of getting
memory protection on simple architectures that lack an MMU. This is analogous to managed code in Microsoft's
.NET Common Language Runtime, and conceptually similar to capability architectures such as the Plessey 250, and
IBM System/38.
Bytecode instructions
The JVM has instructions for the following groups of tasks:
• Load and store
• Arithmetic
• Type conversion
• Object creation and manipulation
• Operand stack management (push / pop)
• Control transfer (branching)
• Method invocation and return
• Throwing exceptions
• Monitor-based concurrency
The aim is binary compatibility. Each particular host operating system needs its own implementation of the JVM and
runtime. These JVMs interpret the byte code semantically the same way, but the actual implementation may be
different. More complicated than just the emulation of bytecode is compatible and efficient implementation of the
Java core API that has to be mapped to each host operating system.

Java Virtual Machine 302
Secure execution of remote code
A virtual machine architecture allows very fine-grained control over the actions that code within the machine is
permitted to take. This is designed to allow safe execution of untrusted code from remote sources, a model used by
Java applets. Applets run within a VM incorporated into a user's browser, executing code downloaded from a remote
HTTP server. The remote code runs in a restricted "sandbox", which is designed to protect the user from
misbehaving or malicious code. Publishers can purchase a certificate with which to digitally sign applets as "safe",
giving them permission to ask the user to break out of the sandbox and access the local file system, clipboard or
network.
C to bytecode compilers
From the point of view of a compiler, the Java Virtual Machine is just another processor with an instruction set, Java
bytecode, for which code can be generated. The JVM was originally designed to execute programs written in the
Java language. However, the JVM provides an execution environment in the form of a bytecode instruction set and a
runtime system that is general enough that it can be used as the target for compilers of other languages.
Because of its close association with the Java language, the JVM performs the strict runtime checks mandated by the
Java specification. That requires C to bytecode compilers to provide their own "lax machine abstraction", for
instance producing compiled code that uses a Java array to represent main memory (so pointers can be compiled to
integers), and linking the C library to a centralized Java class that emulates system calls. Most or all of the compilers
listed below use a similar approach.
Several C to bytecode compilers exist:
• NestedVM [7] translates C to MIPS machine language first before converting to Java bytecode.
• Cybil [8] works similarly to NestedVM but targets J2ME devices.
• LLJVM [9] compiles C to LLVM IR, which is then translated to JVM bytecode.
• C2J [10] is also GCC-based, but it produces intermediary Java source code before generating bytecode [11] .
Supports the full ANSI C runtime.
• Axiomatic Multi-Platform C [12] supports full ANSI C 1989, SWT, and J2ME CDC 1.1 for mobile devices.
• Java Backend for GCC [13] , possibly the oldest project of its kind, was developed at The University of
Queensland in 1999.
• Javum [14] is an attempt to port the full GNU environment to the JVM, and includes one of the above compilers
packaged with additional utilities.
• egcs-jvm [15] appears to be an inactive project.
Compilers targeting Java bytecode have been written for other programming languages, including Ada and COBOL.
Licensing
Starting with J2SE 5.0, changes to the JVM specification have been developed under the Java Community Process as
JSR 924 [16] . As of 2006, changes to specification to support changes proposed to the class file format (JSR 202 [17] )
are being done as a maintenance release of JSR 924. The specification for the JVM is published in book form, [18]
known as "blue book". The preface states:
We intend that this specification should sufficiently document the Java Virtual Machine to make possible
compatible clean-room implementations. Sun provides tests that verify the proper operation of
implementations of the Java Virtual Machine.
Sun's JVM is called HotSpot. Clean-room Java implementations include Kaffe, IBM J9 and Dalvik. Sun retains
control over the Java trademark, which it uses to certify implementation suites as fully compatible with Sun's
specification.

Java Virtual Machine 303
Heap
The Java Virtual Machine heap is the area of memory used by the JVM (and specifically HotSpot) for dynamic
memory allocation [19] . The heap is split up into "generations":
• The young generation stores short-lived objects that are created and immediately garbage collected.
• Objects that persist longer are moved to the old generation (also called the tenured generation).
[20] [21]
• The permanent generation (or permgen) is used for class definitions and associated metadata.
There was originally no permanent generation, and objects and classes were just stored together in the same area.
But as class unloading occurs much more rarely than objects are collected, moving class structures to a specific area
allows significant performance improvements [20] .
See also
• List of Java virtual machines
• Comparison of application virtual machines
• Automated Exception Handling
• Java performance
• List of JVM languages
References
• Clarifications and Amendments to the Java Virtual Machine Specification, Second Edition [22] includes list of
changes to be made to support J2SE 5.0 and JSR 45
• JSR 45 [23] – Specifies changes to the class file format to support source-level debugging of languages such as
JSP and SQLJ that are translated to Java
External links
• The Java Virtual Machine Specification [7]
• Java implementations [24] at the Open Directory Project
• Sun to build virtual machine for iPhone - ComputerWorld [25]
• Java Virtual Machine Download Link [26]
• JVM implementation in pure Java [27]
References
[1] http:/ / www. java. com/ en/ about/ Learn about Java Technology
[2] 1996, possibly the first new language specifically designed to run on the JVM)
[3] Tolksdorf, Robert (2005). "Languages for the Java VM" (http:/ / www. is-research. de/ info/ vmlanguages/ ). . Retrieved 2008-06-08.
[4] Nutter, Charles (2007-01-03). "InvokeDynamic: Actually Useful?" (http:/ / headius. blogspot. com/ 2007/ 01/ invokedynamic-actually-useful.
html). . Retrieved 2008-01-25.
[5] Krill, Paul (2008-01-31). "Sun's Da Vinci Machine broadens JVM coverage" (http:/ / www. infoworld. com/ article/ 08/ 01/ 31/
davinci-machine_1. html). . Retrieved 2008-02-06.
[6] "The Verification process" (http:/ / java. sun. com/ docs/ books/ jvms/ second_edition/ html/ ClassFile. doc. html#9766). The Java Virtual
Machine Specification. Sun Microsystems. 1999. . Retrieved 2009-05-31.
[7] http:/ / nestedvm. ibex. org/
[8] http:/ / cibyl. googlecode. com
[9] http:/ / da. vidr. cc/ projects/ lljvm/
[10] http:/ / www. novosoft-us. com/ solutions/ product_c2j. shtml
[11] http:/ / tech. novosoft-us. com/ product_c2j_faq. jsp
[12] http:/ / objectmix. com/ compilers/ 37664-ampc-version-1-6-2-released-c-java-class-files-compiler. html
[13] http:/ / www. itee. uq. edu. au/ ~cristina/ uqbt. html#gcc-jvm
[14] http:/ / sourceforge. net/ projects/ javum/

Java Virtual Machine 304
[15] http:/ / sourceforge. net/ projects/ egcs-jvm/
[16] JSR 924 (http:/ / www. jcp. org/ en/ jsr/ detail?id=924) – Specifies changes to the JVM specification starting with J2SE 5.0
[17] JSR 202 (http:/ / www. jcp. org/ en/ jsr/ detail?id=202) – Specifies a number of changes to the class file format
[18] The Java Virtual Machine Specification (http:/ / java. sun. com/ docs/ books/ vmspec/ ) (the first (http:/ / java. sun. com/ docs/ books/
vmspec/ html/ VMSpecTOC. doc. html) and second (http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ html/ VMSpecTOC. doc. html)
editions are also available online)
[19] "Frequently Asked Questions about Garbage Collection in the Hotspot Java Virtual Machine" (http:/ / java. sun. com/ docs/ hotspot/ gc1. 4.
2/ faq. html). Sun Microsystems. 6 February 2003. . Retrieved 7 February 2009.
[20] Masamitsu, Jon (28 November 2006). "Presenting the Permanent Generation" (http:/ / blogs. sun. com/ jonthecollector/ entry/
presenting_the_permanent_generation). . Retrieved 7 February 2009.
[21] Nutter, Charles (11 September 2008). "A First Taste of InvokeDynamic" (http:/ / blog. headius. com/ 2008/ 09/ first-taste-of-invokedynamic.
html). . Retrieved 7 February 2009.
[22] http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ jvms-clarify. html
[23] http:/ / www. jcp. org/ en/ jsr/ detail?id=45
[24] http:/ / www. dmoz. org/ Computers/ Programming/ Languages/ Java/ Implementations/
[25] http:/ / www. computerworld. com/ action/ article. do?command=viewArticleBasic& articleId=9067358
[26] http:/ / java. com/ en/ download/ inc/ windows_new_xpi. jsp
[27] http:/ / igormaznitsa. com/ projects/ mjvm/ index. html
Xerlin
Xerlin is an open source XML editor for the Java 2 platform [1] released under an Apache style license. [2] The project
is a Java based XML modeling application written to make creating and editing XML files easier. The latest version
of Xerlin is 1.3, which was released in May 2005.
Project Details
Xerlin contains contributions originally made to the Merlot XML editor project, the open source project on which
Xerlin is based. ChannelPoint founded and hosted the Merlot XML Editor as an open source project during
2000-2001. Xerlin was created to build on those foundations and in fact used some of the same developers. [3]
Xerlin runs on any Java 2 virtual machine (JDK1.2.2 or higher). The application is extensible via custom editor
interfaces that can be added for individual DTD's. Xerlin can validate XML against both DTDs and Schemas.
See also
• Exari - Project founders
Further reading
• "Jar Bundler User Guide: Creating an Application Package" [4] . 2006-05-23. Retrieved 2009-05-15.
• Kubo, Hiroya; Masatoshi Tamamura, Takashi Kowata, Ikuyo Kaneko (2002) (in Japanese) (pdf). Supporting
School Evaluations by Customizable Questionnaire Schema Sharing [5] . Retrieved 2009-05-15.
• Harold, Elliotte Rusty (2003-10-02). Effective XML: 50 specific ways to improve your XML. Addison-Wesley.
pp. 76 – 77. ISBN 0-321-15040-6.
• Baclawski, Kenneth; Niu, Tianhua (2005-10-01). Ontologies for Bioinformatics (1st ed.). MIT Press. pp. 10, 11,
34. ISBN 0-262-02591-4.
• Barth, Thomas; Schüll, Anke (March 2006) (in German, English). Grid Computing: Konzepte, Technologien,
Anwendungen (1st ed.). Germany: Vieweg+Teubner. pp. 118, 122, 123, 132. ISBN 3-8348-0033-3.
• Magnus, Jørgen Barsett (December 2007). Metabolic Engineering of the Valine Pathway in Corynebacterium
Glutamicum - Analysis and Modelling. Germany: Forschungszentrum Jülich. p. 16. ISBN 3-89336-499-4.

Xerlin 305
• Steinbrenner, Eugen (February 2009) (in German). Internetbasierte interaktive Lernmodule zur hierarchischen
Datenstrukturierung und zur Linienglättung. Germany: Grin Verlag. pp. 9, 88. ISBN 3-640-27276-5.
External links
• Official website [6]
• Xerlin [7] at SourceForge.net
References
[1] Henderson, Robert; Deane, Sharon (2004-01-07). "Real-world XML". XML Made Simple. Amsterdam: Elsevier. p. 125.
ISBN 0-7506-5998-X.
[2] "Xerlin XML Editor license" (http:/ / www. xerlin. org/ LICENSE. txt). . Retrieved 2009-05-15.
[3] "Stylus Studios: Open source XML Editor" (http:/ / www. stylusstudio. com/ xmldev/ 200207/ post20510. html). 2002-07-15. . Retrieved
2009-05-15.
[4] http:/ / developer. apple. com/ documentation/ Java/ Conceptual/ Jar_Bundler/ Packaging/ Packaging. html
[5] http:/ / sqs. cmr. sfc. keio. ac. jp/ 2005/ 01/ gn. pdf
[6] http:/ / www. xerlin. org/
[7] http:/ / sourceforge. net/ projects/ xerlin/

XStream 306
XStream
Developer(s) Codehaus
Initial release January 1, 2004
Written in Java
Operating
system
Cross-platform
License BSD-style license
Website http:/ / xstream. codehaus.
org/
XStream is a simple Java library to serialize objects to XML (or JSON) and back again. [1]
XStream library
XStream stands out for its ease of use and low footprint. It uses reflection to discover the structure of the object
graph to serialize at runtime. The XML it generates is very readable.
The library doesn't require modifications to objects, so it's non intrusive to use the library. It can serialize internal
fields, including private and final. Supports non-public and inner classes. [2]
Object graph serialization
When serializing an object it serializes the full object graph. Duplicate references encountered in the object-model
will be maintained. For example using the following class CD
package com.thoughtworks.xstream;
public class Cd {
private String id;
private Cd bonusCd;
Cd(String id, Cd bonusCd) {
}
this.id = id;
this.bonusCd = bonusCd;
Cd(String id) {
}
this.id = id;
public String getId() {
}
return id;
public Cd getBonusCd() {
}
return bonusCd;

XStream 307
}
and add some of these object to a list
Cd bj = new Cd("basement_jaxx_singles");
Cd mr = new Cd("maria rita");
List order = new ArrayList();
order.add(mr);
// adds the same cd twice (two references to the same object)
order.add(bj);
order.add(bj);
// adds itself (cycle)
order.add(order);
XStream xstream = new XStream();
xstream.alias("cd", Cd.class);
System.out.println(xstream.toXML(order));
If the above code is executed with XStream's default relative references mode, it will generate the following XML:
maria rita
basement_jaxx_singles
XStream is free software, distributed under a permissive, revised BSD-style licence.
Usage
• Confluence [3]
• Apache Muse [3]
External links
• XStream Library Home Page [4]
References
[1] "Serializing Java Objects with XStream" (http:/ / www. xml. com/ lpt/ a/ 1462). XML.com, O'Reilly Media, Inc. 2004-08-18. . Retrieved
2009-12-14.
[2] "Use XStream to serialize Java objects into XML" (http:/ / www. ibm. com/ developerworks/ java/ library/ x-xstream/ index. html). Ibm.com.
. Retrieved 2009-12-14.
[3] "XStream - References" (http:/ / xstream. codehaus. org/ references. html). Xstream.codehaus.org. . Retrieved 2009-12-14.
[4] http:/ / xstream. codehaus. org/

Article Sources and Contributors 308
Article Sources and Contributors
Java (programming language) Source: http://en.wikipedia.org/w/index.php?oldid=379815313 Contributors: -Barry-, 16@r, 172.176.26.xxx, 1wolfblake, 4twenty42o, 7, =JaCyX=, @modi,
ABCD, AJim, Aaron Bowen, Aaron Rotenberg, Abarnea 2000, Abelson, Adam1213, AdamH, Adamacious, Adashiel, Addaintstopnme, Addshore, Aditya, AdjustShift, Adw2000, Ae-a, Aeons,
Aesopos, Agrawaam, Ahoerstemeier, Air pacquiao, Aitias, Aiyizo, Aka042, Akamad, Akersmc, Aksi great, Aktsu, Alai, Alainr345, Alan Rockefeller, Alansohn, AlbertCahalan, Alerante, Alex
LE, Alex.atkins, Alex.muller, Alexdethier, Alexius08, Alfio, Alhoori, Alicam8, AlistairMcMillan, Allan McInnes, Alterego, Altmany, Alvin-cs, Am088, Amareto2, Amazon911,
Ambarishmohan, Amicon, Amire80, Amitchaudhary, Ammubhave, Ancheta Wis, AndonicO, Andre Engels, Andrea Parri, Andres, Andrewferrier, Andrewlp1991, Andypandy.UK, Anger22,
Angusmclellan, Anirudhsshastry, Anirudhvyas010, Anizzah, Anon lynx, Anoopan, Antaeus Feldspar, Antandrus, Antidrugue, Anwar saadat, Aphonik, Arabic Pilot, Arbitrarily0,
ArchMageZeratuL, ArchNemesis, Archenzo, Ardonik, Ardric47, Aremith, Arloz, Armando82, Arnehans, Arrenlex, AscendantOat, Austin Hair, Averell23, B3t, BBUCommander, Baa,
Babarcash, Babedacus, Babomb, Bacchus87, Bachmann1234, Bact, Badgernet, Banaticus, Baricom, Baronnet, BarretBonden, Basitj, Batneil, Bboy123, Bcrowell, Bedel23, Belem tower, Ben
Arnold, BenAveling, Benhocking, Beno1000, Betacommand, Bevo, Biblbroks, BigGuyC, Bijee, Biker Biker, Billy On Bannana Peels, Biot, Bissinger, Blablablob, Blankfrack, Bluemoose,
Blurpeace, Bobblewik, Bobo192, Boing! said Zebedee, Booyabazooka, Borislav, Bovlb, Bravegag, Brick Thrower, Brion VIBBER, Brossow, BruceMagnus, Bubba-, Buchanan-Hermit, Bulatych,
BurntSky, Burzmali, Byronknoll, Bytbox, CAkira, Cal 1234, Calvin 1998, Calvinaustin, Canadafreakazoid, CanadianLinuxUser, Cananian, Candear, CanisRufus, Cap'n Refsmmat, CapitalR,
Capricorn42, CaribDigita, Casperl, Cat-five, Catamorphism, Catgut, Cburnett, Centrx, CesarB, Cgs, Chandrasekar78, Chaotic cultist, Charles Matthews, CharlesC, Chasingsol, Chazwatson,
Chealer, Cheesy mike, Chei, Cheung1303, Chinhnt2k3, Chiok, Chip Zero, Chiprunner, Chocolateboy, Chowbok, Chrislk02, Chrissyboi, ChristianEdwardGruber, ChristopheS, Christopher
Mahan, Chu Jetcheng, Chuayw2000, Chuq, ClanCC, Classical Esther, Cleared as filed, ClockworkLunch, Closedmouth, Clydedoris, Coffee, Coley s, Cometstyles, Connelly, Conor H.,
Conversion script, Coolshit, Corpx, Corti, Cp98ak, Cpl Syx, Crazz bug 5, Creidieki, CunningLinguist, Cureden, Curmudgeon99, Curps, Cwfrei, Cwolfsheep, Cyan, Cybercobra, CyborgTosser,
Cynic783, Cyp, Cyrius, D'Agosta, D6, DARTH SIDIOUS 2, DJ Clayworth, DMacks, DNewhall, Daf, Daimengrui, Damian Yerrick, Dan aka jack, Danakil, Dancraggs, Danhash, Daniel
Brockman, DanielTrox, Danrah, Darklilac, Dave Runger, David Gerard, Davidjk, Davidweiner23, Dawnseeker2000, Dbiagioli, Dcoetzee, Dcprice555, DeadEyeArrow, Debajit, Debashish, Debeo
Morium, Decagon, Delian31, Delirium, Delldot, Delta G, DennisWithem, Derek farn, DetlevSchm, Dgies, Dgwarwick, Dhoom, Diberri, Dibujon, Diderot's dreams, Dillard421, DineshMungra,
Dingskes, Dipet343, Discospinster, Djsuess, Dll99, Dmyersturnbull, Dominic7848, Don-vip, Dongiulio, Doradus, Doug Bell, Dpark, Dr-unifex, DrIdiot, Drakkos, Drappel, Dreadstar, Dream of
Goats, DreamGuy, Drmies, DropDeadGorgias, Dterei, Dumitru Gherea, Dysprosia, Dystopianray, Eagleal, Easyas12c, EatMyShortz, EbulaJonez, Ed Poor, Edcolins, Edknol, Edward, Edwin.wei,
Efriedman, Egomaniac, Ekashp, ElBenevolente, Elf, Ellenaz, Ellmist, Eloquence, Elvarg, Ems2, Enchanter, EngineerScotty, Enough2000, EpiQ SkiLL, Er Komandante, ErKURITA, Errandir,
Ervinn, Essjay, Ethridgela, Etz Haim, Euchiasmus, Everyking, Evice, Evil Monkey, Evil saltine, Evildeathmath, Excirial, FactChecker1199, Fagstein, Fakahi, Falcon300000, Falcon8765, Fang
Aili, Fasga, Fashionslide, Fast.ch, Fasten, Favonian, Fennec, Ferdinand Pienaar, Feureau, Ff1959, Fieldday-sunday, Finlay McWalter, Flamingantichimp, Flash200, FlavrSavr, Fleminra, Fogger,
Fotinakis, Frap, Frecklefoot, Fredrik, Freedom to share, FreplySpang, Ftiercel, Fuchsias, Funandtrvl, Furrykef, Fx2, Gail, Gaius Cornelius, Galaxy001, Galwhaa, Gamma, Gary King,
Garygateaux, Garyzx, Gazwim, Gdavidp, Geekler, Generalguy11, Georgia guy, Giftlite, Gilgamesh, Gimme danger, Gimmekat, Givegains, Glasser, Glenn Maddox, Glezos, GnuDoyng, Gogo
Dodo, Gortsack, Gracenotes, GraemeL, Graffity, Grandscribe, Graue, Great Cthulhu, Green caterpillar, Green meklar, Greenrd, Gronky, Grunt, Gscshoyru, Gudeldar, Gurch, Gurklurk, Gutworth,
Guusbosman, Guy Peters, Guyjohnston, Gwern, Gzkn, Gökhan, H-b-g, H4xx0r, Hadal, Haham hanuka, HalfShadow, Hao2lian, HappyInGeneral, Hara100, Hariva, Harm.frielink,
HarmonicSphere, HarryAlffa, Harshadoak, Haseo9999, Havarhen, Hayabusa future, Hdante, Hedoluna, Henning Makholm, Henrygb, HereToHelp, Hervegirod, Hfastedge, Hgfernan, Hirudo,
Hirzel, Hmains, HoganLong, Hooperbloob, Hosterweis, Hrshtkumar, Hu12, Husond, IBlender, Ideogram, Imaginationac, Immunize, Int19h, Ioakar, Iodine, Iridescent, Irish Souffle, Irishguy,
Ishanthasiribaddana, J Di, J.J.Sagnella, J.delanoy, J.l.barthel, J7, JEBrown87544, JHeinonen, JIP, JLaTondre, JOptionPane, JTN, JWaide, Jabberrock, Jaglnx, Jamesday, Jarchitect, Java jack jan,
Javageek212, Javawizard, Jay, Jay Gatsby, Jaybee, Jaydeki, Jcw69, Jdforrester, Jeff G., Jeffq, Jeffrey Mall, Jeffuit, Jeltz, Jemijohn, JenniferHeartsU, Jeronimo, Jesse Viviano, JesseHogan, Jglick,
Jibjibjib, Jijithp, JimWae, Jimguot, Jiy, Jj137, Jjaazz, Jleedev, Jmendez, Joelr31, Joerite, John Hendrikx, John Vandenberg, JohnCongerton, Johnuniq, Jojit fb, Jonabbey, Jonathanischoice, Jondel,
Jonik, Jopo sf, JorgePeixoto, Joseph Solis in Australia, JoshHolloway, Joshisachin79, Jsavit, Juansempere, Julian Mendez, Junes, Jusdafax, Justforasecond, KUsam, Kaldari, Kamalraja,
Kamasutra, Kariteh, Karl-Henner, Kbolino, Kcirb, Kedit1181, Keith Azzopardi, KelleyCook, Kevin Saff, Keycard, Khakipuce, Khalid hassani, Killick, Kingturtle, Kkm010, Kks krishna,
Klausness, Klingpl0x, KnowledgeOfSelf, Knyf, Kona1611, Koyaanis Qatsi, Kozuch, Kprobst, Kula85, Kungfuadam, Kurrgo master of planet x, Kvdveer, Kwaku, Kyle Baggs, LFaraone,
Landryhc, Lavellem, Leafyplant, LeaveSleaves, Lee Daniel Crocker, Lee J Haywood, LeeHunter, LeilaniLad, LestatdeLioncourt, Levin, Lights, Little Mountain 5, LittleDan, Loadmaster,
Logariasmo, Lpetrazickis, Lucas Malor, Luk, Lukejea, Lumingz, Luna Santin, Lupin, Lysander89, M1chu, M4gnum0n, MER-C, MIT Trekkie, MYC36, MaBe, Magicfox13, Magioladitis,
Magister Mathematicae, Magnus Manske, Mahanga, MaikSchreiber, Mailer diablo, Mainepenguin, Majorly, Malcohol, Mani1, Maoj-wsu-MC, MarSch, MarXidad, Maraist, Marcelbutucea,
Marcoandre, Mark Harrison, Mark Renier, MarkSweep, Marky1981, Marlow4, Martarius, Marteau, Marty360, Maryo1912, Massysett, Matherson, Matthew Yeager, Matthewpun, Matthieu fr,
Mav, Max Schwarz, MaxEnt, Maxim, Mcclain, Meara, Mecanismo, MeekMark, Meekohi, Melnakeeb, Melsaran, Menchi, Mentifisto, Metamorf, Mfb52, Mhorlbec, Michaelneale, Mikademus,
Mike0001, Mikelo.Arbaro, Mikm, Minesweeper, Minghong, Minipie8, Minkythecat, Minute Lake, Mipadi, Mirror Vax, Misantropo, Misza13, Mitchellfx, Mjroots, Modster, Modulatum,
Mohamedloey, Mohsens, Molteanu, Momet, Monkbel, MoraSique, Morte, Morwen, Mr link, MrCoder, MrJones, Mritunjai, Mrstonky, Msusmangani, Mtleslie, MuZemike, Mucus, Mxn, Myanw,
Mzajac, N4te, NJM, Naddy, Nanshu, NapoliRoma, NathanBeach, Ncmathsadist, Neilc, Nephelin, Nephtes, Neurolysis, NevilleDNZ, NewEnglandYankee, Newsmaestro, Nick R Hill, Nick125,
NickBush24, Nigelj, Nikai, Nikhil.bandekar, Nil Einne, Nimur, Nixeagle, Nmrd, Nnp, NoirNoir, Nopetro, Npovmachine, Ntsimp, NuclearWarfare, Nwbeeson, Oatmealcookiemon, Oblivious,
Odinjobs, Ohnoitsjamie, Oldadamml, Oleg Alexandrov, Oli Filth, Onehundredandtwo, Onevalefan, Opt 05, Orderud, Orisino, OscarTheCat3, OwenBlacker, OwenX, Oysterguitarist, P-unit,
P0lyglut, PGibbons, PMJain, Pagingmrherman, Pascalv, Patman g, Patrick987, Paul Murray, Paul Richter, Paul99, Paules nl, Pavel Vozenilek, Peepeedia, Pengo, PerLundberg, Perfecto, Peter
Delmonte, Peter Griffin, Peter lawrey, Peterl, Pgk, PhageRules1, Phantomsteve, Pharos, Phgao, Phil websurfer@yahoo.com, PhilKnight, Philipwhiuk, Phoenix-forgotten, Piano non troppo, Piet
Delport, Pigpigking, Pinktulip, Pipedreamergrey, Pizza Puzzle, Plugwash, PlusMinus, Pmronchi, Pne, Poccil, Polluxian, Polydor, Pontillo, Poor Yorick, Potatoj316, Premvvnc, Priyankgokani, Pro
Grape, Professor Calculus, Proficient, ProvingReliabilty, Public Menace, Pundeerd, PuzzletChung, Pwooster, Quadell, Qwertyus, R3m0t, Rab8613, Raistlin11325, RandalSchwartz, Ranjith16,
Rao crazy, Raul654, Ravchit, Raven4x4x, Raynoism, Rccarman, Rcs, Rdsmith4, Real-Life Sock Puppet, RedWolf, RedZombie125, Redrocket, Redvers, Reisio, Rettetast, RexNL, Rgeorgy,
Rhobite, RichF, Rick Jelliffe, Risk one, Rjmfernandes, Rjwilmsi, Robert Merkel, Robert Skyhawk, RobertG, Robo.mind, Rodhullandemu, Rogerd, Ron mmi, Ronz, RossPatterson, Rossmann,
RoyBoy, Rror, Rtanz, Rufous, Ruiz, Ruud Koot, Rzwitserloot, S-n-ushakov, SAE1962, SF007, SGNDave, SNIyer12, ST47, Sam Hocevar, Sam Korn, Sam jervis, Samohyl Jan, San25872,
Santiago Roza (Kq), Saravask, Sasha Slutsker, Sass24, Satanjava, Scarian, Schissel, SchnitzelMannGreek, Scientus, Scjessey, Scm83x, Scovetta, Sdfisher, Sdornan, SeanJA, Seanhan,
Search4Lancer, Sebastiangarth, Seraphimblade, Sfmontyo, Shadowjams, Shenme, Siddartha.kaja, Sigma 7, SimonP, Sinn, Sir Anon, SirWoland, Siroxo, Sirworthyduck, Sj, Sjarosz, Sjc,
SkyWalker, Sleske, Slike, SlitherM, Smyth, Snowolf, Socablg2, SocratesJedi, Sohil it, Some P. Erson, Soptep, Spalding, Sparker046, Speedogoo, Spencer, Spiff, SpikeToronto, Spookfish,
Spoon!, Spug, Squingynaut, Starblind, Starwiz, Steffen Felbinger, Stephen, Stephen B Streater, Stereo, Stevenj, Stevenrasnick, Stevietheman, Stormie, Styrofoam1994, Subanark, Suffusion of
Yellow, Sunderland06, Super Quinn, SuperU, Superfly Jon, Superm401, Supernova17, Supertouch, Susvolans, SvGeloven, Swintrob, Sylent, Synthiac, Szajd, TOReilly, TRauMa, TakuyaMurata,
Talandor, Tar5047, Tariqabjotu, Tasc, TastyPoutine, Tcgunner90, Tcncv, Teabeard, Technopat, Tedickey, Tellyaddict, Template namespace initialisation script, TerokNor, Terrible Tim,
Testmod1, The Anome, The Elves Of Dunsimore, The Hokkaido Crow, The Thing That Should Not Be, The wub, The1physicist, The2ndflood, TheDarkArchon, TheSpook, Thehelpfulone,
Theresa knott, Theuser, Thingg, Thornelytaylor, Thue, Thumperward, Thunderbolt16, Tillmo, Tim1988, TimTay, Timwhit, Titoxd, Tjansen, Tkgd2007, Tlim7882, Tmaher, Tmbg37, Tom 99,
Tommy2010, Tompsci, Torc2, Tothwolf, Toussaint, Toytoy, Tresiden, Troels Arvin, Tthorley, Ttwaring, Turing, Tushar.kute, Tustin2121, Tvynr, Twister nt, Tyraios, Tyrol5, Tyw7, Ubuntu2,
Ultimus, Uncle G, UnitedStatesian, Unixer, Unixxx, Urod, Uselesswarrior, Utcursch, UtherSRG, VX, Valerio81, VantagePoint, Vchimpanzee, VeLoCiTy89, Vera.tetrix, Viciodk, Viebel, Viento,
Violetriga, Visor, Vizspring, Vocaro, Volt4ire, Vvidetta, WJBscribe, Wasimbargujar, Wbrameld, Wdyoung, Web-Crawling Stickler, Webmink, Weregerbil, Wesley crossman, Wgw2024, Wgw4,
White Cat, Whosyourjudas, Wiggin15, Wik, WikiLeon, Wikianon, Wikipelli, Wikipendant, Wikiwerks, Wikiwikiwifi, William Allen Simpson, Wimt, Windchaser, Wknight94, Wlievens,
Wmahan, Wonko, Wootery, Wowus, Wrp103, Wsaryada, WurmWoode, Ww, Wyredchris, Wzwz, Xan 213, Xaosflux, Xelgen, Xezbeth, Xinconnu, Xpodmaniac, Xproject, Yamaguchi先生,
Yamamoto Ichiro, Yamla, Yozh, Yulracso, Yurik, Yurivict, Zawersh, Zazpot, Zekeo, Zenohockey, Zijian, Zik-Zak, Zxcvbnm, Zyphrix, Ævar Arnfjörð Bjarmason, 六脉飞天牛, 2413 anonymous
edits
Web Language Source: http://en.wikipedia.org/w/index.php?oldid=296014078 Contributors: Amalas, Anshul, Codeseg, Satori Son, Solarapex, Vycanis
AgentSheets Source: http://en.wikipedia.org/w/index.php?oldid=345477334 Contributors: Adjusting, Andreas Kaufmann, Birbilis, CRGreathouse, CharlesGillingham, DNewhall, Destynova,
Dragentsheets, Dugwiki, Gudeldar, Hroðulf, Karatorian, Kvn8907, Mange01, McLar eng, Oddharmonic, Peterl, The Thing That Should Not Be, Tziortzioti, VX, Waldir, William Avery, 12
anonymous edits
Oak (programming language) Source: http://en.wikipedia.org/w/index.php?oldid=368212204 Contributors: Csl77, Hervegirod, Hmains, Loadmaster, Paul Foxworthy, Rich Farmbrough, Ryan
suchocki, 4 anonymous edits
Lightweight Java Source: http://en.wikipedia.org/w/index.php?oldid=363175217 Contributors: Alainr345, Hmains, Rich Farmbrough, VX, Vortigen
.properties Source: http://en.wikipedia.org/w/index.php?oldid=374340272 Contributors: .digamma, Andy.goryachev, Bissinger, Brsanthu, Chridd, Cybercobra, Goatcheez, Greenrd, Ike-bana,
Iridescent, J. Finkelstein, Jerome Charles Potts, Jmlk17, John Vandenberg, Kjoonlee, Mipadi, Nick, Od Mishehu, PatrikR, Ptomasek, Rror, Spacebirdy, Timothy Truckle, Tom Morris, Waxigloo,
22 anonymous edits
Apache Harmony Source: http://en.wikipedia.org/w/index.php?oldid=378992487 Contributors: Aidan W, Alainr345, Andareed, Audriusa, Brian Geppert, Burschik, C. A. Russell, Daev,
Dave.tillman, Dirk Riehle, Doug Bell, East718, Engas, Evice, Faisal.akeel, Fiftyquid, Frap, Gaius Cornelius, Geirmagnussonjr, Greenrd, Gronky, Grutness, Haakon, Hervegirod, Hu12, Ike-bana,
ItsProgrammable, JLaTondre, JensMueller, Joehni, John of Reading, Kesla, Khalid hassani, LazyEditor, Lightmouse, Logixoul, Marudubshinki, Maurogiachero, Membar2,

Article Sources and Contributors 309
Mercadodiego@gmail.com, MoreNet, Per Abrahamsen, Qutezuce, Revolus, Rich Farmbrough, Rjwilmsi, SF007, SimonP, Straxus, Superm401, SymlynX, TakuyaMurata, The Thing That Should
Not Be, TheParanoidOne, UU, Uga2, Waldoalvarez00, 169 anonymous edits
Apache Muse Source: http://en.wikipedia.org/w/index.php?oldid=331712358 Contributors: CultureDrone, EdGl, M4gnum0n, MauriceKA, Mlaffs, Power.corrupts
Apache Shiro Source: http://en.wikipedia.org/w/index.php?oldid=371264579 Contributors: Achille, Alainr345, Cameronbraid, Jeandré du Toit, Kyle1278, Malcolma, Manjula.aw, Rhino1977,
Skipshot4, Tokek, 8 anonymous edits
Java applet Source: http://en.wikipedia.org/w/index.php?oldid=380110454 Contributors: 213.89.18.xxx, Alainr345, Alansohn, Alexwright, Alvin-cs, Amareto2, Anonymous56789, Artw,
Audriusa, Bdiscoe, BonzoESC, Borgx, Bryan Derksen, Brz7, Byronknoll, Canderra, Cesarsorm, Charivari, Chris Wood, ChronoKinetic, Cmccormick8, Conradbate, Conversion script, Da rulz07,
Doug Bell, Ency, EoffreyGey, FactChecker1199, Frap, Frecklefoot, Futurix, Fuzzie, Giftiger wunsch, Group29, Grshiplett, Haakon, Hellisp, Hem1234, Heron, Hu12, Ian Pitchford, Iridescent,
Jacobolus, Jay, JeLuF, Jengelh, Jmnbatista, Jwoodger, Lee J Haywood, LittleDan, Lotje, Magioladitis, Maima, Marcobiscaro2112, Mark Renier, MartinHarper, Michael Hardy, Mikenolte,
Minghong, Modulatum, NawlinWiki, Nipesh1, Od Mishehu, Patobrien99, Peak, Pearle, PhilKnight, Phyzome, Plugwash, Prodego, RealWorldExperience, RedWolf, Reisio, Rich Farmbrough,
Rick Block, Rror, SDiZ, Sahib12, Shandru, Shanes, Sherool, Skeejay, SnowFire, Spoon!, Stephen B Streater, Taka, TimTay, TonyW, Toussaint, Twi20Pi, UU, Udittmer, Unknown W. Brackets,
Wapcaplet, Wtmitchell, Yozh, 用心阁, 169 anonymous edits
Associació d'Usuaris de Java de Catalunya Source: http://en.wikipedia.org/w/index.php?oldid=348025725 Contributors: Chris the speller, Jordi.pujol.ulied, LilHelpa, Malcolma, Rich
Farmbrough, Skier Dude, Tabletop, 3 anonymous edits
Automated exception handling Source: http://en.wikipedia.org/w/index.php?oldid=364328873 Contributors: Abarnea 2000, Alansohn, Cybercobra, Intgr, Reinyday, Rigadoun, Shabda, 1
anonymous edits
Bean Scripting Framework Source: http://en.wikipedia.org/w/index.php?oldid=345196680 Contributors: BeBop, Bkkbrad, Bluemoose, Caerwine, Curps, Faisal.akeel, Gaius Cornelius,
JLaTondre, Jnc, Jpp, Kopf1988, Madhero88, Malcolma, TheParanoidOne, Weyes, Wikimsd, Winptor, 16 anonymous edits
CJAN Source: http://en.wikipedia.org/w/index.php?oldid=300894550 Contributors: Elonka, JanGB, Rjwilmsi, Scrool, Skysmith, Tabletop, UncleFester, WRK, 6 anonymous edits
Celtix Source: http://en.wikipedia.org/w/index.php?oldid=368606334 Contributors: Frap, MrOllie, Tassedethe, Yadab Das, 1 anonymous edits
Chainsaw (log file viewer) Source: http://en.wikipedia.org/w/index.php?oldid=305625547 Contributors: Fabrictramp, Gamefreak2413, LAX, PigFlu Oink, Sci girl, 12 anonymous edits
clone (Java method) Source: http://en.wikipedia.org/w/index.php?oldid=371965403 Contributors: Abdull, Afromayun, Andreafrancia, Btx40, Faustus, Gerd-HH, Jcarroll, Jugular, Ketiltrout,
Lax4mike, Mcorazao, Pjpringle, Spoon!, Supereddy, Tyraios, Yaniv Kunda, Zxcvcxz, 19 anonymous edits
Comparison of Java and C Sharp Source: http://en.wikipedia.org/w/index.php?oldid=379974742 Contributors: (www itshixun com)GaoXiaoZu, 21655, Acid2base, Ahoerstemeier, Ajgorhoe,
Alasdairking, AmadeoV, Amniarix, Ancheta Wis, Audriusa, Bertport, Bilal.alsallakh, Blowdart, Brunoton, Btx40, CCFS, Canderra, CanisRufus, Capnmidnight, Cerowyn, Chip Zero, Chowells,
Chri1753, Chrisahn, Closedmouth, Collard, Colonies Chris, Coolboy1234, Craig Stuntz, Creek23, Curps, Cybercobra, CyborgTosser, Cyril, Daniel Earwicker, Darthsco, Debresser,
DerrickOswald, DevastatorIIC, Developer38, Donhalcon, DoomBringer, Doug Bell, Dreftymac, Drstorm, EDNY200901(FLYASDRAGON), EDNY20090105maona, Ed Poor, Edurant,
Elsendero, Enchanter, Erik Sandberg, FayssalF, Firsfron, Frecklefoot, Futurix, Gaijin42, Gatoatigrado, Greggobridges, GregorB, GreyCat, Groat, Gurch, Helpsloose, Hervegirod, Hooperbloob,
Howcheng, Idolescent, Ieee8023, Ike-bana, Inquisitus, Int19h, ItsProgrammable, J04n, JHunterJ, JIP, Jackcsk, Jamelan, JamesNK, JavaKid, Jaydec, Jdthood, Jfbilodeau, Jfrascencio, Jkl, Jmundo,
Josephw, Jvorchak, Kenyon, Kesla, Khabara, Kittybrewster, Knowzilla, KrisK, Ktalon, Leotohill, Lightxx, Loadmaster, Lobner, Maghnus, Maraist, Martin Fuchs, Mazi, Mboverload, Melchoir,
Mets501, Mfb52, Mik01aj, Mikenolte, Mikon, Mirror Vax, Mishka.medvezhonok, Mitch Ames, MovGP0, Mugunth Kumar, NaibStilgar, Nathanaeljones, Neilc, Netoholic, NewEnglandYankee,
Nma wiki, Norm mit, Nuggetboy, Numberp, Oldadamml, Omegarad, Orderud, Oren0, PPGMD, Pelister, Philu, Piano non troppo, Porges, Promit, Psiphiorg, Quota, Qutezuce, RHB, Rajakhr,
Ralesk, RapidSkis, Raptor3676, Rednblu, RenataLiting, RevRagnarok, Robartin, Root4(one), Rp, Rror, Rursus, Samrolken, Sarloth, SchfiftyThree, ShadowRangerRIT, Shubhkarmansandhawalia,
Soumyasch, Spidermario, Squash, SteinbDJ, Steven Zhang, Strangeweather, Subanark, Superm401, Svick, Tbjablin, The Elves Of Dunsimore, The1physicist, Tim1357, TimBentley, TimTay,
Timwi, Tleave2000, Tmcdouga, TobiasPersson, Tohd8BohaithuGh1, Torc2, Toussaint, Triplesub, UnitedStatesian, Useerup, Vahid83, Valodzka, Vazbik, Visor, Vlad, W3bbo, Waldir, War
Famine Pestilence Death, Webmaster961, Winterst, Woohookitty, Yms, Ynhockey, Yurik, ZacBowling, Zain engineer, 543 anonymous edits
Comparison of Java and C++ Source: http://en.wikipedia.org/w/index.php?oldid=380005248 Contributors: 1exec1, Aandu, Aavindraa, ActiveSelective, Adamd1008, Alainr345, Alex Heinz,
Alexnye, Alterego, Aprock, Barefootguru, Bdodo1992, Bjdehut, Bovineone, Bryan Derksen, Buckyboy314, CanisRufus, Cardatron, Catamorphism, Cfeet77, Chip Zero, CmdrRickHunter,
CodedoC, Crashie, Curps, CyborgTosser, Damian Yerrick, Dangiankit, DanielPharos, Daquell, Darkwind, David Wahler, Decltype, Derek Ross, DerrickOswald, DevastatorIIC, Donhalcon, Doug
Bell, Dthomsen8, Dustball, EYOLs, Ed Poor, EdSquareCat, Eelis.net, Ees, EmeryD, Erik Sandberg, Esben, EverGreg, Ezrakilty, Flums, Frecklefoot, Gamahucheur, Garyzx, Giftlite, Grunt,
Gudeldar, Harryboyles, Hgb asicwizard, Hirzel, Hsz, Ivec, JavaKid, Jayaram ganapathy, Jespdj, Johntabularasa, JulesH, Juliano, KardinalKill, Karl Dickman, Kazkaskazkasako, Kbolino, Kexyn,
Kilo-Lima, King Mir, Kittybrewster, Kmorozov, Kwertii, Lkinkade, Loadmaster, MarSch, Marco255, Martin Fuchs, MartinDK, Mathieu, McNepp, Medinoc, Michael Trigoboff, Miffy900,
Mikon, Mirror Vax, Molteanu, Mwn3d, Mysekurity, Neilc, Netoholic, Nono64, Orderud, OverlordQ, Owl order, Pascal.Tesson, Pcu123456789, Peterdjones, Peterl, Pfunk42, Rainwarrior,
Ranjyad, Rdsmith4, Reckjavik, Rengolin, Requestion, Rjwilmsi, Rodrigostrauss, Root4(one), Sandahl, Saucepan, Schapel, SeverityOne, Sfmontyo, Sjc, SlitherM, Solarswordsman, Specs112,
Spoon!, Squash, Super Quinn, Sussexonian, Tarquin, The Elves Of Dunsimore, The Thing That Should Not Be, Themusicgod1, Thenarrowmargin, Thymefromti, Tiagofassoni, Tim Starling,
Timgurto, TobiasPersson, Tundra010, Urod, Veritas Blue, Vertexua, Vqwj, War Famine Pestilence Death, Weregerbil, Wesley, Wikitoov, Wrldwzrd89, Wtmitchell, XNinto, Ysangkok, Zertyz,
Zzuuzz, Ævar Arnfjörð Bjarmason, 334 anonymous edits
Comparison of the Java and .NET platforms Source: http://en.wikipedia.org/w/index.php?oldid=377659395 Contributors: ACSE, Aadnk, Adw2000, Alexander Abramov, AlonzoChurch,
Andrewpmk, Audriusa, BorisDušek, Chip Zero, ChorizoLasagna, Crazycomputers, CritterNYC, Cyril, DH85868993, Danrah, Dethme0w, EdgeOfEpsilon, Edward, Erik Sandberg, Eriks81989,
Evildeathmath, Fduch, Frap, Futurix, GoingBatty, Gordonrox24, Gracefool, HAl, Haoyao, Hervegirod, Hexene, Ike-bana, Inks.LWC, Iridescent, JavaKid, Jcarroll, Jzubeck, Kingboyk,
Kubanczyk, LedgendGamer, Leotohill, MER-C, Maghnus, Meebey, Mernen, Mfb52, Mike Linksvayer, Mitch Ames, Mk*, Mrnatural, NaibStilgar, Ootachi, Paul Foxworthy, Powerlord,
Ricvelozo, Rjwilmsi, SF007, Sebleblanc, Sedimin, Shadowjams, Starionwolf, Stetorvs, Superfly Jon, Svick, Tavilis, Tbjablin, Tokek, Torc2, Wtaa, Xpclient, Yozh, Yusnielb, ZacBowling, 73
anonymous edits
Constant interface Source: http://en.wikipedia.org/w/index.php?oldid=318583679 Contributors: BlindWanderer, Libsoc, Malcolma, Melchoir, Mister Farkas, Savastio, TreasuryTag, 1
anonymous edits
Java 4K Game Programming Contest Source: http://en.wikipedia.org/w/index.php?oldid=353912194 Contributors: Alynna Kasmira, Amalas, Dreftymac, Invader Zim, Jbanes, Kelly Martin,
Kylu, Marasmusine, Morre, NapoliRoma, Renanse, Retired username, Rjwilmsi, Synergy, West.andrew.g, 22 anonymous edits
CookXml Source: http://en.wikipedia.org/w/index.php?oldid=367970361 Contributors: Aboriginal Noise, Bryan Derksen, Coconut99 99, Elwikipedista, Gronky, Isilanes, Kl4m-AWB,
Seraphimblade, Torc2, TubularWorld, 2 anonymous edits
Cougaar Source: http://en.wikipedia.org/w/index.php?oldid=344288000 Contributors: Atlantima, CanisRufus, Dr Gangrene, Gvidaver, Khalid hassani, Malcolma, Midavalo, Network Inkling,
Rob Cranfill, Ruud Koot, Waldir, Zootalures, 3 anonymous edits
Deterministic Parallel Java Source: http://en.wikipedia.org/w/index.php?oldid=348783386 Contributors: Esfand30, Malcolma, Pointillist, R'n'B, 1 anonymous edits
Devoxx Source: http://en.wikipedia.org/w/index.php?oldid=352925745 Contributors: Dawynn, Fabrictramp, HenkvD, Hu12, Michig, Pascal.Tesson, Shalom Yechiel, Sjabejug, Skittleys, Turb,
Zqudlyba, 2 anonymous edits
Doclets Source: http://en.wikipedia.org/w/index.php?oldid=338833861 Contributors: (:Julien:), Rolfedh, 1 anonymous edits
Elastic Path Source: http://en.wikipedia.org/w/index.php?oldid=378169053 Contributors: Cander0000, Elasticpath, Nihiltres, R'n'B
Electronic Disturbance Theater Source: http://en.wikipedia.org/w/index.php?oldid=370943445 Contributors: Badassant, CosineKitty, EagleFan, Paine Ellsworth, R'n'B, RoboHomo, SatyrTN,
ShadowNano169, Woohookitty, 1 anonymous edits
Event dispatching thread Source: http://en.wikipedia.org/w/index.php?oldid=372792428 Contributors: Auric, Doug Bell, Echawkes, FredSwartz, Hervegirod, Pearle, R. S. Shaw, Stolsvik,
Ultimatepolo, 15 anonymous edits

Article Sources and Contributors 310
Facelets Source: http://en.wikipedia.org/w/index.php?oldid=368769435 Contributors: Alainr345, Arjant, Gernhwak, HairyFotr, Hosamaly, MacGyverMagic, MatthewVanitas, Olekva, Penkeen,
RHaworth, T@nn, Tassedethe, Tritium6, Tyraios, 43 anonymous edits
final (Java) Source: http://en.wikipedia.org/w/index.php?oldid=377437826 Contributors: 16@r, Abdull, Aitias, AndrewHowse, Art187, Bluemoose, Calimo, Chetandandgey, Choas, Darend,
Ezrarez, Fahadsadah, Genesis, Jann2005, Kingpin13, Kulandai, Looris, Max Schwarz, Muchness, Myncknm, Niclas Wiberg, Oleh Kernytskyi, P1h3r1e3d13, Psbsub, Randomblue, Rp, SAE1962,
Sethrh, Smallman12q, Spoon!, Techman224, Tobyr2, Zolv, 45 anonymous edits
FloodNet Source: http://en.wikipedia.org/w/index.php?oldid=345439463 Contributors: Badassant, Interiot, Kenb215, Malcolma, Rjwilmsi, 5 anonymous edits
FormEngine Source: http://en.wikipedia.org/w/index.php?oldid=377446090 Contributors: Jpbowen, Rich Farmbrough, Ustark, Vbublitz, 2 anonymous edits
Generics in Java Source: http://en.wikipedia.org/w/index.php?oldid=379190046 Contributors: 16@r, Adw2000, Alfe, BernardSumption, Buttermilchtrinker, Carlosayam, Chip Zero,
Closedmouth, Cybercobra, Delirium, Dmyersturnbull, Dreish, Ed Poor, Eve Teschlemacher, Godbe, Gracenotes, Green caterpillar, Gryzlo, Hervegirod, Irrªtiºnal, Jagat321, Jjdawson7,
Jluuwindsorca, John Vandenberg, KKI, Karl Stroetmann, Kauan, Maghnus, Matthew0028, Mstuomel, Nawaf.albadia, Neilc, Philip Trueman, Prodoc, Rheaghen, Ruakh, Sleske, Spoon!, Stagalj,
Subanark, Tardis, Tbleher, Tuntable, Urhixidur, Zippanova, 73 anonymous edits
G-java Source: http://en.wikipedia.org/w/index.php?oldid=367210806 Contributors: Blakeo x, Cynical, Elvis, Fedor GM, Frap, Fuzzie, Gm guru, IanManka, IsmAvatar, JLaTondre, John
Vandenberg, Ketiltrout, Luiscubal, Malcolma, Markco1, Mike926908240680, OTAVIO1981, Pampas Cat, Sladen, XDanielx, 38 anonymous edits
GlassFish Metro Source: http://en.wikipedia.org/w/index.php?oldid=368613545 Contributors: Anetode, Anthony Appleyard, Dockurt2k, Frap, Pxma, Sebleblanc, Shaun mcgrath, Tassedethe,
UC Bill, 6 anonymous edits
James Gosling Source: http://en.wikipedia.org/w/index.php?oldid=379579153 Contributors: Acerperi, Alainr345, Alansohn, AlistairMcMillan, Altenmann, AnOddName, Arathald,
AutumnSnow, Avenged Eightfold, Bact, Badgernet, Bearcat, Bertport, Bhoeble, Blanchardb, Bobula101, Bondolo, Bosmon, Braiam, CDN99, CIreland, Cagecrawler, CharlotteWebb,
Chithiraiyan, Chrislk02, Colinkem, D6, Daltenty, Dan100, Daniel, Darolew, DerHexer, Doug Bell, Ed Poor, EncMstr, EronMain, EugeneZelenko, Fieldday-sunday, FrenchIsAwesome, Ftiercel,
Gary King, Geekler, Geni, GregorB, Gronky, Groogle, Guat6, Hholt01, Hooperbloob, Ibagli, J Milburn, J.delanoy, JamesTeterenko, Jarchitect, Jesse Viviano, John Vandenberg, Joolz, Jpbowen,
Kaihsu, Katharineamy, LAAFan, Lamat, Luís Felipe Braga, M5mm5m, MarXidad, Martarius, Marudubshinki, Matt Crypto, Mav, Mayumashu, Michael Drew, Mirror Vax, Mre5765, Mrwojo,
Ms2ger, Mxn, NapoliRoma, Neilc, Nolookingca, Nsaa, Per Abrahamsen, Peter Campbell, Prolog, RazorICE, RedWolf, Revence27, Rich Farmbrough, Scm83x, Section6, Seddon, Shadesofgrey,
Shipmaster, Sionus, Snigbrook, Spinboy, Stephensuleeman, SteveSims, Stevertigo, Stolkin, Straxus, Sunray, THEN WHO WAS PHONE?, Taejo, Tanbace, The Thing That Should Not Be,
TheParanoidOne, Tobias Bergemann, Toussaint, Traroth, Trialsanderrors, TrungH, Twimoki, Ugur Basak, UsefulDreams, Verner a, Vineetkrjoshi, Vprajkumar, Wayl, Webmink, Westpeter,
Wikiwikiwikiwikiwiki, Woodjr, WulfTheSaxon, YUL89YYZ, 214 anonymous edits
Gray Flimmer Source: http://en.wikipedia.org/w/index.php?oldid=331985933 Contributors: Malcolma, Rgopal, 4 anonymous edits
Todd Greanier Source: http://en.wikipedia.org/w/index.php?oldid=368910388 Contributors: 1ForTheMoney, Alainr345, Anson2995, Bearcat, Jpbowen, Kyle1278, Oscarthecat, 4 anonymous
edits
Head First (book series) Source: http://en.wikipedia.org/w/index.php?oldid=338683996 Contributors: DoriSmith, Frecklefoot, Jerryobject, Kak, RayAYang, Tassedethe, 27 anonymous edits
Jim Hugunin Source: http://en.wikipedia.org/w/index.php?oldid=368533905 Contributors: 1ForTheMoney, Alainr345, Andreas Kaufmann, Bruckie, Equarter, Hadrianheugh, Jacobolus,
Jeodesic, Katharineamy, Sgodth, 10 anonymous edits
Inner class Source: http://en.wikipedia.org/w/index.php?oldid=379495526 Contributors: Anwar saadat, Ashu8845, Brick Thrower, Ccarey, Daniel Brockman, Doug Bell, Green caterpillar,
Harborsparrow, Hervegirod, Michael Slone, Mipper, Msyed, Nihiltres, Rich Farmbrough, Spoon!, Spug, Vald, Wootery, కిరణ్మయి, 21 anonymous edits
Interface (Java) Source: http://en.wikipedia.org/w/index.php?oldid=364526965 Contributors: Agent Conundrum, Almost Anonymous, Andmatt, Anwar saadat, Cokoli, Corpx, Courcelles,
Demitsu, Doug Bell, Dʒɑn, Ed g2s, EngineerScotty, Explanator, Fnielsen, Genpfault, Gmtress, Green caterpillar, GregorB, Hvn0413, Intgr, JaGa, Jamestochter, John Vandenberg, JonHarder,
King of Hearts, Kulandai, Lexischemen, MER-C, Matthew0028, Mike0001, Moeron, Ordinant, Pcap, Pdelong, Petri Krohn, Phrenq, Piet Delport, Qwertyus, Radagast83, Sachinwfs, Sagaciousuk,
Simeon, Spoon!, Telepheedian, Venkatsalem, Wigleboy, Wlievens, XDanielx, 101 anonymous edits
Internet Foundation Classes Source: http://en.wikipedia.org/w/index.php?oldid=343164647 Contributors: DeXXus, Docu, Hervegirod, Jeepday, Marcobiscaro2112, Pegship, 5 anonymous
edits
JAD (JAva Decompiler) Source: http://en.wikipedia.org/w/index.php?oldid=377671774 Contributors: 2GooD, AlexWaelde, Daniel Roethlisberger, Dawynn, Green caterpillar, Ivmai77,
Klausst, Merlin G., Midnight Comet, R'n'B, Tassedethe, Tomtheeditor, Yannick56, 20 anonymous edits
JAD (file format) Source: http://en.wikipedia.org/w/index.php?oldid=368157547 Contributors: Amalas, Andrwsc, Bambinn, Coercorash, CyberSkull, David Haslam, Encyclopath, Excirial,
Garas, Gurch, Jj137, JohnCD, Karsten.meier, Lauriwriter, Merbabu, Oda Mari, Patrick, Vegaswikian, Xaje, Zahakiel, 34 anonymous edits
JAMWiki Source: http://en.wikipedia.org/w/index.php?oldid=375686267 Contributors: Audriusa, Dfisla, Ean5533, EvanProdromou, Gioto, Khartlage, Salamurai, Wrh2, 6 anonymous edits
JGroups Source: http://en.wikipedia.org/w/index.php?oldid=297352083 Contributors: Alitokmen, John Vandenberg, Phatom87, Rigadoun, 7 anonymous edits
JPicus Source: http://en.wikipedia.org/w/index.php?oldid=348860897 Contributors: Casablanca2000in, DanielRigal, Dv82matt, Katharineamy, Malcolma, Pavel.genevski
Java Class Library Source: http://en.wikipedia.org/w/index.php?oldid=366545552 Contributors: Alainr345, Alansohn, Dxgriffiths, HamburgerRadio, Hervegirod, Hugh16, Phobos11,
Romanc19s, ScottBlomquist, Tokek, Vocaro, Waldoalvarez00, 9 anonymous edits
Java Classloader Source: http://en.wikipedia.org/w/index.php?oldid=378332996 Contributors: Aalvarez, Alainr345, Capn ed, Climbon, DenaDweller, Elpecek, GeoffMacartney, Ghettoblaster,
Hervegirod, Isidore, Jengelh, JustAnotherJoe, Kreline, Krusch, Kwetal, MER-C, Michael Safyan, PaulRussell, Petri Krohn, Quarl, Romanc19s, Samkass, Sct72, Serpent's Choice, Timsabin,
Urhixidur, Wikilolo, Wikimsd, Wknight94, 57 anonymous edits
Java compiler Source: http://en.wikipedia.org/w/index.php?oldid=377671183 Contributors: Alansohn, AlonzoChurch, Caltas, CanisRufus, CesarB, Derek farn, Dogaroon, Doug Bell, Furrykef,
HereToHelp, Hervegirod, Ike-bana, Joel12321ps, LittleDan, Oleg Alexandrov, Orderud, Pdwalker, Psycosonik222842, Quadell, Radagast83, Shanes, Spectre 25gt, TakuyaMurata, Thumperward,
Tide rolls, Tomtheeditor, Tribaal, Tripleyew, Tvarnoe, 36 anonymous edits
Java Development Kit Source: http://en.wikipedia.org/w/index.php?oldid=373992477 Contributors: Akendall, Alainr345, Alexey Izbyshev, Anantshayan, Apavlo, Bluemoose, Caowm, Centrx,
Chochopk, Ctmt, DarkFalls, Dbabbitt, DeegC, Deineka, Dongiulio, Doug Bell, Easyas12c, Echawkes, Edknol, Elg fr, Epbr123, Feureau, Frap, Ftiercel, General Wesc, Graham87, Gronky,
GrooveDog, Hervegirod, IOLJeff, Ike-bana, Improv, Isilanes, Itai, JLaTondre, JVz, John Vandenberg, JorgePeixoto, Kkm010, Kl4m-AWB, L daruwala, MIT Trekkie, Mark Renier, Melnakeeb,
Michal.pise, Mmddyyyy, Mysdaao, Naradawickramage, Nixeagle, Nwbeeson, Octahedron80, Opticyclic, Philip Trueman, Plinkit, Ppntori, Qiq, RandomProcess, Rettetast, RossPatterson, Salsb,
Saxifrage, Sfmontyo, Smyth, Softwaresavant, Soimort, Spoon!, Stefan h, Stephan Leeds, Swarm, TimTay, Toussaint, Valodzka, Vlad, Webmink, Wellithy, Winterst, WissensDürster,
YUL89YYZ, Ylai, Yurikoles, 83 anonymous edits
Java Interface Definition Language Source: http://en.wikipedia.org/w/index.php?oldid=354441014 Contributors: Alainr345, ChrisHibbert, Pammann, Shalom Yechiel, Sloman, 2 anonymous
edits
Java resource bundle Source: http://en.wikipedia.org/w/index.php?oldid=321826780 Contributors: Alansohn, J. Finkelstein, JLaTondre, Padrecamara, Rror, 3 anonymous edits
Java TV Source: http://en.wikipedia.org/w/index.php?oldid=367075768 Contributors: Amareto2, IMSoP, Jandockx, Kathleen.wright5, Shalom Yechiel, Surachit, Tothebarricades.tk,
WOSlinker, 6 anonymous edits
Java Work Framework Source: http://en.wikipedia.org/w/index.php?oldid=328511613 Contributors: J04n, JLaTondre, Kosta.mosta, LilHelpa, Rror, Tassedethe, Tedickey
Java annotation Source: http://en.wikipedia.org/w/index.php?oldid=372015952 Contributors: Abdull, Alelinuxbsd, Cafewalter, Cyde, Delirium, Dmccreary, Fatespeaks, Fred Bradstadt,
JLaTondre, Jimmyzimms, Jwkpiano1, Kanonkas, Kesla, Nailbiter, Netizen, Ogai, Onjacktallcuca, Qutezuce, Sikon, Stagalj, Tchite, Techi2ee, Thumperward, Tyraios, W3bbo, 51 anonymous edits

Article Sources and Contributors 311
Java collections framework Source: http://en.wikipedia.org/w/index.php?oldid=375536927 Contributors: Alainr345, Chrisahn, Chronodm, D, DenisKrivosheev, Eraserhead1, Explanator,
Jespdj, Kamalraja, LINK3, Ohnoitsjamie, Prodoc, Qutezuce, Tassedethe, Toyota Dream House, Wikilolo, Wlievens, Wrp103, 10 anonymous edits
Java concurrency Source: http://en.wikipedia.org/w/index.php?oldid=374383735 Contributors: Abortz, Alvin-cs, Anwar saadat, Black Pepper, Chowbok, JonHarder, M4gnum0n,
Mati22081979, Veinor, Vonfraginoff, 8 anonymous edits
Java syntax Source: http://en.wikipedia.org/w/index.php?oldid=378326840 Contributors: 16@r, Ahoerstemeier, Alainr345, Alexwright, AnOddName, Ash211, Aspects, Avenged Eightfold,
AverageAmerican, AxelBoldt, Axlape, Barticus88, Benjiboi, Bigbluefish, Cairnarvon, CaptainVindaloo, Ceyockey, Chip Zero, Creidieki, D6, Dmyersturnbull, Doug Bell, Dvd Avins, Ed Poor,
Edward, Excirial, Flash200, FreplySpang, Ftiercel, Gaius Cornelius, Geeman, Gilgamesh, Gortsack, Gracenotes, Hagerman, Hervegirod, HotXRock, Ikip, Jnc, Joe Schmedley, John of Reading,
Jorge Stolfi, Karlzt, Kelly Martin, Ketiltrout, Kgwikipedian, Killy mcgee, King Mir, Leafyplant, LilHelpa, Lph, MBisanz, Maokart444, MarkSweep, Marvinscj, Max Schwarz, Maxwell Gerald
Anderson, Mike.lifeguard, Montgomery '39, Mzanime, Neilc, Oysterguitarist, Princess Lirin, Quoth, Quuxplusone, RCX, RealBadApple, Remember the dot, Renesis, Ruud Koot, Salsia, Snowolf,
Snowysquirrels, Someguy1221, SpaceLem, Sparky132, TakuyaMurata, Thumperward, Tobias Bergemann, Toussaint, Uncle G, Vihangvk, Wikimsd, Wiremore, Wtshymanski, ZeroOne, 148
anonymous edits
Java: View Technologies and Frameworks Source: http://en.wikipedia.org/w/index.php?oldid=366545291 Contributors: Fabrictramp, JonasMeinertz, Katharineamy, Matt5091, Mlavannis,
Vendeka, Woohookitty, 7 anonymous edits
JavaBeans Activation Framework Source: http://en.wikipedia.org/w/index.php?oldid=372079143 Contributors: NoNonsenseHumJock, Pammann, Shalom Yechiel, Stormbay, 1 anonymous
edits
JavaThreads Source: http://en.wikipedia.org/w/index.php?oldid=367334786 Contributors: 1ForTheMoney, Adimovk5, Andreas Kaufmann, Avalon, Fabrictramp, Katharineamy, Myjavaguru, 5
anonymous edits
javac Source: http://en.wikipedia.org/w/index.php?oldid=366877635 Contributors: Alansohn, Anwar saadat, Da rulz07, Frap, Hervegirod, Hgfernan, Ike-bana, Jonabbey, Oleg Alexandrov,
Osndok, Ralmin, Spoon!, TakuyaMurata, Tkircher, 16 anonymous edits
JavaFX Source: http://en.wikipedia.org/w/index.php?oldid=376249800 Contributors: AKA MBG, Alainr345, Anatolnsk, Arichnad, Arindamb, BenAveling, BlastStu, CapitalR, CardinalDan,
Chase me ladies, I'm the Cavalry, Chekristo, Chowbok, Coty, Creek23, Cwlq, CyberSkull, Damiens.rf, Daniel newton, Darkfrog26, Deineka, Dotfx, DreamGuy, Dunkinacha, Faisal.akeel,
Felixschrape, Ghettoblaster, GosiaCh, Gpvos, Grshiplett, HenryMinsky, Hervegirod, Hnarayanan, JavaKid, Jeshan, Jlweaver, Kinema, Kks krishna, Lkt1126, Local contributor, M1chu,
M4gnum0n, Martarius, Mathiastck, Mugunth Kumar, Nabbia, Naku, Nurg, OssDev, Pqd, Publicly Visible, QBK2006, Raysonho, Rjwilmsi, Ronz, SaltyDawg, SamJohnston, Samdutton, Sherb,
Shiki2, Simogasp, Sipoyraj, Sleske, Soumyasch, Surikov, Swarm, Tassedethe, Thumperward, Tokek, Toussaint, Van der Hoorn, Woodenfox, Wootery, Wwwwolf, ZZyXx, 115 anonymous edits
Jawin Source: http://en.wikipedia.org/w/index.php?oldid=332020757 Contributors: MER-C, MZimmer, Pvss, Samir, Shalom Yechiel, Warren, 1 anonymous edits
JExamples Source: http://en.wikipedia.org/w/index.php?oldid=380060395 Contributors: Alainr345, Andreas Kaufmann, Cwebster93, Eakle, Gennaro Prota, JLaTondre, Jonomacdrones,
Kenb215, Midoladido, Nathan, RainbowCrane, Ronz, Tim1357, 8 anonymous edits
Jfig Source: http://en.wikipedia.org/w/index.php?oldid=306624227 Contributors: Alpta, Benjaminevans82, Colonies Chris, EdGl, Hamitr, John Vandenberg, Kasjanek21, LQST, Rjsc, 5
anonymous edits
Jikes Source: http://en.wikipedia.org/w/index.php?oldid=366621186 Contributors: Chip Zero, Chruck, Delirium, Den fjättrade ankan, Doug Bell, Faisal.akeel, Fleminra, Frap, Greenrd, Greudin,
Gronky, Grutness, Hervegirod, Interiot, Isilanes, Jarekadam, Kl4m-AWB, KnightRider, Lost-theory, Lumingz, Myork, Netizen, Segin, TakuyaMurata, Tedder, Thedaveshields, Wootery, Zil, 21
anonymous edits
jnSynch Source: http://en.wikipedia.org/w/index.php?oldid=333423646 Contributors: Janunezc, Kasjanek21, S. Ugarte, Uncle G, 2 anonymous edits
Michael Kölling Source: http://en.wikipedia.org/w/index.php?oldid=365995556 Contributors: Artie p, DiablosDevil, Drbreznjev, Ed Fitzgerald, Gaius Cornelius, Garik, Gene Nygaard, JTA,
JimVC3, John Vandenberg, John254, KarlFrei, Kraftlos, Lame Name, Lubiann, Possum, Rainalee au, Sky HIgh, Stephenchou0722, Timrollpickering, Tony Hunter, Utgard Loki, 27 anonymous
edits
List of Java keywords Source: http://en.wikipedia.org/w/index.php?oldid=376075258 Contributors: 16@r, Altenmann, Anwar saadat, Cheung1303, Chowbok, Creek23, Cybercobra, Doug
Bell, Drae, DropDeadGorgias, Fx2, Gaius Cornelius, Green caterpillar, Henning Makholm, Jay, Jayzed882, Jinxed, KathrynLybarger, Kbdesai, Kusunose, M3tainfo, MarkSweep, Matt73,
Muchness, Mzanime, Programming gecko, RCX, Rsrikanth05, Selket, Smyth, Spoon!, Thumperward, Tothwolf, Twi20Pi, Zhmort, Zwirello, 40 anonymous edits
Marker interface pattern Source: http://en.wikipedia.org/w/index.php?oldid=352209532 Contributors: Ashutosh.shukla, Doug Bell, EALacey, Elf, Erechtheus, Jay, Jogloran, Jpp, Julesd,
KevinTeague, MoraSique, NickBush24, OpenFuture, Piano non troppo, PolyGlot, Quagmire, RedWolf, SAE1962, Texture, Timwi, 26 anonymous edits
Name mangling Source: http://en.wikipedia.org/w/index.php?oldid=376816035 Contributors: 16@r, AKGhetto, Abdull, Agnerf, AlistairMcMillan, Andreas Kaufmann, BB-Froggy, Benhoyt,
Blaxthos, Bluetulip, Bovineone, BrokenBeta, Bvanderveen, Chmod007, Curps, DancingMan, Darkwind, David.Monniaux, DmitTrix, Doug Bell, Dysprosia, Eelis.net, Efa, Finlay McWalter,
Fplay, Fredrik, Fresheneesz, Fumblebruschi, Gadfium, Gerbrant, Ghettoblaster, Itsme, Jalanpalmer, Jerryobject, Jesin, Jsmethers, Kate, Liangent, Marudubshinki, Matthew V Ball, Medinoc,
Mirror Vax, Mr1278, Nimur, Orderud, PdDemeter, Percy Snoodle, Petri Krohn, Phatom87, Pinzo, Quuxplusone, Rich Farmbrough, Sam Hocevar, Solipsist, Stevenj, Strimo, Suruena,
TakuyaMurata, Tausif.ik, Tedjn, TerraNova whatcanidotomakethisnottoosimilartosomeothername, Thecabinet, Thegeneralguy, TimBentley, VeryVeryTired, Wykypydya, Xezbeth, 63 anonymous
edits
Patrick Naughton Source: http://en.wikipedia.org/w/index.php?oldid=379356040 Contributors: 1ForTheMoney, Colonies Chris, Hervegirod, Jpbowen, Martarius, Merovingian,
Moonriddengirl, MrStalker, 3 anonymous edits
New I/O Source: http://en.wikipedia.org/w/index.php?oldid=379224036 Contributors: Aleksander Zawitkowski, Andyengle, Bluemoose, Bobo192, DJ Creature, DanielPitts, Doug Bell,
Dthomsen8, Hervegirod, Julesd, KenFehling, Meonkeys, Noisy, Outlyer, Peter Grey, Plasticup, TakuyaMurata, Thegeneralguy, Tobias Bergemann, Uncopy, Urhixidur, Wragge, 38 anonymous
edits
Object type (object-oriented programming) Source: http://en.wikipedia.org/w/index.php?oldid=378790181 Contributors: Aj045, BenAveling, Brewthatistrue, Capricorn42, Chanlyn,
ChanningWalton, Davidfstr, Doug Bell, Ed Poor, Egriffin, FlyHigh, Garyzx, Haakon, Jeff3000, Matt Crypto, Medinoc, Nuggetboy, Orderud, Pcap, R. S. Shaw, RJFJR, Rich Farmbrough,
RockMFR, Rtistique, TakuyaMurata, Tobych, Workingonmygooglefu, Xaonon, 31 anonymous edits
Omniscient Debugger Source: http://en.wikipedia.org/w/index.php?oldid=299648988 Contributors: Geni, John Vandenberg, Unforgettableid, Witchinghour, 1 anonymous edits
OpenJDK Source: http://en.wikipedia.org/w/index.php?oldid=379455981 Contributors: 16@r, A.Lingo, Alainr345, Arifsaha, Audriusa, Bratch, Chealer, Choij, DStoykov, Dmyersturnbull,
Dridus, Earthsound, EatMyShortz, Eugene Volchek, Euphoria, Flash200, Frap, Free Software Knight, Ghalas, Gnu andrew, Guyjohnston, Hervegirod, Jcarroll, Jimthing, Jm307, Lkt1126,
LodeRunner, Mathiastck, Melnakeeb, Mranderson2008, Nabbia, NeMeSiS, Neustradamus, Phobos11, Pixel-fodder, Ramalho, Rjwilmsi, SF007, Specious, Stinerman, Theoneintraining, Tokek,
Trasz, Two Bananas, WouterdeGroot, Wwwwolf, Yworo, ZeroOne, 63 anonymous edits
PHP/Java Bridge Source: http://en.wikipedia.org/w/index.php?oldid=343363652 Contributors: AntPhillips, Etphonehome, Intgr, JLaTondre, JaGa, Methmann, MuffledThud, Steve carlson, 4
anonymous edits
Java package Source: http://en.wikipedia.org/w/index.php?oldid=363502245 Contributors: Akhristov, Alex43223, Anwar saadat, Blueharmony, Christan80, Clemens vi, Doug Bell, Dreadstar,
Ed Poor, GeeJo, Grendelkhan, Henning Makholm, Hervegirod, ItsProgrammable, Jaxad0127, Jonik, Karl Dickman, LahiriB, Mandolinface, Markkauffman2000, Mbarbier, Mcorazao, Mentifisto,
Mike Rosoft, Miko3k, Paramlaghane, Pearle, Pjvpjv, RedWolf, Ruchira37, Shadanan, Simeon, SonniWP, Vy0123, Willmtz, 40 anonymous edits
Parboiled (Java) Source: http://en.wikipedia.org/w/index.php?oldid=367958629 Contributors: Ash, Elwikipedista, Rich Farmbrough, Sirthias, Tedickey
Plain Old Java Object Source: http://en.wikipedia.org/w/index.php?oldid=366362072 Contributors: Adzinok, Alainr345, Alesj, Bachrach44, Bart Carny, Bertport, Besem, Bruguiea,
Chillmann, China Crisis, Chronist, Coleopterous, DasAlbatross, Donsez, Dthomsen8, Ed Poor, Emmanuel.keller, Epbernard, Fred Bradstadt, Gracenotes, Graham87, Haakon, IWikediana,
Iridescent, Jay, Johnny Kewl, Jpp, Kennardconsulting, Keylay31, Lunacrescens, MLRoach, Magioladitis, Mild Bill Hiccup, Mumia-w-18, Nburden, OlavN, Plugwash, Plumpurple, Raul Lapeira,
Rbonvall, Rdvdijk, Rpawson, Sspecter, Stevage, WikiFan04, Zoquero, 99 anonymous edits

Article Sources and Contributors 312
Pluggable look and feel Source: http://en.wikipedia.org/w/index.php?oldid=330618711 Contributors: Barnacles phd, Doczilla, Hervegirod, Julesd, Michael miceli, Pegship, RedWolf, Rjwilmsi,
3 anonymous edits
Primitive wrapper class Source: http://en.wikipedia.org/w/index.php?oldid=336364034 Contributors: Bovineone, Chip Zero, Doug Bell, Ed Poor, Ekamaloff, Hervegirod, John Vandenberg,
Mareeswaran.m, Matthew0028, Naohiro19, Quilokos, Tobias Bergemann, Vedant lath, Wimt, 19 anonymous edits
Project Semplice Source: http://en.wikipedia.org/w/index.php?oldid=354488754 Contributors: Cmdrjameson, Creek23, Greenrd, RTucker, 3 anonymous edits
Quark Framework Source: http://en.wikipedia.org/w/index.php?oldid=370974561 Contributors: Btyner, CRGreathouse, ConalElliott, Gcom, Inferno, Iridescent, IvanAndreevich, Luke.evans,
R'n'B, René Vincent Jansen, Tabletop, Tassedethe, Thumperward, 5 anonymous edits
REPLAY (software) Source: http://en.wikipedia.org/w/index.php?oldid=361237690 Contributors: James R. Ward, LilHelpa, NJA, Oas777, SoWhy, Stuartyeates, 3 anonymous edits
Real time Java Source: http://en.wikipedia.org/w/index.php?oldid=373239585 Contributors: Abdull, Buntfalke, CanisRufus, Dautelle, Dcoetzee, Donsez, Dusclaux, FlyHigh, Fultonm,
Jamesjhunt, Jm307, John Gorn, Jsmethers, LaurentMeilleur, NapoliRoma, On5deu, Paddles, Pearle, Radagast83, RasputinAXP, Rror, Schoeberl, Skyemoor, Stemonitis, Tarret, Vörös, 31
anonymous edits
Resource (Java) Source: http://en.wikipedia.org/w/index.php?oldid=329573963 Contributors: Debresser, Fasten, JerroldProthero, John Vandenberg, Shyam, 2 anonymous edits
Restlet Source: http://en.wikipedia.org/w/index.php?oldid=378167831 Contributors: Alainr345, Avi4now, JLaTondre, Malcolma, Robheittman, 14 anonymous edits
Retrotranslator Source: http://en.wikipedia.org/w/index.php?oldid=332489708 Contributors: Davidedelvento, Fredrick Night, Hervegirod, 1 anonymous edits
SLAMD Source: http://en.wikipedia.org/w/index.php?oldid=300258495 Contributors: Benfred, Blaxthos, C777, EagleOne, Ff1959, JLaTondre, NapoliRoma, Sshoaff
SLAMD Server Source: http://en.wikipedia.org/w/index.php?oldid=302640824 Contributors: Dino, Ff1959, J04n
SLF4J Source: http://en.wikipedia.org/w/index.php?oldid=373825379 Contributors: Ashik, Bostonvaulter, Cgulcu, M4gnum0n, Malcolmxl5, RickBeton, SzpakEng, Tassedethe, Tedickey,
Tedyu002, 9 anonymous edits
Bruno Souza Source: http://en.wikipedia.org/w/index.php?oldid=372286903 Contributors: Damiens.rf, Jpbowen, Kitudo, Mwalder, Rich Farmbrough, Vmeruck, 2 anonymous edits
Static import Source: http://en.wikipedia.org/w/index.php?oldid=379160043 Contributors: Melchoir, Omahaprogrammer, 2 anonymous edits
StormMQ Source: http://en.wikipedia.org/w/index.php?oldid=370843656 Contributors: Ranjithsutari, Raphcohn
strictfp Source: http://en.wikipedia.org/w/index.php?oldid=367892479 Contributors: Atomota, Dddenton, Dmyersturnbull, Doug Bell, Enochlau, Faisal.akeel, Glasser, Iamnitin, JSMoller,
Jackzhp, Mipadi, Rich Farmbrough, Thryduulf, 22 anonymous edits
String Buffer Source: http://en.wikipedia.org/w/index.php?oldid=373917932 Contributors: Acdx, Alainr345, Andmatt, Evaders99, Joshporter, Malcolma, Michael Hardy, Rjwilmsi, RockMFR,
TakuyaMurata, Vald, Voice of All, Wwwwolf, 8 anonymous edits
Sun Web Developer Pack Source: http://en.wikipedia.org/w/index.php?oldid=336745405 Contributors: Alainr345, Ijevans, Rjwilmsi, 3 anonymous edits
Swing (Java) Source: http://en.wikipedia.org/w/index.php?oldid=377420554 Contributors: ALFP, Abhinav.rajsingh, AnOddName, Anna Lincoln, Appraiser, Audriusa, Avitaltr, Bewildebeast,
Blackbyrus, Bobgerac, BrianDuff, CAkira, CannotResolveSymbol, ChKa, Coconut99 99, Crosstimer, Darrien, Dave Messina, Davetron5000, Denizstij, Dgrant, Doug Bell, Dugwiki, Dxgriffiths,
ESkog, EatMyShortz, Echawkes, Eghbali, Elf, Explanator, Faisal.akeel, Feezo, Furrykef, Garoad, Gobias industries inc, Harry Wood, Hem1234, Hervegirod, Hu12, Iamthenew!!, Ike-bana,
Invalidname, Isnow, Jacek79, JackieBird, Jarsyl, Jaydeki, Jeshan, Jfrascencio, Jjaazz, Johnflan, Jokes Free4Me, JonHarder, Juancnuno, Justin W Smith, Kauczuk, Laterality, MC10, MIT Trekkie,
MaNeMeBasat, Maxim.zakharenkov, Meegs, Michalis Famelis, Mikeshk, MinorContributor, Mjparme, Mucus, Mygerardromance, Ocatecir, Ojigiri, Peruvianllama, Plustgarten, Pmsyyz, Poccil,
Prodoc, Prolog, Rafael.afonso, RedWolf, Rich Farmbrough, Rjwilmsi, Rockear, Rodhullandemu, Romanc19s, Rubicon, SJP, Saintamh, Salix alba, Sam Korn, Sebastian.Dietrich, Shinmawa,
Sikon, Simonjl, SkiBumMSP, Spasemunki, Squiggleslash, Stacrd, Stolsvik, Tarquin, Thatfunkymunki, The wub, Themusicgod1, Thumperward, Toussaint, Traroth, Vnsd, Weichbrodt, Wellithy,
Wootery, WreckLoose, 230 anonymous edits
SwingLabs Source: http://en.wikipedia.org/w/index.php?oldid=364207864 Contributors: Alainr345, Hervegirod
Synth Look and Feel Source: http://en.wikipedia.org/w/index.php?oldid=371233438 Contributors: Ghettoblaster, Hervegirod, Pegship, Powerlord, 6 anonymous edits
TeachScheme! Source: http://en.wikipedia.org/w/index.php?oldid=369013022 Contributors: Cat Parade, Chriscorv4, Clements, Ilmari Karonen, Instinct, JLaTondre, JonHarder, Lexein,
Matthias.f, Woohookitty, 23 anonymous edits
The Java Posse Source: http://en.wikipedia.org/w/index.php?oldid=370922550 Contributors: Betacommand, Blue520, Doug Bell, FunHappySprinkles, Grstain, Gwern, Invalidname, JavaKid,
Jlandin, Kenb215, MarsRover, Matt Crypto, Muzzamo, Shalom Yechiel, Vjosullivan, Wwiktorr, 16 anonymous edits
Unified Expression Language Source: http://en.wikipedia.org/w/index.php?oldid=317810356 Contributors: Hannabee, Jérôme, Madalino, Pinanti, Weggie, 4 anonymous edits
Java Virtual Machine Source: http://en.wikipedia.org/w/index.php?oldid=379985491 Contributors: @modi, A3csc300, AWendt, Aavviof, Abarnea 2000, Abu badali, Ahoerstemeier,
Alainr345, Aldie, Alifakoor, Alphachimp, Alphax, AnOddName, Andre Engels, Angitha.t, Anwar saadat, Arrenlex, Atramos, Axlq, Bawolff, BeauPaisley, Blue Em, Boing! said Zebedee, Bryan
Derksen, Burschik, CALR, Cactus.man, Calm, Chrismear, ClashTheBunny, Classicalecon, CodeMonk, Congruence, Conversion script, CyberSkull, Cyp, Dalvizu, Damian Yerrick, Danhicks,
DataWraith, Dave Cohoe, David Gerard, DavidCary, Dbabbitt, Debackerl, Dejvid, Delirium, Derek farn, Dnstest, Doradus, Doug Bell, DougsTech, Dreish, Ds13, EatMyShortz, Epbr123, Frap,
Fromageestciel, Furrykef, Gazpacho, Ghettoblaster, Gtoal, Gwernol, Haakon, Hairy Dude, Happysailor, Harborsparrow, Harp, Hdante, Headius, Hervegirod, Hfastedge, Hirzel, Hu12, Iane,
Igoldste, Intgr, J E Bailey, JWB, Jabman, JacobBramley, Jason.grossman, Jim88Argentina, Jj137, Joaopaulo1511, Joehni, John of Reading, JokerXtreme, Jondel, Karl Dickman, Khalid hassani,
Kishonti, Kks krishna, Krishan.sunbeam, Kuasha, Kungfuadam, Lee J Haywood, Liberty Miller, Livy the pixie, Lumingz, Ma8thew, Mariolina, Mav, Mboverload, Mfc, Miko3k, Mjscud,
Moa3333, Modster, Moppet65535, Napi, Neilc, Nemti, Ng.j, Nickg, NoIdeaNick, Nuno Tavares, Oleg Alexandrov, Ortolan88, Paul Foxworthy, Pegasus1138, Phyzome, Plasticup, Poccil,
Quaysea, Rakesh.usenet, Randolf Richardson, Raven4x4x, RedWolf, Rich Farmbrough, Rursus, SAE1962, SF007, SJP, Sander123, Schoeberl, Shadowjams, Sixth Estate, Slamb, Smarkflea,
Smjg, Smyth, Square87, Stephen B Streater, Stw, Tagus, Takis, TakuyaMurata, The Anome, Thumperward, TimTay, TittoAssini, ToddFincannon, Toussaint, Tyomitch, UU, Underpants,
Unsungzeros, VasilievVV, Versus22, Vicarious, Vinny, VladimirReshetnikov, Vy0123, Weregerbil, Whiner01, Whispering, Wikicrusader, Woohookitty, Wootery, Wrelwser43, Xevious, Yar2,
Yozh, 258 anonymous edits
Xerlin Source: http://en.wikipedia.org/w/index.php?oldid=367971010 Contributors: Beeblebrox, Elwikipedista, Iamthenewno2, Koavf, Ron Ritzman, Tassedethe, Tothwolf, WikiLaurent, 2
anonymous edits
XStream Source: http://en.wikipedia.org/w/index.php?oldid=367972218 Contributors: Alansohn, Andreas Kaufmann, Bryan Derksen, Den fjättrade ankan, DrHok, Elwikipedista, Fedor,
Gronky, Haschuur, Isilanes, John Vandenberg, Kl4m-AWB, Laserprinter, M4gnum0n, Melab-1, Pegship, Rich Farmbrough, Rror, SmackEater, Xmlizer, 5 anonymous edits

Image Sources, Licenses and Contributors 313
Image Sources, Licenses and Contributors
File:Java logo.svg Source: http://en.wikipedia.org/w/index.php?title=File:Java_logo.svg License: unknown Contributors: Eastmain, MBisanz, Sophus Bie, The wub, TimTay, Tkgd2007,
Webmink, 2 anonymous edits
File:Wikibooks-logo-en.svg Source: http://en.wikipedia.org/w/index.php?title=File:Wikibooks-logo-en.svg License: logo Contributors: User:Bastique, User:Ramac
File:Wave.svg Source: http://en.wikipedia.org/w/index.php?title=File:Wave.svg License: unknown Contributors: sbmehta converted to SVG from Sun Microsystems AI version.
Image:JavaPlatform.png Source: http://en.wikipedia.org/w/index.php?title=File:JavaPlatform.png License: unknown Contributors: Sun Microsystems, Inc.
Image:Wave.svg Source: http://en.wikipedia.org/w/index.php?title=File:Wave.svg License: unknown Contributors: sbmehta converted to SVG from Sun Microsystems AI version.
Image:Agentsheets IDE.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Agentsheets_IDE.jpg License: Public Domain Contributors: User:Dragentsheets
Image:AS-projects.jpg Source: http://en.wikipedia.org/w/index.php?title=File:AS-projects.jpg License: Public Domain Contributors: Dragentsheets
File:Java applet.png Source: http://en.wikipedia.org/w/index.php?title=File:Java_applet.png License: Public Domain Contributors: User:Audriusa
File:OpenAstexViewer.jpg Source: http://en.wikipedia.org/w/index.php?title=File:OpenAstexViewer.jpg License: GNU Lesser General Public License Contributors: Original uploader was
Audriusa at en.wikipedia
File:Cardiac cells applet.png Source: http://en.wikipedia.org/w/index.php?title=File:Cardiac_cells_applet.png License: GNU General Public License Contributors: Elizabeth Cherry and Flavio
Fenton (see )
File:Mandelbrot java applet.png Source: http://en.wikipedia.org/w/index.php?title=File:Mandelbrot_java_applet.png License: GNU General Public License Contributors: Original uploader
was Audriusa at en.wikipedia
File:ChessApplet.png Source: http://en.wikipedia.org/w/index.php?title=File:ChessApplet.png License: BSD Contributors: Original uploader was Audriusa at en.wikipedia
File:NASA World Wind.jpg Source: http://en.wikipedia.org/w/index.php?title=File:NASA_World_Wind.jpg License: unknown Contributors: Deadstar, WikipediaMaster
File:Remoteconsoleapplet.png Source: http://en.wikipedia.org/w/index.php?title=File:Remoteconsoleapplet.png License: unknown Contributors: Audriusa
Image:Aujac logo oficial.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_logo_oficial.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jordi.pujol.ulied
Image:Logo jjc 2003.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Logo_jjc_2003.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jordi.pujol.ulied
Image:Inauguracio.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Inauguracio.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jordi.pujol.ulied.
Image:Aujac cartell jjc2004.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_cartell_jjc2004.jpg License: Creative Commons Attribution 3.0 Contributors:
User:Jordi.pujol.ulied
Image:Aujac cartell jjc2005.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_cartell_jjc2005.jpg License: Attribution Contributors: User:Jordi.pujol.ulied
Image:Aujac sun tech day sabadell.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_sun_tech_day_sabadell.jpg License: Creative Commons Attribution 3.0 Contributors:
User:Jordi.pujol.ulied
Image:Aujac soci honor 2003 jordi roig.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_soci_honor_2003_jordi_roig.jpg License: Creative Commons Attribution 3.0
Contributors: User:Jordi.pujol.ulied
Image:Aujac soci honor 2004 eduard elias.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_soci_honor_2004_eduard_elias.jpg License: Creative Commons Attribution 3.0
Contributors: User:Jordi.pujol.ulied
Image:javapolis1.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Javapolis1.jpg License: Creative Commons Attribution-Sharealike 2.5 Contributors: Sjabejug
Image:javapolis2.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Javapolis2.jpg License: Creative Commons Attribution-Sharealike 2.5 Contributors: Sjabejug
File:James_Gosling_2008.jpg Source: http://en.wikipedia.org/w/index.php?title=File:James_Gosling_2008.jpg License: Attribution Contributors: User:Peter Campbell
Image:Java logo.svg Source: http://en.wikipedia.org/w/index.php?title=File:Java_logo.svg License: unknown Contributors: Eastmain, MBisanz, Sophus Bie, The wub, TimTay, Tkgd2007,
Webmink, 2 anonymous edits
Image:Java keywords highlighted.png Source: http://en.wikipedia.org/w/index.php?title=File:Java_keywords_highlighted.png License: Creative Commons Attribution-Sharealike 3.0
Contributors: User:Programming gecko
Image:JavaFX logo.jpg Source: http://en.wikipedia.org/w/index.php?title=File:JavaFX_logo.jpg License: unknown Contributors: GosiaCh, Salavat, Ysangkok
Image:CALlogo3D.png Source: http://en.wikipedia.org/w/index.php?title=File:CALlogo3D.png License: Public Domain Contributors: Luke.evans
File:Bruno_Souza.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Bruno_Souza.jpg License: Public Domain Contributors: Damiens.rf, Kitudo
Image:Gui-widgets.png Source: http://en.wikipedia.org/w/index.php?title=File:Gui-widgets.png License: GNU General Public License Contributors: Alex.ryazantsev, Faxe, Sven, Theoteryi,
Wutsje, 3 anonymous edits
File:AWTSwingClassHierarchy.png Source: http://en.wikipedia.org/w/index.php?title=File:AWTSwingClassHierarchy.png License: Public Domain Contributors: Jakub Závěrka
Image:Java-posse.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Java-posse.jpg License: Creative Commons Attribution 2.0 Contributors:
http://www.flickr.com/photos/joenuxoll/315005590/

License 314
License
Creative Commons Attribution-Share Alike 3.0 Unported
http:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/