by Steven Haines
- Java is simple. That simplicity derives from syntax similar to C/C++ and the omission of complex C/C++ features such as multiple implementation inheritance, pointers, and operator overloading.
- Java is object-oriented. Java’s object-oriented nature encourages a developer to think in terms of classes and objects rather than separate code and data. That class/object focus results in code that is easier to write, easier to maintain, and easier to reuse.
- Java is network-savvy. A TCP/IP library simplifies the development of programs that communicate with HTTP, FTP, and other TCP/IP network processes. Furthermore, the library’s use of the same stream-oriented mechanism for communicating with remote network processes that file-oriented code uses to communicate with files on a computer’s local hard drive helps a developer write network code faster.
- Java is interpreted. Java’s compiler translates source code into class files of bytecode instructions. A virtual machine examines each instruction and uses that instruction’s meaning to execute an equivalent sequence of platform-dependent instructions. Interpretation speeds up the development process and simplifies debugging.
- Java is robust. Errant programs do not crash the virtual machine or corrupt the underlying (native) platform. Robustness is achieved, in part, by not supporting C/C++ pointers, by providing a garbage collector to automatically free up dynamically allocated memory (instead of forcing the developer to accomplish that task), by performing strict compile-time/runtime type checking, and by providing true arrays with bounds checking.
- Java is secure. Java’s "sandbox" security model identifies sensitive operations (such as file I/O) that a malicious program can exploit to harm the native platform, and provides a mechanism for allowing or preventing access to those operations.
- Java is architecture-neutral. A compiled Java program’s bytecode instructions target a generic virtual machine instead of a specific platform. Because each platform-specific virtual machine implementation supplies a consistent interface to the bytecodes, the same Java program runs on diverse platforms (via their virtual machines).
- Java is portable. Portability is achieved through architecture neutrality and through a strict definition of the language (which permits no implementation-dependent features). For example, Java’s integer primitive type always means a signed 2’s complement 32-bit integer. In contrast, the C/C++ integer type can be unsigned, and its size varies according to a platform’s register size (typically 32 bits or 64 bits).
- Java is high-performance. Many virtual machines use a just-in-time (JIT) compiler to dynamically compile a program’s bytecode instructions into platform-specific instructions (which execute faster than bytecodes) as the program runs.
- Java is multithreaded. Support for threads is built into the language via thread-synchronization primitives. There is also a thread library.
- Java is dynamic. Java’s use of an interface type to distinguish between what a program must do and how that task gets accomplished helps Java adapt to a continually evolving environment, and makes it easier for vendors to modify Java libraries without breaking program code that uses those libraries.