the object is constructed, we may still call its setter methods (provided we
defined them in the class definition) to change the value of data members to any
other value. By providing a no-argument constructor, we ensure that any newly
created object will have its data members set to the default values specified
in the constructor.
what if we want to set the data members to a different value each time we
create an object? For this, we need to pass the values as parameters to the constructor.
Therefore, we need to declare a constructor that takes parameters. This type of
constructors is known as parameterized constructor, such a
constructor is shown in the following code fragment:
public Point(int x, int y)
this.x = x;
this.y = y;
assign the values specified by the two parameters to the two instance variables
using this as a reference to the current object. To call this constructor in
our program code, we use the following statement:
p = new Point(4, 5);
we call the constructor, we set the values for its arguments. The instance
variables will now be initialized using these values. We can verify this by dumping
the object’s contents as illustrated in the previous example.
we may want to initialize only one of the instance variables while letting the other
variable have some default value. In such a case, we declare another
constructor for our Point class, as follows:
public Point(int x)
this.x = x;
y = 10;
constructor takes only one argument, the value of which is assigned to the x
field. The other instance variable, y, is set to a value of 10. If we do not
assign a value to the variable y, it will take a default value of 0, which is
provided by the compiler. We can now call the constructor with the following
p = new Point(5);
creates the Point object (5, 10), which can be verified by printing the
class may declare more than one constructor in its definition. If this is the
case, how do we know which constructor is called when the class is instantiated?
The compiler decides which constructor to call depending on the number of
parameters and their types. Look at the following code fragment:
p1 = new Point();
p2 = new Point(15);
p3 = new Point(5, 10);
· The first statement calls
the no-argument constructor and creates the object p1(10, 10).
· The second statement creates
the object p2(15, 10),
· and the third statement
creates the object p3(5, 10).
the compiler has decided which constructor to call depending on the number of parameters
passed to it.
is one more noticeable thing here is that, we cannot write two constructors
that have the same number and type of arguments for the same class because the
platform would not be able to differentiate between them. Doing so causes a compile-time
the previous section, we learned to write our own constructor. In all our
previous examples, we hadn’t written any constructors. So is there any
constructor provided by default? Yes, there is. If we do not write a constructor,
the Java compiler provides a constructor with no arguments. This is
called the default constructor, and the implementation of the default
constructor is null, which means it does not contain any code.
for Defining a Constructor
rules for constructor creation can be summarized as follows:
A constructor must have the
same name as the class name.
A constructor does not
return anything, not even a void type.
A constructor may take zero
or more arguments.
By default, the compiler
provides a no-argument constructor.