• An Observation:
  • We have had difficulty making our code "type safe" on a few different occasions
• How We Have Handled These Cases:
  • We have used type casting and/or used overloaded methods (one of which was type safe and the other of which wasn't)
  • We have created multiple classes that were very similar
• This Lecture:
  • Discuss a more elegant solution

• A Common Problem:
  • We need to associate an entity with a unique identifier
• An Example:
  • We have a Person class (that does not include an ID) and we want to be able to associate an ID with each Person object

javaexamples/parameterized/typespecific/Identified.java

/**
 * A type-specific encapsulation of an Identified entity.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Identified
{
    private int       id;
    private Person    entity;
    
    /**
     * Explicit Value Constructor.
     *
     * @param id      The unique identifier for the entity
     * @param entity  The entity
     */
    public Identified(int id, Person entity)
    {
        this.id     = id;
        this.entity = entity;
    }
    
    /**
     * Get the ID of this Identified entity.
     *
     * @return   The ID
     */
    public int getID()
    {
        return id;
    }

    /**
     * Get the entity.
     *
     * @return   The entity
     */
    public Person getEntity()
    {
        return entity;
    }
}
        

• A Shortcoming:
  • We will have to create a class like this for every class that needs to be identified (and the code will be virtually identical)
• An Observation:
  • If all of the classes that need to be identified have a common ancestor then we can generalize this solution
• Another Observation:
  • They do!
    All classes have Object as a common ancestor

javaexamples/parameterized/object/Identified.java

/**
 * A generic but not type-safe encapsulation of an Identified entity.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Identified
{
    private int       id;
    private Object    entity;
    
    /**
     * Explicit Value Constructor.
     *
     * @param id      The unique identifier for the entity
     * @param entity  The entity
     */
    public Identified(int id, Object entity)
    {
        this.id     = id;
        this.entity = entity;
    }
    
    /**
     * Get the ID of this Identified entity.
     *
     * @return   The ID
     */
    public int getID()
    {
        return id;
    }

    /**
     * Get the entity.
     *
     * @return   The entity
     */
    public Object getEntity()
    {
        return entity;
    }
}
        

• An Advantage:
  • Any kind of Object can be "identified"
• A Shortcoming:
  • The Object returned by the getEntity() method will need to be typecast to be used
• A Danger:
  • The programmer might typecast the Object improperly which will result in a ClassCastException being thrown at runtime

• An Observation:
  • The compiler normally provides "type safety" (i.e., since Java is strongly typed, the compiler is able to ensure that types conform)
• What Would Be Nice:
  • It would be nice if we could tell the compiler that the entity being identified must be of a particular type
• Is this Possible in Java?
  • Yes, using a parameterized class (sometimes called a generic class)

• Parameterized Types in the Class Definition:
  • Class declarations can be parameterized
  • The parameters of the class are listed in angle brackets
  • Example: public class Identified<T>
• Parameterized Types in Attributes and Methods:
  • Attributes and methods can use the parameterized type as if it were an actual type

javaexamples/parameterized/Identified.java

/**
 * A parameterized (i.e., type-safe) encapsulation of an Identified entity.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Identified<T>
{
    private int       id;
    private T         entity;
    
    /**
     * Explicit Value Constructor.
     *
     * @param id      The unique identifier for the entity
     * @param entity  The entity
     */
    public Identified(int id, T entity)
    {
        this.id     = id;
        this.entity = entity;
    }
    
    /**
     * Get the ID of this Identified entity.
     *
     * @return   The ID
     */
    public int getID()
    {
        return id;
    }

    /**
     * Get the entity.
     *
     * @return   The entity
     */
    public T getEntity()
    {
        return entity;
    }
}
        

• Why Does This Help?
  • We can tell the compiler what kind of Object is appropriate
• How?
  • We can bind the parameterized type to a particular class

javaexamples/parameterized/Driver.java (Fragment: 0)

        Identified<Person>   person;
        Identified<Product>  product;
        
        
        person  = new Identified<Person>(   10, new Person());
        product = new Identified<Product>(3415, new Product());


        Person fred;
        fred   = person.getEntity();  // This will compile

        Person barney;
        barney = product.getEntity(); // This will not compile
        

