Object references in java

Those readers familiar with C/C++ have probably noticed that object references appear
to be similar to pointers. This suspicion is, essentially, correct. An object reference is
similar to a memory pointer. The main difference—and the key to Java’s safety—is that
you cannot manipulate references as you can actual pointers. Thus, you cannot cause an
object reference to point to an arbitrary memory location or manipulate it like an integer.



The new operator dynamically allocates memory for an object. It has
this general form:
class-var = new classname( );
Here, class-var is a variable of the class type being created. The classname is the name of
the class that is being instantiated. The class name followed by parentheses specifies the
constructor for the class.

Assigning Object Reference Variables

Box b1 = new Box();
Box b2 = b1;



b1 and b2 will

both refer to the same object.

Box b1 = new Box();
Box b2 = b1;
// ...
b1 = null;
Here, b1 has been set to null, but b2 still points to the original object.
Note : When you assign one object reference variable to another object reference variable, you
are not creating a copy of the object, you are only making a copy of the reference.

this - same as cpp



Garbage Collection
Since objects are dynamically allocated by using the new operator, you might be
wondering how such objects are destroyed and their memory released for later
reallocation. In some languages, such as C++, dynamically allocated objects must
be manually released by use of a delete operator. Java takes a different approach; it
handles deallocation for you automatically. The technique that accomplishes this is
called garbage collection. It works like this: when no references to an object exist, that
object is assumed to be no longer needed, and the memory occupied by the object can
be reclaimed. There is no explicit need to destroy objects as in C++. Garbage collection
only occurs sporadically (if at all) during the execution of your program. It will not
occur simply because one or more objects exist that are no longer used. Furthermore,
different Java run-time implementations will take varying approaches to garbage
collection, but for the most part, you should not have to think about it while writing
your programs.







The finalize( ) Method
Sometimes an object will need to perform some action when it is destroyed. For
example, if an object is holding some non-Java resource such as a file handle or
window character font, then you might want to make sure these resources are freed
before an object is destroyed. To handle such situations, Java provides a mechanism

called finalization. By using finalization, you can define specific actions that will occur
when an object is just about to be reclaimed by the garbage collector.

To add a finalizer to a class, you simply define the finalize( ) method. The Java run
time calls that method whenever it is about to recycle an object of that class. Inside the
finalize( ) method you will specify those actions that must be performed before an
object is destroyed. The garbage collector runs periodically, checking for objects that
are no longer referenced by any running state or indirectly through other referenced
objects. Right before an asset is freed, the Java run time calls the finalize( ) method on
the object.
The finalize( ) method has this general form:
protected void finalize( )
{
// finalization code here
}
Here, the keyword protected is a specifier that prevents access to finalize( ) by code
defined outside its class. This and the other access specifiers are explained in Chapter 7.
It is important to understand that finalize( ) is only called just prior to garbage
collection. It is not called when an object goes out-of-scope, for example. This means
that you cannot know when—or even if—finalize( ) will be executed. Therefore, your
program should provide other means of releasing system resources, etc., used by the
object. It must not rely on finalize( ) for normal program operation.
If you are familiar with C++, then you know that C++ allows you to define a destructor
for a class, which is called when an object goes out-of-scope. Java does not support this
idea or provide for destructors. The finalize( ) method only approximates the function
of a destructor. As you get more experienced with Java, you will see that the need for
destructor functions is minimal because of Java’s garbage collection subsystem.