Giddu

Contents
[hide]
• 1 History
○ 1.1 Principles
• 2 Practices
○ 2.1 Java Platform
 2.1.1 Implementations
 2.1.2 Performance
○ 2.2 Automatic memory management
• 3 Syntax
• 4 Examples
○ 4.1 Hello world
○ 4.2 A more comprehensive example
• 5 Special classes
○ 5.1 Applet
○ 5.2 Servlet
○ 5.3 JavaServer Pages
○ 5.4 Swing application
○ 5.5 Generics
• 6 Criticism
• 7 Class libraries
• 8 Documentation
• 9 Editions
• 10 See also
• 11 Notes
• 12 References
13 External links
Java (programming language)

Java
Paradigm Object-oriented, structured, imperative
Appeared in 1995
Sun Microsystems (now owned by Oracle

Designed by
Corporation)
Developer James Gosling & Sun Microsystems
Java Standard Edition 6 (1.6.0_25) (April

Stable release
21, 2011; 7 days ago (2011-04-21))
Typing discipline Static, strong, safe, nominative, manifest
Major
OpenJDK, HotSpot, many others
implementations
Dialects Generic Java, Pizza
Ada 83, C++, C#,[1] Delphi Object Pascal,

[2]
Eiffel,[3] Generic Java, Mesa,[4] Modula-
Influenced by
3,[5] Objective-C,[6] UCSD Pascal,[7][8]
Smalltalk
Ada 2005, BeanShell, C#, Clojure, D,
Influenced ECMAScript, Groovy, J#, JavaScript,
PHP, Python, Scala
OS Cross-platform (multi-platform)
GNU General Public License / Java

