James Gosling, Mike Sheridan, andPatrick Naughtoninitiated 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 calledOakafter anoak treethat stood outside Gosling's office; it went by the nameGreenlater, and was later renamedJava, from Java coffee, said to be consumed in large quantities by the language's creators.[13]Gosling aimed to implement avirtual machineand a language that had a familiarC/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 popularplatforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Javaappletswithin web pages, and Java quickly became popular. With the advent ofJava 2(released initially as J2SE 1.2 in December 1998–1999), new versions had multiple configurations built for different types of platforms. For example,J2EEtargeted enterprise applications and the greatly stripped-down versionJ2MEfor mobile applications (Mobile Java).J2SEdesignated the Standard Edition. In 2006, for marketing purposes, Sun renamed newJ2versions asJava EE,Java ME, andJava SE, respectively.

On November 13, 2006, Sun released much of Java asopen source softwareunder the terms of theGNU General Public License(GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available underfree 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]

FollowingOracle 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]

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 calledJava bytecode, instead of directly to platform-specificmachine code. Java bytecode instructions are analogous to machine code, but are intended to beinterpretedby avirtual machine(VM) written specifically for the host hardware.End-userscommonly use aJava Runtime Environment(JRE) installed on their own machine for standalone Java applications, or in a Web browser for Javaapplets.

Standardized libraries provide a generic way to access host-specific features such as graphics,threading, andnetworking.

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.

Implementations

Sun Microsystemsofficially licenses the Java Standard Edition platform forLinux,[21]Mac OS X,[22]andSolaris. In the past Sun licensed Java to Microsoft but the license expired without renewal.[23]Because Windows does not ship with a Java software platform, a network of third-party vendors and licensees[24]develop them for Windows and other operating system/hardware platforms.

Sun's trademark license for usage of the Java brand insists that all implementations be "compatible". This resulted in a legal dispute withMicrosoftafter Sun claimed that the Microsoft implementation did not supportRMIorJNIand 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 withWindows, and in recent versions of Windows,Internet Explorercannot 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.

Programs written in Java have a reputation for being slower and requiring more memory than those written inC.[26]However, Java programs' execution speed improved significantly with the introduction ofJust-in-time compilationin 1997/1998 forJava 1.1,[27]the addition of language features supporting better code analysis (such as inner classes, StringBuffer class, optional assertions, etc.), and optimizations in theJava Virtual Machineitself, such asHotSpotbecoming the default for Sun's JVM in 2000. Currently, Java 2.0 code had approximately half the performance of C code.[28]However, Java 5.0 has been shown to run at native speeds that sometimes match and occasionally beat the speed ofCandC++.[citation needed]

Some platforms offer direct hardware support for Java; there are microcontrollers that can run Java in hardware instead of a software JVM, andARMbased processors can have hardware support for executing Java bytecode through itsJazelleoption.

Automatic memory management

Java uses anautomatic garbage collectorto manage memory in theobject 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, theunreachable memorybecomes eligible to be freed automatically by the garbage collector. Something similar to amemory leakmay 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 thestack, or explicitly allocated and deallocated from theheap. In the latter case the responsibility of managing memory resides with the programmer. If the program does not deallocate an object, amemory leakoccurs. 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 ofsmart 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++ stylepointer 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 inC++and some other object-oriented languages, variables of Java'sprimitive data typesare not objects. Values of primitive types are either stored directly in fields (for objects) or on thestack(for methods) rather than on the heap, as commonly true for objects (but seeEscape 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,autoboxingenables programmers to proceed as if primitive types were instances of their wrapper class.

Java contains multiple types of garbage collectors. By default, HotSpot uses theConcurrent 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]

Syntax

The syntax of Java is largely derived fromC++. 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.

