Class 04: More Classes and Objects

Held Friday, January 29

Summary

• Fields and object state
• Constructors
• Overloading
• Lab: J3: Building Your Own Objects

Contents

Notes

• Just to make it clear: you get extra credit for finding errors in the lab manual and the textbook (you haven't received the textbook yet). You do not get extra credit for finding errors in my web site (the web site is a much more casual thing). However, I do appreciate hearing about errors (and will correct them).
• Clif Flynt, who is teaching the other section of 152, has made his overheads available online.
• I do not expect you to finish the lab sessions during class time. I would, however, appreciate knowing how long the labs are taking. (If they're taking too long, I'll ease off on homework or suggest that you do less.)
  • How much time for preparatory reading?
  • How much time after class for remainder of lab?
  • Would you prefer more answers in the back? Do you use them?
  • Is it helpful to have a printed copy? Does it encourage you to do the readings?

Preliminaries

A Short Review

• It seems that I've been moving fairly quickly. Let's take a few minutes to pause, catch our breath, and think about what's going on in most object oriented languages.
• As I've said, an object-oriented program consists of a number of objects, each which may have attributes and abilities.
• A central coordinator (the main method) creates objects and tells them what to do.
  • Almost every ``step'' (method call) in a program will require an object to do the step, and may also require additional things.
  • Objects can also create other objects and tell them what to do.
• You can think of the parts of the program as being simple sentences.
  • ``Pen, please write `Hello' on the board.'' (or ``Jack writes `Hello' on the board.'')
  • ``Jack, please write your name on the board, using this pen.'' (``Jack writes his name on the board, using this pen.'')
  • ``Plane, please plot this point.'' (``The plane plots this point.'')
  • ``Point, please tell me your x coordinate.'' (``The point reports on its x coordinate.'')
• In practical terms, this means that whenever you call a method, you must specify which object will do the method.
  • If the Point class has a print method, and pt is a Point, you would use pt.print(...).
  • The Java interpreter says (more or less) ``Ah ha! pt is a Point. Hence, I'll look at the instructions for the print in the Point class.''
• Note that multiple classes can use the same method name. This can lead to either confusion or clarity, depending on your perspective. However, it does suggest that saying which object uses the method is important.

Warning! Aliasing and references

• As you (hopefully) noticed from discussion for lab J2 and the corresponding exercises, ``object variables'' store references to objects, rather than the objects themselves.
• This means that you can have two variables refer to the same object.
• A change to one will be a change to another.
• In some languages, this is called aliasing.
• It sometimes leads to subtle errors in programs, so be careful.

Detour: Directories

• As you do more and more work in computer science, you will find that you gather an absurdly large number of files.
• It behooves you to create a separate folder or directory for each reasonable set of files.
  • I would suggest that you create a separate folders for labs and assignments, with subfolders for each lab or assignment.
• You can use the file manager (the icon that looks like a drawer) to manage your files and folders.
• You can also use the Unix shell, with dtterm.
  • You can create a new directory with

    % mkdir dirname
    

  • You always have a ``current working directory''. You can change your current working directory to a particlar directory with

    % cd dirname
    

  • You can determine your present working directory with

    % pwd
    

  • You can determine the contents of the current directory with

    % ls -F
    

  • You can determine the contents of a particular directory with

    % ls -F dirname
    

  • You can return to your home directory with

    % cd /home/youraccount
    

  • You can move a file to a directory with

    % mv file dirname
    

  • Let me know if there are other things you'd like to do.

Fields and object state

• As we've noted, most objects have attributes: facts we can state about the objects.
  • Books have titles, authors, bindings, and such.
  • Points have X coordinates and Y coordinates.
  • Planes may have a sequence of plotted points.
  • ...
• When designing classes and objects, you must consider which attributes objects in the class will have, and the types of those attributes.
• These attributes look a lot like variables, except that they don't fall within methods.
• Java custom says that we call attributes fields.
• When you declare fields, you will typically make them protected. This means that other classes can't access fields directly. Such protection is part of information hiding, an important software design strategy.
• For example, here's the start of a description of a Book class.

  public class Book {
    // +--------+--------------------------------------------------
    // | Fields |
    // +--------+
  
    /** The title of the book. */
    protected String title;
  
    /** The binding of the book. */
    protected Binding binding;
  
    /** The authors of the book. */
    protected AuthorList authors;
  
    /** The price of the book. */
    protected float price;
  
    // ...
  } // class Book
  

• Similarly, here's a start of the description of a Point class.

  /**
   * A point in two-space.
   */
  public class Point {
    // +--------+--------------------------------------------------
    // | Fields |
    // +--------+
  
    /** The x coordinate. */
    protected double x;
  
    /** The y coordinate. */
    protected double y;
  } // Point()
  

• You can get access to the fields of an object with this.fieldName
• For example,

    // Set the x coordinate of the current point to 0.
    this.x = 0.0;
    // Set the y coordinate of the current point to the x coordinate
    // of the current point.
    this.y = this.x;
  

Constructors

• Now, how do we fill in the fields of an object? Clearly, different objects within the same class will have different values for the same fields.
  • Two points will often be at different places on the plane.
  • Two people will often have different names.
• Typically, you create a constructor to build new objects in a particular class.
  • The constructor constructs and initializes an object.
• A constructor always has the same name as the class and no specified return type (since a constructor always returns an object in the class, no return type is necessary).
• Here is a constructor for the Point class.

    /** Create a new point with specified x and y coordinates. */
    public Point(double xcoord, double ycoord) {
      this.x = xcoord;
      this.y = ycoord;
    } // Point(double,double)
  

Overloading

• What if you'd like to have more than one constructor for a class? For example, what if we'd like to have a second constructor for the Point class in which the user does not have to specify the x and y coordinates (we'll initialize them to 0).
• In some languages, we'd have difficulty, since we are only allowed to use a method name once.
• In Java, you can overload the constructor name. For example, here's a constructor for the Point class that takes no parameters.

    /** Create the point (0,0). */
    public Point() {
      this.x = 0.0;
      this.y = 0.0;
    } // Point()
  

• As you will see in the lab, you can also overload method names.
  • In fact, you've already seen one form of overloading: different classes can share method names.
• How does Java decide which method to use?
  • It looks at the class first.
  • Then it looks at the method name.
  • Then it looks at the types of the parameters.
  • It finds the best match it can (as long as there is a best match).

Lab

Do Lab J3.

Reflection

• What were some of the interesting things you learned from this lab?
• What was the most challenging part of this lab?

History

• Created Monday, January 11, 1999
• Added short summary on Friday, January 22, 1999.
• Added note about aliasing on Wednesday, January 27, 1999.
• Added further details on Friday, January 29, 1999.