Programming with Objects

Most of what you have studied about object-oriented programming so far has centered on subclasses. A subclass takes on the properties and behaviors of an existing class, and it can change those inherited behaviors or add new ones of its own. This article looks at a side of the same system that you may not have noticed yet. Every class in Java, with one exception, already sits underneath some other class. The class that makes this possible is named Object.

Object is a special class in the package java.lang, and it is the one class in Java that is not a subclass of any other class. Keep this single exception in mind, because it explains almost everything else in this article. As you read, ask yourself a simple question about each class you meet: what is its parent? By the end, you should be able to answer that question for any class, including classes that never mention a parent at all.

Start with any class and follow its parent, then that parent's parent, and so on. Each step moves one level up the class structure. The source describes this as a chain of parents. The chain can be one step long, as with a class that has no explicit parent, or several steps long, as with a class that inherits from a class that itself inherits from another. In every case, the chain stops at the same place.

The rule for a class with no explicit parent is the first thing to learn. A class that does not state an extends clause automatically becomes a subclass of Object. Trace a small example with three classes. Animal has no extends clause, so its parent is Object. Dog is written to extend Animal, so its parent is Animal. Car has no extends clause either, so its parent is Object. Follow any arrow upward and you reach Object.

Read the diagram from the bottom up. Dog reaches Object through Animal. Because Animal is a subclass of Object, and Dog is a subclass of Animal, the rule that a subclass inherits from its parent applies at each step. The source does not walk through this exact example, but the result follows directly from its statements: every class except Object is a subclass of some other class, and a class with no explicit parent defaults to Object.

Because every other class is a subclass of some class, and every class's chain of superclasses must end somewhere, the chain always terminates at Object. This is why the source describes Object as the root of the whole class structure. You can think of the class structure as a tree that grows downward from Object: every chain of parents, followed upward from any class you write, eventually reaches Object. Object is the one node in the tree that has no parent of its own.

Because every class is a subclass of Object, a variable whose type is Object can refer to an object of any class you write. The idea is that the Object type sits above every class in the structure, so a reference typed as Object has a place for any of them. The short example below illustrates this relationship. It was written for this article to show the rule, and it is not taken from the source.

Notice what the variables a, b, and c have in common. Their declared type is Object, yet each holds an object whose class you wrote yourself. The Object type is the common ground that all three classes share, which is exactly what the chain of parents predicts. Reading the code this way lets you see that the class structure, not any single class, is what makes this assignment possible.

The second major fact in this section concerns behavior rather than structure. Class Object defines several instance methods. Because every other class is a subclass of Object, every other class inherits those methods. The source states that these methods can be used with any object whatsoever. That phrase matters: you do not need to write any special code inside a class for its objects to have access to the methods defined in Object.

The diagram shows the key idea. The methods are written once, in Object, and they flow downward to every class beneath it. Animal and Car each inherit them directly. Dog inherits them through Animal, because Dog is a subclass of Animal and Animal is a subclass of Object. Your classes do not need to repeat these methods, and they do not need to declare any special support for them. Inheritance supplies the methods automatically, which is why they are available on objects of any class.