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.
NOTE If you are familiar with C++, then you know that C++ allows you to define a destructor for
OTE
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.
A Stack Class
While the Box class is useful to illustrate the essential elements of a class, it is of little practical
value. To show the real power of classes, this chapter will conclude with a more sophisticated
example. As you recall from the discussion of object-oriented programming (OOP) presented in
Chapter 2, one of OOP's most important benefits is the encapsulation of data and the code that
manipulates that data. As you have seen, the class is the mechanism by which encapsulation
is achieved in Java. By creating a class, you are creating a new data type that defines both the
nature of the data being manipulated and the routines used to manipulate it. Further, the
methods define a consistent and controlled interface to the class' data. Thus, you can use
the class through its methods without having to worry about the details of its implementation
or how the data is actually managed within the class. In a sense, a class is like a "data engine."
No knowledge of what goes on inside the engine is required to use the engine through its
controls. In fact, since the details are hidden, its inner workings can be changed as needed.
As long as your code uses the class through its methods, internal details can change without
causing side effects outside the class.
Search WWH :
