Developing Classes that have Static Members

Developing Classes that have Static Members
With Examples in Java

Prof. David Bernstein
James Madison University

Computer Science Department

bernstdh@jmu.edu

Review

The Process Thus Far

Read the textual description
Create an initial encapsulation with private attributes
Add a constructor
Add a toString() method
Add an equals() and/or compareTo() method
Add necessary accessors
Add necessary mutators
Add useful private methods (i.e., helper methods)
Add convenient overloaded methods
Add convenient overloaded constructors

Motivation

One Observation:
- Sometimes a class has attributes and/or all of the objects in a class have the same value for one or more attributes
Another Observation:
- Sometimes an object's behavior does not depend on its attributes (in which case, it is as if the behavior belongs to the class)

Class Attributes

Definition:
- Attributes that belong to a class (or all of its instances) rather than individual instances of a class
Implication:
- They can be used without instantiating an object
Java:
- Must be declared static

Class Attributes (cont.)

Common Uses:
- Class constants, flags and special values
- Common values (across all instances)
- Object counters
An Observation:
- These situations may arise both in classes you develop and classes you use

Class Attributes - Constants etc...

In the Integer Class:
- MIN_VALUE
- MAX_VALUE
In the Double Class:
- NEGATIVE_INFINITY
- POSITIVE_INFINITY
- MIN_VALUE
- MAX_VALUE
In the Math Class:
- E (base of the natural log)
- PI

Class Attributes - Constants etc... (cont.)

An Improved PictureFrame Class

javaexamples/oopbasics/pictureframe/staticattributes/PictureFrame.java

/**
 * An encapsulation of a picture frame.
 *
 * This version makes use of static attributes.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 4.0
 */
public class PictureFrame
{
    private static final double DOLLARS_PER_IN_OF_FRAME    = 0.15;
    private static final double DOLLARS_PER_SQ_IN_OF_GLASS = 0.05;    
    private boolean    stand;    
    private double     height, matte, width;
    
    /**
     * Construct a PictureFrame object.
     *
     * Note: Negative values are converted to positive values 
     * and the width and height are put in canonical form 
     * (i.e., a portrait orientation).
     *
     * @param width   The width (in inches)
     * @param height  The height (in inches)
     * @param matte   The size of the matte (in inches) on all 4 sides
     * @param stand   true if there is a built-in stand
     */
    public PictureFrame(double width, double height, double matte, 
                        boolean stand)
    {
        double     h, w;
        
        h = Math.abs(height);
        w = Math.abs(width);

        this.width  = Math.min(w, h);
        this.height = Math.max(w, h);
        this.matte  = Math.abs(matte);
        this.stand  = stand;
    }

    /**
     * Calculate the area of this PictureFrame.
     *
     * @return  The area (in square inches)
     */
    private double area()
    {
        return width * height;
    }

    /**
     * Calculate the area of the matte.
     *
     * @return  The area (in square inches)
     */
    private double matteArea()
    {
               // Top and Bottom   + Sides (not including the top and bottom)
        return 2.0*(matte * width) + 2.0*(matte * (height - 2.0*matte));
    }

    /**
     * Calculate the perimeter of this PictureFrame.
     *
     * @return  The area (in inches)
     */
    private double perimeter()
    {
        return 2.0*width + 2.0*height;
    }

    /**
     * Return true if the owning PictureFrame and the given PictureFrame
     * have the same attributes.
     *
     * @return  true if the attributes are the same; false otherwise
     */
    public boolean equals(PictureFrame other)
    {
        return (this.width == other.width) && (this.height == other.height)
            && (this.matte == other.matte) && (this.stand == other.stand);
    }

    /**
     * Return the cost of this PictureFrame (which is a function
     * of the perimeter and the area) in dollars.
     *
     * @return   The cost
     */
    public double getCost()
    {
        double     frame, glass;
        
        frame = perimeter() * DOLLARS_PER_IN_OF_FRAME;
        glass = area() * DOLLARS_PER_SQ_IN_OF_GLASS;

        return frame+glass;
    }

    /**
     * Get the height of this PictureFrame.
     *
     * @return   The height
     */
    public double getHeight()
    {
        return height;
    }

    /**
     * Get the size of the matte.
     *
     * @return   The size of the matte
     */
    public double getMatte()
    {
        return matte;
    }

    /**
     * Get the width of this PictureFrame.
     *
     * @return   The width
     */
    public double getWidth()
    {
        return width;
    }

    /**
     * Return the visible area (in square inches) of the content
     * contained in this PictureFrame.
     *
     * @return   The visible area
     */
    public double getVisibleArea()
    {
        return area() - matteArea();
    }

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @return  The String representation
     */
    public String toString()
    {
        String      result;
        
        result = String.format("%5.2f in. x %5.2f in.", width, height);
        if (matte > 0.0)
            result += String.format(" with a %5.2f in. matte", matte);
        if (stand)
            result += " (w/ stand)";
        
        return result;
    }
}

