• What is a set?
  A finite or infinite collection of unique elements/members (in which order may or may not have significance)
• How are sets defined?
  Extension - Listing all of the elements/members
  (e.g., \(S = \{1, 3, 5\}\))
  Intension - Describing the properties of the elements/members
  (e.g., \(T = \{t: 0 \leq t \leq 10\}\))

• Definition:
  • A definition of a set that is written in terms of the properties of the elements/members (i.e., an intensive definition of a set)
  • The set of elements/members so defined
• What is an object?
  • An element/member of the set
• Encapsulation:
  • (v) The process of defining an entity in terms of its characteristics
  • (n) A result of the encapsulation process

• What is involved in designing and implementing a class?
  • Creating an intensive definition (i.e., a list of attributes and behaviors)
• What is involved in designing and implementing the attributes?
  • Declaring the names and types of instance variables
  • Declaring the names and types of class variables
• What is involved in designing and implementing the behaviors?
  • Declaring the signatures of instance and class methods
  • Implementing the bodies of instance and class methods

1. Create an initial encapsulation
2. Refine the encapsulation
3. Identify constructors
4. Think about the need for private methods
5. Identify helpful overloaded methods
6. Identify class attributes
7. Identify class behaviors

• When Things are Simple:
  • A brief textual description (i.e., a paragraph or two), written by a single person, that contains a discussion of what needs to be remembered about the entity and what the entity needs to be able to do.
• In Most Situations:
  • Possibly conflicting lists of needs and desires from all of the stakeholders. (More on this when you study software engineering.)

An Example of a Textual Description

A picture frame is used to display a picture. It always has a width and height (measured in inches). It may or may not have a matte/border (also measured in inches). If it has a matte, it is the same size on all four sides. One can calculate the visible area of a picture frame from its area and the area of the matte.

A picture frame may or may not have a stand.

One can calculate the cost of a picture frame from the amount of material used in the perimeter of the frame itself and the area of the glass.

• Instance Attributes/Fields:
  • Identify the noun phrases in the description
  • Think about the data types to use for each noun phrase
• Instance Behaviors/Methods:
  • Identify the verb phrases in the description
  • Think about the parameters for each verb phrase

1. Make all instance attributes private
2. Provide "get" methods (called accessors) where needed
3. Provide "set" methods (one type of mutator) methods where needed

An Example

A picture frame is used to display a picture. It always has a width and height (measured in inches). It may or may not have a matte/border (also measured in inches). If it has a matte, it is the same size on all four sides. One can calculate the visible area of a picture frame from its area and the area of the matte.

A picture frame may or may not have a stand.

One can calculate the cost of a picture frame from the amount of material used in the perimeter of the frame itself and the area of the glass.

An Example

public class PictureFrame
{
    private double    width;
    private double    height;
    private double    matte;

    private boolean   stand;
    private boolean   hasMatte;

    public double calculateVisibleArea(){return 0.0;}
    public double calculateCost(){return 0.0;}
}

• Local Variables:
  • Should be used whenever possible
  • Remember that local variables can be passed between methods
• Instance Attributes:
  • Should be essential to the definition of the class
  • Should define the "state" of the objects in the class
  • Should not be redundant

Overuse of Instance Attributes

javaexamples/oopbasics/Screen.java

import java.io.*;
import java.text.*;

/**
 * A simple class that performs formatted output to the
 * console (i.e., standard output)
 *
 * Note: This class uses attributes in places where it would be
 *       better to use local variable 
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0bad
 */
public class Screen
{
    private boolean               group;
    private int                   minLeft, maxLeft, minRight, maxRight;
    private NumberFormat          formatter;
    private OutputStreamWriter    osw;
    private PrintWriter           out;
    private String                formattedString, outputString;

    /**
     * Default Constructor
     */
    public Screen()
    {
        osw = new OutputStreamWriter(System.out);
        out = new PrintWriter(osw);
    }



   /**
     * Create a NumberFormatter object
     */
    private NumberFormat createFormatter()
    {
        formatter = NumberFormat.getInstance();
        formatter.setMinimumIntegerDigits(minLeft);
        formatter.setMaximumIntegerDigits(maxLeft);
        formatter.setMinimumFractionDigits(minRight);
        formatter.setMaximumFractionDigits(maxRight);
        formatter.setGroupingUsed(group);

        return formatter;
    }


