#

| Chapter 3 Classes and Objects in Java |

## 3.10 C++ Features Not Found in Java

Throughout this chapter, we've noted similarities and differences between Java and C++ in footnotes. Java shares enough concepts and features with C++ to make it an easy language for C++ programmers to pick up. There are several features of C++ that have no parallel in Java, however. In general, Java does not adopt those features of C++ that make the language significantly more complicated. These omissions from Java (or simplifications of C++) are described below.

C++ supports "multiple inheritance" of method implementations from more than one superclass at a time. While this seems like a very useful feature, adding it to the language actually turns out to introduce many complexities. The Java language designers chose to avoid the added complexity by using interfaces instead. Thus, a class in Java can only inherit method implementations from a single superclass, but it can inherit method declarations from any number of interfaces. In practice, this is not any particular hardship.

C++ supports (though not yet in a very standardized way) templates that allow you, for example, to implement a `Stack` class and then instantiate it as `Stack<int>` or `Stack<double>` to produce two separate types: a stack of integers and a stack of floating-point values. Java has no such facility. However, the fact that every class in Java is a subclass of `Object` means that every object can be cast to an instance of `Object`. Thus, in Java, it is often sufficient to define a data structure (such as a `Stack` class) that operates on `Object` values--the objects can be cast back to their actual type whenever necessary.

C++ allows you to define operators that perform arbitrary operations on instances of your classes. In effect, it allows you to extend the syntax of the language. This is a nifty feature, called operator overloading, that makes for very elegant examples. In practice, however, it tends to make code hard to understand. After much debate, the Java language designers decided to omit such "operator overloading" from the language. Note, though, that the use of the `+` operator for string concatenation in Java is at least reminiscent of operator overloading.

C++ allows you to define "conversion functions" for a class that automatically invoke an appropriate constructor method when a value is assigned to a variable of that class. This is simply a syntactic shortcut (similar to overriding the assignment operator) and is not included in Java.

In C++, objects are by default manipulated by value; you must use `&` to specify a variable or function argument that is automatically manipulated by reference. In Java, all objects are manipulated by reference, so there is no need for this `&` syntax.

Abstract Classes and Interfaces |  | Summary