• Type Parameter and Type Argument:
  • The type used in the definition of the class is often called the type parameter
  • The type that is being bound to is often called the type argument
• Raw Type:
  • Used to describe situations in which the type argument (i.e., the the class to bind to) is omitted (e.g., in Identified i;, Identified is the raw type of Identified<T> )

• Naming Convention:
  • Type parameters are normally a single, upper-case letter
• Common Type Parameters:
  • E - element
  • K - key
  • N - number
  • T - type
  • V - value

• Type Parameters:
  • Are listed in an "overlapping" dashed rectangle at the top right of the class, for example:
    
• Type Arguments:
  • Use angle brackets in the type specifier

• The Need:
  • A single method in a class that can work with parameterized types
• The Solution:
  • A "generic" method with its own type parameters
  • Example: public static <E> void fillArray(E[] a, E e)

• The Situation:
  • When constructing the parameterized class, you want to restrict the types that can be used as type arguments (i.e., the classes that can be bound to)
• The Solution:
  • List the parameter name followed by extends, followed by the bounding types (separated by an &)
• A Notes:
  • The term extends was probably a bad choice since any class that either extends the bounding type or implements the bounding type can be used (which is why there can be more than one)
  • Only one class can be a bounding type and it must appear first in the list; the list can contain multiple interfaces

javaexamples/parameterized/bounded/Identified.java

/**
 * A bounded parameterized encapsulation of an Identified entity.
 *
 * @author  Prof. David Bernstein, James Madison University
 */
public class Identified<T extends Person>
{
    private int       id;
    private T         entity;
    
    /**
     * Explicit Value Constructor.
     *
     * @param id      The unique identifier for the entity
     * @param entity  The entity
     */
    public Identified(int id, T entity)
    {
        this.id     = id;
        this.entity = entity;
    }
    
    /**
     * Get the ID of this Identified entity.
     *
     * @return   The ID
     */
    public int getID()
    {
        return id;
    }

    /**
     * Get the entity.
     *
     * @return   The entity
     */
    public T getEntity()
    {
        return entity;
    }
}
        

• The Situation:
  • We want to specify the requirements of one or more parameterized classes without specifying the implementation
• The Solution:
  • Create a parameterized interface
• An Example Revisited:
  • Recall that we've discussed an example

• An Example Revisited:
  • javaexamples/oopbasics/interfaces/Ordered.java

    /**
     * The requirements of objects that can be ordered.
     *
     * @author  Prof. David Bernstein, James Madison University
     * @version 1.0
     */
    public interface Ordered
    {
        /**
         * Compare this object to the given object. Return -1 if this
         * is "less than" other, 0 if they are "equal", and 1 if this 
         * is "greater than" other.
         *
         * @return -1, 0, or 1 as appropriate
         */
        public abstract int compareTo(Ordered other);
    }
            

• A Parameterized Version (in Java):

  • public interface Comparable<T>
    {
      public abstract int  compareTo(T other);
    }
            

This allows us to avoid the risky typecast that we needed in the compareTo() method in the class that realized the interface.

javaexamples/parameterized/comparable/Person.java

/**
 * A simple encapsulation of a Person.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0 (Using Comparable)
 */
public class Person implements Comparable<Person>
{
    private int    age;    
    private String name;

    /**
     * Constructor.
     *
     * @param name  The name
     * @param age   The age
     */
    public Person(String name, int age)
    {
        this.name = name;
        this.age  = age;
    }

    /**
     * Compare the Person to the given object based on age. Return -1
     * if this is "less than" other, 0 if they are "equal", and 1 if
     * this is "greater than" other. (Required by Comparable)
     *
     * @param other  The Person to compare to
     * @return -1, 0, or 1 as appropriate
     */
    public int compareTo(Person other)
    {
        if       (this.age  < other.age) return -1;
        else if  (this.age == other.age) return  0;
        else                             return  1;
    }

    /**
     * Get the age.
     *
     * @return  The age
     */
    public int getAge()
    {
        return age;
    }

    /**
     * Get the name.
     *
     * @return  The name
     */
    public String getName()
    {
        return name;
    }
}
        

• A Continuing Shortcoming in this Example:
  • Recall that we had a Statistics class with min() and max() methods that had to return an Ordered
  • Now they can return a Comparable<T>, but we want them to return a T
