Outline of Class 5: More on Objects and Classes

Held: Monday, January 26, 1998

Administrivia

• Does anyone still need a book? The bookstore says that you can come in and have them special order a copy (apparently, they misjudged the registration). You might also be able to convince someone who took 152 last term to loan/sell you their copy.
• This summer, I'll be working on building web design and analysis tools and I'm looking for students to work with me. (I'm new, so I'm still working on the intracacies of summer research fellowships; if you're interested, let me know and we'll figure out what to do next.) Once you complete 152, you'll have enough background, so don't be afraid to let me know that you're interested.
• There seemed to be some misunderstanding in assignment one. In particular, your calculator needs to repeatedly read an expression. I've updated the description and notes.
• Assignment two is now ready. It draws upon the lab that we'll do today or tomorrow.
• Hopefully, we'll do lab two today. If not, we'll work on it tomorrow.
• Note that there is often a class in the MathLAN laboratory at the same time as our class. Please do not exit through the back of the room.

What goes in a method?

• What can you put in the body of a method?
• A number of things ...
  • Variable declarations
  • Assignments of values to variables
  • Messages/calls to the methods of objects
  • Calls to class methods (general methods not associated with a particular object)
  • Control structures that sequence these other things

Objects and References

• Java carefully distinguishes between the objects we create and the variables that refer to them.
• Each object occupies some area of memory. This area holds the fields of the object and additional information to help the system decide which method to execute.
• Instead of containing objects, variables hold references to objects.
  • We usually indicate this visually by drawing an arrow from a variable's name to the object it refers to.
  • These references are essentially the same as pointers, except that you may be more limited in what you can do with references.
• Because variables hold references, and not objects, it is possible for more than one variable to refer to the same object. A change through variable will be to the underlying object, so the change will be observable through all variables.
• Because variables hold references, and not objects, it is necessary to create new objects when we want independent "values" for our variables. This is why we use the new operation in conjunction with constructors.
• When you pass objects to methods, you are, in effect, passing references to those objects. This means that if a method modifies one of its parameters, it will modify it globally, and not just in the routine.
• Note that the separation of name from object is a common one. You might refer to me as "Sam", "SamR", "The person teaching today's class", and so on and so forth. In Java-esque syntax

    // The current teacher I have to deal with.
    Teacher current_teacher;
    ...
    // Oh boy, time to work in 152.
    current_teacher = samr;
    ...
    // Time for the cool languages reading group.
    current_teacher = stone;
    ...
  

  • In this example, we assume that samr and stone have already been make to refer to particular objects.

Conditionals

• The if or conditional statement is one of the simplest control structures.
• Java provides the two basic forms of the if statement.
• if (test) statement executes the statement only when the test holds.
  • Note that the test must return a boolean (truth) value.
  • Note that the test must be surrounded by parentheses.
• if (test) statement else statement selects between the two statements. It executes the first if the test evaluates to true and the second if it evalutes to false.
• Java does not provide a special facility for nesting if statements.

Constructors

• Along with creating new objects, we may need to initialize the objects (assigning values to particular fields, allocating new objects for some fields, etc.)
• Classes can include constructors that describe how to create such objects.
• Constructors can have parameters that are used in the initialization of the object.

• Constructors look very much like methods, with the difference that they have the same name as the class.
• Java is something of a polymorphic language: it permits you to define multiple methods or constructors with the same name, as long as they have different parameter types.
• This is particularly important for constructors, as there are many different ways that we may want to describe a new object.

• For our sample Complex class, we'll have three constructors:
  • A default constructor, with no parameters
  • A constructor used for converting doubles to complex numbers (so the imaginary part should be 0)
  • A constructor that takes both a real and imaginary part
• Here are the three constructors:

    /**
     * Initialize to 0.0 + 0.0i
     */
    public Complex() 
    {
      real_part = 0.0;
      imaginary_part = 0.0;
    } // Complex()
    /**
     * Initialize to x + y*i
     */
    public Complex(double x,double y) 
    {
      real_part = x;
      imaginary_part = y;
    } // Complex(double,double)
    /**
     * Initialize to x + 0.0i
     */
    public Complex(double x) 
    {
       real_part = x;
       imaginary_part = 0.0;
    } // Complex(double)
  

• If you don't declare any constructors, Java uses a default constructor with no parameters.
• If you do declare constructors, that default constructors is no longer available.
• When building classes for this course, you should always define constructors.
• You can have one constructor call another by using this. For example, we might redefine the simplest constructor as

    /**
     * Initialize to 0 + 0i.
     */
    public Complex() 
    {
      this(0.0, 0.0);
    } // Complex()
  

• It is generally considered a good strategy to create one general constructor and have your other constructors call it.