AppletTalk.com

charles hottel · Guest

Hi to all!

I am new to Java and have run into something confusing to me.

I know that 'this' can refer to the current object but what does 'this' mean
when used inside a constructor before the object has been completely
created? Specifically the book I am reading has the following example:

There is a DiscountBookOrder class that extends a BookOrder class. Both
classes have a 'total' field and a 'setTotal()' method and the constructors
of both classes invoke a 'setTotal()' method. The DiscountBookOrder
constructor invokes the BookOrder constructor and I have found that the call
to 'setTotal()' in the BookOrder constructor actually invokes the
'setTotal()' method in the DiscountBookOrder class. This was somewhat
confusing at first but understandable since the method is overridden. I
experimented by changing the call in the BookOrder constructor to
'this.setTotal()' thinking that the 'setTotal()' method in BookOrder would
be the one used, but adding the 'this' did not cause any difference. At this
point in the execution sequence neither the DiscountBookOrder object nor the
BookOrder object is fully created yet a 'this' reference to
DiscountBookOrder clearly exists. At exactly what point did it come into
being? Why does 'this' within the BookOrder constructor refer to a
DiscountBookOrder object? Also how would I change the code in the BookOrder
constructor to invoke BookOrder 'setTotal()' method? At this point there is
no BookOrder object to use to invoke the method. I would also appreciate any
comments about this design i.e. is this a typical thing to do? Also I
really do not like the variable names that they used and I think that the
'total' field in the DiscountBookOrder class should at least be changed to
'discountTotal'. Is it typical to use the same variable names in a class and
its superclass?

This seems kind of confusing for a first example of inheritance. I wonder if
it was intentional or a mistake. I mean maybe the author did not realize
that this was happening. Maybe it is just because this is still a new
concept to me.

Below is the code with the irrelevant (I hope) bits snipped out. I can post
the whole thing if necessary. Thanks in advance for you comments and help.

public class DiscountBookOrder extends BookOrder{
private String discountCode;
private double subtotal, percentOff, total;

public DiscountBookOrder(String bookCode, int bookQuantity, String
keyCode){
super(bookCode, bookQuantity);
discountCode = keyCode;
setPercentOff();
setTotal();
}

public void setPercentOff(){
if (discountCode.equalsIgnoreCase("a10"))
percentOff = 0.1;
else
percentOff = 0.0;
}

public void setTotal(){
System.out.println("DiscountBookOrder.setTotal"); //test
subtotal = super.getQuantity() * super.getBook().getPrice();
total = subtotal - (subtotal * percentOff);
System.out.println(subtotal); //test
System.out.println(total); //test
}

//*******************************************************************************************************

public class BookOrder{
private Book book;
private int quantity;
private double total;

private static int orderObjectCount = 0;

public BookOrder(String bookCode, int bookQuantity){
book = new Book(bookCode);
quantity = bookQuantity;
// System.out.println(quantity); //test
// System.out.println(book.getPrice()); //test
//when this constructor is invoked from DiscountBookOrder then
the method invoked
//next is the setTotal in DiscountBookOrder even if you change
it to
//this.setTotal(). This leaves BookOrder.total initialized to
zero
setTotal();
//System.out.println(total); //test
orderObjectCount++;
}

public void setTotal(){
System.out.println("BookOrder.setTotal"); //test
total = quantity * book.getPrice();
}

Roedy Green · Guest

On Fri, 24 Mar 2006 17:52:35 -0500, "charles hottel"
<jghottel (AT) yahoo (DOT) com> wrote, quoted or indirectly quoted someone who
said :

Hal Rosser · Guest

"charles hottel" <jghottel (AT) yahoo (DOT) com> wrote in message
news:97d16$4424782e$4f9c607$16271 (AT) DIALUPUSA (DOT) NET...

Bjorn Abelli · Guest

"charles hottel" wrote...

BWill · Guest

The basic point is that calling the parent constructor within a
constructor is a special case recognized by the language (in fact, the
rule is that calling the parent constructor must be the first thing done
in a constructor). So the answer to your question is, what object 'this'
refers to depends upon the object being constructed:

new BookStore(...);

/* the 'this' reference in the BookStore constructor refers to the
BookStore object being created */

new DiscountBookStore(...);

/* the 'this' reference used in the DiscountBookStore constructor refers
to the DiscountBookStore object being constructed, and when that
constructor calls the constructor of its parent, 'this' in the parent
constructor also refers to the DiscountBookStore object being constructed */

If this was not apparent, a clue is that the call to the parent
constructor in DiscountBookStore() does not use the keyword 'new'
because it is not constructing a new, different object but rather the
very same object already under construction. (I suppose this is one
justification for the unnecessary new keyword.) So remember, a
constructor always begins with a call to a constructor of the parent
class (if such a call is omited, Java calls the parameterless
constructor of the parent implicitly; you'll get a compile error if you
leave out any call to the parent when the parent doesn't have a
parameterless constructor).

Roedy Green · Guest

On Sat, 25 Mar 2006 12:37:17 -0800, BWill <brianwill1 (AT) adelphia (DOT) net>
wrote, quoted or indirectly quoted someone who said :