License
Community Process
Usual file
.java, .class, .jar
extensions
Website For Java Developers
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 to web applications.[9][10]
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
alternative implementations of these Sun technologies, such as the GNU Compiler for Java, GNU Classpath, and
Dalvik.
[edit] History
See also: Java (software platform)#History and Java version history
Duke, the Java mascot
James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June 1991.[11] Java was
originally designed for interactive television, but it was too advanced for the digital cable television industry at the
time.[12] 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.[13] Gosling aimed to implement a virtual
machine and a language that had a familiar C/C++ style of notation.[14]
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.[15] Java remains a de facto standard, controlled through the
Java Community Process.[16] 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.
[17]
Sun's vice-president Rich Green has said that Sun's ideal role with regards to Java is as an "evangelist."[18]
Following Oracle Corporation's acquisition of Sun Microsystems in 2009–2010, Oracle has described itself as the
"steward of Java technology with a relentless commitment to fostering a community of participation and
transparency".[19]
[edit] 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 have "an architecture-neutral and portable environment".
4. It should execute with "high performance".
5. It should be "interpreted, threaded, and dynamic".
[edit] Practices
[edit] Java Platform
Main articles: Java (software platform) and Java Virtual Machine
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.
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.
[edit] 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 US$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.
[edit] Performance
Main article: Java performance
Programs written in Java have a reputation for being slower and requiring more memory than those written in C.[26]
However, Java programs' execution speed improved significantly with the introduction of Just-in-time compilation
in 1997/1998 for Java 1.1,[27] 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. Currently, Java code has approximately half the performance of C
code.[28]
Some platforms offer direct hardware support for Java; there are microcontrollers that can run java in hardware
instead of a software JVM, and ARM based processors can have hardware support for executing Java bytecode
through its Jazelle option.
[edit] 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.[29]
[30]
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. In the latter case 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.
Java contains multiple types of garbage collectors. By default, HotSpot uses the Concurrent Mark Sweep collector,
also known as the CMS Garbage Collector. However, there are also several other garbage collectors that can be used
to manage the Heap. For 90% of applications in Java, the CMS Garbage Collector is good enough.[31]
[edit] Syntax
Main article: Java 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 primitive data types (integers, floating-point
numbers, boolean values, and characters), which are not classes for performance reasons.
Unlike C++, Java does not support 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 Javadoc comment; Javadoc can compile documentation
* from this text.
*/
[edit] Examples
[edit] Hello world
The traditional Hello world program can be written in Java as:[32]
class HelloWorldApp {
public static void main(String[] args) {
System.out.println("Hello World!"); // Display the string.
}
}
To compare this to other programming languages see the list of hello world program examples.
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 located.
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.
[edit] 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() {
/*
* 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 user doesn't put
one in then the compiler
* will create an empty one.
*/
}
// This is the main method. It gets called when this class is run through
a Java interpreter.
/*
* 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
* the "showDialog()" method, which brings up a prompt to ask you for
a number
*/
OddEven number = new OddEven();
number.showDialog();
}
public void showDialog() {

/*
* "try" makes sure nothing goes wrong. If something does,
* the interpreter skips to "catch" to see what it should do.
*/
try {
/*
* The code below brings up a JOptionPane, which is a dialog box
* The String returned by the "showInputDialog()" method is
converted into
* an integer, making the program treat it as a number instead of
a word.
* After that, this method calls a second method, calculate()
that will
* 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
* the number. Probably some letters were typed in instead of a
number.
*/
System.err.println("ERROR: Invalid input. Please type in a
numerical value.");
}
}
/*
* 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 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.
[edit] Special classes
[edit] Applet
Main article: Java 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 {
@Override
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 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.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">

<html>
<head>
<title>Hello World Applet</title>
</head>
<body>
<applet code="Hello" width="200" height="200">
</applet>
</body>
</html>
An applet is placed in an HTML document using the <applet> 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,[33] although support for these elements by Web browsers is inconsistent.[34] 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.
[edit] Servlet
Main article: Java 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 packages in the compilation.
The Hello class extends the GenericServlet 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) method defined by the
Servlet interface to provide the code for the service request handler. The service() method is passed a
ServletRequest object that contains the request from the client and a ServletResponse object used to
create the response returned to the client. The service() method declares that it throws the exceptions
ServletException and IOException if a problem prevents it from responding to the request.
The setContentType(String) method in the response object is called to set the MIME content type of the
returned data to "text/html". The getWriter() 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.
[edit] JavaServer Pages
Main article: 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 <% and %>. 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.
[edit] Swing application
Main article: Swing (Java)
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() {
super("hello");
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
add(new JLabel("Hello, world!"));
setVisible(true);
pack();
}

new Hello();
}
}
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 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.
[edit] Generics
Main article: Generics in Java
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.
[edit] Criticism
Main article: Criticism of Java
A number of criticisms have been leveled at Java programming language for various design choices in the language
and platform. Such criticisms include the implementation of generics, the handling of unsigned numbers, the
implementation of floating-point arithmetic, and security vulnerabilities.
[edit] Class libraries
Java Platform and Class libraries diagram
• 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, sets,
queues and double-ended queue, or stacks
 XML Processing (Parsing, Transforming, Validating) libraries
 Security
 Internationalization and localization libraries
○ 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
 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.
[edit] Documentation
Main article: Javadoc
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. Javadoc comments have an extra asterisk
at the beginning, i.e. the tags are /** and */, whereas the normal multi-line comment tags comments in Java and C
are set off with /* and */.
[edit] Editions
See also: Free Java implementations#Class library
Java 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.
[edit] See also
Wikiversity has learning materials about Topic:Java
Java portal
• Comparison of programming languages

• Comparison of Java and C++
• Comparison of Java and C#
• JavaOne
• Javapedia
• List of Java virtual machines
• List of Java APIs
• List of JVM languages
• C#
• Java version history
• Oak
[edit] Notes
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 [1][2]
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. ^ Gosling and McGilton (May 1996). "The Java Language Environment".
http://java.sun.com/docs/white/langenv/Intro.doc1.html#943.
4. ^ J. Gosling, B. Joy, G. Steele, G. Brachda. "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". Computerworld.com.au.
http://www.computerworld.com.au/index.php/id;1422447371;pp;3;fp;4194304;fpid;1. Retrieved 2010-06-
09.
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. [3]
7. ^ TechMetrix Research (1999). "History of Java". Java Application Servers Report.
http://www.fscript.org/prof/javapassport.pdf. "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". Queue.acm.org. 2004-08-31.
http://queue.acm.org/detail.cfm?id=1017013. Retrieved 2010-06-09.
9. ^ "Programming Language Popularity". 2009. http://www.langpop.com/. Retrieved 2009-01-16.
10. ^ "TIOBE Programming Community Index". 2009.
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html. Retrieved 2009-05-06.
11. ^ Byous, Jon (ca. 1998). "Java technology: The early years". Sun Developer Network. Sun Microsystems.
Archived from the original on April 20, 2005.
http://web.archive.org/web/20050420081440/http://java.sun.com/features/1998/05/birthday.html. Retrieved
2005-04-22.
12. ^ "The History of Java Technology". Sun Developer Network. ca. 1995.
http://www.java.com/en/javahistory/. Retrieved 2010-04-30.
13. ^ "Jonathan Schwartz's Blog: Different Isn't Always Better, But Better's Always Different". Blogs.sun.com.
http://blogs.sun.com/jonathan/entry/better_is_always_different. Retrieved 2010-06-09.
14. ^ Heinz Kabutz, Once Upon an Oak. Artima. Retrieved April 29, 2007.
15. ^ Java Study Group; Why Java Was – Not – Standardized Twice; What is ECMA—and why Microsoft
cares
16. ^ "Java Community Process website". Jcp.org. 2010-05-24. http://www.jcp.org/en/home/index. Retrieved
2010-06-09.
17. ^ "JAVAONE: Sun – The bulk of Java is open sourced". open.itworld.com.
http://open.itworld.com/4915/070508opsjava/page_1.html. Retrieved 2010-06-09.
18. ^ "Sun’s Evolving Role as Java Evangelist". O'Reilly Media.
http://onjava.com/pub/a/onjava/2002/04/17/evangelism.html.
19. ^ "Oracle and Java". oracle.com. Oracle Corporation.
http://www.oracle.com/us/technologies/java/index.html. Retrieved 2010-08-23. "Oracle has been a leading
and substantive supporter of Java since its emergence in 1995 and takes on the new role as steward of Java
technology with a relentless commitment to fostering a community of participation and transparency."
20. ^ "1.2 Design Goals of the JavaTM Programming Language". Java.sun.com. 1999-01-01.
http://java.sun.com/docs/white/langenv/Intro.doc2.html. Retrieved 2010-06-09.
21. ^ Andy Patrizio (2006). "Sun Embraces Linux With New Java License". Internet News. Web Media
Brands. http://www.internetnews.com/dev-news/article.php/3606656. Retrieved 2009-09-29.
22. ^ "Java for Mac OS X". Apple Developer Connection. Apple. http://developer.apple.com/java/. Retrieved
2009-09-29.
23. ^ "Microsoft Java Virtual Machine Support". Microsoft.com.
http://www.microsoft.com/mscorp/java/default.mspx. Retrieved 2010-06-09.
24. ^ "Java SE – Licensees". Java.sun.com. 2008-08-12. http://java.sun.com/javase/licensees.jsp. Retrieved
2010-06-09.
25. ^ James Niccolai (January 23, 2001). "Sun, Microsoft settle Java lawsuit". JavaWorld (IDG).
http://www.javaworld.com/javaworld/jw-01-2001/jw-0124-iw-mssuncourt.html. 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. ^ http://shootout.alioth.debian.org/u32q/which-programming-languages-are-fastest.php?
gcc=on&gpp=on&javasteady=on&java=on&csharp=on&javaxint=on&python3=on&python=on&jruby=on
&php=on&perl=on&calc=chart
29. ^ "NullPointerException". Java.sun.com.
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/NullPointerException.html. Retrieved 2010-06-09.
30. ^ "Exceptions in Java". Artima.com. http://www.artima.com/designtechniques/exceptions.html. Retrieved
2010-08-10.
31. ^ http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html
32. ^ "Lesson: A Closer Look at the "Hello World!" Application". The Java™ Tutorials > Getting Started.
Oracle Corporation. http://download.oracle.com/javase/tutorial/getStarted/application/index.html.
Retrieved 2011-04-14.
33. ^ "Using applet, object and embed Tags". oracle.com.
http://download.oracle.com/javase/1.5.0/docs/guide/plugin/developer_guide/using_tags.html. Retrieved
2010-10-14.
34. ^ "Deploying Applets in a Mixed-Browser Environment". oracle.com.
http://download.oracle.com/javase/1.5.0/docs/guide/plugin/developer_guide/using_tags.html#mixed.
[edit] References
• James Gosling, A brief history of the Green project. 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).
• 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).
[edit] External links
Look up Java in Wiktionary, the free dictionary.
Wikibooks has a book on the topic of

Java Programming
Wikiversity has learning materials about Java
Wikimedia Commons has media related to: Java (programming language)
• Java: Java for End-users

