Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.java.programmer > #17362

Re: why does this work?

From Eric Sosman <esosman@ieee-dot-org.invalid>
Newsgroups comp.lang.java.programmer
Subject Re: why does this work?
Date 2012-08-08 14:03 -0400
Organization A noiseless patient Spider
Message-ID <jvu9m7$25u$1@dont-email.me> (permalink)
References <aa374d3f-d1d4-43e0-be0a-972b80316255@googlegroups.com>

Show all headers | View raw


On 8/8/2012 1:30 PM, dkoleary wrote:
> [...]
> 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."

-- 
Eric Sosman
esosman@ieee-dot-org.invalid

Back to comp.lang.java.programmer | Previous | NextPrevious in thread | Next in thread | Find similar | Unroll thread


Thread

why does this work? dkoleary <dkoleary@olearycomputers.com> - 2012-08-08 10:30 -0700
  Re: why does this work? Daniel Pitts <newsgroup.nospam@virtualinfinity.net> - 2012-08-08 10:38 -0700
    Re: why does this work? dkoleary <dkoleary@olearycomputers.com> - 2012-08-08 11:39 -0700
      Re: why does this work? Lew <lewbloch@gmail.com> - 2012-08-08 17:33 -0700
  Re: why does this work? Eric Sosman <esosman@ieee-dot-org.invalid> - 2012-08-08 14:03 -0400
  Re: why does this work? Roedy Green <see_website@mindprod.com.invalid> - 2012-08-09 02:41 -0700
    Re: why does this work? glen herrmannsfeldt <gah@ugcs.caltech.edu> - 2012-08-09 20:17 +0000

csiph-web