• A Question:
  • What is the relationship between "dogs" and "animals"?
• Some Answers:
  A dog is an animal
  All dogs are animals
  All dogs are animals but all animals are not dogs
  The set of dogs is a proper subset of the set of animals

• What is a class?
  A definition of a set that is written in terms of the properties of the elements (i.e., an intensive definition of a set)
  The set of elements so defined
• What is an object?
  An element of the set

• 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

• A Subset:
  • Has additional characteristics
  • Is a specialization
  • Mathematical Notation: \(A \subset B\) denotes that \(A\) is a (proper) subset of \(B\)
• A Superset:
  • Ignores some characteristics
  • Is a generalization
  • Mathematical Notation: \(G \supset H\) denotes that \(G\) is a (proper) superset of \(H\)

• The "is-a" relationship:
  • An object of class A "is-an" object of class B if A is/does everything that B is/does and more
• Other Terminology:
  • Subclass/Superclass
  • Child Class/Parent Class
  • Derived Class/Base Class

• Recall:
  • A definition of a set that is written by listing the elements (i.e., an extensive definition of a set)
• What Would a Specialization Be?
  • A subset (i.e., a list of elements to omit from the parent)
• The Implication:
  • Java does not allow enums to be specialized (though the "is a" relationship can be achieved in other ways as discussed later)

• A Loose Definition:
  • Instances of the child class have the characteristics of the parent class without having to implement them
• What Is/Isn't Inherited in Java?
  • The subclass inherits the attributes of the superclass
  • The subclass inherits the methods of the superclass
  • The subclass does not inherit constructors from the superclass
• Visibility/Accessibility:
  • The subclass cannot directly access private members in the superclass
  • The superclass can restrict access to descendants by declaring members to be protected

• Visibility:
  • Protected accessibility/visibility is denoted using a #
• Inherited Methods:
  • Inherited methods are (typically) not explicitly listed in the subclass

• Declaring a Subclass:
  • Use extends in the declaration of the class
• Accessing Members in a Superclass from a Subclass:
  • Use super as the left-side operand of the . operator to eliminate ambiguity (if needed)
• Calling the Constructor in a Superclass from a Subclass:
  • Call super() (which must be the first statement in a constructor of the subclass)

• Explicit Value Constructors in the Subclass:
  • Should include a call to an appropriate constructor in the superclass
  • If no version of super() is called explicitly, the default constructor in the superclass will be called (so, if there isn't one, the subclass won't compile)
• Default Constructors in the Subclass:
  • Should include a call to the default constructor in the superclass
  • If no version of super() is called explicitly, the default constructor in the superclass will be called (so, if there isn't one, the subclass won't compile)

• Purpose:
  • Add attributes
  • Add behaviors
  • Modify existing behavior
• Situations:
  • You only have the byte code (i.e., the .class file) for an existing class
  • You have the source code (i.e., the .java file) for an existing class but don't want to change it
  • You are designing classes "from scratch"

• Existing Classes:
  • Part of the Java API (e.g., DecimalFormat )
  • Written by a "third party"
• If only:
  • it also had the following attributes
  • it also had the following methods

javaexamples/oopbasics/FieldFormat.java

import java.text.*;

/**
 * A DecimalFormat that understand the notion of a "field".
 * That is, you can set the field width of a FieldFormat and
 * it will right-justify the formatted String in a field
 * of that width.
 *
 * Note: This version is for illustrative purposes only.
 *       It does not override all constructors.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class FieldFormat extends DecimalFormat
{
    private int        fieldWidth = -1;

    /**
     * Default Constructor
     */
    public FieldFormat()
    {
        super();
    }

    /**
     * Change the length of a String to fit exactly into
     * a field with the current width
     *
     * If the String is lengthened it will be right-justified
     *
     * @param original  The original String
     * @return          The shortened or lengthened String
     */
    public String fitStringToField(String original)
    {
        int            i;
        String         returnString;

        returnString = "";

        if (fieldWidth > 0)  // The field width has been set
        {
           if (original.length() <= fieldWidth)  // Lengthen original
           {
              for (i=1; i <= fieldWidth-original.length(); i++)
              {
                 returnString += " ";
              }

              returnString += original;
            } 
           else                                // Shorten original
           {
              returnString = original.substring(0, fieldWidth);
           }
        }
        else              // The field width hasn't been set
        {
            returnString = original;
        }

        return returnString;
    }

    /**
     * Set the field width
     *
     * @param width  The width of the field
     */
    public void setFieldWidth(int width)
    {
        fieldWidth = width;
    }
}
        