Java uses similar commenting methods to C++. There are three different styles of comments: a single line style marked with two slashes (//), a multiple line style opened with/*and closed with*/, and theJavadoccommenting style opened with/**and closed with*/. 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

Source files must be named after the public class they contain, appending the suffix.java, for example,HelloWorldApp.java. It must first be compiled into bytecode, using aJava compiler, producing a file namedHelloWorldApp.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 publicinner classes.

Aclassthat is not declaredpublicmay 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.classappended. For class file generation,anonymous classesare treated as if their name were the concatenation of the name of their enclosing class, a$, and an integer.

Thekeywordpublicdenotes 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 keywordstaticin front of a method indicates astatic 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 class members that are not also static.

The keywordvoidindicates 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 andEnterprise JavaBeando not use or need amain()method. A Java program may contain multiple classes that havemainmethods, which means that the VM needs to be explicitly told which class to launch from.

The main method must accept anarrayofStringobjects. By convention, it is referenced asargsalthough any other legal identifier name can be used. Since Java 5, the main method can also usevariable arguments, in the form ofpublic static void main(String... args), allowing the main method to be invoked with an arbitrary number ofStringarguments. The effect of this alternate declaration is semantically identical (theargsparameter is still an array ofStringobjects), 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 aJAR) and starting itspublic static void main(String[])method. Stand-alone programs must declare this method explicitly. TheString[] argsparameter is anarrayofStringobjects containing any arguments passed to the class. The parameters tomainare often passed by means of acommand line.

Printing is part of a Java standard library: TheSystemclass defines a public static field calledout. Theoutobject is an instance of thePrintStreamclass and provides many methods for printing data tostandard out, includingprintln(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.

A more comprehensive example

// OddEven.java

importjavax.swing.JOptionPane;

publicclass OddEven {

// "input" is the number that the user gives to the computer

privateint 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.

publicstaticvoid 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

* the "showDialog()" method, which brings up a prompt to ask you for a number

*/

OddEven number =new OddEven();

number.showDialog();

}

publicvoid 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

§TheOddEvenclass declares a singleprivatefieldof typeintnamedinput. Every instance of theOddEvenclass has its own copy of theinputfield. The private declaration means that no other class can access (read or write) theinputfield.

§OddEven()is apublicconstructor. Constructors have the same name as the enclosing class they are declared in, and unlike a method, have noreturn type. A constructor is used to initialize anobjectthat is a newly created instance of the class.

§Thecalculate()method is declared without thestatickeyword. This means that the method is invoked using a specific instance of theOddEvenclass. (Thereferenceused to invoke the method is passed as an undeclared parameter of typeOddEvennamedthis.) The method tests the expressioninput % 2 == 0using theifkeyword to see if the remainder of dividing theinputfield belonging to the instance of the class by two is zero. If this expression is true, then it printsEven; if this expression is false it printsOdd. (Theinputfield can be equivalently accessed asthis.input, which explicitly uses the undeclaredthisparameter.)

§OddEven number = new OddEven();declares a local objectreferencevariable in themainmethod namednumber. This variable can hold a reference to an object of typeOddEven. The declaration initializesnumberby first creating an instance of theOddEvenclass, using thenewkeyword and theOddEven()constructor, and then assigning this instance to the variable.

§The statementnumber.showDialog();calls the calculate method. The instance ofOddEvenobject referenced by thenumberlocal variableis used to invoke the method and passed as the undeclaredthisparameter to thecalculatemethod.

Java applets are programs that are embedded in other applications, typically in a Web page displayed in aWeb browser.

// Hello.java

importjavax.swing.JApplet;

importjava.awt.Graphics;

publicclass Hello extendsJApplet{

@Override

publicvoid paintComponent(Graphics g){

g.drawString("Hello, world!", 65, 95);

}

}

Theimportstatements direct theJava compilerto include thejavax.swing.JAppletandjava.awt.Graphicsclasses in the compilation. The import statement allows these classes to be referenced in thesource codeusing thesimple class name(i.e.JApplet) instead of thefully qualified class name(i.e.javax.swing.JApplet).

TheHelloclassextends(subclasses) theJApplet(Java Applet) class; theJAppletclass provides the framework for the host application to display and control thelifecycleof the applet. TheJAppletclass is a JComponent (Java Graphical Component) which provides the applet with the capability to display agraphical user interface(GUI) and respond to userevents.

TheHelloclassoverridesthepaintComponent(Graphics)method (additionally indicated with theannotation, supported as of JDK 1.5,Override) inherited from theContainersuperclassto provide the code to display the applet. ThepaintComponent()method is passed aGraphicsobject that contains the graphic context used to display the applet. ThepaintComponent()method calls the graphic contextdrawString(String, int, int)method to display the"Hello, world!"string at apixeloffset 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">

<!-- Hello.html -->

<html>

<head>

<title>Hello World Applet</title>

</head>

<body>

<appletcode="Hello"width="200"height="200">

</applet>

</body>

</html>

An applet is placed in anHTMLdocument using the<applet>HTML element. Theapplettag has three attributes set:code="Hello"specifies the name of theJAppletclass andwidth="200" height="200"sets the pixel width and height of the applet. Applets may also be embedded in HTML using either theobjectorembedelement,[33]although support for these elements by Web browsers is inconsistent.[34]However, theapplettag is deprecated, so theobjecttag is preferred where supported.

The host application, typically a Web browser, instantiates theHelloapplet and creates anAppletContextfor the applet. Once the applet has initialized itself, it is added to the AWT display hierarchy. ThepaintComponent()method is called by the AWTevent dispatching threadwhenever the display needs the applet to draw itself.

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 areserver-sideJava EE components that generate responses (typicallyHTMLpages) to requests (typicallyHTTPrequests) fromclients. A servlet can almost be thought of as an applet that runs on the server side—without a face.

// Hello.java

importjava.io.*;

importjavax.servlet.*;

publicclass Hello extends GenericServlet {

publicvoid service(ServletRequest request, ServletResponse response)

throws ServletException, IOException{

response.setContentType("text/html");

finalPrintWriter pw = response.getWriter();

try{

pw.println("Hello, world!");

}finally{

pw.close();

}

}

}

Theimportstatements direct the Java compiler to include all of the public classes andinterfacesfrom thejava.ioandjavax.servletpackages in the compilation.

TheHelloclassextendstheGenericServletclass; theGenericServletclass provides the interface for theserverto forward requests to the servlet and control the servlet's lifecycle.

ThesetContentType(String)method in the response object is called to set theMIMEcontent type of the returned data to"text/html". ThegetWriter()method in the response returns aPrintWriterobject that is used to write the data that is sent to the client. Theprintln(String)method is called to write the"Hello, world!"string to the response and then theclose()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) areserver-sideJava EE components that generate responses, typicallyHTMLpages, toHTTPrequests fromclients. JSPs embed Java code in an HTML page by using the specialdelimiters<%and%>. A JSP is compiled to a Javaservlet, a Java application in its own right, the first time it is accessed. After that, the generated servlet creates the response.

