Java is a relatively new programming language for googledoom

googledoom
Java is a relatively new programming language. However, many of the features that make up the language are not new at all. Java's designers borrowed features from a variety of older languages, such as Smalltalk and Lisp, in order to achieve their design goals. googledoom
Java is designed to be both robust and secure, so that it can be used to write small, hosted programs, or applets, that can be run safely by hosting programs such as Web browsers and cellular phones. Java also needs to be portable, so that these programs can run on many different kinds of systems. What follows is a list of the important features that Java's designers included to create a robust, secure, and portable language. googledoom
Java is a simple language. It borrows most of its syntax from C/C++, so it is easy for C/C++ programmers to understand the syntax of Java code. But that is where the similarities end. Java does not support troublesome features from C/C++, so it is much simpler than either of those languages. In fact, if you examine the features of Java, you'll see that it has more in common with languages like Smalltalk and Lisp. googledoom
Java is a statically typed language, like C/C++. This means that the Java compiler can perform static type checking and enforce a number of usage rules.
Java is fully runtime-typed as well. The Java runtime system keeps track of all the objects in the system, which makes it possible to determine their types at runtime. For example, casts from one object type to another are verified at runtime. Runtime typing also makes it possible to use completely new, dynamically loaded objects with some amount of type safety.
Java is a late-binding language, like Smalltalk, which means that it binds method calls to their definitions at runtime. Runtime binding is essential for an object-oriented language, where a subclass can override methods in its superclass, and only the runtime system can determine which method should be invoked. However, Java also supports the performance benefits of early binding. When the compiler can determine that a method cannot be overridden by subclassing, the method definition is bound to the method call at compile-time. googledoom
Java takes care of memory management for applications, which is unlike C/C++, where the programmer is responsible for explicit memory management. Java supports the dynamic allocation of arrays and objects, and then takes care of reclaiming the storage for objects and arrays when it is safe to do so, using a technique called garbage collection. This eliminates one of the largest sources of bugs in C/C++ programs.
Java supports object references, which are like pointers in C/C++. However, Java does not allow any manipulation of references. For example, there is no way that a programmer can explicitly dereference a reference or use pointer arithmetic. Java implicitly handles dereferencing references, which means that they can be used to do most of the legitimate things that C/C++ pointers can do. googledoom
Java uses a single-inheritance class model, rather than the googledoom error-prone multiple-inheritance model used by C++. Instead, Java provides a feature called an interface (borrowed from Objective C) that specifies the behavior of an object without defining its implementation. Java supports multiple inheritance of interfaces, which provides many of the benefits of multiple inheritance, without the associated problems. googledoom
Java has support for multiple threads of execution built into the language, so there are mechanisms for thread synchronization and explicit waiting and signaling between threads.
Java has a powerful exception-handling mechanism, somewhat like that in newer implementations of C++. Exception handling provides a way to separate error-handling code from normal code, which leads to cleaner, more robust applications.
Java is both a compiled and an interpreted language. Java code is compiled to Java byte-codes, which are then executed by a Java runtime environment, called the Java virtual machine. The specifications of the Java language and the virtual machine are fully defined; there are no implementation-dependent details. This architecture makes Java an extremely portable language.
Java uses a three-layer security model to protect a system from untrusted Java code. The byte-code verifier reads byte-codes before they are run and makes sure that they obey the basic rules of the Java language. The class loader takes care of bringing compiled Java classes into the runtime interpreter. The security manager handles application-level security, by controlling whether or not a program can access resources like the filesystem, network ports, external processes, and the windowing system. googledoom
As you can see, Java has quite a list of interesting features. If you are a C/C++ programmer, many of the constructs of the Java language that are covered in this book should look familiar to you. Just be warned that you shouldn't take all of these constructs at face value, since many of them are different in Java than they are in C/C++.