Java language passes all the arrays and objects by reference but will not have an explicit pointer type. You cannot construct a reference to anonymous memory. In addition of making the programming easier, this prevents the common errors due to the pointer mismanagement.

The Java language do not support either structures or unions. Instead they use classes or interfaces to build the composite types.

Command line arguments passed to the Java application are different in number and in types than those passed to C or C++ programs.

In C and C++ when the program is invoked, the system passes two parameters to it: These arguments are shown below.

When we invoke a Java application, the system passes only one parameter to it:

In C and C++ programming, the system passes the whole command line to the program as its arguments, including a name used to invoke it. Consider for example, if we invoked the C program like this: Then first argument in the argv parameter is diff.

In Java Programming, you always know the name of application because it is the name of class where the main method is been defined. So, the Java runtime system does not pass the class name we invoke to main method. Instead, the system passes only the those items on the command line which appears after the class name. Consider for example, if we invoked a Java application like this:

By convention, the C and C++ strings are the null-terminated array of characters; there is no such real entity in C and C++ that is a string. The Java strings are first-class objects.

To illustrate why this is one of the important feature of Java programming language, let us look at the small example. This C function will copy the contents of str1 into str2.

In the above example, the developer uses the pointer arithmetic to step through both the strings copying one into the other. While allowing the programmers to inspect the arbitrary memory locations through pointers is the powerful tool, this power can be a source of many errors. One of the fruitful source of errors is pointers which stray off the end of the array. myStrCopy function above has such an error: the for loop in the function will not check the length of a string str2, and if the string str1 is longer compared to str2 the string copy writes right over the end of the string str2. Here is a program which tickles the bug.

The myStrCopy function writes over the end of string str2 thereby corrupting all that which was stored in the memory after it. NOTE: the %s, %s are the characters that happened to be stored in a memory location after the string str2 and will probably be different when we run the program on our machine.

Java strings are the first-class objects deriving either from a String class or a StringBuffer class. This makes the finding and fixing the whole class of common and frustrating programming errors such as the one illustrated the below trivial. Here is the program above (including an error) rewritten in the Java language.

Notice that this translation will do use the String class, the StringBuffer class and the methods which are appropriate to obtain a specific characters instead of the character arrays and the pointers.

Like the C version, Java programming versions of the myStrCopy method loops over the length of the str1 and never checks length of str2. Thus, when the string str1 is longer than the string str2, the method will try to obtain the characters beyond the end of the end of the str2. However, when we run the Java language version, we will see the following runtime error message.

The primary difference between the Java Programming language version of this program and the C, is that the Java program reliably and obviously will crash, where as the C program will do something obscure.