Class 07: More Classes and Objects

Held Monday, September 6, 1999

Overview

Today, we will continue our investigation of classes by considering two other aspects of classes: fields and constructors.

Contents

• Classes, Revisited
  • Fields and Object State
  • Constructors
    • Overloading Constructors
  • Overloading, Revisited
• Lab

Handouts

• Assignment 1: Your First Class: Mail Messages

Summary

• New class components
  • Fields
  • Constructors
• Overloading
• Lab: J3.
• Assigned: Assignment 1: Your First Class: Mail Messages (due 4p.m. Tuesday, September 14, 1999).

Classes, Revisited

• As we've seen in the past weeks, objects and classes form the core of Java programs.
• Although we've abstractly said that objects have both attributes and capabilities, so far we've focused on the capabilities (methods, functions).
• Today, we'll consider attributes and constructors.

Fields and Object State

• The attributes of an object are typically facts we can state about the object (or the state of the object).
  • Books have titles, authors, bindings, and such.
  • Points have X coordinates and Y coordinates.
  • Diagrams may have a sequence of plotted points.
  • ...
• Some attributes are static: they don't change.
  • Once a book has a title, it always has that title.
• Some attributes are dynamic: they may change.
  • A book's condition tends to deteriorate until you restore the book.
• 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.
• Generally, 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.
• 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;
  
    /** The condition of the book. */
    protected String condition;
  
    // ...
  } // 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

• We've seen how to fill in the values of the various fields in an object. But what are the values in a new object?
  • Java will fill in default values. You can then change the values.
  • A better solution is to write a constructor: a method that describes how to build new objects in a particular class.
  • The constructor constructs and initializes an object.
• Note: constructors are just methods. They just have a slightly different form than other methods. (They are also called differently.)
  • 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 Constructors

• 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()
  

Overloading, Revisited

• Can you overload more than constructors?
  • You may have noted that Java (and Scheme) overload some operators. For example, addition can be applied to reals or integers.
  • In Java, you can't overload operators but you can overload methods.
  • You may have already seen one form of overloading of methods different classes can share method names.
• How does Java decide which method to use?
  • It looks at the class of the underlying object 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).
• If there is no best match, the Java compiler will complain.
• In today's lab, you'll explore overloading and other issues.

Lab

Begin lab J3. You should plan to do sections J3.2, J3.3, J3.4, J3.5 and J3.7. We will continue the lab on Wednesday.

You may also do the other sections, but are not required to do so.