javaexamples/oopbasics/FieldFormatWhatHappensAndWhy.java

import java.text.*;

/**
 * A series of questions involving the 
 * FieldFormat class
 *
 * Note:  Before testing question n, comment-out questions 
 *        before and after.  Each question stands alone.
 */
public class FieldFormatWhatHappensAndWhy
{
    /**
     * The entry point
     *
     * @param args   The command line arguments
     */
    public static void main(String[] args)
    {
        DecimalFormat         decimal;
        FieldFormat           field;
        String                output, temp;


        // Question 1
        decimal = new DecimalFormat();
        decimal.setFieldWidth(5);
        output = decimal.format(12.5);
        System.out.println(output);

        
        // Question 2
        field = new FieldFormat();
        field.setMinimumIntegerDigits(3);
        output = field.format(12.5);
        System.out.println(output);


        // Question 3
        decimal = new DecimalFormat();
        decimal.setMinimumIntegerDigits(3);
        field = decimal;
        output = field.format(12.5);
        System.out.println(output);


        // Question 4
        field = new FieldFormat();
        field.setMinimumIntegerDigits(3);
        decimal = field;
        output = decimal.format(12.5);
        System.out.println(output);


        // Question 5
        field = new FieldFormat();
        field.setMinimumIntegerDigits(3);
        field.setFieldWidth(10);
        decimal = field;
        output = decimal.format(12.5);
        System.out.println(output);


        // Question 6
        field = new FieldFormat();
        field.setMinimumIntegerDigits(3);
        field.setFieldWidth(10);
        decimal = field;
        output = decimal.fitStringToField("12.5");
        System.out.println(output);

        // Question 7
        field = new FieldFormat();
        field.setFieldWidth(20);
        temp   = field.format(12.5);
        output = field.fitStringToField(temp);
        System.out.println(output);

        // Question 8
        decimal = new DecimalFormat();
        setupField(decimal);
        output = decimal.format(12.5);
        System.out.println(output);

        // Question 9
        decimal = new DecimalFormat();
        setupFormat(decimal);
        output = decimal.format(12.5);
        System.out.println(output);

        // Question 10
        field = new FieldFormat();
        setupField(field);
        output = field.fitStringToField(temp);
        System.out.println(output);
    }



    /**
     * Setup a format object
     *
     * @param formatter   The format object
     */
    private static void setupField(FieldFormat  formatter)
    {
        setupFormat(formatter);
        
        formatter.setFieldWidth(20);
    }


    /**
     * Setup a format object
     *
     * @param formatter   The format object
     */
    private static void setupFormat(DecimalFormat  formatter)
    {
        formatter.setMinimumFractionDigits(2);
        formatter.setMaximumFractionDigits(2);
    }
}
        

• Existing Classes:
  • Part of the Java API (e.g., StringTokenizer )
  • Written by a "third party"
• If only:
  • it did this instead
• What Can the Subclass Do?
  • Override methods in the superclass (i.e., include a method with the same signature but a different implementation)

javaexamples/oopbasics/CaseInsensitiveStringTokenizer.java

import java.util.*;

/**
 * A specialized version of the StringTokenizer that ignores the
 * case of the delimiters.  That is, if either 'a' or 'A' is
 * made a delimiter then both 'a' and 'A' will be treated as
 * delimiters.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class CaseInsensitiveStringTokenizer extends StringTokenizer
{
    /**
     * Explicit Value Constructor
     *
     * @param str  The String to tokenize
     *
     * @see java.util.StringTokenizer#StringTokenizer(java.lang.String)
     */
    public CaseInsensitiveStringTokenizer(String str)
    {
        super(str);
    }

    /**
     * Explicit Value Constructor
     *
     * @param str          The String to tokenize
     * @param delim        The set of delimiters to use
     *
     * @see java.util.StringTokenizer#StringTokenizer(java.lang.String,java.lang.String)
     */
    public CaseInsensitiveStringTokenizer(String str, String delim)
    {
        this(str, delim, false);
    }

    /**
     * Explicit Value Constructor
     *
     * @param str          The String to tokenize
     * @param delim        The set of delimiters to use
     * @param returnDelims true to return delimiters as tokens
     *
     * @see java.util.StringTokenizer#StringTokenizer(java.lang.String,java.lang.String)
     */
    public CaseInsensitiveStringTokenizer(String str, String delim, 
                                          boolean returnDelims)
    {
        // While admittedly messy, remember that the call to super() 
        // must be in the first statement in the method
        super(str, delim.toLowerCase()+delim.toUpperCase(), returnDelims);
    }
}
        