Swing application

Swingis a graphical user interfacelibraryfor the Java SE platform. It is possible to specify a different look and feel through thepluggable look and feelsystem of Swing. Clones ofWindows,GTK+andMotifare supplied by Sun.Applealso provides anAqualook and feel forMac 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 nativeGUI widgetdrawing routines of the underlying platforms.

This example Swing application creates a single window with "Hello, world!" inside:

// Hello.java (Java SE 5)

importjavax.swing.*;

publicclass Hello extendsJFrame{

public Hello(){

super("hello");

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

add(newJLabel("Hello, world!"));

pack();

setVisible(true);

}

publicstaticvoid main(String[] args){

new Hello();

}

}

The firstimportincludes all of the public classes and interfaces from thejavax.swingpackage.

TheHello()constructorinitializes the frame by first calling the superclass constructor, passing the parameter"hello", which is used as the window's title. It then calls thesetDefaultCloseOperation(int)method inherited fromJFrameto set the default operation when the close control on the title bar is selected toWindowConstants.EXIT_ON_CLOSE— this causes theJFrameto 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, aJLabelis created for the string"Hello, world!"and theadd(Component)method inherited from theContainersuperclass is called to add the label to the frame. Thepack()method inherited from theWindowsuperclass is called to size the window and lay out its contents.

Themain()method is called by the JVM when the program starts. Itinstantiatesa newHelloframe and causes it to be displayed by calling thesetVisible(boolean)method inherited from theComponentsuperclass with the boolean parametertrue. Once the frame is displayed, exiting themainmethod does not cause the program to terminate because the AWTevent dispatching threadremains active until all of the Swing top-level windows have been disposed.

Generics

In 2004,genericswere 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, usuallyObject, 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.

Criticism

A number of criticisms have been leveled at Java for various design choices in the language and platform. Such criticisms include the implementation of generics[35], the handling of unsigned numbers[36], the implementation of floating-point arithmetic[37], and security vulnerabilities.[clarification needed]

Class libraries

§Javalibrariesare the compiledbytecodesofsource codedeveloped by the JRE implementor to support application development in Java. Examples of these libraries are:

Javadocis a comprehensive documentation system, created bySun 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 andCare set off with /* and */.

Theclassesin the Java APIs are organized into separate groups calledpackages. Each package contains a set of relatedinterfaces, classes andexceptions. 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 theJava Community Processprogram. 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 calledPersonalJavathat has been superseded by later, standards-based Java ME configuration-profile pairings.