Chapter 51
Java versus C(++)

Square s1 = new Square (5);
Square s2 = new Square (10);
s2=s1;

As soon as you perform the final assignment, both s1 and s2 refer to the same object. There are no longer any references to the Square object that was created as Square(10). It is at that point that the object created as Square(10) will, in principle, be destroyed.

Why do I keep saying "in principle?" That's because Java uses a form of dynamic memory management known as garbage collection. This means that memory deallocation is done automatically by the Java garbage collector, rather than under the control of the programmer. Since the garbage collector usually runs in a separate thread, it would be more accurate to say that an object "is eligible for garbage collection" rather than to say that it is "destroyed." The distinction is really only academic, however; whether it is destroyed or just made ready for garbage collection, the reality is that the object can no longer be used in the program. For all practical purposes, that object has "ceased to exist."

NOTE: Although Java supports constructors, it doesn't support explicit destructors, as in C++. There is a finalize method, however, which you can override in your class definition, and which will be invoked when the object is garbage collected. Since the timing of garbage collection is not predictable, however, the finalize method is not as commonly used as a destructor is in C++.

Java References versus C++ Pointers

It has probably become clear to you in this section that much of the Java syntax for manipulating objects is very similar to that used in C++--right down to the use of the new operator to instantiate an object. But when using the new operator in C++ you are given an address of an object, which you can then assign to a pointer variable. In Java, the new operator returns an object reference to you that you can then assign to a reference variable.

Some people, especially those new to Java, feel that the use of references in Java is really the same as the use of pointers in C++--that it is the same construct with a different name. There is some truth to this, and if you are familiar with C++ syntax you will likely find the Java syntax quite easy to pick up. But there is an important difference. In Java all the memory management is done for you automatically, and you can never manipulate a memory address directly. Whether the Java interpreter uses pointers underneath it all to implement references isn't really important. What's important is that Java programs will, in this regard, be more stable and reliable than their C and C++ counterparts.

NOTE: C++ programmers will be familiar with this, which is a pointer variable containing the address of the object for which a method was invoked. In Java, you have this as well, only now it is a reference, instead of a pointer. Other than that, its meaning is the same.

Aggregates: Strings, Arrays, and Vectors

Like C and C++, Java provides a number of mechanisms for creating aggregates of values, whether those values be of primitive type or of a reference type. In this section you will look at the three most common aggregates in Java: strings, arrays, and vectors.

Strings

In Java, strings are handled much as they are in C++. The most significant exception is that once a String is declared, its contents may not be changed. To actually modify a String, you must create a StringBuffer object that can be initialized with a String and then modified. You can then create a new String with the contents of the StringBuffer. The following code fragment illustrates such a process:

//create the initial String object
String badString = new String("This is a String");
// create the StringBuffer that we can modify
StringBuffer correction = new StringBuffer(badString);
// make the modification to the StringBuffer object
correction.insert(12,=i=);
// create a new String object with the corrected contents
String goodString = new String(correction);

TIP: Java Strings, like many other Java objects, have known and dependable sizes. For a String object, the length method returns the length of the String as an int. It is not possible for Strings to "overflow" as it is in C and C++.

Arrays

Java arrays are very similar to C and C++ arrays: They are homogenous aggregates (that is, each element is of the same data type) and they have a fixed size. However, there are also some subtle differences.

Arrays of Primitive Types In Java, arrays are instances of a "hidden" array class-- hidden in the sense that there is no Array keyword to denote the class name. Nonetheless, arrays must be instantiated just as other objects must. The following example declares myArray to be an array of ints:

int[] myArray;

NOTE: In Java, the empty square brackets that indicate myArray are an array reference that can be placed just after the data type (as above), or can be placed after the variable name:

int myArray[];

Placing them immediately after the type name is the preferred Java style.

myArray = new int[10];

TIP: The size of a Java array is fixed at compile time, just as it is in C and C++. If you need to create a dynamically sized array, use a vector instead. As in C++, the two steps outlined above can be combined onto one statement, as follows:

int[] myArray = new int[10];

C and C++ programmers are used to being able to initialize arrays at the time they are declared, using syntax similar to the following:

// declaring and initializing a C array
int powers[3] = {3,9,27};

In such situations, the size of the array can be omitted; the compiler will determine the size of the array based on the number of initial values supplied.

