• The objects in memory, and their instance variables and methods.
• The static instance variables and methods.
• Inheritance.
• Method execution.
• Name resolution.
• The call stack of the computer.

Keep these points in mind as you read through this page.

To follow the rules below, I recommend that you have E0.java and E0.ps open.
• Every class has its own section of memory for its static members. For example, class Z in the examples always has its own box. Inside is the main() method, since main() is static.

• There are two parts to each method, the name and the body. The body looks like '{=}' in the examples. The method name is linked to a method body -- this is represented by an arrow.

• In order to invoke a method, you need to find the correct method body. For static methods, first look inside the box for the method's class -- for example, if the static method is called X.f(), look inside the box for X. When you find the name, follow the arrow to the method body.

• In order to execute the statements in a method, the computer needs a place to store local variables and parameters. We represent this by another box, called a "frame" or "activation record", and this frame is drawn in the same area where the method body was found. (Not where the method name was found -- you'll see why in a minute.)

  In the examples, that's where the frame labeled "main_0" came from. Notice that in E0.java, there is a variable 'a', which in the picture E0.ps has a small box to store a reference.

  This frame represents the frame on the call stack, and is where we keep track of all local variables and parameters.

• Executing X a = new X()
  • The 'new X();' part instantiates a new object of type X -- that's the big bottom box in E0.ps. A reference to the new object is returned, and is stored in 'a'. (That's what the arrow from a to the box represents.)
  • Inside the new object are all the names of variables and methods in class X. Also included are the method bodies, represented by '{=}' directly under each method name. All static names also exist, but each name merely has a pointer to the instance variable or method body with the same name in the class box.

• Invoking a.f()
  • Just like with static methods, we must first find the appropriate method body. The rule for non-static method invocation is to start at the reference 'a', find the object that a refers to, look inside for the method name, and follow the arrow to the implementation. When the method body is found, draw a frame for the method, and fill in local variables and parameters. We write "from main_0" in this example, so that when the method ends we know which was the calling frame -- this simulates the computer's call stack.
  • As f() executes, it will obviously refer to variables. In order to resolve a variable name, we first look in the current frame. If we find that name, use it. If we don't, we know that the variable must be an instance variable or a method.
  • To find the correct name, remember that the name 'i' is short for 'this.i', and that 'this' is a reference to the current object. Find the word 'this' in the same area as the method body, and follow it to the current object; look there for the name. (Note that if the name we are looking for is inherited, there will be additional steps, described below.)

• Inheritance and resolving a name To follow the rules below, I recommend that you have E1.java and E1.ps open.
• Executing Y a = new Y();
  • The 'new Y();' part instantiates a new object of type Y -- that's the big bottom box in E1.ps. A reference to the new object is returned, and is stored in 'a'. (That's what the arrow from a to the box represents.)
  • Inside the new object are all the names of variables and methods in class Y. Also included are the method bodies, represented by '{=}' directly under each method name. In addition, the new object has all the stuff inherited from X, and we represent this by drawing another box inside Y that includes X's information.
  • Note that both parts have this and super references.
  • To find a.f(), we begin the way we did before -- start at the reference 'a', find the object that a refers to, and look inside for the method name. If we don't find it, then it must be inherited -- simply look inside the inherited part. In E1.ps, that is X's part of the object. Once we find the name, we follow the arrow to the implementation, and everything happens as before.

    If we don't find the name at all, then it is not valid, and the compiler generates an error message.

• Overriding non-static methods. To follow the rules below, I recommend that you have E2.java and E2.ps open; we will focus on the object pointed to by b.
  • When a method is overridden, both the base class (X in this case) and the derived class have the method name and the method body. The important thing to note is that both method names point to the derived method body. Thus, the frame is drawn inside Y's part of the object, not X's.

• Shadowing static methods. Static methods cannot be overriden, although you can shadow them. What this means is that for a static method, the name of the method is always bound to the same method body, even if a subclass redefines the method. Note that to resolve a static name that has been inherited, we follow the same rule as for objects -- if we do not find the name in the box for the derived class, we look in the box for the base class.

• Types and Type Casting
  • For the code in E3.java, the line 'X c = b;' causes c to refer to the inner part of what b points to -- the X part of the object -- So c.f() will refer to the name f() inside the X part. When following that arrow, we arrive at the method body in Y's part of the object. Type casting, both up and down the hierarchy, follows exactly the same rule -- (X)b returns a reference to X's part of b.