Question

After reading the Java White Paper, I have a question on my mind and it might not be a very smart question but here it is anyway:
From what I gathered, Java attempted to improve an a number of fallacies associated with C++ such as redundancy, confusion with pointers, full-object orientation etc.,
If Java managed to overcome these issues, why would it be incorret to say that Java can replace C++.

Answer 1

There are many situations where C++ is a better option than Java. Comparison here.

Specifically:

In addition to running a compiled Java program, computers running Java
applications generally must also run the Java Virtual Machine JVM,
while compiled C++ programs can be run without external applications.
Early versions of Java were significantly outperformed by statically
compiled languages such as C++. This is because the program statements
of these two closely related languages may compile to a few machine
instructions with C++, while compiling into several byte codes
involving several machine instructions each when interpreted by a JVM.

Certain inefficiencies are inherent to the Java language itself,
primarily:

1. All objects are allocated on the heap. For functions using small objects this can result in performance degradation as stack
   allocation, in contrast, costs essentially zero. However, this
   advantage is obsoleted by modern JIT compilers utilising escape
   analysis or escape detection to allocate objects on the stack. Escape
   analysis was introduced in Oracle JDK 6.

2. Methods are by-default virtual. This slightly increases memory usage by adding a single pointer to a virtual table per each object.
   Also, it induces a startup performance penalty, because a JIT compiler
   has to do additional optimization passes even for de-virtualization of
   small functions.

3. A lot of casting required even using standard containers induces a performance penalty. However, most of these casts are statically
   eliminated by the JIT compiler, and the casts that remain in the code
   usually do not cost more than a single CPU cycle on modern processors,
   thanks to branch prediction.

4. Array access must be safe. The compiler is required to put appropriate range checks in the code. Naive approach of guarding each
   array access with a range check is not efficient, so most JIT
   compilers generate range check instructions only if they cannot
   statically prove the array access is safe. Even if all runtime range
   checks cannot be statically elided, JIT compilers try to move them out
   of inner loops to make the performance degradation as low as possible.

5. Lack of access to low level details does not allow the developer to better optimize the program where the compiler is unable to do
   so.[10]. Programmers can interface with the OS directly by providing
   code in C or C++ and calling that code from Java by means of JNI.

Also as an iOS/Mac dev, and strong background in DSP, and lover of many open source C++ and Objective C libraries, I could go on and on as to why Java is not better…