Constructors
B.Bhuvaneswaran
Assistant Professor (SS)
Department of Computer Science & Engineering
Rajalakshmi Engineering College
Thandalam
Chennai 602 105
bhuvaneswaran@rajalakshmi.edu.in
Constructors
It can be tedious to initialize all of the
variables in a class each time an instance
is created.
Java allows objects to initialize themselves
when they are created.
This automatic initialization is performed
through the use of a constructor.
B.Bhuvaneswaran / AP (SS) / CSE / REC
A constructor initializes an object immediately upon
creation.
It has the same name as the class in which it resides and is
syntactically similar to a method.
Once defined, the constructor is automatically called
immediately after the object is created, before the new
operator completes.
Constructors look a little strange because they have no
return type, not even void.
This is because the implicit return type of a class
constructor is the class type itself.
It is the constructors job to initialize the internal state of
an object so that the code creating an instance will have a
fully initialized, usable object immediately.
B.Bhuvaneswaran / AP (SS) / CSE / REC
You can rework the Box example so that
the dimensions of a box are automatically
initialized when an object is constructed.
To do so, replace setDim( ) with a
constructor.
Lets begin by defining a simple
constructor that simply sets the
dimensions of each box to the same
values.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
B.Bhuvaneswaran / AP (SS) / CSE / REC
Output
Constructing Box
Constructing Box
Volume is 1000.0
Volume is 1000.0
B.Bhuvaneswaran / AP (SS) / CSE / REC
Both mybox1 and mybox2 were initialized by the
Box( ) constructor when they were created.
Since the constructor gives all boxes the same
dimensions, 10 by 10 by 10, both mybox1 and
mybox2 will have the same volume.
The println( ) statement inside Box( )is for the
sake of illustration only.
Most constructors will not display anything.
They will simply initialize an object.
B.Bhuvaneswaran / AP (SS) / CSE / REC
In the line
Box mybox1 = new Box();
new Box( ) is calling the Box( ) constructor.
When you do not explicitly define a constructor for a class,
then Java creates a default constructor for the class.
This is why the preceding line of code worked in earlier
versions of Box that did not define a constructor.
The default constructor automatically initializes all instance
variables to zero.
The default constructor is often sufficient for simple classes,
but it usually wont do for more sophisticated ones.
Once you define your own constructor, the default
constructor is no longer used.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Parameterized Constructors
While the Box( ) constructor in the
preceding example does initialize a Box
object, it is not very usefulall boxes
have the same dimensions.
What is needed is a way to construct Box
objects of various dimensions.
The easy solution is to add parameters to
the constructor.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Program
B.Bhuvaneswaran / AP (SS) / CSE / REC
Output
Volume is 3000.0
Volume is 162.0
B.Bhuvaneswaran / AP (SS) / CSE / REC
Each object is initialized as specified in the
parameters to its constructor.
For example, in the following line,
Box mybox1 = new Box(10, 20, 15);
the values 10, 20, and 15 are passed to
the Box( ) constructor when new creates
the object.
Thus, mybox1s copy of width, height,
anddepth will contain the values 10, 20,
and 15, respectively.
B.Bhuvaneswaran / AP (SS) / CSE / REC
The this Keyword
Sometimes a method will need to refer to the
object that invoked it.
To allow this, Java defines the this keyword.
this can be used inside any method to refer to
the current object.
That is, this is always a reference to the object
on which the method was invoked.
You can use this anywhere a reference to an
object of the current class type is permitted.
B.Bhuvaneswaran / AP (SS) / CSE / REC
To better understand what this refers to,
consider the following version of Box( ):
// A redundant use of this.
Box(double w, double h, double d) {
this.width = w;
this.height = h;
this.depth = d;
}
B.Bhuvaneswaran / AP (SS) / CSE / REC
This version of Box( ) operates exactly like
the earlier version.
The use of this is redundant, but perfectly
correct.
Inside Box( ), this will always refer to the
invoking object.
While it is redundant in this case, this is
useful in other contexts.
B.Bhuvaneswaran / AP (SS) / CSE / REC
Instance Variable Hiding
As you know, it is illegal in Java to declare
two local variables with the same name
inside the same or enclosing scopes.
Interestingly, you can have local
variables, including formal parameters to
methods, which overlap with the names of
the class instance variables.
However, when a local variable has the
same name as an instance variable, the
local variable hides the instance variable.
B.Bhuvaneswaran / AP (SS) / CSE / REC
This is why width, height, and depth were not
used as the names of the parameters to the Box(
) constructor inside the Box class.
If they had been, then width, for example, would
have referred to the formal parameter, hiding the
instance variable width.
While it is usually easier to simply use different
names, there is another way around this
situation.
Because this lets you refer directly to the object,
you can use it to resolve any namespace
collisions that might occur between instance
variables and local variables.
B.Bhuvaneswaran / AP (SS) / CSE / REC
For example, here is another version of Box( ),
which uses width, height, and depth for
parameter names and then uses this to access
the instance variables by the same name:
// Use this to resolve name-space collisions.
Box(double width, double height, double depth) {
this.width = width;
this.height = height;
this.depth = depth;
}
B.Bhuvaneswaran / AP (SS) / CSE / REC
Caution
The use of this in such a context can sometimes
be confusing, and some programmers are careful
not to use local variables and formal parameter
names that hide instance variables.
Of course, other programmers believe the
contrarythat it is a good convention to use the
same names for clarity, and use this to overcome
the instance variable hiding.
It is a matter of taste which approach you adopt.
B.Bhuvaneswaran / AP (SS) / CSE / REC
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
The finalize( ) Method
Sometimes an object will need to perform some
action when it is destroyed.
For example, if an object is holding some nonJava resource such as a file handle or 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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
The finalize( ) method has this general
form:
protected void finalize( )
{
// finalization code here
}
The keyword protected is a specifier that
prevents access to finalize( ) by code
defined outside its class.
B.Bhuvaneswaran / AP (SS) / CSE / REC
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
whenor even iffinalize( ) 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.
B.Bhuvaneswaran / AP (SS) / CSE / REC
B.Bhuvaneswaran / AP (SS) / CSE / REC
References
Herbert Schildt, Java The Complete
Reference, 8th Edition, Oracle Press,
2011.
B.Bhuvaneswaran / AP (SS) / CSE / REC
B.Bhuvaneswaran / AP (SS) / CSE / REC