Class Attributes - Constants etc... (cont.)

Building a Model of Memory

  PictureFrame    p, q;
  p = new PictureFrame(8.0, 10.0, 0.0, false);
  q = new PictureFrame(3.0,  5.0, 0.0, false);

  System.out.printf("Cost: %6.2f\n", p.getCost());

Class Attributes - Constants etc... (cont.)

Could We Use Instance Attributes?
- Yes
How Can We Know?
- Build a model of memory and trace a method call assuming they aren't static
Why Shouldn't We?
- It is confusing to do so because non-static attributes should be defining characteristics of instances of the class
- It wastes memory (though this is of secondary importance)

Class Attributes - Common Values

An Example

public class ProgressiveSlotMachine
{
    // Attributes of the class
    private static double      jackpot;


    // Attributes of objects
    private double             currentBet;

    .
    .
    .


    private void handleLosingSpin()
    {
        jackpot = jackpot + 0.5 * currentBet;
    }
}

Class Attributes - Object Counters

An Example

/**
 * A user account
 */
public class UserAccount
{
    // Attributes of the class
    private static   int              nextAccountNumber;


    // Attributes of objects
    private          int              accountNumber;
    private          String           name;



    /**
     * Explicit Value Constructor
     *
     * @param name   The name of the account holder
     */
    public UserAccount(String name)
    {
        // Store the name
        this.name     = name;

        // Store the account number
        accountNumber = nextAccountNumber;

	// Setuup the account number for the next account
        nextAccountNumber++;
    }

Class Attributes - Object Counters (cont.)

Building a Model of Memory

  UserAccount         u, w;
  u = new UserAccount("Fred");
  w = new UserAccount("Wilma");

Class Attributes - Common Attributes and Counters (cont.)

Could We Use Instance Attributes?
- No
Why Not?
- Each object would have its own value (which is exactly what we are trying to avoid)
How Can We Know?
- Build a model of memory and trace a method call assuming they aren't static

Class Behaviors

Definition:
- Methods that belong to a class rather than instances of a class
Implication:
- They can be used without instantiating an object
Java:
- Must be declared static

Class Behaviors (cont.)

Common Uses:
- Type conversion
- "Factory" methods
- Attribute-free calculations
An Observation:
- These situations may arise both in classes you develop and classes you use

Class Behaviors - Type Conversion

In the Integer Class:
- parseInt()
- toString()
In the Double Class:
- parseDouble()
- toString()

Class Behaviors - Attribute-Free Methods

In the Math Class:
- abs()
- max() and min()
In the Color Class:
- RGBtoHSB()

Class Attributes - Attribute-Free Methods (cont.)

Could We Use Instance Methods?
- Yes
Why Shouldn't We?
- It is confusing to do so because non-static methods should be behaviors that define instances of the class
- It is inconvenient (e.g., Why should we be required to construct an instance of a Math object to calculate the square root of a number?)

Class Behaviors - "Factory" Methods

Definition:
- Methods that are used like constructors
Observations:
- Sometimes construct the object when asked, sometimes construct a "pool" and just return one when asked
- Sometimes have obvious names (like getInstance()) and sometimes do not

Class Behaviors - "Factory" Methods (cont.)

In the String Class:
- format()
- valueOf()
In the NumberFormat Class:
- getInstance()
In the Color Class:
- getColor()

Class Attributes - "Factory" Methods (cont.)

Could We Use Instance Methods?
- No
Why Not?
- We would have to have an object in order to create one

A Common Mistake

Three Related Questions:

What happens if you use a non-static attribute/method in a static method, why, and when?

public class Interval {

  private double left, right;

  public Interval(double l, double r) {
    left = l;
    right = r;
  }

  // What's happens here, why, and when?
  public static double getLength() {
    return right - left;
  }
}

Another Question:
- How do you fix this problem? (Hint: The answer is not to behave like 10,000 monkeys at 10,000 keyboards!)

A Common Mistake (cont.)

Where Else Beginning Programmers Often Encounter This:

In the main() method of the main class

public class Game {

  private int lives;

  // What's happens here and why? (And when?)
  public static void main(String[] args) {
    lives = Integer.parseInt(args[0]);
  }
}

Another Question:
- How do you fix this problem? (Hint: Again, the answer is not to behave like 10,000 monkeys at 10,000 keyboards!)

A Common Confusion

One Question:
- Can I use a static attribute/method as if it is non-static?
Another Question:
- Should I?

The Process Thus Far

Read the textual description
Create an initial encapsulation with private attributes
Add a constructor
Add a toString() method
Add an equals() and/or compareTo() method
Add necessary accessors
Add necessary mutators
Add useful private methods (i.e., helper methods)
Add convenient overloaded methods
Add convenient overloaded constructors
Add necessary static attributes
Add necessary static methods