The same syntax can be used in Java. The following example accomplishes three distinct tasks: it declares powers to be an array of ints, instantiates the array, and initializes each element in the array. The size of the array is taken from the number of initializers:

int[] powers = {3,9,27};

The empty square brackets are also used to denote an array when the array is being passed to a method as an argument. The following example shows an array of ints and an array of chars being accepted as arguments in a method definition:

public syntaxExample(int[]  thisInt,
char[] thisChar)
       {
// method body goes here
       }

Arrays of ReferencesAs in C and C++, it is also possible to have Java arrays of non-primitive types. In Java, such arrays are of reference types; that is, such an array will be an array of references. The basic syntax still holds. The following example creates an array of 31 Month references:

month[] year = new Month[12];

Once the line above has been executed, an array of 12 Month references will have been instantiated, and year will be a reference variable that refers to that array. But none of the 12 elements in the array yet refer to anything. You have instantiated the array, but you have not yet instantiated any of the 12 Months. If the Month class has a constructor that takes a String as an argument, you might go ahead and instantiate the elements of the array as follows:

year[0] = new Month ("January");
year[1] = new Month ("February");
year[2] = new Month ("March");
// ... and so on

NOTE: Java arrays, like their C and C++ counterparts, use only zero-origin subscripting. Thus an array of 12 elements will have valid subscripts from 0 to 11 inclusive.

TIP: Java arrays, like Java Strings, have fixed and dependable sizes. The Each array object has a length variable associated with it that contains the correct length of the array. In the above example, year.length would be 12.

Vectors

In C and C++, dynamic memory allocation under the control of the programmer is a time- honored tradition--unfortunately a tradition that has produced some pretty unstable code over the years. In Java such dynamic memory allocation is not directly possible. However, there are many situations in which a data structure of dynamic size is critical to the solution of the problem. In such situations, Java programmers can turn to the Vector class.

Java Vectors are like dynamically sized arrays. They consist of a dynamic number of references to Objects. References can be added to and removed from the Vector at will, using methods such as addElement and removeElement. Since all Java classes inherit from the Object class, it follows that the elements in a Java Vector can be references to any Java class.

NOTE: When a reference is retrieved from a Vector it will be of type Object. It must therefore be cast to be of the appropriate reference type before it can be used reliably.

NOTE: Each element in a Vector is numbered, with element numbers beginning at 0. This is consistent with the subscripting of Java arrays and with the use of arrays in C and C++.

TIP: Java Vectors, like Java arrays and strings, have dependable sizes. The size method in the Vector class returns the number of elements currently stored in the Vector.

The following code fragment shows a Vector of Months, very similar to the array of Months we had a few pages ago.