• Oracle: Developer Resources for Java Technology.
• Sun Microsystems: Java Language Specification 3rd Edition.
• Java SE 6 API Javadocs
• A Brief History of the Green Project
• Michael O'Connell: Java: The Inside Story, SunWord, July 1995.
• Patrick Naughton: Java Was Strongly Influenced by Objective-C (no date).
• David Bank: The Java Saga, Wired Issue 3.12 (December 1995).
• Shahrooz Feizabadi: A history of Java in: Marc Abrams, ed., World Wide Web – Beyond the Basics,
Prentice Hall, 1998.
• Patrick Naughton: The Long Strange Trip to Java, March 18, 1996.
• Open University (UK): M254 Java Everywhere (free open content documents).
• is-research GmbH: List of programming languages for a Java Virtual Machine.
• How Java's Floating-Point Hurts Everyone Everywhere, by W. Kahan and Joseph D. Darcy, University of
California, Berkeley.
[show]v · d · eJava
J
a
v
a
p
l Java language · JVM · Micro Edition · Standard Edition · Enterprise Edition · Java Card
a
t
f
o
r
m
S
u
n
t
e
c
h
Squawk · Java Development Kit · OpenJDK · Java Virtual Machine · JavaFX · Maxine VM
n
o
l
o
g
i
e
s
P Applets · Servlets · MIDlets · jsp · Web Start (jnlp)

l
a
t
f
o
r
m
t
e
c
h
n
o
l
o
g
i
e
s
M
a
j
o
r
t
h
i
r
d
-
p
a
r JRockit · GNU Classpath · Kaffe · TopLink · Apache Harmony · Apache Struts · Spring framework ·
t Hibernate · JBoss application server · Tapestry · Jazelle
y
t
e
c
h
n
o
l
o
g
i
e
s
H
i
s
t Java version history · Java Community Process · Sun Microsystems · Free Java implementations
o
r
y
M BeanShell · Clojure · Groovy · Java Tcl · JRuby · Jython · Processing · Rhino · Scala · more…
a
j
o
r
p
r
o
g
r
a
m
m
i
n
g
l
a
n
g
u
a
g
e
s
J
a
v
a
c
o
n
JavaOne
f
e
r
e
n
c
e
s
[show]v · d · eSun Microsystems (an Oracle Corporation company)
H
a
r
d Sun-1 · Sun-2 · Sun-3 · Sun386i · Sun-4 · SPARCstation · Netra · Ultra · Enterprise · Sun Blade · Sun Fire ·
w SPARC Enterprise · SPARC · JavaStation · Sun Ray · Sun Modular Datacenter · more...
a
r
e
S
o
f
SunOS · Solaris · NIS (+) · NFS · ZFS · SunView · NeWS · OpenWindows · Java Desktop System · Sun
t
Studio · Java · StarOffice · iPlanet/Sun ONE/Java Enterprise System · Sun Secure Global Desktop · MySQL ·
w
Sun xVM · GlassFish · more...
a
r
e
S StorageTek · Sun Open Storage · QFS · ZFS

t
o
r
a
g
e
H
i
g
h
-
P
e
r
f
o
r
m
a
Sun Cloud · Sun Constellation System · Sun Visualization System · Sun Grid Engine · Lustre
n
c
e
C
o
m
p
u
t
i
n
g
R
e
s
e
Sun Labs · picoJava · Fortress · Project Looking Glass
a
r
c
h
E SCPs · List of notable employees · BlueJ

d
u
c
a
t
i
o
n
a
n
d
R
e
c
o
g
n
i
t
i
o
n
C
o
m
m
CDDL · Java Community Process · NetBeans · OpenOffice.org · OpenSolaris · OpenSPARC · OpenJDK ·
u
OSUM
n
i
t
y
[show]v · d · eFree and open source software
G
e
n Copyleft · Events and Awards · Free software · Free Software Definition · Gratis versus libre · List of free and
e open source software packages · List of project directories/Comparison of hosting facilities · Open-source
r software
a
l
O
p
e
r
a
t
i
n
g
s
y
AROS · BSD · Darwin · eCos · FreeDOS · GNU · Haiku · Inferno · Linux · Mach · MINIX · OpenSolaris ·
s
Plan 9 · ReactOS · Symbian
t
e
m
f
a
m
i
l
i
e
s
D Eclipse · Free Pascal · GCC · Gambas · Java · LLVM · Lua · NetBeans · Open64 · Perl · PHP · Python ·
e
v
e
l
o
ROSE · Ruby · Tcl
p
m
e
n
t
H
i
s
t GNU · Haiku · Linux · Mozilla (Application Suite · Firefox · Thunderbird)
o
r
y
O
r
g
a
n Apache Software Foundation · Blender Foundation · Eclipse Foundation · freedesktop.org · Free Software
i Foundation (Europe · India · Latin America) · FSMI · GNOME Foundation · GNU Project · Google Code ·
z KDE e.V. · Linux Foundation · Mozilla Foundation · Open Source Geospatial Foundation · Open Source
a Initiative · Software Freedom Conservancy · SourceForge · Symbian Foundation · The Document
t Foundation · Xiph.Org Foundation · XMPP Standards Foundation · X.Org Foundation
i
o
n
s
L
i
c
e Apache · Artistic · BSD · GNU GPL · GNU LGPL · ISC · MIT · MPL · Ms-PL/RL · zlib · FSF approved
n licenses
c
e
s
L Open Source Definition · The Free Software Definition · Debian Free Software Guidelines
i
c
e
n
s
e
s
t
a
n
d
a
r
d
s
C
h
a
l
Binary blob · Canonical's contributor agreement · Digital rights management · Graphics hardware
l
compatibility · License proliferation · Mozilla software rebranding · Proprietary software · SCO-Linux
e
controversies · Security · Software patents · Hardware restrictions · Trusted Computing · Viral license
n
g
e
s
O
t
h
e
r
Alternative terms · Community · Linux distribution · Forking · Movement · Microsoft Open Specification
t Promise · Revolution OS · Comparison with closed source
o
p
i
c
s
Book:Free and Open Source Software · Category:Free software · Portal:Free software

Retrieved from "http://en.wikipedia.org/wiki/Java_(programming_language)"
Categories: Class-based programming languages | Concurrent programming languages | C programming language
family | Cross-platform software | Java platform | Java programming language | Java specification requests | JVM
programming languages | Object-oriented programming languages | Programming languages created in 1995 | Sun
Microsystems
Hidden categories: Articles to be merged from September 2010 | All articles to be merged
Java version history

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Java Web Start, first introduced for J2SE 1.3, allows provision of applications over the Web by clicking a desktop
icon or a link on a website.
The Java language has undergone several changes since JDK 1.0 as well as numerous additions of classes and
packages to the standard library. Since J2SE 1.4, the evolution of the Java language has been governed by the Java
Community Process (JCP), which uses Java Specification Requests (JSRs) to propose and specify additions and
changes to the Java platform. The language is specified by the Java Language Specification (JLS); changes to the
JLS are managed under JSR 901.
In addition to the language changes, much more dramatic changes have been made to the Java class library over the
years, which has grown from a few hundred classes in JDK 1.0 to over three thousand in J2SE 5000 Entire new
APIs, such as Swing and Java2D, have been introduced, and many of the original JDK 1.0 classes and methods have
been deprecated.
Some programs allow conversion of Java programs from one version of the Java Platform to an older one (for
example Java 5.0 backported to 1.4) (see Java backporting tools).
Contents
[hide]
• 1 JDK 1.0 (January 23, 1996)
• 2 JDK 1.1 (February 19, 1997)
• 3 J2SE 1.2 (December 8, 1998)
• 4 J2SE 1.3 (May 8, 2000)
• 5 J2SE 1.4 (February 6, 2002)
• 6 J2SE 5.0 (September 30, 2004)
• 7 Java SE 6 (December 11, 2006)
○ 7.1 Java SE 6 Update 10
• 8 Java SE 7
• 9 Java SE 8
• 10 See also
• 11 References
• 12 External links
[edit] JDK 1.0 (January 23, 1996)

