We will progress through the similarities between the C++ and Java languages by discussing the basics and then moving on to the more advanced features of the Java language

The Java programming language supports comment characters of C++: both the block sequence /* */ and the single line comment pair // characters are supported by Java.

In Java, comments have an added benefit. By using special character tokens in your source files and the javadoc utility program, you can produce documentation for your source files. A documenting comment must begin with the character sequence /** and must end with the sequence */. Special document keywords, preceded with the @ symbol, are used to specify comment sections. You can also imbed HTML tags within the document block. The following example demonstrates the document commenting feature:

/**
* sleepMethod - sleeps a specified number of milliseconds
* @param long millis - milliseconds to sleep
* @return void * @exception IOException
* @author: Some Java Developer
* @version: 1.0  */
public void sleepMethod( ) thows IOException
{
//...
}
You execute the javadoc utility program, specifying one or more source files to parse. The javadoc utility outputs HTML files containing documentation for the parsed source files. This documentation can then be viewed using a Web browser.

Java divides data types into two distinct categories: primitive types and reference types. Java has no struct or union types—these are replaced by classes. More important to C++ programmers, Java has no pointers. All nonprimitive types are passed by reference; Java takes care of the garbage collection (cleaning up memory) for you 

The boolean data type supported by Java is a true Boolean, not just an integral type. The only two values that can be stored to and retrieved from a boolean are true and false. The result of a conditional expression must be Boolean and not integral. The following code snippet shows legal and illegal uses of the boolean type:

boolean result = false ; // okay, default is false
int value = result ; // wrong! Java doesn’t allow
this. value = 1 ; // okay
result = value ; // sorry, can’t do this either! You cannot coerce the conversion using an explicit cast, as in this example:
result = (boolean)value ;// this will not work either.

import java.io.* ;
public class Test
{
public static void main( String args[] )
{
int anInt = 10 ;
System.out.println( “anInt before is:” + anInt ) ;
anInt = anInt >>> 1 ;
System.out.println( “anInt after is:” + anInt ) ;
}
}

The output from this application is shown here:

anInt before is: 10
anInt after is: 5

All the statements used to control the flow of a C++ application are also provided for in Java. For decision making, you have the if-else and switch-case statements; for looping, you have for, while, and do-while; for exception handling, there is try-catchfinally and throw; and finally, in the miscellaneous category, you have break, continue, label:, and return. Exception handling is discussed later in this chapter. The keyword goto is reserved, but is not supported by the Java language. You should also be aware that the result of a control flow expression must be Boolean

Another distinction between Java and C++ is that the const keyword is not applied to method parameters. The const keyword (or some variation of it) is not required in Java because Java uses pass-by-value for primitive type arguments to a method. This means that you cannot change the value of the object argument. Within the member function, you operate on a copy of the original object, not the actual object referred to by the argument. In Java, if you pass an object (nonprimitive), a reference is passed, not the object itself. You cannot change the reference passed in, but you can access the actual object’s public methods and instance variables. T
Example:
import java.io.* ;
public class Goofy
{
public Goofy( )
{
/* ... */
}
public void doubleArg( int value )
{
value *= 2 ;
}
static public void main( String arg[] )
{

int theValue = 5 ;
System.out.println(“1. theValue is: “ + theValue ) ;
Goofy g = new Goofy( ) ;
g.doubleArg( theValue ) ;
System.out.println(“2. theValue is: “ + theValue ) ;

}
}
The output of this application is as follows:
1. theValue is: 5
2. theValue is: 5
This code demonstrates that the member function doubleArg() merely gets a copy of, not a reference to, the original object theValue. If you pass a reference to the member function, you actually operate on the referenced-to object.

import java.io.* ;
public class Int
{ // this class will need to be in it’s own file
public Int() { /* ... */ }
public int intValue = 5 ;
}
public class Goofy
{
public Goofy( ) { /* ... */ }
public void doubleArg( Int value ) { value.intValue *= 2 ; }
static public void main( String arg[] )
{
Int theValue = new Int( ) ;
System.out.println(“1. theValue is: “ + theValue.intValue ) ;
Goofy g = new Goofy( ) ;
g.doubleArg( theValue ) ;
System.out.println(“2. theValue is: “ + theValue.intValue ) ;
}
}

The output from this application is shown here:
1. theValue is: 5
2. theValue is: 10
One last note in closing: Arrays are first-class objects in Java. In the previous example, if
theValue was an array of int, then the member function doubleArg() would change the
actual passed-to argument.

In C++, the enum keyword is available to specify an entity that contains enumerated values.
Java does not offer the enum keyword, but you can simulate enum by creating a class
that only contains instance variables that are static final. By declaring the instance
variables as static final, you are, in effect, defining the variables as constant. The following
example demonstrates a simulated enum in Java:

public class DrawingColor
{
public static final int red = 1;
public static final int yellow = 2;
public static final int green = 3;
}
//...
pen.color( DrawingColor.red ) ;
//...

There is a drawback to the C++ (and C) enum: Each member of an enum must have a
unique name with respect to other enums and variables. Consider the previous example’s
equivalent declaration in C++. If you had an additional enum named WindowColor that
contained member variables named red, yellow, and green, you would have a name
clash. This sort of problem does not happen in Java

Arrays in Java are considered first-class objects. You access the elements of a Java array in the same way you access the elements of a C++ array: You use array indexing. Java offers runtime array-bounds checking. Java arrays contain an instance variable named length that holds the number of elements (depending on the context) of the named array. The placement of the brackets can be on the left or right side of the array name. In Java, you cannot specify the array dimension at the point of declaration as you can in C++. Arrays in Java must be allocated using new. Let’s look at an example of declaring
and using a Java array:

#1: int array1[] ; // brackets on right
#2: int [] array2 ; // brackets on left, both are okay
#3: int array3[10] ; // ERROR, can’t specify dimension!
#4: Object [] array3 = new Object[10] ;
#5: array1 = new int[10] ;
#6: array2 = new int[10] ;
#7: array1[1] = 5 ;
#8: array1[12] = 5 ; // ERROR, beyond boundaries
#9: for( int i = 0; i < array1.length; i++ )
#10: array1[i] = i ;

The first two statements merely declare a reference to an int array; we have not yet defined the dimension of the two arrays. The third line produces a compiletime error. Line 4 allocates an array of 10 Objects, and array3 is the named reference to those objects. Lines 5 and 6 allocate 10 ints and bind them to the array names. An assignment happens on line 7: The value 5 is assigned to the second element of array1. Line 8 is interesting because, although the compiler allows the statement, you get a runtime diagnostic: java.lang.ArrayIndexOutOfBoundsException. Finally, line 9 uses the lengthmember variable of array1 to determine the upper bound.