MonthVector = new Vector();
MonthVector.addElement (new Month ("January");
MonthVector.addElement (new Month ("February");
MonthVector.addElement (new Month ("March");
// and so on...

For more information on Vectors, take a look at Chapter 33, which covers the java.util package.

Class Hierarchies and Inheritance

Most Java programs, like most C++ programs, make extensive use of inheritance, in which one class is defined in terms of another. The new class, also called the derived class or the subclass, is said to inherit all the characteristics of the original class-- also called the base class or the superclass. When a base class itself inherits characteristics from another class, the result is said to be a class hierarchy. (For more on inheritance, see Chapter 5 on object-oriented programming.)

NOTE: In a class hierarchy, one class may be both a subclass of some class, and a superclass of another. This should not strike you as being strange: In real life, someone's parent is also someone else's child.

NOTE: In Java, all classes are subclasses of the Object base class and inherit all its characteristics.

The Syntax of Inheritance

The syntax for creating derived classes in Java is different from C++. When deriving a subclass from a superclass, Java uses the extends keyword in the new class's definition. The following example contrasts the syntax for both C++ and Java. In both cases, you are creating a class called CaptionedRectangle, which inherits from the Rectangle base class.

First, the C++ version:

class CaptionedRectangle : public Rectangle
       {
// definition of class here
       }

Now here's the Java equivalent:

class CaptionedRectangle extends Rectangle
       {
// definition of class here
       }

The instanceof Operator

The instanceof operator is a real bit of convenience. This operator takes two operands: a reference on the left and the name of a class on the right. The operator returns true if the object referred to by the reference is an instance of the class on the right, or of any of its subclasses. In the following example, you only want to invoke the checkInsurance method if obj refers to an object of the Vehicle class:

void quarterlyUpdates (Object obj)
       {
if ( obj instanceof Vehicle )
         {
obj.checkInsurance ();
         }
       }

NOTE: Since all classes are derived from Object, the expression (obj instanceof Object) will always return true.

Inheritance and Polymorphism

In Java, a variable declared to be of some class type can actually be used to refer to any object of that class or of any of its subclasses. Given the classes Rectangle and CaptionedRectangle above, you could have the following:

void updateScreen ( Rectangle r )
       {
r.display ();
       }

If r happens to refer to a Rectangle object, then the display method from the Rectangle class will be invoked (if there is one). If r refers to a CaptionedRectangle, then the display method of the CaptionedRectangle class will be invoked. This is the essence of polymorphism, a concept in object-oriented programming in which a single interface (in this case the display method) can actually have multiple implementations.

NOTE: C++ programmers will be familiar with this behavior. However, for a C++ class hierarchy to exhibit this behavior, the display method in the base class must be declared to be virtual. Java methods are all "virtual" in the C++ sense.

Interfaces versus Multiple Inheritance

In C++, one class may inherit the characteristics of multiple base classes--a concept known as multiple inheritance. A Java class, by contrast, may only inherit the characteristics of one base class. A Java class, however, may be said to implement a Java interface. For example, you might have the following:

class CaptionedRectangle
extends Rectangle
implements Displayable
       {
// class definition goes here
       }

A Java interface is similar to a class, but its data items are all static and final, and its methods are all abstract. Within the definition of the new class, each of the methods in the interface must be given actual definitions. The interface is really a form of guarantee: If a class is defined to implement an interface, it is a guarantee to the user of the class that each of the methods in the interface will be fully defined in the class. Interfaces are covered in depth in Chapter 12.

NOTE: The multiple inheritance mechanism in C++ has a number of subtle problem areas. As a result, the most reliable and common use of multiple inheritance in C++ programs is when there is one "primary" chain of inheritance, and any other classes used as base classes are collections of utility methods and constant values. It is this behavior that is formalized in the Java interface construct.

The super Reference

Just as you have a this reference, which refers to the object for which a method has been invoked, so too you have a super reference which refers to the this object's parent class. It can be used in situations when a method in the derived class needs to explicitly invoke a method from the superclass. Consider the following example of a display method defined within the captionedRectangle class:

void display ()
       {
System.out.println (this.caption);
super.display ();
       }

The super reference can also be used on the first line of a base class constructor method to explicitly invoke a superclass constructor. Once again, it is instructive to compare the C++ and Java equivalents here. The following is one possibility in C++ of a CaptionedRectangle constructor that takes five arguments: four that define the Rectangle, and one that defines the caption of the CaptionedRectangle:

// C++ constructor
CaptionedRectangle::CaptionedRectangle
( int x, int y, int width, int height, String caption ):
Rectangle ( x,y,width,height )
       {
// body of CaptionedRectangle constructor here
       }

The Java equivalent might be the following:

// Java constructor
CaptionedRectangle
( int x, int y, int width, int height, String caption )
       {
super ( x,y,width,height );
// balance of CaptionedRectangle constructor here
       }

No Scope Resolution Operator

Many C++ programmers will be alarmed to find that there is no scope resolution operator (the double colon ::) in Java. In fact there is no way in Java to elect to invoke a method from a specific class in a hierarchy.

TIP: If the method you wish to invoke is in the superclass, then the method can be invoked using the super reference.

NOTE: Many new Java programmers attempt to invoke a method from elsewhere in the hierarchy using multiple super's, something like super.super.display(). This is an interesting idea, but it's not Java!

Statements

By and large, Java supports the same control statements as C++, which in turn are pretty much the same as in the original C language. The areas of difference will be highlighted in this section.

See "Control Flow," Chapter 10

Loops

The loop statements in Java are virtually identical to their counterparts in C++. However, in Java it is possible to add a label to a loop. The label can then be used as an argument on a break or continue statement. Here is an example:

start:
for(int j=0;j<20;j++)
for(int k=0;k<20;k++)
for(int l=0;l<20;l++)
if ((j+k+l)==20) break start;

When the break statement is encountered in the if statement, the outermost loop will be broken. This is one effect that was very difficult to achieve in C or C++ without the use of goto.

NOTE: Because this was the one use of a goto that was generally accepted in practice, and because the goto is no longer required to achieve this effect, the goto statement has been eliminated from the Java syntax.

You will notice in the above example that the control variables (j, k, and l) are defined right in the for loop control statement. This is very convenient in those common situations where the control variable is only relevant within the loop and has no real meaning outside of the loop. This syntax is also legal in C++, but there is a subtle difference. In C++, the scope of the control variable begins with the for loop control statement but then continues to the end of the block. In Java, the scope of the control variable is only the body of the loop. The variable is undefined elsewhere in the block.

Conditionals

The explicit condition in the Java if statement, as well as the implicit conditions in the various Java loops, all require an expression that produces a Boolean value. This is not true in C or C++, where the expression can produce any value at all; a non-zero value is taken to be true, and a zero value is taken to be false. Thus a whole category of C and C++ errors is eliminated:

// The world's most common C error
// luckily enough, this will no longer compile in Java!
if ( x = 5 )
       {
       }

Synchronized Statements

With the addition of support for multithreading to the list of Java features comes a few problem areas. Specifically, you may have sections of code in which multiple threads might modify objects simultaneously, possibly corrupting the object. The synchronized statement deals with these critical sections by blocking the execution of code until exclusive access to the object can be acquired.

The syntax for the synchronized statement is:

synchronized (expression) statement

where the expression yields a reference to the object to be protected, and statement is a block of code to be executed once primary control of the object is acquired.

public swapFirstValues(int[] k)
       {
synchronized(k)
         {
int temp;
temp=k[0];
k[0]=k[1];
k[1]=temp;
         }
       }

CAUTION:
Do not use the synchronized statement if the object is never accessed by more than one thread, as it introduces needless processing overhead at runtime.

Operators and Expressions

The list of operators Java supports is almost identical to that of C++, as is the order of precedence and associativity of those operators (seeChapter 9). Here are the major differences:

• The instanceof operator has been added, as you've already seen.

See "The instanceof Operator" earlier in this chapter.

• The + operator can now be used with two String objects to concatenate them.
  
  
• The right shift operator (>>) now explicitly sign-extends the value, while the new logical right shift operator (>>>) populates vacant spaces with zero-bits.
  
  
• As you've seen, the relational and logical operators all produce Boolean results, and the logical operators only take Boolean operands.

See "Boolean Data Type," earlier in this chapter.

• The scope resolution operator has been removed.

See "No Scope Resolution Operator," earlier in this chapter.

• The comma operator has been removed.

NOTE: Although the comma has been removed, it can still be used within a for loop control statement to separate multiple control expressions, as in the following:

for (i=5,j=0; i>j; i--,j++)

Unlike in C++, Java operators may not be overloaded. This means that the meaning of an operator is fixed by the grammar of the language. Any special behavior that you wish to implement must be done by using an explicit method invocation.

Java expressions are evaluated in a much more predictable fashion than in C or C++. In any expression that involves one operator and two operands, the left operand is always evaluated first and the right operand is evaluated second. In method invocations, the argument list is evaluated strictly left-to-right.

Name Spaces

Name spaces essentially define the scope of a name or symbol --that portion of a program or collection of classes in which the name or symbol has meaning. More importantly, distinct name spaces protect variable and method names from conflicts--so-called name collisions.

The first and simplest difference between Java and C or C++ is that in Java programs there are no global variables or functions of any kind. This helps to keep name-space violations and conflicts to a minimum.

Java also incorporates the concept of packages to help you manage your name spaces. A package is a collection of classes. Each package has its own name space. In practice, this means that the name of a class is combined with its associated package to create a globally unique class name. And since method and variable names are managed locally within a class, the possibility of name collisions has essentially been eliminated.

See "Packages," Chapter 11

NOTE: Since the classes and methods of the Java API all belong to predefined packages, it is not possible for someone to create classes or methods that either deliberately or inadvertently conflict with system-supplied classes or methods. This is good both from the point-of-view of system security, as well as for protecting the user from programmer error.

Java was designed from the ground up to be Internet-enabled. Packages, and the name space protection that they provide, were necessary in order to provide robustness in the distributed Internet environment. But while packages may have been necessary because of the Internet, they have the added benefit of eliminating the name collisions that are possible with C and C++.