having several this() invocations in a row

[arefeh]

class A
{
	private int a;
	private int b;
	A()
	{
		this(1);
		System.out.println("a= "+a);//a=1
		System.out.println("b= "+b);//b=5
	}
	A(int a)
	{
		this(2,5);
		this.a=a;
	}
	A(int a, int b)
	{
		this.a=a;
		this.b=b;
	}
}

public class Row_OF_This
{
	public static void main(String args[])
	{
		A ob=new A();
	}
}

Hello

From Object Initialization in Java
You can have several this() invocations in a row if you wish. In other words, you could have an <init> method that invokes another with this(), and that <init> method invokes yet another with this(), and so on.

My question:
Is quote's aim above program?

[pbrockway2]

Your program seems to be a good example of what the quote is saying.

The important point being made comes just after the bit you quoted: "But in the end, there will always be an <init> method with a super() invocation -- either an explicit super() invocation or a compiler-generated one. Since this() and super() are both always the first action a constructor takes, the instance variables will always be initialized in order from the base class on down."

To show this perhaps you could have A extends some other class B. And have the A(int,int) constructor call super(). The aim is to see the order in which things happen - particularly the "base first" bit - so perhaps all of the constructors could have System.out.println() statements to illustrate this.

[Lil_Aziz1]

I got a question. This will never occur right?

		System.out.println("a= "+a);//a=1
		System.out.println("b= "+b);//b=5

[pbrockway2]

I got a question. This will never occur right?

		System.out.println("a= "+a);//a=1
		System.out.println("b= "+b);//b=5

What I see when I run the program is

a= 1
b= 5

Each of the this() statements causes another constructor to be called. But after that constructor has finished the rest of the first constructor gets to finish.

There are two points here: first, no, the System.out.println()'s still get carried out. And secondly they happen after the constructors later in the chain. The author's point in the article was that this means that the base class constructor will be the first thing to happen and then the class's constructor. If there are a number of constructors chained together they will all get carried out from the end of the chain back to the start.

[Lil_Aziz1]

Ah alright. So the first thing that occurs is:

		this(1);
		this(2,5);

Next

		this.a=a;
		this.b=b;

then

		System.out.println("a= "+a);//a=1
		System.out.println("b= "+b);//b=5

Finally

		this.a=a;

Correct?

[pbrockway2]

I think you may have in the wrong place.

The way to check - as I said earlier - is to remove the assignments that are going on (for no particular reason). Instead give each of the constructors a single System.out.println() identifying which constructor it is.

By running the code you will see in which order the code following each of the this(...) statements is performed.

There is nothing special about constructors here. Exactly the same thing happens if you have a bunch of methods each one calling the next as its first statement.

[Tolls]

The order is like:

A()          A(int a)          A(int a, int b)
this(1) --> this(2,5) ---> this.a = a;
                           this.b = b;
            this.a = a <---
println() <--

[arefeh]

Hello
Thank you.

To show this perhaps you could have A extends some other class B. And have the A(int,int) constructor call super(). The aim is to see the order in which things happen - particularly the "base first" bit - so perhaps all of the constructors could have System.out.println() statements to illustrate this.

The following program is good for your quote's aim?

class A
{
	private int a;
	private int b;
	A()
	{
		System.out.println("a= "+a);//a=0
		System.out.println("b= "+b);//b=0
	}
	A(int a)
	{
		this();
		this.a=a;
		System.out.println("a= "+a);//a=5
	}
	A(int a, int b)
	{
		this(a);
		this.b=b;
		System.out.println("b= "+b);//b=6
	}
	int addab()
	{
		return a+b;
	}
}

class B extends A
{
	B(int a, int b)
	{
		super(a,b);
	}
}

public class Row_OF_This
{
	public static void main(String args[])
	{
		B ob=new B(5,6);
		System.out.println("a+b= "+ob.addab());//a+b=11
	}
}

[gcampton]

Naming conventions

[arefeh]

Hello
My aim was not this link. I want to khow that following quote Comeoffs with my second program.

To show this perhaps you could have A extends some other class B. And have the A(int,int) constructor call super(). The aim is to see the order in which things happen - particularly the "base first" bit - so perhaps all of the constructors could have System.out.println() statements to illustrate this.

[JosAH]

Naming conventions

True, the underscores in the name Row_OF_This are a bit funny but all of this has nothing to do with the problem being discussed.

Jos

[pbrockway2]

I was thinking more like:

class A  extends B 
{
    A() 
    {
        this(1);
        System.out.println("no arg constructor");
    }

    A(int a)
    {
        this(1, 2);
        System.out.println("one arg constructor");
    }

    A(int a, int b)
    {
        super(); // not really needed
        System.out.println("two arg constructor");
    }
}

class B 
{
    B()
    {
        System.out.println("Base constructor");
    }
}

public class Test 
{
    public static void main(String[] args)
    {
        new A();
    }
}

[arefeh]

Thanks a lot.