2.1 Main Features of the Java Language

Java follows C++ to some degree, which carries the benefit of it being familiar
to many programmers. This section describes the essential features of Java and
points out where the language diverges from its ancestors C and C++.

2.1.1 Primitive Data

Other than the primitive data types discussed here, everything in Java is an
object. Even the primitive data types can be encapsulated inside librarysupplied
objects if required. Java follows C and C++ fairly closely in its set of
basic data types, with a couple of minor exceptions. There are only three
groups of primitive data types, namely, numeric types, Boolean types, and
arrays.

Numeric Data Types

Integer numeric types are 8-bit byte, 16-bit short, 32-bit int, and 64-bit long.
The 8-bit byte data type in Java has replaced the old C and C++ char data
type. Java places a different interpretation on the char data type, as discussed
below.

There is no unsigned type specifier for integer data types in Java.
Real numeric types are 32-bit float and 64-bit double. Real numeric types
and their arithmetic operations are as defined by the IEEE 754 specification. A
floating point literal value, like 23.79, is considered double by default; you
must explicitly cast it to float if you wish to assign it to a float variable.

Character Data Types

Java language character data is a departure from traditional C. Java’s char data
type defines a sixteen-bit Unicode character. Unicode characters are unsigned
16-bit values that define character codes in the range 0 through 65,535. If you
write a declaration such as
char myChar = ‘Q’;
you get a Unicode (16-bit unsigned value) type that’s initialized to the Unicode
value of the character Q. By adopting the Unicode character set standard for its
character data type, Java language applications are amenable to
internationalization and localization, greatly expanding the market for worldwide
applications.

Boolean Data Types

Java has added a boolean data type as a primitive type, tacitly ratifying
existing C and C++ programming practice, where developers define keywords
for TRUE and FALSE or YES and NO or similar constructs. A Java boolean
variable assumes the value true or false. A Java boolean is a distinct data
type; unlike common C practice, a Java boolean type can’t be converted to
any numeric type.

Read More

1.3 The Java Base System

The complete Java system includes a number of libraries of utility classes and
methods of use to developers in creating multi-platform applications.

Very briefly, these libraries are:

java.lang—the collection of base types (language types) that are always
imported into any given compilation unit. This where you’ll find the
declarations of Object (the root of the class hierarchy) and Class, plus
threads, exceptions, wrappers for the primitive data types, and a variety of
other fundamental classes.

java.io—streams and random-access files. This is where you find the rough
equivalent of the Standard I/O Library you’re familiar with on most UNIX
systems. A further library is called java.net, and provides support for
sockets, telnet interfaces, and URLs.

java.util—container and utility classes. Here you’ll find classes such as
Dictionary, HashTable, and Stack, among others, plus encoder and
decoder techniques, and Date and Time classes.

java.awt—an Abstract Windowing Toolkit that provides an abstract layer
enabling you to port Java applications easily from one window system to
another. This library contains classes for basic interface components such as
events, colors, fonts, and controls such as buttons and scrollbars.

Read More

1.2 Design Goals of Java

The design requirements of Java are driven by the nature of the computing
environments in which software must be deployed.
The massive growth of the Internet and the World-Wide Web leads us to a
completely new way of looking at development and distribution of software.
To live in the world of electronic commerce and distribution, Java must enable
the development of secure, high performance, and highly robust applications on
multiple platforms in heterogeneous, distributed networks.

Operating on multiple platforms in heterogeneous networks invalidates the
traditional schemes of binary distribution, release, upgrade, patch, and so on.
To survive in this jungle, Java must be architecture neutral, portable, and
dynamically adaptable.
The Java system that emerged to meet these needs is simple, so it can be easily
programmed by most developers; familiar, so that current developers can easily
learn Java; object oriented, to take advantage of modern software development
methodologies and to fit into distributed client-server applications;
multithreaded, for high performance in applications that need to perform
multiple concurrent activities, such as multimedia; and interpreted, for
maximum portability and dynamic capabilities.
Together, the above requirements comprise quite a collection of buzzwords, so
let’s examine some of them and their respective benefits before going on.

1.2.1 Simple, Object Oriented, and Familiar

Primary characteristics of Java include a simple language that can be
programmed without extensive programmer training while being attuned to
current software practices. The fundamental concepts of Java are grasped
quickly; programmers can be productive from the very beginning.
Java is designed to be object oriented from the ground up. Object technology has
finally found its way into the programming mainstream after a gestation
period of thirty years. The needs of distributed, client-server based systems
coincide with the encapsulated, message-passing paradigms of object-based
software. To function within increasingly complex, network-based
environments, programming systems must adopt object-oriented concepts.
Java provides a clean and efficient object-based development environment.
Programmers using Java can access existing libraries of tested objects that
provide functionality ranging from basic data types through I/O and network
interfaces to graphical user interface toolkits. These libraries can be extended
to provide new behavior.

Even though C++ was rejected as an implementation language, keeping Java
looking like C++ as far as possible results in Java being a familiar language,
while removing the unnecessary complexities of C++. Having Java retain many
of the object-oriented features and the “look and feel” of C++ means that
programmers can migrate easily to Java and be productive quickly.
1.2.2 Robust and Secure

