C++ vs Java -- an example

C++	Java	Comments
// ISLList.cpp // Roberto Ordonez	// ISLList.java // Roberto Ordonez	Files should be named mainClassName.java Comments look exactly the same (except for javadoc comments: /** */)
#include <iostream.h>		No header (.h) files to #include in Java--the compiler finds the necessary classes automatically All java.lang.* classes are automatically imported (available for use without full package name)
template <class T>		No need to use templates--since all classes are derived from Object, a reference to an Object can hold a reference to any subclass, i.e., any object
class ISLNode {	class ISLNode {	Class declarations look almost identical
public:		No public/protected/private sections in Java--instead, each member is given a specific access level
T *data;	public Object data;	Instead of a pointer to a template class, use a reference to a (generalized) Object
ISLNode<T> *next;	public ISLNode next;	No pointers--variables of class type are always references to (dynamically allocated) objects in Java
ISLNode() { data = next = NULL; }	ISLNode() { data = next = null; }	The value null (which must be lowercase) is actually part of the Java language; in C++ it's only a #defined constant (that is why we have to #include <iostream.h>); also, in Java, methods must be defined within the class definition (you cannot have separate .h and .cpp files as in C++)
};	}	No semicolon after class declarations in Java
template <class T>
class ISLList	public class ISLList	Classes have access specifiers (for access level within/outside the package) in Java (note that a public class must be in a file called className.java)
{ protected: ISLNode<T> head, curr;	{ protected ISLNode head, curr;	Remember that variables of class types are actually references (like C++ pointers without the messy pointer notation)
public: ISLList(): head(NULL), curr(NULL) { }	public ISLList() { head = curr = null; }	There is no special "constructor notation" in Java, since object are never constructed without an explicit call to a constructor
ISLList<T>& operator<<=(T * newData) { ISLNode<T> prev1, curr1,	public ISLList insertBefore(Object newData) { ISLNode prev1, curr1,	No operator overloading in Java--you must use member functions instead
new1 = new ISLNode<T> ;	new1 = new ISLNode();	Calls to constructors always require ()
new1->data = newData;	new1.data = newData;	No messy pointer notation--you always use the dot operator!
if (!head) head = new1; else { prev1 = NULL; curr1 = head; while (curr1 != curr) { prev1 = curr1; curr1 = curr1->next; } if (prev1) prev1->next = new1; else head = new1; new1->next = curr; } curr = new1;	if (head == null) head = new1; else { prev1 = null; curr1 = head; while (curr1 != curr) { prev1 = curr1; curr1 = curr1.next; } if (prev1 != null) prev1.next = new1; else head = new1; new1.next = curr; } curr = new1;	Java has a boolean type (with values true and false) which must be used in conditionals like if and while (you cannot simply use an integer as in the bolded C++ statements)
return *this; } };	return this; } }	No need to dereference pointers (ever)!

A few other important differences that are not immediately obvious from this example:

There are no structs, unions or enums (but structs and enums can be mimicked by classes with all data elements public and no methods, classes with no methods and all data alements public, static and final, respectively). There is no trivial way to provide the functionality of unions, but it would violate typesafety anyway.
No consts (but final means basically the same thing).
cin and cout are approxiamtely equivalent to System.in and System.out, although the Java equivalents provide significantly less functionality for various reasons.
There is no preprocessor (and therefore no #include, #define and #if directives)--Java has other ways to do this, all of which are more elegant as a whole.
The sizes of all primitive data types are strictly defined in Java (as opposed to the platform-dependent sizing in C++):

byte = 8 bits
char = 16 bits (Unicode)
short = 16 bits
int = 32 bits
long = 64 bits
boolean = 1 bit (but wastes 7 others)
float = 32 bits
double = 64 bits

Strings and arrays are both native data types (actually, classes), and both have reliable sizes. Arrays must, however, still be statically sized (but the Vector class provides dynamic sizing). (Note that you cannot declare an object of type Array--there is no such class--but the compiler knows how to use it anyway).
Since object "variables" are nothing more than references, assigning the value of one to another simply copies a reference--it does not create a new copy of the object. Most objects can be cloned (via the clone() method--those that can be cloned implement the Cloneable interface), but this must be done explicitly.
Passing to methods is done "by value" of primitive types and "by reference" for objects.
Since many classes (especially containers) require objects as parameters, there are wrapper classes for each of the primitive types (Byte, Integer, etc.)
All objects can give a string representation of themselves via the toString() method (defined in the Object class and therefore available in all classes). However, graphcial objects, containers and other objects which have no simple string representation may return a seemingly nonsensical string.
Objects are destroyed automatically (they are "garbage collected" by a low-priority thread that runs constantly in every Java program). Destructors are therefore usually not necessary, although there is a finalize() method that is invoked when the object is about to be garbage collected.
The instanceof operator allows you to test whether an object is an instance of any particular class, as in the following example:

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

Inheritance works much the same (although no multiple inheritance is allowed--see the section on interfaces), but the syntax is different: instead of class CaptionedRectangle: public Rectangle, Java uses the keyword extends: class CaptionedRectangle extends Rectangle
All Java methods are "virtual" in the C++ sense.
Although multiple inheritance is disallowed, a class may choose to implement multiple interfaces (which are similar to classes, but all their data items must be static and final, and all their methods are abstract, i.e., declared but not defined). For example: class CaptionedRectangle extends Rectangle implements Displayable
Every object has a super reference, which refers to the class directly above it in the hierarchy. However, you may not use super.super!
There is not scope resolution operator (::) in Java. In fact, there is no way in Java to elect to invoke a method from a specific class in a hierarchy.
Loops may be labeled (start: for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) if (i+j == 20) break start;), basically eliminating any need for a goto statement.
Since Java supports multithreading, the problem of two methods accessing the same object simultaneously arises. The synchronized statement deals with this problem effectively.