Outline of Class 16: Objects, Revisited

Held: Thursday, March 12, 1998

Administrivia

• Assigned:
  • read chapter 5 (if you haven't done so already)
  • journal assignment 13
  • journal assignment 14
  • computing assignment 8
• Due:
  • problem set 6
  • computing assignment 7
  • journal assignment 11
  • journal assignment 12
  • Late materials
• We'll spend most of today on a simulation lab. This is an experimental lab (that is, I just developed it over the past few days and I'm not sure that it will work).

Java Basics, Revisited

• In Java, you program by defining classes, constructing instances of (objects from) those classes, and doing things with those instances.
• Each class is stored in a separate file. (Okay, you can combine the source code for a number of classes into one file, but when compiled they are broken into separate files.)
• When building large projects, you often group classes into packages. We'll come back to these later.
• What are the components of a class? (Not in order.)
  • The class name
  • The protection level of the class (for now, we'll just use public)
  • The body of the class, which includes
    • attributes (also called fields), which are then customized for each instance of the class
    • methods, which may behave differently for each instance of the class
    • class attributes, which belong to the class as a whole, rather than to any individual members (we'll come back to these later)
    • class methods, which belong to the class as a whole, and are not associated with individual members
    • constructors, which describe how to build instances of the class
    • destructors, which describe how to get rid of instances of the class
• How do you define a class?
  • A class definition begins with the keyword class and the name of the class. Custom says that we capitalize the names of classes.
  • The body of the class begins with a left brace, and ends with a right brace.
  • Attributes are declared by writing the class (or primitive type) of the attribute, followed by the name of the attribute, followed by a semicolon.
  • Java allows you to restrict access to classes. To make a class generally accessible, you precede the keyword class with public.
  • Java allows you to base classes on other classes. We'll get back to this later.
  • Java allows you to indicate that your class will support particular sets of actions. We'll get back to this later.
  • Attributes can also have protection modifiers (like the public we use with the class).

• The "primitive types" mentioned above are the primary building blocks of objects. They are the basic kinds of values that the Java machine knows about, and include
  • boolean, for true/false values
  • char, for characters (unlike many other languages, Java officially supports more than just the basic American set; it has built-in support for full Unicode)
  • byte, for very small integers in the range -128 to 127 (integers are numbers without fractional portions)
  • short, for small integers in the range -32,768 to 32,767.
  • int, for integers in the approximate range -2 billion to 2 billion
  • long, for integers in a much bigger range
  • float, for numbers that may have a fractional component (e.g., 10.32533).
  • double, for better accuracy
  • See p. 227 of Flanagan for full list.
• The names are composed of letters, numbers, and underscores (and perhaps a few other things) and must begin with a letter or underscore.

• Here's a simple class definition of a class that has no methods.

  public class Complex
  {
    double real_part;
    double imaginary_part;
  }
  

• This says that class Complex has two fields, each of type double.
• As I suggested earlier, you should include a number of comments in your program. Hence, a more appropriate version would be.

  /**
   * A simple representation of Complex Numbers.
   *
   * @author Samuel A. Rebelsky
   * @version 1.1 of January 1998
   */
  public class Complex
  {
    /**
     * The real part of a complex number in standard format. 
     * The "x" in "x + y*i".
     */
    double real_part;
    /**
     * The imaginary part of a complex number in standard format.
     * The "y" in "x + y*i".
     */
    double imaginary_part;
  } // Complex
  

• Note that I may not include all these comments in my sample code, but you should plan to.

• How do you get a new object from this class? Traditionally, you can declare a new object with
  class-name variable-name = new class-name()
• For example,
  Complex c1 = new Complex()

• To define a method of a class, you provide
  • The return type of the method (you return values from methods with the return statement).
  • The name of the method
  • An open paren
  • The list of parameters to the method
  • A close paren
  • An open brace
  • The body of the method (a series of statements, each of which is terminated by a semicolon)
  • A close brace
• You can also preface the return type with a number of modifiers, which we'll come back to later.
• Standard methods can refer to the attributes associated with the class (and ancestor classes, but we'll get back to that later).
• To call the method associated with an object, you use
  • the object's name
  • a period
  • the method's name
  • an open paren
  • the paremeters to the method
  • a close paren
• Note that this is somewhat different than in a language like C or Pascal, in which the object would be one of the parameters.

• Here's our sample class, extended with three methods, one to set the parts, one to get the real part, and one to get the imaginary part.

  /**
   * A simple representation of Complex Numbers.
   *
   * @author Samuel A. Rebelsky
   * @version 1.1 of January 1998
   */
  public class Complex
  {
    /**
     * The real part of a complex number in standard format. 
     * The "x" in "x + y*i".
     */
    double real_part;
    /**
     * The imaginary part of a complex number in standard format.
     * The "y" in "x + y*i".
     */
    double imaginary_part;
    /**
     * Set the value of our imaginary number.
     */
    public void setValue(double rpart, double ipart)
    {
      real_part = rpart;
      imaginary_part = ipart;
    } // setValue
    /**
     * Get the real part of this complex number.
     */
    public double getReal()
    {
      return real_part;
    } // getReal
    /**
     * Get the imaginary part of this complex number.
     */
    public double getImaginary()
    {
      return imaginary_part;
    } // getImaginary
  }  // Complex
  

• How does Java know where to begin executing your program, especially when you may have multiple classes, each with multiple methods? You must tell the Java interpreter which class to begin with, and that class must have a special main method, which is where the interpreter begins. main has type void and must be public and static. It takes one parameter, an array of strings.
• Here is a main routine for our sample class

  /**
   * Test various aspects of our complex class.
   */
  public static void main(String[] args) {
    // Set up an object for printing output
    SimpleOutput out = new SimpleOutput();
    // Set up a new complex variable
    Complex c1 = new Complex();
    // Print the initial values of the real number
    out.print("Initially, the real part is ");
    out.println(c1.getReal());
    out.print("Initially, the imaginary part is ");
    out.println(c1.getImaginary());
    // Set the value to a particular value and see if it's changed
    c1.setValue(1.0,3.4);
    out.print("Now, the real part is ");
    out.println(c1.getReal());
    out.print("Now, the imaginary part is ");
    out.println(c1.getImaginary());
    // Exit gracefully
    System.exit(0);
  } // main
  

Inheritance

• Java, like most object-oriented languages, lets you subclass existing classes to refine their functionality for particular instances.
• For example, we might have a general DrawableObject class and refine that to particular drawable objects, such as Circle or Square.
• How do you indicate that one class is a subclass of another? With the extends keyword.

  public class Circle
    extends DrawableObject
  {
    ...
  } // Circle
  

• A subclass inherits all the methods and fields of its superclass (with some restrictions due to protection mechanisms).
  • That is, it can use those methods and fields without explicitly defining or declaring them.
• A subclass may also override any of these methods by including its own definition.
  • That is, if a class defines any methods with the same name and argument types as the superclass, then that method is used instead.
• Inheritance is used in two ways. First, it's used to automatically provide some core functionality. In addition, it's used guarantee the functions an object will provide. Since an object inherits all of the ancestors methods, someone using the object knows that they will all be available.
• Java allows you to use a member of a subclass anywhere a member of a superclass is permitted. For example, it is perfectly valid to write:

  DrawableObject obj = new Circle();
  

• Similarly, if you write a function that uses a superclass, you can pass in a member of the subclass.

  public void drawWithStrangeColors(DrawableObject obj)
  {
  ...
  } // drawWithStrangeColors(DrawableObject)
  ...
  drawWithStrangeColors(new Circle());
  

• Java is much more restrictive on using members of superclasses in place of members of subclasses.
• Why do you think Java has these restrictions?
• Note that if you do not provide an extends clause, Java assumes that your object extends java.lang.Object.
• Java permits only single inheritance -- a particular class can only directly derive from one other class.
  • In the alternative, multiple inheritance -- a particular class can directly derive from more than one other class.
  • Single inheritance makes analysis and design much easier. Otherwise, there are potential problems with the same method name being defined in both parent classes.
  • Java provides interfaces to support many of the needs of multiple inheritance.

A Balloon Race

• If we were to design a balloon race, what are the objects we might include, and what attributes and methods are appropriate for each object?
• It might be best to begin by describing in English what happens in a balloon race. If we circle the nouns, we'll get some idea of the objects we'll need.
• Once we have a list of objects, we can also use the English description to see how they'll interact. That sense of interaction may suggest both attributes and methods.
• I've chosen to use the following classes of objects:
  • Balloons which are the contestants in the race
  • Strategists who decide what to do given the current status of the race
  • Wind that blows the balloons
  • A balloon race that ties it all together and provides the visual interface.
• We'll look at details in class.

Lab

We'll work on computing assignment 8, which delves further into this simulation.