Simple
We wanted to build a system that could be programmed easily without a lot of esoteric training and which leveraged today's standard practice. So even though we found that C++ was unsuitable, we designed Java as closely to C++ as possible in order to make the system more comprehensible. Java omits many rarely used, poorly understood, confusing features of C++ that, in our experience, bring more grief than benefit.
The syntax for Java is, indeed, a cleaned-up version of the
syntax for C++. There is no need for header files, pointer arithmetic (or even a
pointer syntax), structures, unions, operator overloading, virtual base classes,
and so on. (See the C++ notes interspersed throughout the text for more on the
differences between Java and C++.) The designers did not, however, attempt to
fix all of the clumsy features of C++. For example, the syntax of the
switch statement is unchanged in Java. If you know C++, you will find
the transition to the Java syntax easy.
If you are used to a visual programming environment (such as
Visual Basic), you will not find Java simple. There is much strange syntax
(though it does not take long to get the hang of it). More important, you must
do a lot more programming in Java. The beauty of Visual Basic is that its visual
design environment almost automatically provides a lot of the infrastructure for
an application. The equivalent functionality must be programmed manually,
usually with a fair bit of code, in Java. There are, however, third-party
development environments that provide "drag-and-drop"-style program
development.
Another aspect of being simple is being small. One of the goals of Java is to enable the construction of software that can run stand-alone in small machines. The size of the basic interpreter and class support is about 40K bytes; adding the basic standard libraries and thread support (essentially a self-contained microkernel) adds an additional 175K.
This is a great achievement. Note, however, that the graphical
user interface (GUI) libraries are significantly larger.
Object Oriented
Simply stated, object-oriented design is a technique for programming that focuses on the data (= objects) and on the interfaces to that object. To make an analogy with carpentry, an "object-oriented" carpenter would be mostly concerned with the chair he was building, and secondarily with the tools used to make it; a "non-object-oriented" carpenter would think primarily of his tools. The object-oriented facilities of Java are essentially those of C++.
Distributed
Java has an extensive library of routines for coping with TCP/IP protocols like HTTP and FTP. Java applications can open and access objects across the Net via URLs with the same ease as when accessing a local file system.
Robust
Java is intended for writing programs that must be reliable in a variety of ways. Java puts a lot of emphasis on early checking for possible problems, later dynamic (run-time) checking, and eliminating situations that are error-prone.… The single biggest difference between Java and C/C++ is that Java has a pointer model that eliminates the possibility of overwriting memory and corrupting data.
This feature is also very useful. The Java compiler detects
many problems that, in other languages, would show up only at run time. As for
the second point, anyone who has spent hours chasing memory corruption caused by
a pointer bug will be very happy with this feature of Java.
If you are coming from a language like Visual Basic that
doesn't explicitly use pointers, you are probably wondering why this is so
important. C programmers are not so lucky. They need pointers to access strings,
arrays, objects, and even files. In Visual Basic, you do not use pointers for
any of these entities, nor do you need to worry about memory allocation for
them. On the other hand, many data structures are difficult to implement in a
pointerless language. Java gives you the best of both worlds. You do not need
pointers for everyday constructs like strings and arrays. You have the power of
pointers if you need it, for example, for linked lists. And you always have
complete safety, because you can never access a bad pointer, make memory
allocation errors, or have to protect against memory leaking away.
Secure
From the beginning, Java was designed to make certain kinds of
attacks impossible, among them:
-
Overrunning the runtime stack—a common attack of worms and viruses
-
Corrupting memory outside its own process space
-
Reading or writing files without permission
A number of security features have been added to Java over
time. Since version 1.1, Java has the notion of digitally signed classes . With a signed class, you can be sure who wrote it. Any time you trust
the author of the class, the class can be allowed more privileges on your
machine.
NOTE
Architecture Neutral
The compiler generates an architecture-neutral object file format—the compiled code is executable on many processors, given the presence of the Java runtime system. The Java compiler does this by generating bytecode instructions which have nothing to do with a particular computer architecture. Rather, they are designed to be both easy to interpret on any machine and easily translated into native machine code on the fly.
This is not a new idea. More than 20 years ago, both Niklaus
Wirth's original implementation of Pascal and the UCSD Pascal system used the
same technique.
Of course, interpreting bytecodes is necessarily slower than
running machine instructions at full speed, so it isn't clear that this is even
a good idea. However, virtual machines have the option of translating the most
frequently executed bytecode sequences into machine code, a process called
just-in-time compilation. This strategy has proven so effective that even
Microsoft's .NET platform relies on a virtual machine.
The virtual machine has other advantages. It increases security
because the virtual machine can check the behavior of instruction sequences.
Some programs even produce bytecodes on the fly, dynamically enhancing the
capabilities of a running program.
Portable
Unlike C and C++, there are no "implementation-dependent" aspects of the specification. The sizes of the primitive data types are specified, as is the behavior of arithmetic on them.
For example, an int in Java is always a 32-bit
integer. In C/C++, int can mean a 16-bit integer, a 32-bit integer, or
any other size that the compiler vendor likes. The only restriction is that the
int type must have at least as many bytes as a short int and
cannot have more bytes than a long int. Having a fixed size for number
types eliminates a major porting headache. Binary data is stored and transmitted
in a fixed format, eliminating confusion about byte ordering. Strings are saved
in a standard Unicode format.
The libraries that are a part of the system define portable interfaces. For example, there is an abstract Window class and implementations of it for UNIX, Windows, and the Macintosh.
As anyone who has ever tried knows, it is an effort of heroic
proportions to write a program that looks good on Windows, the Macintosh, and 10
flavors of UNIX. Java 1.0 made the heroic effort, delivering a simple toolkit
that mapped common user interface elements to a number of platforms.
Unfortunately, the result was a library that, with a lot of work, could give
barely acceptable results on different systems. (And there were often different bugs on the different platform graphics
implementations.) But it was a start. There are many applications in which
portability is more important than user interface slickness, and these
applications did benefit from early versions of Java. By now, the user interface
toolkit has been completely rewritten so that it no longer relies on the host
user interface. The result is far more consistent and, we think, more attractive
than in earlier versions of Java.
Interpreted
The Java interpreter can execute Java bytecodes directly on any machine to which the interpreter has been ported. Since linking is a more incremental and lightweight process, the development process can be much more rapid and exploratory.
Incremental linking has advantages, but its benefit for the
development process is clearly overstated. In any case, we have found Java
development tools to be quite slow. If you are used to the speed of the classic
Microsoft Visual C++ environment, you will likely be disappointed with the
performance of Java development environments. (The current version of Visual
Studio isn't as zippy as the classic environments, however. No matter what
language you program in, you should definitely ask your boss for a faster
computer to run the latest development environments. )
High Performance
While the performance of interpreted bytecodes is usually more than adequate, there are situations where higher performance is required. The bytecodes can be translated on the fly (at run time) into machine code for the particular CPU the application is running on.
If you use an interpreter to execute the bytecodes, "high
performance" is not the term that we would use. However, on many platforms,
there is also another form of compilation, the just-in-time (JIT) compilers. These work by compiling
the bytecodes into native code once, caching the results, and then calling them
again if needed. This approach speeds up commonly used code tremendously because
one has to do the interpretation only once. Although still slightly slower than
a true native code compiler, a just-in-time compiler can give you a 10- or even
20-fold speedup for some programs and will almost always be significantly faster
than an interpreter. This technology is being improved continuously and may
eventually yield results that cannot be matched by traditional compilation
systems. For example, a just-in-time compiler can monitor which code is executed
frequently and optimize just that code for speed.
Multithreaded
[The] benefits of multithreading are better interactive responsiveness and real-time behavior.
If you have ever tried to do multithreading in another
language, you will be pleasantly surprised at how easy it is in Java. Threads in
Java also can take advantage of multiprocessor systems if the base operating
system does so. On the downside, thread implementations on the major platforms
differ widely, and Java makes no effort to be platform independent in this
regard. Only the code for calling multithreading remains the same across
machines; Java offloads the implementation of multithreading to the underlying
operating system or a thread library. (Threading is covered in Volume 2.)
Nonetheless, the ease of multithreading is one of the main reasons why Java is
such an appealing language for server-side development.
Dynamic
This is an important feature in those situations in which code needs to be added to a running program. A prime example is code that is downloaded from the Internet to run in a browser. In Java 1.0, finding out runtime type information was anything but straightforward, but current versions of Java give the programmer full insight into both the structure and behavior of its objects. This is extremely useful for systems that need to analyze objects at run time, such as Java GUI builders, smart debuggers, pluggable components, and object databases.In a number of ways, Java is a more dynamic language than C or C++. It was designed to adapt to an evolving environment. Libraries can freely add new methods and instance variables without any effect on their clients. In Java, finding out run time type information is straightforward.
0 comments:
Post a Comment