by Laura Lemay
This appendix contains a description of most of the major differences between C, C++ , and the Java language. If you are a programmer familiar with either C or C++, you may want to review this appendix to catch some of the common mistakes and assumptions programmers make when using Java.
Java does not have an explicit pointer type. Instead of pointers, all references to objects—including variable assignments, arguments passed into methods, and array elements—are accomplished by using implicit references. References and pointers are essentially the same thing except that you can't do pointer arithmetic on references (nor do you need to).
References also allow structures such as linked lists to be created easily in Java without explicit pointers; simply create a linked list node with variables that point to the next and the previous node. Then, to insert items in the list, assign those variables to other node objects.
Arrays in Java are first class objects, and references to arrays and their contents are accomplished through implicit references rather than via point arithmetic. Array boundaries are strictly enforced; attempting to read past the end of an array is a compile or run-time error. As with other objects, passing an array to a method passes a reference to the original array, so changing the contents of that array reference changes the original array object.
Arrays of objects are arrays of references that are not automatically initialized to contain actual objects. Using the following Java code produces an array of type MyObject with ten elements, but that array initially contains only nulls:
MyObject arrayofobjs[] = new MyObject[10];
You must now add actual MyObject objects to that array:
for (int i=0; i < arrayofobjs.length; i++) {
arrayofobjs[i] = new MyObject();
Java does not support multidimensional arrays as in C and C++. In Java, you must create arrays that contain other arrays.
Strings in C and C++ are arrays of characters, terminated by a null character ('\0'). To operate on and manage strings, you treat them as you would any other array, with all the inherent difficulties of keeping track of pointer arithmetic and being careful not to stray off the end of the array.
Strings in Java are objects, and all methods that operate on strings can treat the string as a complete entity. Strings are not terminated by a null, nor can you accidentally overstep the end of a string (like arrays, string boundaries are strictly enforced).
All memory management in Java is automatic; memory is allocated automatically when an object is created, and a run-time garbage collector (the "gc") frees that memory when the object is no longer in use. C's malloc() and free() functions do not exist in Java.
To "force" an object to be freed, remove all references to that object (assign all variables and array elements holding it to null). The next time the Java gc runs, that object is reclaimed.
As mentioned in the early part of this book, all Java primitive data types (char, int, long, and so on) have consistent sizes and behavior across platforms and operating systems. There are no unsigned data types as in C and C++ (except for char, which is a 16-bit unsigned integer).
The boolean primitive data type can have two values: true or false. Boolean is not an integer, nor can it be treated as one, although you can cast 0 or 1 (integers) to boolean types in Java.
Composite data types are accomplished in Java exclusively through the use of class definitions. The struct, union, and typedef keywords have all been removed in favor of classes.
Casting between data types is much more controlled in Java; automatic casting occurs only when there will be no loss of information. All other casts must be explicit. The primitive data types (int, float, long, char, boolean, and so on) cannot be cast to objects or vice versa; there are methods and special "wrapper" classes to convert values between objects and primitive types.
Operator precedence and association behaves as it does in C. Note, however, that the new keyword (for creating a new object) binds tighter than dot notation (.), which is different behavior from C++. In particular, note the following expression:
new foo().bar;
This expression operates as if it were written like this:
(new foo()).bar;
Operator overloading, as in C++, cannot be accomplished in Java. The , operator of C has been deleted.
The >>> operator produces an unsigned logical right shift (remember, there are no unsigned integer data types).
The + operator can be used to concatenate strings.
Although the if, while, for, and do statements in Java are syntactically the same as they are in C and C++, there is one significant difference. The test expression for each control flow construct must return an actual boolean value (true or false). In C and C++, the expression can return an integer.
Java does not support mechanisms for variable-length argument lists to functions as in C and C++. All method definitions must have a specific number of arguments.
Command-line arguments in Java behave differently from those in C and C++. The first element in the argument vector (argv[0]) in C and C++ is the name of the program itself; in Java, that first argument is the first of the additional arguments. In other words, in Java, argv[0] is argv[1] in C and C++; there is no way to get hold of the actual name of the Java program.
The following other minor differences from C and C++ exist in Java: