Reviews : Java Books :
Beginning Java Objects : Chapters 2 and 3

Buy this book Title: Beginning Java Objects ISBN: 1861004176 US Price: $ 39.99 Canadian Price: C$ 59.95 UK Price: £ 28.99 Publication Date: November 2000 Pages: 800 © Wrox Press Limited, US and UK.

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.

How to Add Java Applets to Your Site

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.