Java is designed for creating highly reliable software. It provides extensive
compile-time checking, followed by a second level of run-time checking.
Language features guide programmers towards reliable programming habits.
The memory management model—no pointers or pointer
arithmetic—eliminates entire classes of programming errors that bedevil C and
C++ programmers. You can develop Java language code with confidence that
the system will find many errors quickly and that major problems won’t lay
dormant until after your production code has shipped.

Java is designed to operate in distributed environments, which means that
security is of paramount importance. With security features designed into the
language and run-time system, Java lets you construct applications that can’t
be invaded from outside. In the networked environment, applications written
in Java are secure from intrusion by unauthorized code attempting to get
behind the scenes and create viruses or invade file systems.

1.2.3 Architecture Neutral and Portable

Java is designed to support applications that will be deployed into
heterogeneous networked environments. In such environments, applications
must be capable of executing on a variety of hardware architectures. Within
this variety of hardware platforms, applications must execute atop a variety of
operating systems and interoperate with multiple programming language
interfaces. To accommodate the diversity of operating environments, the Java
compiler generates bytecodes—an architecture neutral intermediate format
designed to transport code efficiently to multiple hardware and software
platforms. The interpreted nature of Java solves both the binary distribution
problem and the version problem; the same Java language byte codes will run
on any platform.

Architecture neutrality is just one part of a truly portable system. Java takes
portability a stage further by being strict in its definition of the basic language.
Java puts a stake in the ground and specifies the sizes of its basic data types
and the behavior of its arithmetic operators. Your programs are the same on
every platform—there are no data type incompatibilities across hardware and
software architectures.

The architecture-neutral and portable language environment of Java is known
as the Java Virtual Machine. It’s the specification of an abstract machine for
which Java language compilers can generate code. Specific implementations of
the Java Virtual Machine for specific hardware and software platforms then
provide the concrete realization of the virtual machine. The Java Virtual
Machine is based primarily on the POSIX interface specification—an industrystandard
definition of a portable system interface. Implementing the Java
Virtual Machine on new architectures is a relatively straightforward task as
long as the target platform meets basic requirements such as support for
multithreading.

1.2.4 High Performance

Performance is always a consideration. Java achieves superior performance by
adopting a scheme by which the interpreter can run at full speed without
needing to check the run-time environment. The automatic garbage collector runs
as a low-priority background thread, ensuring a high probability that memory
is available when required, leading to better performance. Applications
requiring large amounts of compute power can be designed such that
compute-intensive sections can be rewritten in native machine code as required
and interfaced with the Java environment. In general, users perceive that
interactive applications respond quickly even though they’re interpreted.

1.2.5 Interpreted, Threaded, and Dynamic

The Java interpreter can execute Java bytecodes directly on any machine to
which the interpreter and run-time system have been ported. In an interpreted
environment such as Java system, the link phase of a program is simple,
incremental, and lightweight. You benefit from much faster development
cycles—prototyping, experimentation, and rapid development are the normal
case, versus the traditional heavyweight compile, link, and test cycles.
Modern network-based applications, such as the HotJava World-Wide Web
browser, typically need to do several things at the same time. A user working
with HotJava can run several animations concurrently while downloading an
image and scrolling the page. Java’s multithreading capability provides the
means to build applications with many concurrent threads of activity.
Multithreading thus results in a high degree of interactivity for the end user.

Java supports multithreading at the language level with the addition of
sophisticated synchronization primitives: the language library provides the
Thread class, and the run-time system provides monitor and condition lock
primitives. At the library level, moreover, Java’s high-level system libraries
have been written to be thread safe: the functionality provided by the libraries is
available without conflict to multiple concurrent threads of execution.
While the Java compiler is strict in its compile-time static checking, the
language and run-time system are dynamic in their linking stages. Classes are
linked only as needed. New code modules can be linked in on demand from a
variety of sources, even from sources across a network. In the case of the
HotJava browser and similar applications, interactive executable code can be
loaded from anywhere, which enables transparent updating of applications.
The result is on-line services that constantly evolve; they can remain innovative
and fresh, draw more customers, and spur the growth of electronic commerce
on the Internet.

Read More

1.1 Beginnings of the Java Language Project

Java is designed to meet the challenges of application development in the
context of heterogeneous, network-wide distributed environments. Paramount
among these challenges is secure delivery of applications that consume the
minimum of system resources, can run on any hardware and software
platform, and can be extended dynamically.

Java originated as part of a research project to develop advanced software for a
wide variety of networked devices and embedded systems. The goal was to
develop a small, reliable, portable, distributed, real-time operating
environment.

When the project started, C++ was the language of choice. But
over time the difficulties encountered with C++ grew to the point where the
problems could best be addressed by creating an entirely new language
environment. Design and architecture decisions drew from a variety of
languages such as Eiffel, SmallTalk, Objective C, and Cedar/Mesa.

The result is a language environment that has proven ideal for developing secure,
distributed, network-based end-user applications in environments ranging
from networked-embedded devices to the World-Wide Web and the desktop.

Read More