ch1.htm

JAVA Developing Professional JavaApplets

and computing, television and computers, consumer appliances and
telecommunications, and so forth. Each of these converging factors
comes from areas of technology that, until recently, have not
had much in common. For example, the technology of fiber optics
does not have much to do directly with the problems of computing.
At the same time that these <I>disparate</I> technologies have
converged, there have also been pressures from <I>within</I> computing
to bring together disciplines historically considered unrelated.
This convergence within computing has been brought about by various
pressures that have arisen:
<UL>
<LI><FONT COLOR=#000000>An overwhelming need to deal with the
</FONT><I>software crisis </I>has developed. This term has been
coined to describe problems that have plagued the software community.
Software development has been marred by high cost, low quality,
and ever-increasing demand; these problems have been both caused
and exacerbated by increasing software complexity. Because of
these trends, there is tremendous interest in any technique that
can increase the productivity of software developers, improve
reliability, and make it easier to design software that tackles
complex problems. Over the last decade the technology that has
been viewed as having the best chance of successfully dealing
with these problems is <I>object-oriented programming</I>. Object-oriented
features of abstraction, encapsulation, and modularity are particularly
well suited for making complex real-world problems easier to model
and, hence, design. A true object-oriented language's support
for inheritance and dynamic binding improves software reuse and
also, as a consequence, programmer productivity. The garbage collection
facility in some object-oriented languages improves <I>reliability</I>
by freeing the programmer from the intricate concerns of memory
management.
<LI><FONT COLOR=#000000>The predominance of a variety of operating
systems and platforms has created a heavy demand for </FONT><I>portable</I>
software. Programs need to be written that will not only run on
several different platforms, but do so in a way that fits into
the native &quot;look and feel&quot; of the environment. Furthermore,
portable software needs to have the <I>high performance</I> that
is typical of the software written for the target platform. Interest
in soft-ware that is portable but slow is waning rapidly.
<LI><FONT COLOR=#000000>The rapid growth of computer networks
has been matched by a corresponding rise of interest in </FONT><I>distributed
computing</I>. This discipline is concerned with the problems
of software distributed across multiple computers. Distributed
computing issues include interprocess communication, concurrent
processing, data sharing and replication, and security. Although
the Internet is the most well-known distributed environment, it
is in just the early stages of using the full potential of distributed
computing. Until recently, for example, there has been no solution
to the problem of dynamically downloading an application both
efficiently and securely. <I>Efficiency</I> is important since
you want to download only the code you need when you need it;
you don't want to wait thirty minutes to download a 3MB application.
Even more important, you need to be concerned with the <I>security</I>
of the code. You won't run applications from the Internet if it
means giving the green light to hackers around the world to attack
your hard disk. You also do not want a poorly written Internet
application to crash your system-the software has to be <I>reliable</I>.
</UL>
<P>
Each of these problems has been seriously addressed from many
fronts, but no approach has simultaneously addressed all these
problems. For example, there might be a programming language that's
good for rapid development but isn't portable, or a development
environment might be portable, but could not work in a distributed
environment without opening you up to serious breaches of security.
A single solution to all these problems has been lacking&#133;until
Java!
<H3><A NAME="WhyJavaIsaComprehensiveSolution">Why Java Is a Comprehensive
Solution</A></H3>
<P>
The designers of Java created a programming environment to attack
each and every one of these problems. As a comprehensive solution
to these pressing issues, Java needs to be understood as not just
a programming language, but as a general-purpose environment.
Its unique combination of a programming language, compiler, and
runtime environment provides a general architecture well suited
for addressing many of the concerns that have been plaguing the
computing community for years. This general development environment
is often referred to with the solitary term <I>Java</I>.
<P>
In part, Java's evolution into a comprehensive solution stems
from its twisted history of being a language for general consumer
electronics to being one for PDAs and set-top boxes for interactive
television. Features common to each of these potential platforms
include severe memory constraints and the need to support multiple
operating systems. These problems forced the language to address
the problems of distributed computing, efficiency, security, portability,
and reliability. For Java to be a successful language, furthermore,
it would also have to address the problems associated with the
software crisis-it would need to be object-oriented.
<P>
Being object-oriented carried another bonus for Java. The object-oriented
message-passing model of invoking class methods makes it a natural
for network-based application development. Consequently, being
object-oriented is one of the cornerstones of Java, so it's a
good place to begin a tour of its general architectural features.
<H3><A NAME="WhyObjectOrientedIsImportant">Why Object-Oriented
Is Important</A></H3>
<P>
Why is it important for Java to be an object-oriented language?
As stated before, modern programming languages need to address
the problems of the software crisis. Perhaps the most serious
difficulty a software engineer encounters is the inherent complexity
involved in modeling a real-world problem. Through the past decades
of computing, analysis techniques have come in and out of fashion
that aim to make modeling the world a more comprehensible and
stable practice. When you were taking your first classes in programming,
you might have seen flowcharts used as a modeling tool. The Structured
Analysis school of thought uses data flow diagrams to model the
world. These approaches have some contributions to make, but they
have one serious problem: they are heavily oriented toward the
<I>procedural</I> side of the activities being modeled. The problem
with a procedural approach is that it does not translate well
to software that is compact, easy to maintain, and reusable. In
its worst implementations, a system based on the procedural model
has a different function for every different type of procedure
that could occur. You have probably seen such systems-they are
so incomprehensible and hard to follow that the only goal of the
poor soul who has to maintain the system is to &quot;just make
it work.&quot;
<P>
Object-oriented analysis, design, and programming is a radical
departure from the procedural model. Its focus is not on the procedures
of the modeled world, but on the <I>objects</I> appearing in it.
Objects are a natural thing to model because that's what the world
is made of. Planes, dogs, and computers are all objects. Even
abstract concepts, such as a priority queue, can be thought of
as an object. What all objects have in common is that they have
<I>state</I> and <I>behavior</I>. For example, the state of a
plane can be partially indicated by its speed and location, but
its behavior might be represented by its ability to change altitude.
<P>
Another feature of objects is that they are self-contained; in
other words, they are <I>modular</I>. When modeling a car engine,
for example, you can focus on the characteristics of each object
in the engine as opposed to the flow of gas and energy through
it. The object model breaks the engine down into a series of components
that can be described on their own terms, as opposed to what they
are in a complex global view of things. Instead of writing a single
huge procedure describing what's going on in the car, you can
focus on how each of the individual elements behaves.
<P>
Finally, objects have the quality of being hierarchical. A large
complex object, a house, for example, consists of other objects,
such as its physical structure, the electrical system, the plumbing,
and so forth. These are in turn made up of yet other objects,
such as a chimney, the light switches, and a sink. These can be
broken down into yet smaller components such as wood, wires, and
pipes. By modeling a system based on <I>hierarchy</I>, you can
use the model of smaller, more easily understood objects, such
as a wire, to construct more complex objects, such as a light
switch. Since the switch is now seen as an object that consists
of yet simpler objects, its complexity is easier to understand
and manage.
<P>
In object-oriented systems, objects communicate through a <I>message-passing</I>
mechanism. When an object receives a message, it may change its
state and behavior as part of the response. For example, sending
a message of &quot;play&quot; to a CD player object might result
in the CD playing a music track. This message-passing aspect of
objects translates very nicely into the needs of network programming,
where transactions are carried out by the mechanism of messages.
It is particularly well suited to distributed systems because
objects communicate by a standard message-passing mechanism, in
which the actual location of the objects becomes less important.
If your object needs to talk to an object, it isn't particularly
important if it is on your computer or a remote host. All that
really counts is that the object gets your message.
<H3><A NAME="JavaasanObjectOrientedLanguage">Java as an Object-Oriented
Language</A></H3>
<P>
Java is unusual for an object-oriented programming language in
that it is &quot;objects all the way down.&quot; Unlike C++, which
is a confusing combination of objects and functions, everything
in Java is an object. Strings are objects, numbers are objects,
threads are objects, even applets are objects. Because of this,
Java has all the helpful features of object-oriented systems just
described. Its core constructs of classes, objects, methods, and
instance variables are, by their very nature, managed in a modular
fashion. Java's support for inheritance allows you to build new
classes from other classes. Each class you construct becomes a
tool that can be used to create yet more complex classes.
<P>
Java's particular object-oriented implementation allows it to
have yet even more desirable features than those already discussed.
It has a runtime <I>garbage collector</I> that removes objects
from memory that you no longer need. No longer will your program
run out of memory because you forgot to explicitly delete an object.
The garbage collector, which your program doesn't even have to
be aware of, does this for you. Furthermore, Java's total orientation
toward objects removes another construct that has been a blight
of programmers-the pointer. Java hides almost all aspects of memory
management from the programmer. C or C++ programmers who have
had to deal with complex bugs caused by the misuse of pointers
or bad pointer arithmetic will no longer have to deal with this
entire class of problems. In Java, you will never deal with pointers,
only objects. Because of this combination of garbage collection
and removal of the pointer construct, Java has generally taken
the problem of memory management away from you. Consequently,
programs written in Java are more <I>reliable</I>.
<P>
Java's unique object-oriented implementation gives it another
set of desirable characteristics-<I>simplicity</I> and <I>familiarity</I>.
In many ways, its syntax is similar to C and C++, thus making
it familiar. On the other hand, it strips out all the programming
constructs of this language that are historical artifacts contributing
little to writing object-oriented programs. For example, the structure
construct is removed because everything in Java is an object.
Unions are removed because they make you think too much about
how memory is laid out, a low-level memory consideration that
Java's garbage collection and removal of pointers tries to abolish.
Other procedural features of C and C++ that are removed include
functions, which are replaced by class methods; preprocessor constructs,
such as <TT>typedef</TT> and <TT>ifdef</TT>;
the hated <TT>goto</TT> statement;
and, of course, pointers. Java also replaces the complex and troublesome
multiple inheritance of C++ by a simpler combination of single
inheritance and interfaces. With all these features in mind, Java
becomes a simpler and easier language to use.
<P>
Java has all the object-oriented features discussed in the previous
section. It uses message passing to let objects communicate, and
it supports <I>dynamic binding</I>, allowing a message to be sent
to an object even though its specific type may not be known until
runtime. Abstract classes and interfaces enable you to specify
a design without having to worry about a specific implementation.
With Java's access control constructs, you can define different
levels of access to your class's methods and variables that are
available to external classes.
<H3><A NAME="JavaasaPortableEnvironment">Java as a Portable Environment</A>
</H3>
<P>
<I>Portability</I> is critical to success in the emerging world
of networked applications and commerce. On the Internet, you cannot
make assumptions about what kind of platform your applet will
run on. Not only do you have to write software that will run on
the client's underlying architecture-such as 80x86, PowerPC, or
68000 series-but you must also ensure it will have the correct
look and feel of the native interface. To make things even tougher,
this software needs to be fast and compact.
<P>
Java takes a multipronged approach to this challenge. At the heart
of this approach is the fact that the Java compiler generates
<I>bytecodes</I> that are <I>interpreted</I> at runtime. The fact
that bytecodes are generated is important because it avoids the
problem of basing the binary code on a basic set of primitive
types-such as integers and floating point-that would be tied to
a specific platform. For example, even something as simple as
an integer data type is implemented in a different manner on different
platforms (16-bit on some, 32-bit on others). Java defines its
own set of primitive data types and reconstructs large 16-bit
or 32-bit values at runtime by composing them out of individual
bytecodes. Java consistently uses the big-endian format to do
this, thus avoiding another portability conflict about how platforms
store primitive data types. You can also quickly and efficiently
convert the bytecodes at runtime to the underlying native formats
if necessary. In short, Java's underlying encoding scheme is <I>architecture-neutral</I>.
<P>
The bytecode-based system is important to writing a portable interpreter.
The bytecodes generated by the compiler are based on the specification
of a <I>Java Virtual Machine,</I> which, as its name suggests,
is not a specific hardware platform but a machine implemented
in software. The virtual machine is very similar to a real CPU
with its own instruction set, storage formats, and registers.