Codename Oak. Initial release[1][2] The first stable version was the JDK 1.0.2. is called Java 1[2]
[edit] JDK 1.1 (February 19, 1997)
Major additions included:[3]
• an extensive retooling of the AWT event model
• inner classes added to the language
• JavaBeans
• JDBC
• RMI
• reflection which supported Introspection only, no modification at runtime was possible.
[edit] J2SE 1.2 (December 8, 1998)
Codename Playground. This and subsequent releases through J2SE 5.0 were rebranded retrospectively Java 2 and
the version name "J2SE" (Java 2 Platform, Standard Edition) replaced JDK to distinguish the base platform from
J2EE (Java 2 Platform, Enterprise Edition) and J2ME (Java 2 Platform, Micro Edition). Major additions included:[4]
• strictfp keyword
• the Swing graphical API was integrated into the core classes
• Sun's JVM was equipped with a JIT compiler for the first time
• Java Plug-in
• Java IDL, an IDL implementation for CORBA interoperability
• Collections framework
[edit] J2SE 1.3 (May 8, 2000)
Codename Kestrel. The most notable changes were:[5][6]
• HotSpot JVM included (the HotSpot JVM was first released in April, 1999 for the J2SE 1.2 JVM)
• RMI was modified to support optional compatibility with CORBA
• JavaSound
• Java Naming and Directory Interface (JNDI) included in core libraries (previously available as an
extension)
• Java Platform Debugger Architecture (JPDA)
• Synthetic proxy classes
[edit] J2SE 1.4 (February 6, 2002)
Codename Merlin. This was the first release of the Java platform developed under the Java Community Process as
JSR 59. Major changes included:[7][8]
• assert keyword (Specified in JSR 41.)
• regular expressions modeled after Perl regular expressions
• exception chaining allows an exception to encapsulate original lower-level exception
• Internet Protocol version 6 (IPv6) support
• non-blocking NIO (New Input/Output) (Specified in JSR 51.)
• logging API (Specified in JSR 47.)
• image I/O API for reading and writing images in formats like JPEG and PNG
• integrated XML parser and XSLT processor (JAXP) (Specified in JSR 5 and JSR 63.)
• integrated security and cryptography extensions (JCE, JSSE, JAAS)
• Java Web Start included (Java Web Start was first released in March, 2001 for J2SE 1.3) (Specified in JSR
56.)
• Preferences API (java.util.prefs)
[edit] J2SE 5.0 (September 30, 2004)
Codename Tiger. Originally numbered 1.5, which is still used as the internal version number.[9] This version was
developed under JSR 176.
J2SE 5.0 entered its end-of-life on April 8, 2008 and is no longer supported by Sun as of November 3, 2009.[10]
Tiger added a number of significant new language features:[11][12]
• Generics: Provides compile-time (static) type safety for collections and eliminates the need for most
typecasts (type conversion). (Specified by JSR 14.)
• Metadata: Also called annotations; allows language constructs such as classes and methods to be tagged
with additional data, which can then be processed by metadata-aware utilities. (Specified by JSR 175.)
• Autoboxing/unboxing: Automatic conversions between primitive types (such as int) and primitive
wrapper classes (such as Integer). (Specified by JSR 201.)
• Enumerations: The enum keyword creates a typesafe, ordered list of values (such as Day.MONDAY,
Day.TUESDAY, etc.). Previously this could only be achieved by non-typesafe constant integers or
manually constructed classes (typesafe enum pattern). (Specified by JSR 201.)
• Swing: New skinnable look and feel, called synth.
• Varargs: The last parameter of a method can now be declared using a type name followed by three dots
(e.g. void drawtext(String... lines)). In the calling code any number of parameters of that
type can be used and they are then placed in an array to be passed to the method, or alternatively the calling
code can pass an array of that type.
• Enhanced for each loop: The for loop syntax is extended with special syntax for iterating over each
member of either an array or any Iterable, such as the standard Collection classes, using a
construct of the form:
void displayWidgets (Iterable<Widget> widgets) {
for (Widget w: widgets) {
w.display();
}
}
This example iterates over the Iterable object widgets, assigning each of its items in turn to the variable w,
and then calling the Widget method display() for each item. (Specified by JSR 201.)
• Fix the previously broken semantics of the Java Memory Model, which defines how threads interact
through memory.
• Automatic stub generation for RMI objects.
• Static imports
• Java 5 is the last release of Java to officially support the Microsoft Windows 9x line (Windows 95,
Windows 98, Windows ME). [1] Unofficially, Java SE 6 Update 7 (1.6.0.7) is the last version of Java to be
shown working on this family of operating systems. [2]
• The concurrency utilities in package java.util.concurrent.[13]
• Scanner class for parsing data from various input streams and buffers.
[edit] Java SE 6 (December 11, 2006)
Codename Mustang. As of this version, Sun replaced the name "J2SE" with Java SE and dropped the ".0" from the
version number.[14] Internal numbering for developers remains 1.6.0.[15] This version was developed under JSR 270.
During the development phase, new builds including enhancements and bug fixes were released approximately
weekly. Beta versions were released in February and June 2006, leading up to a final release that occurred on
December 11, 2006. The current revision is Update 24 which was released in February 2011.
Major changes included in this version:[16][17]
• Support for older Win9x versions dropped. Unofficially Java 6 Update 7 is the last release of Java shown to
work on these versions of Windows. This is believed to be due to the major changes in Update 10.
• Scripting Language Support (JSR 223): Generic API for tight integration with scripting languages, and
built-in Mozilla JavaScript Rhino integration
• Dramatic performance improvements for the core platform,[18][19] and Swing.
• Improved Web Service support through JAX-WS (JSR 224)
• JDBC 4.0 support (JSR 221).
• Java Compiler API (JSR 199): an API allowing a Java program to select and invoke a Java Compiler
programmatically.
• Upgrade of JAXB to version 2.0: Including integration of a StAX parser.
• Support for pluggable annotations (JSR 269)[20]
• Many GUI improvements, such as integration of SwingWorker in the API, table sorting and filtering, and
true Swing double-buffering (eliminating the gray-area effect).
• JVM improvements include: synchronization and compiler performance optimizations, new algorithms and
upgrades to existing garbage collection algorithms, and application start-up performance.[21]
[edit] Java SE 6 Update 10
Java SE 6 Update 10 (previously known as Java SE 6 Update N) was released October 15, 2008 and while it does
not change any public API, is meant as a major enhancement in terms of end-user usability. The release version is
currently available for download.[22]
Major changes for this update include:[22][23]
• Java Deployment Toolkit, a set of JavaScript functions to ease the deployment of applets and Java Web
Start applications.[24]
• Java Kernel, a small installer including only the most commonly used JRE classes. Other packages are
downloaded when needed.
• Enhanced updater.
• Enhanced versioning and pack200 support: server-side support is no longer required.[25]
• Java Quick Starter, to improve cold start-up time.
• Improved performance of Java2D graphics primitives on Windows, using Direct3D and hardware
acceleration.
• A new Swing look and feel called Nimbus and based on synth.[26]
• Next-Generation Java Plug-In: applets now run in a separate process and support many features of Web
Start applications.[27]
Released December 3, 2008[28]
This release includes the 64-bit Java Plug-In (for 64-bit browsers only), Windows Server 2008 support, and
performance improvements of Java and JavaFX applications.[29]
Java SE 6 Update 14 (6u14) was released as of May 28, 2009.[30]
This release includes extensive performance updates to the HotSpot JIT compiler, compressed pointers for 64-bit
machines, as well as support for the G1 (Garbage First) low pause garbage collector.[31][32]
The -XX:+DoEscapeAnalysis option directs the HotSpot JIT compiler to use escape analysis to determine if local
objects can be allocated on the stack instead of the heap.[33]
Some developers have noticed an issue introduced in this release which causes debuggers to miss breakpoints
seemingly randomly.[34] Sun has a corresponding bug, which is tracking the issue. The workaround applies to the
Client and Server VMs.[35] Using the -XX:+UseParallelGC option will prevent the failure. Another workaround is
to roll back to update 13, or to upgrade to update 16.
Introduced the patch-in-place functionality .[36]
Released August 11, 2009. Fixes the issue introduced in update 14 which caused debuggers to miss breakpoints.[37]
Released November 4, 2009.[38]
Released January 13, 2010.[39]
Released March 30, 2010.[40]
Released April 15, 2010.[41]
Released July 7, 2010.[42]
Released October 12, 2010.[43]
Released December 8, 2010.[44]
Released February 15, 2011.[45]
Released April 21, 2011.[46]
[edit] Java SE 7
Java 7 (codename Dolphin[47]) is an upcoming major update to Java.[48] The development period is organized into
thirteen milestones; on February 18, 2011, milestone 13, the last milestone was reached.[49][50] Multiple builds, which
generally include enhancements and bug fixes, are released per milestone. The Feature list at the Open JDK 7
project lists many of the expected feature changes.
The expected feature additions for Java 7[51]
• JVM support for dynamic languages, following the prototyping work currently done on the Multi Language
Virtual Machine
• Compressed 64-bit pointers[52] Available in Java 6 with -XX:+UseCompressedOops
• Language changes under Project Coin.[53][54] The features accepted for inclusion in Project Coin are:
• Strings in switch[55]
• Automatic resource management[56]
• Improved Type Inference for Generic Instance Creation[57]
• Simplified Varargs Method Invocation[58]
• Better integral literals allowing for underscores as digit separators
• Language-level support for Collections[59]
• Concurrency utilities under JSR 166[60]
• New file I/O library to enhance platform independence and add support for metadata and symbolic links.
The new packages are java.nio.file and java.nio.file.attribute[61][62]
• Library-level support for Elliptic curve cryptography algorithms
• An XRender pipeline for Java 2D, which improves handling of features specific to modern GPUs
• New platform APIs for the graphics features originally planned for release in Java version 6u10
• Enhanced library-level support for new network protocols, including SCTP and Sockets Direct Protocol
• Upstream updates to XML and Unicode
Lambda, Jigsaw, and part of Coin were dropped from Java 7, which will be released in mid 2011. Java 8 will be
implemented with the remaining features in late 2012.[63]
[edit] Java SE 8
Java 8 is expected in late 2012 [64] and will include at a minimum the features that were planned for Java 7 but later
deferred.
• Modularization of the JDK under Project Jigsaw[65]
• Language-level support for lambda expressions (officially, lambda expressions; unofficially, closures)
under Project Lambda.[66] There was an ongoing debate in the Java community on whether to add support
for lambda expressions.[67][68] Sun later declared that lambda expressions would be included in Java 7 and
asked for community input to refine the feature.[69]
• Parts of project Coin that are not included in Java 7
[edit] External links
• Full list of changes for J2SE 1.3
• Full list of changes for Java SE 6
• Mustang development site for Java SE 6
• Development site for Java SE 7
• Sun Java Supported versions and EOL
• Downloads archive for older version of Java
[hide]v · d · eJava
Java language · JVM · Micro Edition · Standard Edition ·

