Object Construction, Page 3
How the Superclass Is Constructed
When using inheritance, you must know how the parent class is constructed. Remember that when you use inheritance, you are inheriting everything about the parent. Thus, you must become intimately aware of all the parent's data and behavior. The inheritance of an attribute is fairly obvious.
However, how a constructor is inherited is not as obvious. After the new keyword is encountered and the object is allocated, the following steps occur (see Figure 4):
- The first thing that happens inside the constructor is that the constructor of the class's superclass is called.
- Then, each class attribute of the object is initialized. These are the attributes that are part of the class definition (instance variables), not the attributes inside the constructor or any other method (local variables). In the DataBaseReader code presented earlier, the integer startPosition is an instance variable of the class.
- Then, the rest of the code in the constructor executes.
Figure 4 Constructing an object.
The Design of Constructors
When designing a class, it is good practice to initialize all the attributes. In some languages, the compiler might attempt to do this initialization. As always, don't count on the compiler to initialize attributes! In Java, you cannot use an attribute until it is initialized. If the attribute is first set in the code, make sure that you initialize the attribute to some valid condition—for example, set an integer to zero.
Constructors are used to ensure that the application is in a stable state. For example, initializing an attribute to zero, when it is intended for use as a denominator in a division operation, may lead to an unstable application. You must take into consideration the fact that a division by zero is an illegal operation.
During the design, it is good practice to identify a stable state for all attributes and then initialize them to this stable state in the constructor.
This article started a discussion about constructing objects. You covered some of the technical aspects of actually using constructors. Constructing objects properly is a very important object-oriented responsibility. These responsibilities include appropriate memory management as well as putting an object in a safe-state by performing actions like initialization. Next month, you will explore object construction in more detail and see how certain design issues, such as inheritance, impact object constructors.
- Meyers, Scott: Effective C++. Addison-Wesley, 1992.
- Tyma, Paul, Gabriel Torok and Troy Downing: Java Primer Plus. The Waite Group, 1996.
- Ambler, Scott: The Object Primer. Cambridge University Press, 1998.
- Jaworski, Jamie: Java 1.1 Developers Guide. Sams Publishing, 1997.
Gilbert, Stephen, and Bill McCarty: Object-Oriented Design in Java. The Waite Group, 1998.
About the Author
Matt Weisfeld is a faculty member at Cuyahoga Community College (Tri-C) in Cleveland, Ohio. Matt is a member of the Information Technology department, teaching programming languages such as C++, Java, and C# .NET as well as various web technologies. Prior to joining Tri-C, Matt spent 20 years in the information technology industry gaining experience in software development, project management, business development, corporate training, and part-time teaching. Matt holds an MS in computer science and an MBA in project management. Besides the first edition of The Object-Oriented Thought Process, Matt has published two other computer books, and more than a dozen articles in magazines and journals such as Dr. Dobb's Journal, The C/C++ Users Journal, Software Development Magazine, Java Report, and the international journal Project Management. Matt has presented at conferences throughout the United States and Canada.