No discussion of Java’s history is
complete without a look at the Java buzzwords.
Although the fundamental forces that necessitated the invention of Java
are portability and security, other factors also played an
important role in molding the final form of the language. The key considerations were summed up by
the Java team in the following list of buzzwords:
Secure
Portable
Object-oriented
Robust
Multithreaded
Interpreted
High performance
Dynamic
Two of these buzzwords have already been discussed: secure and portable. Let’s examine what each of the others implies.
Simple
Java was designed to be easy for the
professional programmer to learn and use effectively. Assuming that you have some programming experience, you will not find Java hard to master. If you already understand the basic
concepts of object-oriented programming, learning Java will be even easier. Best of all, if you are an experienced C++ programmer, moving to Java will require very little
effort. Because Java inherits the C/C++ syntax and many of the
object-oriented features of C++, most
programmers have little trouble learning Java.
Object-Oriented
Although
influenced by its predecessors, Java was not designed to be source-code compatible with any other language. This allowed the Java team the freedom
to design with a blank slate. One outcome of this was a clean,
usable, pragmatic approach to objects. Borrowing liberally from many seminal object-software
environments of the last few decades, Java
manages to strike a balance between the purist’s “everything is an object”
paradigm and the pragmatist’s “stay
out of my way” model. The object model in Java is simple and easy to extend, while primitive types,
such as integers, are kept as high-performance
nonobjects.
Robust
The multiplatformed environment of the Web places extraordinary demands on a program, because the program must execute
reliably in a variety of systems. Thus, the ability to create robust programs
was given a high priority in the design of Java. To gain reliability, Java restricts you in a few key areas to
force you to find your mistakes early in program
development. At the same time, Java frees you from having to worry about many
of the most common causes of programming errors. Because Java is a
strictly typed language, it checks your code at compile time. However,
it also checks your code at run time. Many
hard-to-track-down bugs that often turn up in hard-to-reproduce run-time
situations are simply impossible to
create in Java. Knowing that what you have written will behave in a predictable way under diverse
conditions is a key feature of Java.
To better understand how
Java is robust, consider two of the main reasons for program failure: memory management mistakes and mishandled
exceptional conditions (that is, run-time
errors). Memory management can be a difficult, tedious task in traditional programming environments. For example, in C/C++, the programmer
must manually allocate
and free all dynamic memory. This sometimes leads to problems,
because programmers will either forget to free memory that has been previously
allocated or, worse, try to free some memory that another
part of their code is still using. Java virtually eliminates these problems by managing
memory allocation and deallocation for you. (In fact, deallocation is completely
automatic,
because Java provides garbage collection for unused objects.) Exceptional conditions in traditional environments often arise in situations
such as division
by zero or “file not found,”
and they must be managed
with clumsy and hard-to-read constructs. Java helps in this area
by providing object-oriented exception handling. In a well-written Java program, all run-time errors can—and should—be managed by your program.
Multithreaded
Java was designed to meet the real-world
requirement of creating interactive, networked
programs. To accomplish this, Java
supports multithreaded programming, which allows
you to write programs that do many things simultaneously. The Java run-time system comes with an elegant yet
sophisticated solution for multiprocess synchronization that enables you to
construct smoothly running interactive systems. Java’s easy-to-use approach to multithreading allows you to
think about the specific behavior of your program, not the multitasking subsystem.
Architecture-Neutral
A central issue
for the Java designers was that of code longevity and portability. One of the main
problems facing programmers is that no guarantee exists that if you write a program today, it will run tomorrow—even on the same machine. Operating
system upgrades, processor upgrades,
and changes in core system resources can all combine to make a program malfunction. The Java
designers made several hard decisions in the Java language and the Java Virtual Machine in an attempt to alter
this situation. Their goal was “write once; run anywhere, any time, forever.” To a great extent, this goal was accomplished.
Interpreted and High Performance
As described earlier,
Java enables the creation of cross-platform programs
by compiling into an
intermediate representation called Java bytecode. This code can be executed on any system that implements the Java
Virtual Machine. Most previous attempts at
cross-platform solutions have done so at
the expense of performance. As explained earlier,
the Java bytecode was carefully designed so that it would be easy to translate
directly into native machine
code for very high performance by using a just-in-time compiler. Java run-time
systems that provide this feature lose none of the benefits
of the platform-independent code.
Distributed
Java is designed for the distributed
environment of the Internet because it handles
TCP/IP protocols. In fact,
accessing a resource
using a URL is not much different from accessing a file. Java also supports Remote Method Invocation (RMI). This
feature enables a program to invoke
methods across a network.
Java programs carry with them substantial
amounts of run-time type information that is used to verify and resolve accesses to
objects at run time. This makes it possible
to
dynamically link code in a safe and
expedient manner. This is crucial to
the robustness of the Java
environment, in which small fragments of bytecode may be dynamically updated on a running system.
No comments:
Post a Comment