Java platform
Enterprise Edition · Java Card
Squawk · Java Development Kit · OpenJDK · Java Virtual

Sun technologies
Machine · JavaFX · Maxine VM
Platform technologies Applets · Servlets · MIDlets · jsp · Web Start (jnlp)
JRockit · GNU Classpath · Kaffe · TopLink · Apache

Major third-party technologies Harmony · Apache Struts · Spring framework · Hibernate ·
JBoss application server · Tapestry · Jazelle
Java version history · Java Community Process · Sun

History
Microsystems · Free Java implementations
Major programming BeanShell · Clojure · Groovy · Java Tcl · JRuby · Jython ·

languages Processing · Rhino · Scala · more…
Java conferences JavaOne
1. History of the World Wide Web

1.4. History of Java
At first glance, it may appear that Java was developed specifically for the world wide web. However, interestingly
enough, Java was developed independently of the web, and went through several stages of metamorphosis before
reaching its current status of de facto programming language for the world wide web. Below is a brief history of
Java since its infancy to its current state.
1.4.1 Oak
According the Java FAQ, [Harold] Bill Joy, currently a vice president at Sun Microsystems, is widely believed to
have been the person to conceive of the idea of a programming language that later became Java. In late 1970's, Joy
wanted to design a language that combined the best features of MESA and C. In an attempt to re-write the UNIX
operating system in 1980's, Joy decided that C++ was inadequate for the job. A better tool was needed to write short
and effective programs. It was this desire to invent a better programming tool that swayed Joy, in 1991, in the
direction of Sun's "Stealth Project" - as named by Scott McNealy, Sun's president. [Harold]
In January of 1991, Bill Joy, James Gosling, Mike Sheradin, Patrick Naughton (formerly the project leader of Sun's
OpenWindows user environment), and several other individuals met in Aspen, Colorado for the first time to discuss
the ideas for the Stealth Project. The goal of the Stealth Project was to do research in the area of application of
computers in the consumer electronics market. The vision of the project was to develop "smart" consumer electronic
devices that could all be centrally controlled and programmed from a handheld-remote-control-like device.
According to Gosling, "the goal was ... to build a system that would let us do a large, distributed, heterogeneous
network of consumer electronic devices all talking to each other." With this goal in mind, the stealth group began
work. [O'Connell]
Members of the Stealth Project, which later became known as the Green Project, divided the tasks amongst
themselves. Mike Sheradin was to focus on business development, Patrick Naughton was to begin work on the
graphics system, and James Gosling was to identify the proper programming language for the project. Gosling who
had joined Sun in 1984, had previously developed the commercially unsuccessful NeWS windowing system as well
as GOSMACS - a C language implementation of GNU EMACS. He began with C++, but soon after was convinced
that C++ was inadequate for this particular project. His extensions and modifications to C++ (also know as C++ ++
--), were the first steps towards the development of an independent language that would fit the project objectives. He
named the language "Oak" while staring at an oak tree outside his office window! The name "Oak" was later
dismissed due to a patent search which determined that the name was copyrighted and used for another
programming language. According to Gosling, "the Java development team discovered that Oak was the name of a
programming language that predated Sun's language, so another name had to be chosen." [O'Connell] [Harold]
"It's surprisingly difficult to find a good name for a programming language, as the team discovered after many hours
of brainstorming. Finally, inspiration struck one day during a trip to the local coffee shop" Gosling recalls. Others
have speculated that the name Java came from several individuals involved in the project: James gosling, Arthur
Van hoff, Andy bechtolsheim. [McCarthy]
There were several criteria that Oak had to meet in order to satisfy the project objective given the consumer
electronics target market. Given the wide array of manufacturers in the market, Oak would have to be completely
platform independent, and function seamlessly regardless of the type of CPU in the device. For this reason, Oak was
designed to be an interpreted language, since it would be practically impossible for a complied version to run on all
available platforms. To facilitate the job of the interpreter, Oak was to be converted to an intermediate "byte-code"
format which is then passed around across the network, and executed/interpreted dynamically. [O'Connell] [Harold]
[McCarthy]
Additionally, reliability was of great concern. A consumer electronics device that would have to be "rebooted"
periodically was not acceptable. Another important design objective for Oak would then have to be high reliability
by allowing the least amount of programmer-introduced errors. This was the motivation for several important
modification to C++. The concepts of multiple-inheritance and operator overloading were identified as sources of
potential errors, and eliminated in Oak. Furthermore, in contrast to C++, Oak included implicit garbage collection
thereby providing efficient memory utilization and higher reliability. Finally, Oak attempted to eliminate all unsafe
constructs used in C and C++ by only providing data structures within objects. [O'Connell] [McCarthy]
Another essential design criterion was security. By design, Oak-based devices were to function in a network and
often exchange code and information. Inherently, security is of great concern in a networked environment,
especially in an environment as network dependent as the conceived Oak-based systems. For this reason, pointers
were excluded in the design of Oak. This would theoretically eliminate the possibility of malicious programs
accessing arbitrary addresses in memory. [O'Connell] [McCarthy]
If Oak were to be widely accepted and used within the consumer electronics industry, it would have to be simple and
compact, so that the language could be mastered relatively easily, and development would not be excessively
complex. Some would argue that Oak/Java is C++ done right, but the jury is still out on that...
In April of 1991, Ed Frank, a SPARCstation 10 architect, joined the green project. He led the project's hardware
development effort. In two months, they developed the first hardware prototype known as star-seven (*7). The name
*7 was somewhat demonstrative of the project's objective. *7 was the key combination to press on any telephone to
answer any other ringing telephone on their network. In the meantime, Gosling was beginning work on the Oak
interpreter. By August of 1991, the team had a working prototype of the user interface and graphical system which
was demonstrated to Sun's co-founders Scott McNealy and Bill Joy. [O'Connell]
Development of Oak, the green OS, the user interface, and the hardware continued through the summer of 1992. In
September of that year, the *7 prototype was complete and demonstrated to McNealy and Joy. The prototype was a
PDA-like (personal digital assistant) device that Gosling described as a "handheld remote control." Patrick
Naughton proclaimed that "in 18 months, we did the equivalent of what 75-people organizations at Sun took three
years to do -- an operating system, a language, a toolkit, an interface, a new hardware platform, ..." [O'Connell]
While impressive, the market was not conducive to this type of technology, as later demonstrated by Apple's
Newton PDA. The Green project's business planner, Mike Sheradin, and hardware designer, Ed Frank had
envisioned a technology similar to that of Dolby Labs which would become the standard for the consumer
electronics products. [O'Connell]
1.4.2 FirstPerson
In November of 1992, the Green Project is incorporated under the name FirstPerson. Given Java's lack of success in
the consumer electronics industry, the company's direction was somewhat uncertain. Under Sun's influence, the
company began re-evaluating its mission.
In early 1993, Time-Warner issued an RFP (request for proposal) for a set-top box operating system and interactive,
video-on-demand technology. FirstPerson identified this area as a new target market, and began working in that
direction. However, despite FirstPerson's great efforts, SGI was granted the contract by Time-Warner. By mid 1993
Sun began negotiating with 3DO to provide a Java-based OS for their set-top box. The negotiations were, however,
unsuccessful and a deal was never made. FirstPerson was left on its own without any viable business prospects.
Another attempt by the company to market its interactive TV technology fails when in February of 1994 a public
launching of their products is canceled. [O'Connell]
A Sun higher level review of FirstPerson determines the interactive TV market to be immature in 1994. FirstPerson
then shifts its focus yet again. Business plans are submitted to Sun's executives for developing Oak-based on-line
and CD-ROM applications. Sun's response was not favorable, and FirstPerson was dissolved. Most of FirstPerson's
employees moved to Sun Interactive to digital video data servers. However, a few individuals from FirstPerson still
pursued the objective of finding a home for Java in a networked desktop market. [O'Connell]
1.4.3 Java and the World Wide Web
In June of 1994, Bill Joy started the "Liveoak" project with the stated objective of building a "big small operating"
system. In July of 1994, the project "clicked" into place. Naughton gets the idea of putting "Liveoak" to work on the
Internet while he was playing with writing a web browser over a long weekend. Just the kind of thing you'd want to
do with your weekend! This was the turning point for Java. [O'Connell]
The world wide web, by nature, had requirements such as reliability, security, and architecture independence which
were fully compatible with Java's design parameters. A perfect match had been found. By September of 1994,
Naughton and Jonathan Payne (a Sun engineer) start writing "WebRunner," a Java-based web browser which was
later renamed "HotJava." By October 1994, HotJava is stable and demonstrated to Sun executives. This time, Java's
potential, in the context of the world wide web, is recognized and the project is supported. Although designed with a
different objective in mind, Java found a perfect match in the World Wide Web. Many of Java's original design
criteria such as platform independence, security, and reliability were directly applicable to the World Wide Web as
well. Introduction of Java marked a new era in the history of the web. Information provides were now given the
capability to not only deliver raw data, but also the applications that would operate on the data.
Sun formally announced Java and HotJava at SunWorld `95. Soon after, Netscape Inc. announced that it would
incorporate Java support in their browser. This was a great triumph for Java since it was now supported by the most
popular browser in the world. Later, Microsoft also announced that they would support Java in their Internet
Explorer web browser, further solidifying Java's role in the World Wide Web.
And the rest is, ...well, in chapter 21.
Shahrooz Feizabadi <shahrooz@vt.edu>
Java
Java in Action Downloads Help Center
Top of Form
Java.com any url contains en Search
Bottom of Form
Learn About Java Technology

To date, the Java platform has attracted more than 6.5 million software developers. It's used in every major
industry segment and has a presence in a wide range of devices, computers, and networks.
Java technology's versatility, efficiency, platform portability, and security make it the ideal technology for network
computing. From laptops to datacenters, game consoles to scientific supercomputers, cell phones to the Internet,
Java is everywhere!
• 1.1 billion desktops run Java
• 930 million Java Runtime Environment downloads each year
• 3 billion mobile phones run Java
• 31 times more Java phones ship every year than Apple and Android combined
• 100% of all Blu-ray players run Java
• 1.4 billion Java Cards are manufactured each year
• Java powers set-top boxes, printers, Web cams, games, car navigation systems, lottery terminals, medical
devices, parking payment stations, and more.
To see places of Java in Action in your daily life, explore java.com.
Why Software Developers Choose Java
Java has been tested, refined, extended, and proven by a dedicated community. And numbering more than 6.5
million developers, it's the largest and most active on the planet. With its versatilty, efficiency, and portability, Java
has become invaluable to developers by enabling them to:
• Write software on one platform and run it on virtually any other platform
• Create programs to run within a Web browser and Web services
• Develop server-side applications for online forums, stores, polls, HTML forms processing, and more
• Combine applications or services using the Java language to create highly customized applications or
services
• Write powerful and efficient applications for mobile phones, remote processors, low-cost consumer
products, and practically any other device with a digital heartbeat
Some Ways Software Developers Learn Java
Many colleges and universities offer courses in programming for the Java platform. In addition, developers can also
enhance their Java programming skills by reading Oracle's Java developer web site, subscribing to Java technology-
focused newsletters, using the Java Tutorial and the New to Java Programming Center, and signing up for Web,
virtual, or instructor-led courses.
The Oracle Technology Network is the world's largest community of application

developers, database admins, system admins/developers, and architects using industry-standard technologies in
combination with Oracle products. It is also the home of oracle.com/technetwork/java, the ultimate, complete, and
authoritative source of technical information about Java. Membership is free, join today! (In your Profile, check the
Oracle Technology Network box under My Community Memberships.)
What Is JavaFX
JavaFX extends your web experience by delivering rich media and content across all the
screens of your life. As users, you will be able to run JavaFX applications in a browser or drag and drop them onto
the desktop. It's a seamless interface!
JavaFX is powered by Java: JavaFX extends the power of Java by allowing developers to use any Java library
within JavaFX applications. This way developers can expand their capabilities in Java and make use of the
revolutionary presentation technology that JavaFX provides to build engaging visual experiences.
Highlights of JavaFX:
• Allows users to view JavaFX applications in a browser or break free of the browser by dragging and
dropping the same application onto the desktop
• Enables an efficient designer-to-developer workflow with Project Nile: designers can work in their tools of
choice while collaborating with Web scripters who use the NetBeans IDE with JavaFX
• Extends Java technology by enabling use of any Java library within a JavaFX application
• Allows developers to integrate vector graphics, animation, audio, and video Web assets into a rich,
interactive, immersive application
To learn more about JavaFX technology, visit javafx.com or java.sun.com/javafx web sites for more information.
Back to top
Help Resources
» What is Java?
» Remove Older Versions
Select Language | About Java | Developers
Privacy | Terms of Use | Trademarks | Disclaimer
Oracle
Feedback
Click here to
rate this page
[edit] References
1. ^ Version 1.0 press release, Sun.
2. ^ a b http://www.oracle.com/technetwork/java/chapter1-159190.pdf
6. ^ Version 1.3 full list of changes, Sun.
7. ^ Version 1.4 press release.
8. ^ Version full 1.4 list of changes.
9. ^ Version 5 release notes, Sun.
10. ^ Java SE Downloads - Previous Release - JDK 5
12. ^ Version 1.5 full list of changes.
13. ^ Goetz, Brian (2006). Java Concurrency in Practice. Addison-Wesley. p. xvii. ISBN 0-321-34960-1.
14. ^ Java brand naming.
15. ^ Version 6, Java webnotes, Sun.
17. ^ Version 1.6 full list of changes.
18. ^ Java Lobby.
19. ^ Mustang’s HotSpot, Sun weblogs.
20. ^ Darcy, Joe (2008-08-03). "An apt replacement". http://blogs.sun.com/darcy/date/20090727. Retrieved
2009-07-29.
21. ^ "Java SE 6 Performance White Paper". 2007-10-25.
http://java.sun.com/performance/reference/whitepapers/6_performance.html. Retrieved 2010-02-04.
22. ^ a b Java SE 6 Update 10 Overview
23. ^ Introducing Java SE 6 Update 10
24. ^ Java Deployment Toolkit
25. ^ Version Download and Pack200 Support
26. ^ Nimbus
27. ^ Release Notes for the Next-Generation Java Plug-In Technology
28. ^ "Sun Java 6 Update 11 Available Now, Waiting on JavaFX". FindMySoft.
http://www.findmysoft.com/news/Sun-Java-6-Update-11-Available-Now-Waiting-on-JavaFX/. Retrieved
2009-11-13.
29. ^ "Changes in 1.6.0_12 (6u12)". Sun Microsystems. http://java.sun.com/javase/6/webnotes/6u12.html.
30. ^ "Update Release Notes". Sun Microsystems. http://java.sun.com/javase/6/webnotes/ReleaseNotes.html.
31. ^ Humble, Charles (2008-05-13). "JavaOne: Garbage First". infoq.com.
http://www.infoq.com/news/2008/05/g1. Retrieved 2008-09-07.
32. ^ Coward, Dany (2008-11-12). "Java VM: Trying a new Garbage Collector for JDK 7".
http://blogs.sun.com/theplanetarium/entry/java_vm_trying_a_new. Retrieved 2008-11-15.
33. ^ "Java SE 6 Update 14 Release Notes". Sun Microsystems.
http://java.sun.com/javase/6/webnotes/6u14.html. Retrieved 2010-01-04.
34. ^ "Breakpoints fail to hit under JDK 1.6.0_14". https://bugs.eclipse.org/bugs/show_bug.cgi?
id=279137#c14. Retrieved 2009-07-14.
35. ^ "Bug ID: 6862295 JDWP threadid changes during debugging session (leading to ignored breakpoints)".
http://bugs.sun.com/view_bug.do?bug_id=6862295. Retrieved 2009-07-22.
36. ^ "Changes in 1.6.0_15 (6u15)". Sun Microsystems. http://www.oracle.com/technetwork/java/javase/6u15-
142514.html.
37. ^ "Changes in 1.6.0_16 (6u16)". Sun Microsystems. 2009-08-11.
43. ^ "Changes in 1.6.0_22 (6u22)". Oracle Corporation. 2010-10-12.
http://www.oracle.com/technetwork/java/javase/6u22releasenotes-176121.html. Retrieved 2010-10-12.
44. ^ "Java SE 6 Update 23". Oracle Corporation. 2010-12-08.
47. ^ JDK7, Sun.
48. ^ Flanagan, David (2007-09-08). "The Open Road: Looking Ahead to Java 7".
http://today.java.net/pub/a/today/2007/08/09/looking-ahead-to-java-7.html. Retrieved 2008-03-09.
49. ^ JDK 7 at OpenJDK
50. ^ http://openjdk.java.net/projects/jdk7/milestones/
51. ^ Miller, Alex. "Java 7". http://tech.puredanger.com/java7. Retrieved 2008-05-30.
52. ^ "Compressed oops in the Hotspot JVM". OpenJDK.
http://wikis.sun.com/display/HotSpotInternals/CompressedOops. Retrieved 2010-04-16.
53. ^ "Project Coin". Sun Microsystems. http://openjdk.java.net/projects/coin/. Retrieved 2009-03-30.
54. ^ Darcy, Joseph D. (2009-01-27). "Project Coin: Small Language Change Proposal Form Available".
http://blogs.sun.com/darcy/entry/project_coin. Retrieved 2009-03-30.
55. ^ http://mail.openjdk.java.net/pipermail/coin-dev/2009-February/000001.html
58. ^ http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000217.html
59. ^ Darcy, Joseph D.. "Project Coin: The Final Five (Or So)".
http://blogs.sun.com/darcy/entry/project_coin_final_five. Retrieved 2010-04-16.
60. ^ "Concurrency JSR-166". http://gee.cs.oswego.edu/dl/concurrency-interest/index.html. Retrieved 2010-
04-16.
61. ^ http://java.sun.com/docs/books/tutorial/essential/io/fileio.html
62. ^ http://java.sun.com/docs/books/tutorial/essential/io/legacy.html
63. ^ "Re-thinking JDK 7". 2010-09-08. http://blogs.sun.com/mr/entry/plan_b. Retrieved 2010-09-20.
64. ^ "Java SE 8 Release Contents". OpenJDK. http://jcp.org/en/jsr/detail?id=337.
65. ^ "Project Jigsaw". OpenJDK. http://openjdk.java.net/projects/jigsaw/.
66. ^ "Java 7 Features". Sun Microsystems. 2010-02-09. http://openjdk.java.net/projects/jdk7/features/#f700.
67. ^ Gafter, Neal (2006-08-18). "Closures for Java". http://gafter.blogspot.com/2006/08/closures-for-
java.html. Retrieved 2008-03-09.
68. ^ Gosling, James (2008-01-31). "Closures". http://blogs.sun.com/jag/entry/closures. Retrieved 2008-03-09.
69. ^ Reinhold, Mark (2009-11-28). "Closures for Java". http://blogs.sun.com/mr/entry/closures. Retrieved
2009-11-24.

Giddu

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Giddu

Загружено:

Авторское право:

Доступные форматы

Contents

Java (programming language)

Paradigm Object-oriented, structured, imperative

Sun Microsystems (now owned by Oracle

Developer James Gosling & Sun Microsystems

Java Standard Edition 6 (1.6.0_25) (April

Typing discipline Static, strong, safe, nominative, manifest

Dialects Generic Java, Pizza

Ada 83, C++, C#,[1] Delphi Object Pascal,

GNU General Public License / Java

Website For Java Developers

Java Programming at Wikibooks

public void showDialog() {

public class Hello extends JApplet {

public class Hello extends GenericServlet {

public static void main(String[] args) {

Micro Edition (ME)

Standard Edition (SE)

Enterprise Edition (EE)

• Comparison of programming languages

Look up Java in Wiktionary, the free dictionary.

Wikibooks has a book on the topic of

Wikiversity has learning materials about Java

Wikimedia Commons has media related to: Java (programming language)

• Java: Java for End-users

P Applets · Servlets · MIDlets · jsp · Web Start (jnlp)

[show]v · d · eSun Microsystems (an Oracle Corporation company)

S StorageTek · Sun Open Storage · QFS · ZFS

E SCPs · List of notable employees · BlueJ

[show]v · d · eFree and open source software

Book:Free and Open Source Software · Category:Free software · Portal:Free software

Java version history

[edit] JDK 1.0 (January 23, 1996)

Java language · JVM · Micro Edition · Standard Edition ·

Squawk · Java Development Kit · OpenJDK · Java Virtual

Platform technologies Applets · Servlets · MIDlets · jsp · Web Start (jnlp)

JRockit · GNU Classpath · Kaffe · TopLink · Apache

Java version history · Java Community Process · Sun

Major programming BeanShell · Clojure · Groovy · Java Tcl · JRuby · Jython ·

Java conferences JavaOne

1. History of the World Wide Web

Shahrooz Feizabadi <shahrooz@vt.edu>

Learn About Java Technology

The Oracle Technology Network is the world's largest community of application

Вам также может понравиться