The new
operator creates an instance of a class as in, for example,
...
int i = 4;
Test test = new Test(i);
...
The statement declares a variable of the Test
type and creates an instance of the class with the new
operator. The argument of new
must correspond to a special method in the class called a constructor.
The constructor signature looks similar to that of a regular method.
It has a name that matches the class name and holds a list of arguments
in parenthesis. However, a constructor has no return type. Instead,
an instance of the class type itself returns.
Constructors are useful for initializing values and invoking any
methods needed for initialization.
The code here shows a simple class with a constructor and one method.
class
Test
{
int i;
Test(int j)
{
i = j;
}
int
get()
{
return i;
}
}
|
A constructor is called when an instance of this class is
first created.
Here
it is used to initialize a variable.
|
The above code for the constructor ,
Test(int
j)
{
i = j;
}
shows that in the process of creating an instance of the class,
an inital value for the instance variable is passed as an argument
in the constructor.
Java does not actually require an explicit constructor in the class
description. If you do not include a constructor, the Java compiler
will create a default constructor in the byte code with an empty
argument. This default constructor is equivalent to the explicit Test(){}
class
Test
{
int i;
int get()
{
return i;
}
}
|
A valid
class with no constructor explicitly defined.
No
constructor is defined so the JVM will use the default constructor:
Test(){}
|
In the discussion of data fields, we
noted that the data can receive explicit initial values or default
values. You might wonder when does this initialization actually
occur?
The java
compiler, in fact, puts the initialization of the data into the
byte code for the constructor. So, for instance, the above default
constructor is equivalent to the one shown below where a constructor
explicitly sets the the int
variable to 0.
class
Test
{
int i;
Test()
{
i = 0;
}
int get()
{
return i;
}
}
|
This
constructor
illustrates explicitly the initialization of property values
to their default values as would occur if we had just used
Test(){}
or if no constructor had been defined.
|
Similarly, for a class with several types of data,
the initialization of the default or explicit values occurs in
the constructor:
class
Test
{
int i;
boolean b;
float f;
double d = 1.1;
Test()
{
i = 0;
b = false;
f = 0.0E0;
d = 1.1;
}
int
get()
{
return i;
}
...
}
|
This constructor
illustrates explicitly the initialization of property values
to their default values as would occur if we had just used
Test(){}
|
You can define multiple constructors to provide optional
ways to create and initialize instances of the class. (We will futher
discuss overloading of constructors
and methods later in this chapter.)
class
Test
{
int i;
boolean b=true;
Test(int j, boolean a)
{
i = j;
b = a;
}
Test(int
j)
{
i = j;
}
int get()
{
return i;
}
}
|
This constructor initializes the two properties to the values
passed as arguements.
A second constructor passes an initial value to just one
of the variables.
|
Note that if a class includes one or more explicit
constructors, the java
compiler does not create the default constructor. So for
the class shown above, the code
Test
ex = new Test();
will generate a compiler error stating that no such constructor
exists.
Latest update: Oct. 17, 2004
|