why does this work?

[dkoleary]

Hi;

New java programmer. So new, in fact, that I'm still working my way through the O'Reilly Head First Java book. One of the end of chapter questions involves identifying if a sample class will compile and what to do to make it compile if it won't.

The sample class from chapter 4 is:

class XCopy
{ public static void main(String[] args)
{ int orig = 42;
XCopy x = new XCopy();
int y = x.go(orig);
System.out.println(orig + " " + y);
}

int go(int arg)
{ return arg * 2; }
}

The book says that it'll compile and run, displaying "42 84" and, sure enough, it does:

$ javac XCopy.java
$ java XCopy
42 84

How come that isn't recursive? XCopy.main() instantiates a new XCopy. Shouldn't that new XCopy instance also instantiate a new XCopy?

I was figuring this would run until the XCopy.go function tried returning a number that wouldn't fit in int anymore... That's obviously not the case, but I don't know why.

Can someone provide the missing concept?

Thanks.

Doug O'Leary

 

[Daniel Pitts]

Hi;

New java programmer. So new, in fact, that I'm still working my way through the O'Reilly Head First Java book. One of the end of chapter questions involves identifying if a sample class will compile and what to do to make it compile if it won't.

The sample class from chapter 4 is:

class XCopy
{ public static void main(String[] args)
{ int orig = 42;
XCopy x = new XCopy();
int y = x.go(orig);
System.out.println(orig + " " + y);
}

int go(int arg)
{ return arg * 2; }
}

The book says that it'll compile and run, displaying "42 84" and, sure enough, it does:

$ javac XCopy.java
$ java XCopy
42 84

How come that isn't recursive? XCopy.main() instantiates a new XCopy. Shouldn't that new XCopy instance also instantiate a new XCopy?

new XCopy() creates a new instance of the XCopy class, which executes
Constructors. main isn't executed again because of this. main is only
automatically executed by the JVM on start-up, once.

I was figuring this would run until the XCopy.go function tried returning a number that wouldn't fit in int anymore... That's obviously not the case, but I don't know why.

int can fit any number in the range [-2^31, 2^31). 42 and 84 are both
within that range. It is possible that if you pass in a number with a
large enough magnitude, you will end up with an overflow. In Java (and
many 2s-compliment integer systems), overflow will simply throw-away the
upper bits, and you will have what is called "wrap-around". This
actually makes many of the basic operations easier, because signed
numbers and unsigned numbers behave the same way.


Hopefully this helps.

 

[Eric Sosman]

[...]
How come that isn't recursive? XCopy.main() instantiates a new XCopy. Shouldn't that new XCopy instance also instantiate a new XCopy?

See Daniel Pitts' explanation. Another thing you could try to
help you see what's going on is to sprinkle some more println()
calls through the code to help trace through the execution. In
this case you're interested in where the constructor fits with
relation to everything else, but there's no explicit constructor
written in the code. As I'm sure you've learned, this means the
compiler will write a simple constructor for you -- but there's
no way to get the compiler to stick println() calls in what it
writes, so your recourse is to write your own explicit constructor.
With this in mind, the code might look like:

class XCopy {
public static void main(String[] args) {
System.out.println("entering main()");
int orig = 42;
System.out.println("main() creates an XCopy");
XCopy x = new XCopy();
System.out.println("main() created an XCopy");
int y = x.go(orig);
System.out.println(orig + " " + y);
System.out.println("main() is finished");
}

int go(int arg) {
System.out.println("executing go(), arg = " + arg);
return arg * 2;
}

// Explicit constructor, just for the println
XCopy() {
System.out.println("constructing an XCopy");
}
}

Run this version, study the output, and see if the sequence of
events becomes clearer.

This technique is sometimes called "printf debugging" (the name
comes from a different programming language). Despite its simplicity,
it can be astonishingly effective, and the overall approach can be
used in most environments and most languages. Indeed, Java's various
logging frameworks (you may learn about them later) are basically
just fancied-up versions of printf debugging: A piece of the program
blurts "Look! I'm *here*, and these are a few interesting values."

 

[dkoleary]

new XCopy() creates a new instance of the XCopy class, which executes
Constructors. main isn't executed again because of this. main is only
automatically executed by the JVM on start-up, once.

Got it... I do remember reading that somewhere else. main only gets executed once.

Thanks for the concept correction. Hopefully, it'll stick now

Doug O'Leary

 

[Lew]

Got it... I do remember reading that somewhere else. main only gets executed once.

That isn't strictly true. The 'main()' method is only called for one class one time by
the JVM when it starts, but nothing prevents code in the program from explicitly
calling some class's 'main()' at some later time.

Thanks for the concept correction. Hopefully, it'll stick now

Read the Java tutorials. They explain constructors vs. methods and such
concepts.

 

[Roedy Green]

How come that isn't recursive?

new allocates some space and XCopy() runs the initialitzer code in the
constructor.

There is no new in the constructor, so why would it be recursive?

There is no more reason for the constructor to be recursive than any
other method. The constructor does not reinvoke the constructor.

 

[glen herrmannsfeldt]

(snip)

There is no new in the constructor, so why would it be recursive?

There is no more reason for the constructor to be recursive than any
other method. The constructor does not reinvoke the constructor.

But if there IS a new in the constructor...


-- glen