Session 21: Objects review

Definitions
Using objects
    Creating a name
    Assigning an object to a name
    Using an object
Defining a class
    Instance variables
    Constructor methods
    Instance methods

Definitions

Note the following definitions.

• object or instance - a ``thing'' that occupies a region of memory.

• class - a category of object. In Java, this is is a type alongside the primitive types like int and double.

• instance variable - a piece of data that an object remembers. For example, a window might remember where its located on the screen and how big it is.

• instance method - a behavior that an object can be asked to perform. For example, a window might be asked to display itself or to grow larger or smaller.

• constructor method - a behavior used when a new object is created. This will set up the instance variables of the object to their initial values.

  Using objects

  Creating a name

  This is simply declaring a variable of the given type.

  Robot rob;
  

  There is no difference between this statement and a statement like ``int i.'' Here, we are creating a variable called rob to be a name for a Robot object.

  We haven't actually made it be a name for any particular object yet. In fact, rob will hold null.

  Or we could create a name for a DrawableFrame object.

  DrawableFrame window;
  

  Assigning an object to a name

  To assign an object to a name, we'll want to create the object.

  window = new DrawableFrame();
  rob = new Robot(window, 100, 100);
  

  Here, we're changing what object the rob name is naming. In this case, the object we're making it be a name for is a new Robot object created on the same line.

  The same object can have multiple names. For example, the following code would create a second name bert for rob.

  Robot bert;
  bert = rob;
  

  The new keyword is used when you want to create an instance. The way it works is as follows.

  new Class_Name (parameters) The parentheses contain the parameters to be passed to the constructor method: They tell the constructor method how the robot should be set up. In the documentation, you'll see this constructor method for the class defined something like the following.

  Robot(DrawableFrame frame, int x, int y)

  (Constructor method) Constructs a robot in frame facing east at coordinates (x, y) in the window.

  What this is saying is that there is a constructor method for the Robot class that takes two int parameters (listed in parentheses). So writing ``new Robot(100, 100)'' is a legal thing to write. The names of the parameters x and y are insignificant; they exist only so that the documentation can refer to them by name (it would be ugly if it would have to write ``first parameter value'' when x is much shorter). The names have no effect on how you write your program.

  Using an object

  Each object has several methods which specify what we can ask of that object. For example, a Robot object might have the following methods. (This is how they might be described in the documentation.)

  int getX()

  Returns the x-coordinate of the robot's current position.

  int getY()

  Returns the x-coordinate of the robot's current position.

  void moveForward(int dist)

  Move forward dist pixels in the current direction, drawing a line underneath.

  void turnLeft()

  Turn left 90 degrees.

  To tell a Robot object to accomplish one of these behaviors, we would give the name of a Robot, followed by a period and the method name, with a set of parentheses. Any parameters required by the method would go inside the parentheses.

  rob.moveForward(50);
  rob.turnLeft();
  

  Here, we have told rob to move forward 50 pixels. Then we told rob to turn left. (Note that when we told rob to turn left, we still had to include the parentheses, even though we had no parameter values to give him.)

  Many methods can return a value - this would be the object's response to the request. You can tell in the documentation that it returns something when there is a type name other than void listed before the method name. For example, the getY() method returns an int. We can put such a method call anywhere we can place an expression. For example, we might put the return value into a variable.

  int y;
  y = rob.getY();
  rob.moveForward(y);
  

  Here, we've asked rob for his y-coordinate, and then we've told rob to move that far forward. We could combine these into a single line to accomplish the same thing.

  rob.moveForward(rob.getY());
  

  Defining a class

  When we design our own systems, we define our own new classes. For example, we might want to define the Robot type. Beginning the class definition is simple.

  public class Robot {
      // : (everything else goes between these two braces)
  }
  

  Instance variables

  The first question we ask about a new class is: What does it need to do? In the case of the Robot class, we've already said what it needs to do.

  The second question we need to ask is: What does it need to remember in order to accomplish this feat? Each thing that the object remembers is an instance variable. (This distinguishes it from a local variable, which is something that is remembered only for the duration of executing a method.)

  What do robots need to remember? Each will need to remember its x- and y-coordinates, which window it is living within, and which direction it is facing.

  public class Robot {
      private DrawableFrame window;
      private int x;
      private int y;
      private int direction; // 0 for east, 1 north, 2 west, 3 south
  
      // : (more to come here)
  }
  

  Constructor methods

  When we create a Robot object, its constructor method is called. Within our class definition, we need to define what the method does. In particular, the method should initialize all the instance variables to their proper values when a new robot is created.

  public class Robot {
      private DrawableFrame window;
      private int x;
      private int y;
      private int direction; // 0 for east, 1 north, 2 west, 3 south
  
      public Robot(DrawableFrame in_window, int in_x, int in_y) {
          window = in_window;
          x = in_x;
          y = in_y;
          direction = 0;
      }
  
      // : (more to come here)
  }
  

  Notice that we have not done the following.

  public class Robot {
      private DrawableFrame window;
      private int x;
      private int y;
      private int direction; // 0 for east, 1 north, 2 west, 3 south
  
      public Robot(DrawableFrame in_window, int in_x, int in_y) {
          DrawableFrame window = in_window;  // BAD!!!
          int x = in_x; // BAD!!
          int y = in_y; // BAD!!
          int direction = 0; // BAD!!
      }
  }
  

  In this example, we have declared local variables within the constructor method whose names just happen to be identical to the instance variable names. But this coincidence of names is of no significance to Java; it thinks of them as being totally different variables, and as a result, the instance variables are not initialized with this technique.

  Instance methods

  We also need to define how the robot handles the various messages. Each method definition is a sequence of statements that the robot performs when requested. These statements may refer to the instance variables or call instance methods.

  public class Robot {
      private DrawableFrame window;
      private int x;
      private int y;
      private int direction; // 0 for east, 1 north, 2 west, 3 south
  
      public Robot(DrawableFrame in_window, int in_x, int in_y) {
          window = in_window;
          x = in_x;
          y = in_y;
          direction = 0;
      }
  
      public int getX() {
          return x;
      }
  
      public int getY() {
          return y;
      }
  
      public void moveForward(int dist) {
          int init_x = x;
          int init_y = y;
  
          if(dist == 0) {
              x += dist;
          } else if(dist == 1) {
              y -= dist;
          } else if(dist == 2) {
              x -= dist;
          } else if(dist == 3) {
              y += dist;
          }
  
          Graphics g = window.getGraphics();
          g.drawLine(init_x, init_y, x, y);
      }
  
      public void turnLeft() {
          dist++;
          if(dist == 4) dist = 0;
      }
  }
  

  Notice how moveForward() declared some local variables - you know they're local, since they're defined inside the method. (If they were declared outside the method, they'd be instance methods.) These are temporary variables, since we only want to remember them while the robot is moving forward. We don't really have any reason for the robot to remember them later, so we make them local variables instead.