Java and C++ are superficially similar, they share a common heritage in there syntax. Blocks of code are enclosed in {braces}; statements terminated by semicolons; the basic procedural statements are shared as is the way variables are introduced.
They key difference between C++ and Java is what a compilation unit builds into. In C++ each compilation unit for an executable is done independently and the built units contain very little type information. By contrast in Java each compilation unit is built in concert with the other compilation units and much type information is contained in the target code.
In Java if you have a simple class you write the code once:
class Simpleton { public static int Negate(int x) { return -x; } }
When you compile that the resulting object contains pretty much all the naming and type information you see in the code. The code is written once, client code looks at the compiled code to use it.
In C++ the same class it typically split across two file, a header file containing:
class Simpleton { public: static int Negate(int x); };
That text is then #included into the sources that use and implement it. The implementation might then be:
int Simpleton::Negate(int x) { return -x; }
The split of code seen in C++ is done by the programmer, whereas the split of interface and implementation is done automatically by Java. The fact the programmer can lead to strange effects, both intended and unintended. For example there can be two versions of the header file, that can cause hard to trace problems.
Both C++ and Java are typed languages, the parameter x in my example code is an integer in both. In Java the type of something absolutely enforces how it can be used, you have to work very hard to interpret the pattern of bits that represent an integer as something else. In C++ it is almost trivial to escape the restrictions of the type system, features like reinterpret_cast allow direct access to the underlying bit patterns.
Java has a memory model in which dynamically created objects are tracked, the memory allocated to those objects is tracked and some time after no references to the memory exist the memory is freed. C++ has a built-in model whereby the code has to specify when dynamically allocated memory needs freeing, however you are not forced to use that model and most modern code abandons that for another models.
It is also true that commonly C++ compiles to native code, whereas Java commonly compiles to a byte-code that is interpreted. That is not universally true though, there are compilers for C++ that produce a byte-code and compilers for Java byte-code that produce native code.
C++ is a standard language controlled by various independent standards bodies. Java is a proprietary language created by Sun, but now owned by Oracle after their purchase of Sun; Java has not been submitted to any standards body.