JETT Workshop - Object-Oriented Programming

Computer Science (CSCI) Department
College of Engineering, Computer Science, & Technology (ECST)

JETT Workshops
Object-Oriented Programming

Fall 2004

Designing Classes

(Example code and figures from Computing Concepts with Java Essentials, 3rd edition, by Cay Horstmann.
Visit www.wiley.com/college/horstmann for information on the current edition of this excellent text.)

from the AP CS Java Subset
- Method overloading (e.g. MyClass.method(String str) and MyClass.method(int num)) is part of the AP Java subset.
  - Students are expected to know that the signature of a method depends only on the number, types, and order of the parameters, and not on its return type.
- Visibility:
  - In the AP Java subset, all classes are public.
  - All instance variables are private.
  - Methods, constructors, and constants (static final variables) are either public, or private.
  - The AP Java subset does not use protected and package (default) visibility.
Choosing Classes
- a class represents a single concept
  - concepts from mathematics:
    Point
    Rectangle
    Ellipse
  - concepts from real life
    BankAccount
    Purse
  - actors (end in -er, -or)
    StringTokenizer
  - utility classes--no objects, only static methods
    Math

general guideline
- look for nouns in the problem description - these are your classes
- look for verbs - these are your methods

Cohesion

cohesive = public interface closely related to the single concept that the class represents

this class lacks cohesion - Purse.java

public class Purse
{
   public Purse(){...} 
   public void addNickels(int count){...} 
   public void addDimes(int count){...} 
   public void addQuarters(int count){...} 
   public double getTotal(){...} 
   public static final double NICKEL_VALUE =0.05; 
   public static final double DIME_VALUE =0.1; 
   public static final double QUARTER_VALUE =0.25; ... 
}

there are really two concepts: purse and coin

the solution - make two classes:

Coin.java

Purse.java

public class Coin 
{ 
   public Coin(double aValue,String aName){...} 
   public double getValue(){...} 
   ... 
}

public class Purse 
{ 
   public Purse(){...} 
   public void add(Coin aCoin){...} 
   public double getTotal(){...} 
   ... 
}

Coupling

a class depends on another if it calls one of its methods
Purse depends on Coin because it calls getValue on coins
Coin does not depend on Purse
high coupling = many class dependencies
minimize coupling to minimize the impact of interface changes

Accessor and Mutator Methods

accessor method - does not change the state of the implicit parameter (e.g. getBalance)
mutator method - changes the state of the implicit parameter (e.g. deposit )
- rule of thumb - a mutator method should return void

from the AP CS Java Subset
- The AP Java subset uses /* */, and // comments. Javadoc comments are not part of the subset.
Preconditions

publish preconditions so the caller won't call methods with bad parameters

/**
   Deposits money into this account.
   @param amount the amount of money to deposit
   (Precondition: amount >= 0)
*/

typical use:

to restrict the parameters of a method

to require that a method is only called when the object is in an appropriate state

method can do anything if called when precondition not fulfilled

Postconditions

postcondition - a condition that's true after a method has completed

/**
   Deposits money into this account.
   (Postcondition: getBalance() >= 0)
   @param amount the amount of money to deposit
   (Precondition: amount >= 0)
*/

don't document trivial postconditions that repeat the @return clause
contract - if caller fulfills precondition, method must fulfill postcondition

from the AP CS Java Subset
- static
  - The concept of static methods is a part of the subset.
  - Students are required to understand when the use of static methods is appropriate.
  - In the exam, static methods are always invoked through a class, never an object (i.e., ClassName.method(), not obj.method()).
  - Static final variables are part of the subset, other static variables are not.
- final
  - The final keyword is only used for final block scope constants and static final class scope constants.
  - final parameters or instance variables, final methods and final classes are not in the subset.

Static Methods

every method must be in a class
static method - a method that does not need (and does not have) an implicit parameter
a static method can't access instance variables in its class

example - when all parameters are primitive types

class Numeric
{  
   public static boolean approxEqual(double x, double y)
   {  
      . . .
   }
}

you call the method with the class name instead of object:
if (Numeric.approxEqual(a, b)) . . .
static methods are also called class methods
main( ) is static--there aren't any objects yet
too many static methods are a sign of too little OO thinking

Static Variables

static variable - one copy of the variable per class

all objects of that class share the variable

public class BankAccount
{
   public BankAccount()
   {
      lastAssignedNumber++;               // increment static field
      accountNumber = lastAssignedNumber; // set instance field
   }
   . . .
   private double balance;
   private int accountNumber;
   private static int lastAssignedNumber;
}

minimize the use of static fields (static final fields are ok)

A Static Field and Instance Fields

Scope

scope of variable - region of program where you can refer to the variable by its name
local variable scope: from definition to end of block
class scope: all methods of the class
you must qualify public members outside scope, e.g. Math.sqrt
overlapping scope: local scope wins over class scope
when this happens the field name is said to be shadowed by the local name

to access the field name, use this

public class Coin
{
   public void draw(Graphics2D g2)
   {
      String name = "SansSerif";         // local scope
      g2.setFont(new Font(name, . . .)); // local name
      g2.drawString(this.name, . . .);   // field name
   }
   ...
   private String name;                  // class scope
}