Class 05: Object Basics

Held: Friday, 3 September 2004

Summary: Today we begin the study of classes, the primary building blocks of Java programs. Classes not only provide the main method, but also serve as templates for creating new objects.

Related Pages:

• EBoard.
• Today's examples.

Building Classes

• Now that we've written some simple programs, we're ready to consider more details about the construction of objects and classes.
• A class provides a template for the construction of objects.
• Classes are intended to represent the similar parts of objects (e.g., every car has a color scheme, even if different cars have different color schemes).
• There are three key parts to each class:
  • The methods that describe and implement the capabilities of objects in the class.
  • The fields that categorize the attributes of objects in the class.
  • The constructors that allow us to construct new objects in the class.
• We'll consider each in turn as we attempt to build a simple class for a vector in two-space. (Not necessarily a Scheme or Java "Vector".)

The Class Declaration

• You must enclose the fields, methods, and constructors of a class in a class declaration.
• Each class gets its own file (at least in CS152).
• The typical structure of a class is as follows.

  import ClassWhoseNameYouDontWantToTypeInFull;
  /**
   * A helpful introductory comment that describes the class.
   */
  public class ClassName
  {
    // Field declarations
  
    // Constructors
  
    // Methods
  
  } // class ClassName
  

Methods

• The things you called functions in Scheme we call methods in Java.
• There are typically 6 parts to a method declaration.
  • A comment that describes the purpose of the method.
  • The protection level of the method (typically public). + The type of value the method returns. You can use void when a method doesn't return anything.
  • The name of the method.
  • The parameters of the method.
  • The body of the method.
• For example
• We tend to classify methods as observers and modifiers.
  • Observers extract a value from the object without changing the object.
  • Mutators change the object.
• What methods might vectors in two-space provide?
  • Note that this is an ADT design question.

Fields

• There are three parts to a field declaration. In reverse order, they are:
  • The name of the field.
  • The type of the field. (The kinds of values it can take on.)
  • An optional protection level. (We won't specify protection levels right now.)
• For example,

    String name;
    

• You may have noted that field declarations look a lot like variable declarations. How do they differ?
  • Field declarations are part of a class; variable declarations are part of a method definition.
  • Fields are available anywhere in the class; variables are available only in the method they are declared in.
  • Fields have protection levels; variables do not.
  • Variables may be initialized when they are declared; fields typically are not.
  • When you reference fields, you should preface them with this.
• Here's an example of methods using the fields of a class.

    public String getName()
    {
      return this.name;
    } // getName()
    public void setName(String newName)
    {
      this.name = newName;
    } // setName(String)
  

• What possible choices do we have for the fields in our "vector in two-space" class?
  • Note that this is a kind of data structure question: We need to think of the precise representation of an abstract data type.

Constructors

• Constructors are special methods used to create new objects within the class. They are much like methods except that you don't include the type.
• Whenever you build a new object in a class, you call a constructor.

The Three Kinds of Classes

• Although I haven't mentioned it explicitly, Java programmers use classes for a number of reasons. I typically classify them as template classes, main classes, and utility classes.
• Template classes provide templates for creating new objects.
  • Template classes are the most common classes.
• Main classes provide a main method. You can think of the main method as a combination of the script and directory of a play. This method creates the objects that form the initial actors of the play that is your program. It then tells them what to do.
• Utility classes (which you haven't really encountered yet) provide methods for manipulating other objects. These methods are primarily class/static methods.
• Some classes are a hybrid of these kinds of classes.

Design Choices

• In object-oriented design (and in all program design) there are often many different ways to solve the same problem.
• For example, there are at least three ways to print TwoDimVector,
  • You can ask the TwoDimVector for information about itself and then use a PrintWriter. For example,

       pen.print(vec.getX());
       pen.print(",")
       pen.println(vec.getY());
    

  • You can hand a PrintWriter object to the TwoDimVector and ask the TwoDimVector to print itself. For example,

       vec.printWith(pen);
    

  • You can hand both the TwoDimVector and the PrinterWriter to a helper and ask the helper to print out the TwoDimVector. For example,

       researchAssistant.print(pen, vec);
    

• We'll spend a little while brainstorming about the advantages and disadvantages of each. We may ground our discussion in typical applications.
  • What if you want to print many different kinds of values?
  • What if you want to print TwoDimVectors in different ways?
  • ...