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();
  }