Java Gotchas

Java Gotchas

Java and C++ are similar in several ways, including syntax, primitive types, and operators. But unlike C++, which was layered on top of C, Java has no legacy capabilities to support. Thus Java is a much cleaner and simpler language than C++. Java supports primitive types, so it is not a pure object language, but otherwise Java is thoroughly object-oriented. Throw in Java's network orientation, and it becomes clear why Java is a perfect match for the multi-tiered, multi-server, component-oriented environment of the future.

Yet the simpler design of Java sometimes gets in the way. Certain aspects of the language are stumbling blocks to developers. These are traps in the language itself, regardless of the class libraries used.

This article will concentrate on aspects of the Java language that may be surprising and perplexing to developers coming from C++ or from any language.

These Java "Gotchas" are not suggestions for changes to the language. While these are certainly possible enhancements to Java, many of the aspects are inherent to the basic design of the language. Changing them would do severe damage to Java.

Interfaces Interfaces are essential to the Java language. They provide for multiple inheritance as well as information hiding and code re-use. Interfaces are similar to abstract classes but have important restrictions:

All method definitions in an interface are implicitly abstract and have no implementation body. An abstract class can declare both abstract and non-abstract methods. The non-abstract methods are for common code shared by derived classes. Because all methods declared in an interface are abstract, each class that implements an interface must declare bodies for the methods of the interface. There can be no sharing of code between derived classes. Classes implementing an interface must duplicate any common code.

Interfaces cannot directly model classes because they do not allow field variables. An interface may declare static final variables, but those are effectively constants, not variables. Abstract classes can declare field variables. Interfaces, on the other hand, can only support variables indirectly. Interfaces emulate field variables using wrapper methods for getting and setting the variables. Classes implementing an interface must include duplicate versions of the variable wrappers.

Read full article from Java Gotchas