javaexamples/oopbasics/CaseInsensitiveStringTokenizerWhatHappensAndWhy.java

import java.util.*;

/**
 * A series of questions involving the 
 * CaseInensitiveStringTokenizer class
 *
 * Note:  Before testing question n, comment-out questions 
 *        before and after.  Each question stands alone.
 */
public class CaseInsensitiveStringTokenizerWhatHappensAndWhy
{
    /**
     * The entry point
     *
     * @param args   The command line arguments
     */
    public static void main(String[] args)
    {
        CaseInsensitiveStringTokenizer     insensitive;
        String                             delimiters, test, token;
        StringTokenizer                    sensitive;


        test = "ThisXisxaXsimplextestXIxthink";
        delimiters = "x";

        // Question 1
        sensitive = new StringTokenizer(test, delimiters);
        printTokens(sensitive);


        // Question 2
        insensitive = new CaseInsensitiveStringTokenizer(test, delimiters);
        printTokens(insensitive);

    }



    /**
     * Loop over all tokens and print them
     *
     * @param   tokenizer   The StringTokenizer to use
     */
    private static void printTokens(StringTokenizer tokenizer)
    {
        String        token;



        System.out.println("Tokens: ");

        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();
            System.out.println(token);
        }
        System.out.println("\n");
    }

}
        

• Situation:
  • You are implementing all of the classes
  • You have the source code
• Why Use Specialization?
  • The base class has already been thoroughly tested
  • The derived class adds significant complexity that is not required by all objects

javaexamples/oopbasics/emergency1/EmergencyMessage.java

/**
 * A message containing emergency information
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class EmergencyMessage
{
    private String message;


    /**
     * Construct a new EmergencyMessage
     *
     * @param message   The text of the mesage
     *
     */
    public EmergencyMessage(String message)
    {
        this.message = message;
    }

    /**
     * Return the text of this message
     *
     * @return   The text of the message
     */
    public String getMessage()
    {
        return message;
    }
}
        

javaexamples/oopbasics/emergency1/Alert.java

/**
 * A message containing normal emergency 
 * information and a supplemental alert
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class Alert extends EmergencyMessage
{
    private String supplement;


    /**
     * Construct a new Alert
     *
     * @param message      The main mesage
     * @param supplement   The supplemental information
     *
     */
    public Alert(String message, String supplement)
    {
        super(message);
        this.supplement = supplement;
    }

    /**
     * Return the supplemental information
     *
     * @return   The supplemental information
     */
    public String getSupplement()
    {
        return supplement;
    }
}
        

javaexamples/oopbasics/im1/Chirp.java

import java.util.*;

/**
 * A missive in an instant messaging system
 *
 * @author  Prof. David Bernstein
 * @version 1.0
 */
public class Chirp
{
    private String          delimiters;  // Delimiters between words
    private String          text;        // The text of the message

    /**
     * Explicit Value Constructor
     *
     * @param typed   What was typed by the user
     */
    public Chirp(String typed)
    {
        text       = typed;
        delimiters = " ,.;!?-\n\r";
    }

    /**
     * Get the number of words in this Chirp
     *
     * @return   The number of words
     */
    public int getNumberOfWords()
    {
        int                 numberOfWords;
        StringTokenizer     tokenizer;

        tokenizer     = new StringTokenizer(text, delimiters);
        numberOfWords = tokenizer.countTokens();

        return numberOfWords;
    }

    /**
     * Get the delimiters
     *
     * @return   The delimiters
     */
    public String getDelimiters()
    {
        return delimiters;
    }

    /**
     * Get the text of this Chirp
     *
     * @return   The text
     */
    public String getText()
    {
        return text;
    }
}
        

javaexamples/oopbasics/im1/ExpandedChirp.java

import java.io.*;
import java.util.*;

