Compiling New Features

Ongoing Learning--Compiling New Structures

As we have noted before in class, as you leave the university and begin our careers, you will no longer have someone around to teach you in the usual sense.  You will need to extend your knowledge on your own to new related concepts and even transfer our understanding to what appear to be completely different situations.  You can do it.  

As an example of this activity, we considered the problem of translating classes and objects by looking at the following simple program as an example:

public class CounterClass
{
  private int counter = 0;

  public static final char BOY  = 'M';
  public static final char GIRL = 'F';

  public CounterClass()
  {
    // This constructor does nothing.  Use it when you want to start
    // the counter at 0.
  }

  public CounterClass(int startingValue)
  {
     counter = startingValue;
  }

  public void plusOne()
  {
    counter++;
  }

  public void minusOne()

  {
    counter--;
  } 

  public int getCounter()
  {
    return counter;
  }

}

public class Countem
{
  public static void main (String[] args) throws Exception
  {
    CounterClass numberOfBoys  = new CounterClass();
    CounterClass numberOfGirls = new CounterClass(10);
    char gender;

    while (true)
    {
      System.out.print("Please enter M for a boy or F for a girl > ");
      gender = BasicIo.readCharacter();
      if (gender == 'M')
      {
        numberOfBoys.plusOne();
      }
      else
      {
        numberOfGirls.plusOne();
      }
      System.out.println("Boys  = " + numberOfBoys.getCounter());
      System.out.println("Girls = " + numberOfGirls.getCounter());
      System.out.println("Total = " + (numberOfBoys.getCounter() + numberOfGirls.getCounter()));
    }
  }
}

We decided on a number of approaches to translating classes:

• The translated code for methods in a class need to appear only once and can be called as necessary regardless of how many objects are instantiated from the class.  These translated methods will thus be part of the translated code section in our run time memory model.  Each method will have a label that can be called (if the method is in scope).
• When an object is instantiated from a class, all that is needed done is that a new record of all of the variables (attributes) of the class is built to hold the attributes for that object.  The space for this record is allocated from the heap portion of our run time memory model, because these object records are created and destroyed as objects are constructed and destructed. The object is then just referenced by a pointer. 
• Calling a method on an object, such as numberOfBoys.plusOne from the example above, just results in the same call mechanism being produced in the run time code for any procedure or function.  The only difference is that the method gets as its first parameter the pointer to the record on the heap for numberOfBoys.  Thus, the method plusOne is applied to the record pointed to by numberOfBoys, so the right attribute gets updated (for example, the counter field in the record for numberOfBoys gets updated, not the counter in the numberOfGirls record.
• Whenever an object is released (destroyed) (i.e., it has no reference to it) it becomes garbage, or unused space, in the heap.  At various points an algorithm can be invoked if the language allows or provides for it that performs garbage collection on the heap, essentially squeezing out all of the unused heap locations and compacting the memory of the heap.
• A  class (as opposed to an object) must also have an associated record if there are static variables declared in it, because these variables must be accessible directly through the class.