Reading:

• Chapter 9, Sections 9.1-9.4, 9.6

This chapter contains conceptually complex material that is central to the course, so it is worth spending time going through it carefully. Do these exercises as you finish reading each section and if things don’t make sense, ask questions, post to the discussion forum, send emails.

As with previous chapters, the Processing-specific material is collected in the example sections; the main sections are general, Java-based in nature.

9.2. Class Design

Focus here on Sections 9.2.1-9.2.2.

• Consider the problem of building a two-dimensional coordinate class, that is, a class for points (x, y). Java doesn’t support such a type, so we’ll focus on building one ourselves. Processing already supports a point class and would allow us to draw (and animate!) the points, but we’ll focus on a simpler, Java version of the class here. What attributes and behaviors would be required to represent a point?

9.3. Class Implementation

Focus here on Sections 9.3.1-9.3.2.

• Implementing Class Attributes

  • Implement the attributes you identified for your coordinate class in the previous question. Use the appropriate type(s), make them private and wrap them in a Coordinate class following the model of the temperature class detailed in the text.
  • Explain the notion of encapsulation. Why is it valuable? What have you encapsulated in your coordinate class so far?
  • Explain the notion of information hiding. Why is it valuable? What information have you hidden in your coordinate class so far?
  • Are there any class invariants you must enforce for your coordinate class or any static constants? Let us know if you can; we can’t think of any meaningful ones!

• Implementing Class Behaviors

  There are quite a few sub-sections here. On the first round, the most important are those on the toString() method, the constructors (default and explicit-value) and the accessors. Start by understanding those, and then move to the other more detailed discussions of the Temperature class behaviors.

  • Add an appropriate toString() method for your coordinate class. It should print a coordinate x, y as: (x, y)
  • Write a default constructor that initializes your coordinate object to the origin (0, 0).
  • A programmer should now be able to write a Java application like this:

    public class CoordinateConsole {
    
    	public static void main(String[] args) {
    		Coordinate c1 = new Coordinate();  // Construct a default coordinate.
    		System.out.println(c1);            // Print out that new coordinate.
    	}
    
    }
    

    And this program should print out the following:

    (0.0, 0.0)
    

  • Draw a picture of what your coordinate object looks like in memory.
  • Now, write an explicit-value constructor that receives an x and a y value and initializes your coordinate object using those values. Because there are no meaningful invariants to enforce your constructor can simply save the two coordinate values into the instance variables without checking their values.
  • A programmer should now be able to write a second Java application like this:

    public class CoordinateConsole {
    
    	public static void main(String[] args) {
    		Coordinate c2 = new Coordinate(1, 2);  
    		System.out.println(c2);            
    	}
    
    }
    

    And this program should print out the following:

    (1.0, 2.0)
    

  • Draw a picture of what this coordinate object looks like in memory.
• Finally, add accessor methods for your x and y coordinate values. When you’ with this, a programmer should now be able to write a Java application like this:

  public class CoordinateConsole {
  
  	public static void main(String[] args) {
  		Coordinate c2 = new Coordinate(1, 2);  
  		System.out.println(c2.getX());
  		System.out.println(c2.getY());
  	}
  
  }
  

  And this program should print out the following:

  1.0
  2.0
  

• The other material in this section on overloading, static/instance methods, mutators and other utilities and methods will be valuable as well, but start with the material outlined above.

9.4. Object Interaction

This section discusses the interaction of multiple class objects. For example, consider the case of adding two coordinate objects together where we would view the result at the sum of the vectors represented by the coordinates. For example, adding the coordinates (1, 2) and (3, 4) would result in a new coordinate (4, 6).

• This new coordinate addition method should receive another coordinate object from the calling program and return a new coordinate object whose x and y values are computed by summing the x and y coordinates of the current object and the other object. Assuming an existing coordinate class that implements two instance variables: myX and myY, the following method implements the coordinate summation method:

  public Coordinate add(Coordinate otherCoordinate) {
  	return new Coordinate(myX + otherCoordinate.getX(), myY + otherCoordinate.getY());
  }
  

  Given this method, a programmer could write:

  public class CoordinateConsole {
  
  	public static void main(String[] args) {
  		Coordinate c2 = new Coordinate(1, 2);
  		Coordinate c3 = new Coordinate(3, 4);  
  		System.out.println(c1.add(c2));
  	}
  
  }
  

  And this program should print out the following:

  (4.0, 6.0)
  

  Play with this example for a bit to make sure that you understand the implementation. Pay attention to a couple issues:

  • The add() method must receive an “other” coordinate and add “itself” to that other coordinate. In addition, it does not modify either itself or the other coordinate; instead, it constructs a new coordinate and returns that as a result.
  • This notation is a bit odd. Instead of saying c3 + c4, the programmer is required to write c3.add(c4). This is a common feature in object-oriented languages.

9.5. Revisiting the Example

This chapter focuses on the Processing-based example. Go through it only if you’re interested in classes in Processing.

9.6. Object-Oriented Programming

Just read this short section and look forward to Chapter 11!