/**
 * A missive in an instant messaging system
 *
 * Unlike a normal Chirp, an ExpandedChirp does not
 * contain abbreviations -- they are all expanded
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ExpandedChirp extends Chirp
{
    private Properties      abbreviations;


    /**
     * Explicit Value Constructor
     *
     * @param typed   What was typed by the user
     */
    public ExpandedChirp(String typed)
    {
        super(typed);
        InputStream      is;

        abbreviations = new Properties();
        try
        {
            is = new FileInputStream("abbreviations.txt");
            abbreviations.load(is);
        }
        catch (IOException ioe)
        {
            // There was a problem opening the file
            // containing the abbreviations
        }
    }

    /**
     * Get the text of this Chirp with all of the
     * abbreviations expanded
     *
     * This method overrides the version in the parent
     *
     * @return   The text
     */
    public String getText()
    {
        String       tempText;

        // Use getText() in the parent
        tempText  = replaceAbbreviations(super.getText());

        return tempText;
    }

    /**
     * Replace the abbreviations in a message
     *
     * @param msg   The original message
     */
    private String replaceAbbreviations(String msg)
    {
        String              replaced, token, word;
        StringTokenizer     tokenizer;

        replaced = "";
        
        tokenizer = new StringTokenizer(msg, getDelimiters(), true);
        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();
            word  = abbreviations.getProperty(token);

            if (word == null) replaced += token;
            else              replaced += word;
        }

        return replaced;
    }
}
        

javaexamples/oopbasics/im1/ChirpDriver.java

/**
 * A driver for illustrating the Chirp and EnglishChirp
 * classes
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ChirpDriver
{
    /**
     * The entry point of the application
     *
     * @param args The command line arguments
     */
    public static void main(String[] args) 
    {

        if ((args.length > 0) && (args[0].equals("-old"))) 
        {
            ExpandedChirp     chirp;
            chirp = new ExpandedChirp("This is it.  TTFN!");
            System.out.println(chirp.getText());
        }
        else
        {
            Chirp        chirp;
            chirp = new Chirp("This is it.  TTFN!");
            System.out.println(chirp.getText());
        }
    }
}
        

• An Observation:
  • It is possible to have an attribute in the derived class with the same type and name as an attribute in the base class (which is called shadowing)
• Best Practice:
  • Where possible, shadowing should be avoided because it is confusing
• Shadowing Private Attributes:
  • You may not always know the private attributes in the base class (especially if you don't have the source code for the base class)

• UML:
  • Overridden methods are (typically) explicitly listed in the subclass
• Java:
  • Overridden methods are often annotated with @Override

• The Situation:
  • A method in the derived class needs to call the method it overrides in the base class
• The Mistake:
  • Forgetting to use super.
• The Symptom:
  • A stack overflow (i.e., the method in the derived class calls itself until it runs out of memory)

• The Situation:
  • An assignment statement doesn't compile (and you think it should or, at least, really want it to)
• A "Rookie" Mistake:
  • Use a typecast
• Why This Makes the Compiler Happy:
  • The compiler believes the programmer

        Chirp          c;
        ExpandedChirp  e;
        
        c = new Chirp("TTFN");
        e = (ExpandedChirp)c;
  

• Why won't the last line compile without the type cast?
  • A Chirp is not an ExpandedChirp and methods might be called on e that it doesn't have
• Why will the last line compile as is?
  • The compiler believes the programmer
• What will happen at run-time?
  • A ClassCastException will be thrown

• In a Base Class:
  • Are attributes/methods of both the base class and any derived classes
• When This Can Be Confusing:
  • When you have multiple derived classes specialize the same base class (because they will "share" the same static members)

• A Particular Method:
  • A method that is declared to be final can't be overridden by a subclass
• An Entire Class:
  • A class that is declared to be final can't be specialized (i.e., a class that extends a final class will not compile)

• A Particular Method:
  • A common convention is to include {leaf} after the return type
• An Entire Class:
  • A common convention is to include {leaf} after the name

• The Object Class:
  • All classes that don't explicitly extend a class implicitly extend the Object class
• Implication:
  • All objects have clone(), equals() and toString() methods, though they don't always do what you want

• Recall:
  • Some exceptions are checked and some are unchecked
• How To Distinguish:
  • Unchecked Exceptions - Descendants of RuntimeException
  • Checked Exceptions - All other descendants of Exception

• Recall:
  • In JUnit, assertEquals() works with int values, double values, objects, etc...
  • The printf() method in the PrintWriter class is passed a format string and then a variable number of arguments of any type
• How?
  • assertEquals() is overloaded and one of the versions has Object parameters
  • The parameters of printf() are String and Object...