Beginning Java Objects: Chapter 3
Objects and Classes
Instantiating Objects: A Closer Look
Different OO languages differ in terms of when an object is actually conceived. In Java, when we
declare a variable to be of a user-defined type, like:
Student y;
we haven't actually created an object in memory yet. Reference variable 'y' merely has the potential to
be a reference to a Student object, but, until we initialize y by assigning it a specific object to refer to,
y is said to have the value null, which as we learned in Chapter 1 is a reserved word in the Java
language. We have to take the distinct step of using a special Java operator, the new operator, to
actually carve out a brand new object in memory, as follows:
y = new Student();
(Don't worry about the parentheses at the end of this statement; we'll talk about their significance in
Chapter 4.)
Think of the newly created object as a helium balloon, and a reference variable as the string that allows
us to hold onto and access (reference) the object whenever we'd like.
Because a reference variable is said to 'hold onto' an object, we often use the informal term handle as a
synonym to the term 'reference'.
We could also create a new object without immediately assigning it to a reference variable, as in the
following line of code:
new Student();
but such an object would be like a helium balloon whose string had been let go: it would indeed exist, but
we'd never be able to access this object in our program. It would in essence, 'float away' from us in memory.
Note that we can combine the two steps — declaring a reference variable and actually instantiating an
object for that variable to refer to — into a single line of code:
Student y = new Student();
Another way to initialize a reference variable is to hand it a preexisting object:
that is, an object ('helium balloon') whose handle ('string') is already being held by
some other reference variable. Let's look at an example:
// We instantiate our first Student object.
Student x = new Student();
// We declare a second reference, but do not instantiate a second object.
Student y;
// We pass y a 'handle' on the same object that x is holding
// (x continues to hold onto it, too). We now, in essence,
// have two 'strings' tied to the same 'balloon'.
y = x;
The conceptual outcome of the preceding code is illustrated below: two 'strings' tied to the same
'balloon' — that is, two reference variables referencing the same object.
We therefore see that the same object can have many reference variables holding onto it; but, as it turns
out, any one reference variable can only hold onto one object at a time. To grab onto a new object
handle means that a reference variable must let go of the old object handle that it was previously
holding onto, if any.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
