JAVA
Java (programming
language)
"Java language" redirects here. For
the natural language from the
Indonesian island of Java, see
Javanese language .
Not to be confused with JavaScript
Paradi
gm(s) multi-paradigm : object-
oriented , structured ,
imperative, functional,
generic, reflective,
concurrent
Design
ed by
James Gosling and
Sun Microsystems
Develo
per
Oracle Corporation
Appea
red in
1995[1]
Stable
releas
e
Java Standard Edition 8
Update 25 (1.8.0_25) /
October 14, 2014; 42 days
ago
Typing
discipl
ine
Static, strong, safe ,
nominative , manifest
Major
imple
menta
tions
OpenJDK , GNU Compiler
for Java (gcj), many others
Dialec
ts
Generic Java, Pizza
Influe
nced
by
Ada 83, C++ , C# , [2] Eiffel ,
[3] Generic Java, Mesa ,[4]
Modula-3 , [5] Oberon, [6]
Objective-C , [7] UCSD
Pascal ,[8][9] Smalltalk
Influe
nced Ada 2005 , BeanShell , C# ,
Clojure , D , ECMAScript ,
Groovy , J# , JavaScript ,
Kotlin, PHP , Python , Scala,
Seed7 , Vala
Imple
menta
tion
langua
ge
C and C++
OS Cross-platform (multi-
platform)
Licens
e
GNU General Public
License, Java Community
Process
Filena
me
extens
ion(s)
.java , .class , .jar
Websi
te For Java Developers
Java is a general-purpose computer
programming language that is
concurrent , class-based , object-
oriented,[10] and specifically
designed to have as few
implementation dependencies as
possible. It is intended to let
application developers " write once,
run anywhere" (WORA), meaning
that code that runs on one platform
does not need to be recompiled to
run on another. Java applications
are typically compiled to bytecode
that can run on any Java virtual
machine (JVM) regardless of
computer architecture . Java is, as
of 2014, one of the most popular
programming languages in use,
particularly for client-server web
applications, with a reported 9
million developers. [11][12] Java
was originally developed by James
Gosling at Sun Microsystems
(which has since merged into
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 it has fewer
low-level facilities than either of
them.
The original and reference
implementation Java compilers ,
virtual machines, and class
libraries were originally released
by Sun under proprietary licences.
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 (bytecode
compiler), GNU Classpath (standard
libraries), and IcedTea-Web
(browser plugin for applets).
History
See also: Java (software platform)
§ History
Duke, the Java mascot
James Gosling, Mike Sheridan, and
Patrick Naughton initiated the Java
language project in June 1991. [13]
Java was originally designed for
interactive television, but it was too
advanced for the digital cable
television industry at the time. [14]
The language was initially called
Oak after an oak tree that stood
outside Gosling's office. Later the
project went by the name Green and
was finally renamed Java, from
Java coffee,[15] said to be
consumed in large quantities by the
language's
creators. [citation needed ] Gosling
designed Java with a C/C++-style
syntax that system and application
programmers would find familiar.
[16]
Sun Microsystems released the first
public implementation as Java 1.0
in 1995. [1] 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. The
Java 1.0 compiler was re-written in
Java by Arthur van Hoff to comply
strictly with the Java 1.0 language
specification. [17] 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. J2EE included
technologies and APIs for
enterprise applications typically run
in server environments, while J2ME
featured APIs optimized for mobile
applications. The desktop version
was renamed J2SE . 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 JTC 1
standards body and later the Ecma
International to formalize Java, but
it soon withdrew from the process.
[18] Java remains a de facto
standard, controlled through the
Java Community Process. [19] 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.
On November 13, 2006, Sun
released much of Java as free and
open-source software , (FOSS),
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.[20]
Sun's vice-president Rich Green
said that Sun's ideal role with
regards to Java was as an
"evangelist". [21] 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". [22] This did not
prevent Oracle from filing a lawsuit
against Google shortly after that for
using Java inside the Android SDK
(see Google section below). Java
software runs on everything from
laptops to data centers, game
consoles to scientific
supercomputers. There are 930
million Java Runtime Environment
downloads each year and 3 billion
mobile phones run Java. [23] On
April 2, 2010, James Gosling
resigned from Oracle.
James Gosling, the creator of Java
There were five primary goals in the
creation of the Java language: [25]
1. It must be "simple, object-
oriented and familiar"
2. It must be "robust and secure"
3. It must be "architecture-neutral
and portable"
4. It must execute with "high
performance"
5. It must be "interpreted, threaded,
and dynamic"
Versions
Main article: Java version history
Major release versions of Java,
along with their release dates:
JDK 1.0 (January 21, 1996)
JDK 1.1 (February 19, 1997)
J2SE 1.2 (December 8, 1998)
J2SE 1.3 (May 8, 2000)
J2SE 1.4 (February 6, 2002)
J2SE 5.0 (September 30, 2004)
Java SE 6 (December 11, 2006)
Java SE 7 (July 28, 2011)
Java SE 8 (March 18, 2014)
Practices
Java platform
Main articles: Java (software
platform) and Java virtual machine
One design goal of Java is
portability, which means that
programs written for the Java
platform must run similarly on any
combination of hardware and
operating system with adequate
runtime support. This is achieved
by compiling the Java language
code to an intermediate
representation called Java
bytecode , instead of directly to
architecture-specific machine
code. Java bytecode instructions
are analogous to machine code, but
they are intended to be executed 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 (JIT)
compilers were introduced from an
early stage that compile bytecodes
to machine code during runtime.
Implementations
See also: Free Java
implementations
Oracle Corporation is the current
owner of the official implementation
of the Java SE platform, following
their acquisition of Sun
Microsystems on January 27, 2010.
This implementation is based on the
original implementation of Java by
Sun. The Oracle implementation is
available for Microsoft Windows ,
Mac OS X , Linux and Solaris .
Because Java lacks any formal
standardization recognized by Ecma
International, ISO/IEC, ANSI, or
other third-party standards
organization, the Oracle
implementation is the de facto
standard.
The Oracle implementation is
packaged into two different
distributions: The Java Runtime
Environment (JRE) which contains
the parts of the Java SE platform
required to run Java programs and
is intended for end users, and the
Java Development Kit (JDK), which
is intended for software developers
and includes development tools
such as the Java compiler ,
Javadoc, Jar , and a debugger .
OpenJDK is another notable Java SE
implementation that is licensed
under the GNU GPL. The
implementation started when Sun
began releasing the Java source
code under the GPL. As of Java SE
7, OpenJDK is the official Java
reference implementation.
The goal of Java is to make all
implementations of Java
compatible. Historically, 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.
[26] As a result, Microsoft no longer
ships Windows with Java.
Platform-independent Java is
essential to Java EE , and an even
more rigorous validation is required
to certify an implementation. This
environment enables portable
server-side applications.
Performance
Main article: Java performance
Programs written in Java have a
reputation for being slower and
requiring more memory than those
written in C++. [27][28] However,
Java programs' execution speed
improved significantly with the
introduction of Just-in-time
compilation in 1997/1998 for Java
1.1 ,[29] the addition of language
features supporting better code
analysis (such as inner classes, the
StringBuilder class, optional
assertions, etc.), and optimizations
in the Java virtual machine, such as
HotSpot becoming the default for
Sun's JVM in 2000.
Some platforms offer direct
hardware support for Java; there
are microcontrollers that can run
Java in hardware instead of a
software Java virtual machine, and
ARM based processors can have
hardware support for executing Java
bytecode through their Jazelle
option.
Automatic memory management
Java uses an automatic garbage
collector to manage memory in the
object lifecycle . The programmer
determines when objects are
created, and the Java runtime is
responsible for recovering the
memory once objects are no longer
in use. Once no references to an
object remain, the unreachable
memory becomes eligible to be
freed automatically by the garbage
collector. Something similar to a
memory leak may still occur if a
programmer's code holds a
reference to an object that is no
longer needed, typically when
objects that are no longer needed
are stored in containers that are
still in use. If methods for a
nonexistent object are called, a
"null pointer exception" is thrown.
[30][31]
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
is 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, [citation needed ] HotSpot
uses the parallel scavenge 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 Concurrent Mark-Sweep
garbage collector is sufficient.[32]
Oracle aims to replace CMS with
the Garbage-first collector (G1).
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, i.e. , integers, floating-point
numbers, boolean values, and
characters, which are not classes
for performance reasons.
Unlike C++, Java does not support
operator overloading or multiple
inheritance for classes . This
simplifies the language and aids in
preventing potential errors and anti-
pattern design.
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 the Javadoc
commenting 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. */
package fibsandlies;
import
java.util.HashMap;
/**
* This is an
example of a Javadoc
comment; Javadoc can
compile documentation
* from this text.
Javadoc comments
must immediately
precede the thing
being documented.
*/
public class
FibCalculator
extends Fibonacci
implements
Calculator {
private static
HashMap<Integer,
Integer> memoized =
new HashMap<Integer,
Integer>();
static {
memoized.put
(1, 1);
memoized.put
(2, 1);
}
/**
* An example of
a method written in
Java, wrapped in a
class.
* Given a non-
negative number
FIBINDEX, returns
* the Nth
Fibonacci number,
where N equals
FIBINDEX.
* @param
fibIndex The index
of the Fibonacci
number
* @return The
Fibonacci number
*/
public static
int fibonacci(int
fibIndex) {
if
(memoized.containsKey
(fibIndex)) {
return
memoized.get
(fibIndex);
} else {
int
answer = fibonacci
(fibIndex - 1) +
fibonacci(fibIndex -
2);
memoized.put
(fibIndex, answer);
return
answer;
}
}
}
Examples
Hello World
The traditional "Hello, world!"
program can be written in Java as:
[33]
class HelloWorldApp {
public static
void main(String[]
args) {
System.out.pr
intln("Hello
World!"); // Print
the string to the
console.
}
}
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,
HelloWorldApp.java . It must
first be compiled into bytecode,
using a Java compiler , producing a
file named
HelloWorldApp.class . Only
then can it be executed, or
'launched'. The Java source file
may only contain one public class,
but it can contain multiple classes
with other than public access and
any number of public inner classes .
When the source file contains
multiple classes, make one class
'public' and name the source file
with that public class name.
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 class
members that are not also 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 JavaBeans 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 it
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.
A more comprehensive example
// OddEven.java
import
javax.swing.JOptionPa
ne;
public class OddEven
{
private int
userInput; // 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.
* 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.
* @param args
command line
arguments (unused)
*/
public static
void main(final
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();
}
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."
*/
userInput =
Integer.parseInt
(JOptionPane.showInpu
tDialog("Please
enter a number."));
calculate
();
} catch
(final
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 *nix
users).(Assuming
it's open)
*/
private void
calculate() {
if
((userInput % 2) ==
0) {
JOptionPa
ne.showMessageDialog
(null, "Even");
} else {
JOptionPa
ne.showMessageDialog
(null, "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 userInput .
Every instance of the OddEven
class has its own copy of the
userInput field. The private
declaration means that no other
class can access (read or write)
the userInput 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 userInput %
2 == 0 using the if
keyword to see if the remainder of
dividing the userInput 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 calculate
method can be equivalently
accessed as this.calculate
and the userInput field can be
equivalently accessed as
this.userInput , which both
explicitly use 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.
userInput =
Integer.parseInt
(JOptionPane.showInputDial
og("Please Enter A
Number")); is a statement that
converts the type of String to the
primitive data type int by using a
utility function in the primitive
wrapper class Integer .
Special classes
Applet
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 {
public void
paintComponent(final
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 (FQCN ,
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
(additionally indicated with the
annotation, supported as of JDK
1.5, Override ) 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">
<!-- Hello.html -->
<html>
<head>
<title>Hello
World Applet</title>
</head>
<body>
<applet
code="Hello.class"
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, [34] although
support for these elements by web
browsers is inconsistent. [35]
However, the applet tag is
deprecated, so the object tag
is preferred where supported.
The host application, typically a
Web browser, instantiates the
Hello applet and creates an
AppletContext for the
applet. Once the applet has
initialized itself, it is added to the
AWT display hierarchy. The
paintComponent() method is
called by the AWT event dispatching
thread whenever the display needs
the applet to draw itself.
Servlet
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(final
ServletRequest
request, final
ServletResponse
response)
throws
ServletException,
IOException {
response.setC
ontentType("text/
html");
final
PrintWriter pw =
response.getWriter();
try {
pw.printl
n("Hello, world!");
} finally {
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. Packages make
Java well suited for large scale
applications.
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.
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.
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");
super.setDefaultClose
Operation
(WindowConstants.EXIT
_ON_CLOSE);
super.add
(new JLabel("Hello,
world!"));
super.pack();
super.setVisible
(true);
}
public static
void main(final
String[] args) {
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_CL
OSE — this causes the
JFrame to be disposed of when
the frame is closed (as opposed to
merely hidden), which allows the
Java virtual machine 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 Java virtual machine when
the program starts. It instantiates a
new Hello frame and causes it
to be displayed by calling the
setVisible(boolean)
method inherited from the
Component superclass with
the boolean parameter true .
Once the frame is displayed, exiting
the main method does not
cause the program to terminate
because the AWT event dispatching
thread remains active until all of the
Swing top-level windows have been
disposed.
Generics
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. In addition to enabling more
efficient code, certain runtime
exceptions are converted to
compile-time errors, a
characteristic known as type safety.
Criticism
Main article: Criticism of Java
Criticisms directed at Java include
the implementation of generics, [36]
speed,[37] the handling of unsigned
numbers, [38] the implementation of
floating-point arithmetic, [39] and a
history of security vulnerabilities in
the primary Java VM
implementation HotSpot .[40]
Use on unofficial software
platforms
Java, the programming language,
requires the presence of a software
platform in order for compiled
programs to be executed. One of the
official software platforms is the
Java SE platform . A very popular
unofficial software platform is the
Android software platform, which
uses a different bytecode language
and virtual machine, and is
designed for low-memory devices
such as smartphones and tablet
computers.