    /**
     * Format an int as a String 
     *
     * @param  value  The int to format
     * @return        The appropriately formatted String
     */
    private String format(int value)
    {
        minLeft  =  0;
        maxLeft  = 15;
        minRight =  0;
        maxRight =  0;
        group    = false;
        formatter = createFormatter();
        formattedString = formatter.format(value);

        return formattedString;
    }




   /**
     * Print an int
     *
     * @param value   The value
     */
    public void printInt(int value)
    {
        outputString = format(value);
        out.print(outputString);
        out.flush();
    }

}
    
        

Eliminating a Redundancy

public class PictureFrame
{
    private double    width;
    private double    height;
    private double    matte; // 0.0 when there is no matte

    private boolean   stand;

    public double calculateCost(){return 0.0;}
    public double calculateVisibleArea(){return 0.0;}
}

• Look for Similar Behaviors:
  • Do they just handle positive/negative numbers differently?
  • Do they just handle upper/lower case differently?
• Look for Missing Behaviors:
  • Have multiple behaviors been rolled into one?
  • Most classes should have a "to string" behavior
  • Most classes should have an "equals" behavior

Adding equals() and toString() Methods

public class PictureFrame
{
    private double    width;
    private double    height;
    private double    matte; // 0.0 when there is no matte

    private boolean   stand;

    public double calculateCost(){return 0.0;}

    public double calculateVisibleArea(){return 0.0;}

    public boolean equals(PictureFrame other) {return false);

    public String toString(){return "";}
}

• Purpose:
  • Initialization that need to be performed when an object is created
• Syntax:
  • Have no return type and the same name as the class

An Example

javaexamples/oopbasics/pictureframe/start/PictureFrame.java

/**
 * An encapsulation of a picture frame.
 *
 * Note: The attributes are public in this version because we
 * have not yet discussed information hiding.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class PictureFrame
{
    public boolean    stand;    
    public 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;
    }
    /**
     * Return the cost of this PictureFrame (which is a function
     * of the perimeter and the area) in dollars.
     *
     * @return   The cost
     */
    public double calculateCost()
    {
        double     frame, glass;
        
        frame = (2.0*width + 2.0*height) * 0.15;
        glass = (width * height) * 0.05;

        return frame+glass;
    }

    /**
     * Return the visible area (in square inches) of the content
     * contained in this PictureFrame.
     *
     * @return   The visible area
     */
    public double calculateVisibleArea()
    {
        return (width - 2.0*matte) * (height - 2.0*matte);
    }
    /**
     * 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 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;
    }
}
        

• Overloaded Constructors:
  • Multiple constructors with different parameters
• Terminology:
  • The default constructor has no parameters and assigns default values to the parameters
  • The copy constructor has a parameter of the same type as the object being constructed and makes a (deep) copy of its parameters
  • All other are called explicit value constructors

• Reducing Code Duplication:
  • Constructors can call other methods
  • Constructors can call other constructors using this() provided the calls are made in the first statement
• Automatic Constructor in Java:
  • A default constructor is created by Java if no constructor is provided
  • If any constructor is provided then you must explicitly include a default constructor if you want to have one

Adding Copy, Default, and Explicit Value Constructors

javaexamples/oopbasics/pictureframe/overloadedconstructors/PictureFrame.java (Fragment: Constructors)

    /**
     * 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;
    }
    
    /**
     * Construct a PictureFrame object with no matte and no stand.
     *
     * @param width   The width (in inches)
     * @param height  The height (in inches)
     */
    public PictureFrame(double width, double height)
    {
        this(width, height, 0.0, false);
    }
    
    /**
     * Default Constructor.
     *
     * Construct a 3x5 PictureFrame with no matte and no stand.
     */
    public PictureFrame()
    {
        this(3.0, 5.0, 0.0, false);
    }
    
    /**
     * Copy Constructor.
     *
     * @param other   The PictureFrame to copy
     */
    public PictureFrame(PictureFrame other)
    {
        this(other.width, other.height, other.matte, other.stand);
    }
        

A Common Mistake

    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;
    }
    
    public PictureFrame(double width, double height)
    {
        PictureFrame     frame;

        frame = new PictureFrame(width, height, 0.0, false);
    }

• Copy Constructors are Particularly Important for Mutable Objects:
  • Aliases are not very dangerous when working with immutable objects
