IntBagArray can only hold integers. Generic programming provides a better approach than having 8 (the number of primitive data types) different classes, each of a different type.
- Object - Java has a data type called
Objectand a variable of that type can hold a reference to any kind of object. - Widening Conversion - A widening conversion is done through an assignment
in which there is a specific data type on the left-hand side and an object on the right-hand
side. No cast is required.
Example:String s = new String("Objection overruled!"); Object obj; obj = s;
Resulting in:
- Narrowing Conversion - A narrowing conversion is an assignment with an object on the right-side and a specific data typed variable on the left-side and always requires a cast.
Example:String s = new String("Objection overruled!"); Object obj; obj = s; s = new String("Make it so."); ... s = (String) obj;
Resulting in:
- Boxing Conversion - A boxing conversion occurs when a primitive data type value is converted to a wrapper object of the corresponding type.
- Unboxing Conversion - An unboxing conversion occurs when a wrapper object is converted to the corresponding primitive.
- Examples:
int i = 42; int j; Integer example; example = new Integer(i); // Boxing example = i; // Autoboxing j = example.intValue( ); // Unboxing j = example; // Auto-unboxing - Advantages of Wrapper Objects - Wrapper objects are full-blown Java objects having helpful methods.
- Disadvantages of Wrapper Objects - Ordinary primitive operations (mathematical operations such as +, -, *, /) are no longer legal or allowed. Also, the wrapper objects take up more memory.
IntBagArray vs DoubleBagArray
you could use Object as the data type.For example:
public static Object middle( Object [] data) {
if (data.length == 0)
{ // The array has no elements, so return null.
return null;
}
else
{ // Return an element near the center of the array.
return data[data.length/2];
}
}
Using Generic Method - A generic method is a method that is written with the types of the parameters not fully specified. Our middle method is written this way as a generic method:
public static <T> T middle(T[] data) {
if (data.length == 0)
{ // The array has no elements, so return null.
return null;
}
else
{ // Return an element near the center of the array.
return data[data.length/2];
}
}
Convention Alert! - The designers of Java recommend using a capital T for data types and a capital E for elements when specifying a generic type parameter.
Generic Type Restrictions - A generic type must be of a class type and cannot be one of Java's primitive data types.
Review: - A generic method is written by putting a generic type parameter in angle brackets before the return type in the heading of the method.
For example:
static <T> T middle(T[] data)...A programmer can activate a generic method just like any other method. The compiler will look at the data types of the arguments and infer a correct type for each generic type parameter. The inferred types help catch type errors at compile time.
For example:
// i is an integer; ia is an Integer array; c is a Character
i = middle(ia); // This is fine
c = middle(ia); // Compile-time type error
For Example:
public class ArrayBag<E> implements Cloneable
{
// Invariant of the ArrayBag<E> generic class:
// 1. The number of elements in the bag is in the instance variable manyItems.
// 2. For an empty bag, we do not care what is stored in any of data;
// for a non-empty bag, the elements in the bag are stored in data[0]
// through data[manyItems-1], and we don't care what's in the rest of the data.
//
//
private Object[ ] data;
private int manyItems;Note: The new bag stores an array of Objects rather than an array of int values. At run time, each Object will actually have type E.
Important Considerations:
- Object Array - Use an object array for storing data of unknown types when developing
a generic class, for example:
private Object[ ] data; - Generic Typecast Warning - When returning items from the Object data array one can
get typecast errors when code like the following executes:
return (E) data[i]; // From the end of the grab method
- Variable Arity Methods & Suppressing Warnings - Warnings like those that one will
get when performing a generic typecast also occur when dealing with Variable Arity Methods that are methods that accept a variable number of paremeters
addManymethod of aBagclass. A proper way of suppressing compiler warnings for generic typecast and varity method warnings is to include the following directive in your code prior to a method that would generate the warning:@SuppressWarnings("unchecked") - Equals Method - Generic classes especially those that provide a collection class are like most any other classes and it is very important that you use and implement the
.equals()method for determining equality at the object level. If converting a regular collection class that stores int values to a generic class, your code may include several==operators that must be changes to the.equals()method. - Unused References - Whenever done with a generic object variable, make sure that you
set it to
nullin your code so that the Java runtime may free up the memory for that object (garbage collection). - Deep Cloning - A shallow clone is of the object itself. It is very important that for complex classes, especially generic classes, that your clone method perform deep cloning. A deep clone includes the superclone of the parent object was well as clones of each of the instance variable objects and arrays within the class.
- Interfaces and Iterators - See section 5.5 of the book and understand these concepts. We won't be using interfaces and iterators in this course, but future courses, especially those taught using C++ will require such knowledge.
- Lab 5 - Lab 5 (here) uses a generic Node as part of a sorted linked list.