JAVA

Java is a computer programming
language that is concurrent, class-
based , object-oriented , 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
( class file ) 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. [10][11] 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 developed by Sun
from 1991 and first released in
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 (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. [12]
Java was originally designed for
interactive television, but it was
too advanced for the digital cable
television industry at the time. [13]
The language was initially called
Oak after an oak tree that stood
outside Gosling's office; it went by
the name Green later, and was later
renamed Java , from Java coffee,
[14] said to be consumed in large
quantities by the language's
creators. [ citation needed ] Gosling
aimed to implement a virtual
machine and a language that had a
familiar C / C++ style of notation.
[15]
Sun Microsystems released the
first public implementation as Java
1.0 in 1995. [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. With
the advent of Java 2 (released
initially as J2SE 1.2 in December
1998 – 1999), new versions had
multiple configurations built for
different types of platforms. For
example, J2EE targeted enterprise
applications and the greatly
stripped-down version J2ME for
mobile applications (Mobile Java).
J2SE designated the Standard
Edition. In 2006, for marketing
purposes, Sun renamed new J2
versions as Java EE , Java ME , and
Java SE , respectively.
In 1997, Sun Microsystems
approached the ISO/IEC JTC1
standards body and later the Ecma
International to formalize Java, but
it soon withdrew from the process.
[16] Java remains a de facto
standard, controlled through the
Java Community Process. [17] At
one time, Sun made most of its
Java implementations available
without charge, despite their
proprietary software status. Sun
generated revenue from Java
through the selling of licenses for
specialized products such as the
Java Enterprise System. Sun
distinguishes between its Software
Development Kit (SDK) and
Runtime Environment (JRE) (a
subset of the SDK); the primary
distinction involves the JRE's lack
of the compiler, utility programs,
and header files.
On November 13, 2006, Sun
released much of Java as 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. [18]
Sun's vice-president Rich Green
said that Sun's ideal role with
regards to Java was as an
"evangelist." [19] 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". [20] This did not
hold Oracle, however, 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. [21] On April 2, 2010, James
Gosling resigned from Oracle. [22]
Principles
James Gosling, the creator of
Java
There were five primary goals in
the creation of the Java language:
[23]
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"
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 characteristic of Java is
portability, which means that
computer programs written in the
Java language must run similarly
on any 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 they 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 (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 Mac OS X , Windows
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 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. [24] 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++ . [25][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,
the StringBuilder class, optional
assertions, etc.), and optimizations
in the Java virtual machine itself,
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.
[28][29]
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 concurrent mark sweep
collector , also known as the CMS
garbage collector or CMS.
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 sufficient.
[30] 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 ru