• We Can Fix This Using Parameterized Types:
  • But its complicated and involves techniques that are beyond the scope of this lecture
• A Different Approach:
  • Use an object that implements the Comparator interface to performing the comparisons

• An Added Benefit of Comparator:
  • The same object can be compared in multiple different ways
• Some Examples:
  • Comparing Person objects based on height or weight
  • Comparing Course objects based on ID or credit hours

• An Observation:
  • The Comparable and Comparator interfaces can be used to do more than find the minimum and maximum, they can be used to sort
• The java.util.Arrays Class:
  • Contains sort() methods that take advantage of this observation

javaexamples/parameterized/Course.java

/**
 * A simple encapsulation of a course.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Course
{

    private int     credits;    
    private String  department, number;
    
    /**
     * Explicit Value Constructor.
     *
     * @param depatment   The department identifier (e.g., "CS")
     * @param number      The course nbumber (e.g., "159")
     * @param credits     The number of credits
     */
    public Course(String department, String number, int credits)
    {
        this.department = department;
        this.number     = number;
        this.credits    = credits;
    }
    
    /**
     * Returns the number of credits asscoiated with this Course.
     *
     * @return   The number of credits
     */
    public int getCredits()
    {
        return credits;
    }

    /**
     * Returns the ID of this Course.
     *
     * @return   The ID
     */
    public String getID()
    {
        return department + number;
    }

    /**
     * Return a String representation of this Course.
     *
     * @return   The String representation
     */
    public String toString()
    {
        return getID() + " (" + getCredits() + "cr)";
    }
}
        

javaexamples/parameterized/IDComparator.java

import java.util.Comparator;

/**
 * A Comparator for Course objects that uses the ID.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class IDComparator implements Comparator<Course>
{
    /**
     * Compares two Course objects (using their IDs)
     * (required by Comparator).
     *
     * @param a   Object a
     * @param b   Object b
     * @return   -1, 0, 1 (as per Comparator)
     */
    public int compare(Course a, Course b)
    {
        return a.getID().compareTo(b.getID());
    }
}
        

javaexamples/parameterized/CreditComparator.java

import java.util.Comparator;

/**
 * A Comparator for Course objects that uses the number of credits.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class CreditComparator implements Comparator<Course>
{
    /**
     * Compares two Course objects (using their credit hours)
     * (required by Comparator).
     *
     * @param a   Object a
     * @param b   Object b
     * @return   -1, 0, 1 (as per Comparator)
     */
    public int compare(Course a, Course b)
    {
        int     an, bn;
        
        an = a.getCredits();
        bn = b.getCredits();
        
        if      (an < bn) return -1;
        else if (an > bn) return  1;
        else              return  0;
    }
}
        

javaexamples/parameterized/CourseDriver.java

import java.util.*;


/**
 * An application that can be used to demonstrate the power
 * of the Comparator interface.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class CourseDriver
{
    /**
     * The entry point of the application.
     *
     * @param args  The command-line arguments
     */
    public static void main(String[] args)
    {
        Comparator<Course> comparator;        
        Course[]           prog;
        
        prog = new Course[3];
        prog[0] = new Course("CS", "240", 3);
        prog[1] = new Course("CS", "159", 3);
        prog[2] = new Course("CS", "139", 4);

        comparator = new IDComparator();        
        Arrays.sort(prog, comparator);
        
        System.out.println("\nSorted by ID:");        
        print(prog);
        
        comparator = new CreditComparator();        
        Arrays.sort(prog, comparator);
        
        System.out.println("\nSorted by Credits:");        
        print(prog);
        
    }

    /**
     * Print an array of Course objects.
     *
     * @param courses   The array.
     */
    private static void print(Course[] courses)
    {
        for (int i=0; i<courses.length; i++) 
        {
            System.out.println(courses[i]);
        }
    }
    
}
        

• Process Details:
  • Reifiable/Non-reifiable Types
  • Type Erasure
• Wildcards:
  • Covariance: ? extends Type
  • Contravariance: ? super Type

• Specialization:
  • Specializing a parameterized class
  • Specializing the parameters of a parameterized class
• Type Inference:
  • What can be and is inferred?