• A Common Convention:
  • The clone() method creates a shallow copy
  • The copy constructor creates a deep copy

In this example, since both of the attributes are primitive types, the distinction between shallow and deep copies does not arise.

javaexamples/basics/Pair.java (Fragment: CopyConstructor)

    /**
     * Copy Constructor
     */
    public Pair(Pair other)
    {
       this.a = other.a;
       this.b = other.b;
    }
        

If, for example, the Pair class included a String attribute named id, then a shallow copy would include the statement:

  this.id = other.id;              // this.id is an alias for other.id
  

whereas a deep copy would include the statement:

  this.id = new String(other.id);  // Use the copy constructor in String
  

• Defined:
  • A private method can not be used by objects of another class or called by functions outside of the class in which it is defined
• What Use Are They?
  • They generally act as "helpers"

javaexamples/oopbasics/pictureframe/privatemethods/PictureFrame.java

/**
 * An encapsulation of a picture frame.
 *
 * This version has overloaded methods.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 6.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;
    }
    
    /**
     * Construct a PictureFrame object with no matte and no stand.
     *
     * @param width   The width (in inches)
     * @param height  The height (in inches)
     */
    public PictureFrame(double width, double height)
    {
        this(width, height, 0.0, false);
    }
    
    /**
     * Default Constructor.
     *
     * Construct a 3x5 PictureFrame with no matte and no stand.
     */
    public PictureFrame()
    {
        this(3.0, 5.0, 0.0, false);
    }
    
    /**
     * Copy Constructor.
     *
     * @param other   The PictureFrame to copy
     */
    public PictureFrame(PictureFrame other)
    {
        this(other.width, other.height, other.matte, other.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.
     *
     * @param    max   true for the maximum possible (i.e., unmatted) area 
     * @return   The visible area
     */
    public double getVisibleArea(boolean max)
    {
        double   result;
        
        result = area();
        if (!max) result -= matteArea();

        return result;
    }

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

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @param   terse  true for a terse representation
     * @return         The String representation
     */
    public String toString(boolean terse)
    {
        String      result;

        if (terse)
        {
            result = ""+width+"x"+height;
        }
        else
        {
            result = ""+width+"in. x "+height+"in.";
            if (matte > 0.0) result += " with a "+matte+"in. matte";
            if (stand)       result += " (w/ stand)";
        }
        
        return result;
    }

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @return         The String representation
     */
    public String toString()
    {
        return toString(false);
    }
}
        

• Definition:
  • Two or more methods with the same name but different signatures in the same class
• Implementation in Java:
  • Must have different parameters (number and/or type)
  • Must have the same return type

javaexamples/oopbasics/pictureframe/overloadedmethods/PictureFrame.java (Fragment: overloadedmethods)

    /**
     * Return the visible area (in square inches) of the content
     * contained in this PictureFrame.
     *
     * @param    max   true for the maximum possible (i.e., unmatted) area 
     * @return   The visible area
     */
    public double getVisibleArea(boolean max)
    {
        double   result;
        
        result = area();
        if (!max) result -= matteArea();

        return result;
    }

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

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @param   terse  true for a terse representation
     * @return         The String representation
     */
    public String toString(boolean terse)
    {
        String      result;

        if (terse)
        {
            result = ""+width+"x"+height;
        }
        else
        {
            result = ""+width+"in. x "+height+"in.";
            if (matte > 0.0) result += " with a "+matte+"in. matte";
            if (stand)       result += " (w/ stand)";
        }
        
        return result;
    }

    /**
     * Return a human-readable String representation of this PictureFrame.
     *
     * @return         The String representation
     */
    public String toString()
    {
        return toString(false);
    }
        

• Handling Default Values
• Different Similar Types
• Two Parameters and Many "Parameters"

• Observation:
  • Sometimes we want a method to use default values and sometimes we want to supply all of the parameters
• Solution:
  • Have two methods with the same name and different numbers of parameters

An Example

public class TaxStand
{
      .
      .
      .

    /** 
     * Calculates the tax payment based on income and
     * filing status
     */
     public double payment(int income, int status)
     {
             ...
     }

     /**
      * Calculates the tax payment assuming the
      * filing status is 0
      */
      public double payment(int income)
      {
          return payment(income, 0);
      }
 }

• Observation:
  • Sometimes we want to perform the same operation on different, but similar, types (e.g., int and double)
• Solution:
  • Have two methods with the same name and different types of parameters

An Example

public class Weight
{
    .
    .
    .

    /**
     * Change this Weight by a given amount
     *
     * @param amount   The amount of the change
     */
     public void changeBy(Weight amount)
     {
        ...
     }


    /**
     * Change this Weight by a given amount
     *
     * @param pounds   Number of pounds in the change
     * @param ounces   Number of ounces in the change
     * @param positive true to increase, false to decrease
     */
     public void changeBy(int pounds, int ounces, boolean positive)
     {
           ...
     }
}

An Example

public class TaxStand
{
          .
          .
          .
      /** 
       * Calculates the tax payment based on income and
       * filing status
       */
       public double payment(int income, int status)
       {
             ...
       }


      /** 
       * Calculates the tax payment based on income and
       * filing status
       */
       public double payment(double income, int status)
       {
             ...
       }

}

• Observation:
  • Calling a function with a similar type might be handled by automatic type conversion.
• In Java:
  • The compiler attempts to use overloading before it attempts to use automatic type conversion
  • If multiple methods are appropriate, the compiler uses the "most specific" version

• Observation:
  • Sometimes we want to perform the same operation on two and "more than two" values
• Solution:
  • Have two methods, one with two parameters and one with an array as the parameter

An Example

public int minimum(int a, int b)
{
    int min;

    min = a;
    if (b <  a) min = b;

    return b;
}

public int minimum(int[] values)
{
    int min;

    min = values[0];
    for (i=1; i < values.length; i++)
    {
        if (values[i] <  min) min = values[i];
    }

    return min;
}

• 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

• Constants, flags and special values
• Common values (across all instances)
• Object counters

• 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

javaexamples/oopbasics/pictureframe/staticattributes/PictureFrame.java (Fragment: staticattributes)

    private static final double DOLLARS_PER_IN_OF_FRAME    = 0.15;
    private static final double DOLLARS_PER_SQ_IN_OF_GLASS = 0.05;    
    /**
     * 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;
    }
        

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;
    }
}
  

An Example

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


    // Attributes of objects
    protected final  int              accountNumber;
    protected        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;

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

• 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

• Utility classes
• System calls
• "Factory" methods

• Definition:
  • A class that groups related functionality and is not "data types"
• The Math Class:
  • abs
  • sin
  • cos
  • tan
  • log
  • pow
  • sqrt

• In the System Class:
  • currentTimeMillis
  • exit

• Definition:
  • Methods that are used like constructors
• Observations:
  • May get an object from a "pool"
  • Must be static to avoid a chicken and egg problem
  • Are much more flexible than constructors because they have an explicit return statement
• Examples:
  • Double.parseDouble(java.lang.String)
  • Integer.parseInt(java.lang.String)
  • NumberFormat.getInstance()

A parsePictureFrame() Method in the PictureFrame Class

javaexamples/oopbasics/pictureframe/factories/PictureFrame.java (Fragment: parse)

    /**
     * Create a PictureFrame object from a comma-delimited
     * String representation.
     *
     * @param s   The String representation
     * @return    The PictureFrame object (or null)
     */
    public static PictureFrame parsePictureFrame(String s)
    {
        double               height, matte, width;        
        PictureFrame         result;        
        String               token;        
        StringTokenizer      st;
        
        st = new StringTokenizer(s, ",");
        try
        {
            token = st.nextToken();
            width = Double.parseDouble(token);
            
            token = st.nextToken();
            height = Double.parseDouble(token);

            token = st.nextToken();
            matte = Double.parseDouble(token);
            
            token = st.nextToken();
            result = new PictureFrame(width, height, matte,
                                      token.equalsIgnoreCase("TRUE"));
        }
        catch (NumberFormatException nfe)
        {
            result = null;
        }
        catch (NoSuchElementException msee)
        {
            result = null;
        }

        return result;
    }
        

• A Question:
  • Why not write a constructor instead?
• Some Answers (Which May Make More Sense Later):
  • It's useful to have an explicit return (e.g., to return a special value like null, to return a specialization, to return a realization, to return a remote object)
  • There are pre-defined objects in the class (e.g., a singleton, an object pool)
  • The object can't be fully initialized