Question

I need to know the order, in which the constructors will be called.

Point class:

public class Point
{
    public int x = 0;
    public int y = 0;

    // a constructor!
    public Point(int a, int b) {
        x = a;
        y = b;
    }
} 

Rectangle class:

public class Rectangle
{
    public int width = 0;
    public int height = 0;
    public Point origin;

    // four constructors
    public Rectangle() {
        origin = new Point(0, 0);
    }
    public Rectangle(Point p) {
        origin = p;
    }
    public Rectangle(int w, int h) {
        origin = new Point(0, 0);
        width = w;
        height = h;
    }
    public Rectangle(Point p, int w, int h) {
       origin = p;
       width = w;
       height = h;
    }

    // a method for moving the rectangle
    public void move(int x, int y) {
        origin.x = x;
        origin.y = y;
    }

    // a method for computing the area of the rectangle
    public int getArea() {
        return width * height;
    }
}

A class which creates objects:

public class CreateObjectDemo {
    public static void main(String[] args) {

        //Declare and create a point object
        //and two rectangle objects.
        Point originOne = new Point(23, 94);
        Rectangle rectOne = new Rectangle(originOne, 100, 200);
        Rectangle rectTwo = new Rectangle(50, 100);
        System.out.println("Width of rectOne: " +  rectOne.width);
        System.out.println("Height of rectOne: " + rectOne.height);
        System.out.println("Area of rectOne: " + rectOne.getArea());

        rectTwo.origin = originOne;
    }
}

1. In which order are the constructors in class Rectangle called?

2. When will the public Rectangle(Point p) be called?

3. What does the statement rectTwo.origin = originOne do ?

The program is from Oracle’s Java Tutorial site.

Answer 1

In general, the control flow is in program order (i.e. left-to-right), with the following exceptions:

• Parameters to methods and constructors are evaluated before the method/constructors itself
• The program starts with the main method.

Thus we have the following order:

1. Point originOne = new Point(23, 94); – this will call the Point constructor.
2. Rectangle rectOne = new Rectangle(originOne, 100, 200); – this will call the Rectangle constructor with a Point and two int arguments.

3. Rectangle rectTwo = new Rectangle(50, 100); – this will call the Rectangle constructor with two int arguments.

   1. This constructor, in turn, will in origin = new Point(0, 0); call the Point constructor.

There are no more explicit constructor calls. But each of these calls includes an implicit call to the constructor of its superclass (which is Object here) at the start.

The constructor Rectangle(Point) is not called at all, it seems.

rectTwo.origin = originOne; changes the origin of the second rectangle from (0,0) to the same point which is used by rectOne, e.g. (23,94).