Generics in Java

Paint QR Code in Java Generics

The type parameter T is specified by Gen2 and is also passed to Gen in the extends clause This means that whatever type is passed to Gen2 will also be passed to Gen For example, this declaration,

Gen2<Integer> num = new Gen2<Integer>(100);

passes Integer as the type parameter to Gen Thus, the ob inside the Gen portion of Gen2 will be of type Integer Notice also that Gen2 does not use the type parameter T except to pass it to the Gen superclass Thus, even if a subclass of a generic superclass would otherwise not need to be generic, it still must specify the type parameter(s) required by its generic superclass Of course, a subclass is free to add its own type parameters, if needed For example, here is a variation on the preceding hierarchy in which Gen2 adds a type parameter of its own:

// A subclass can add its own type parameters class Gen<T> { T ob; // declare an object of type T // Pass the constructor a reference to // an object of type T Gen(T o) { ob = o; } // Return ob T getob() { return ob; } } // A subclass of Gen that defines a second // type parameter, called V class Gen2<T, V> extends Gen<T> { V ob2; Gen2(T o, V o2) { super(o); ob2 = o2; } V getob2() { return ob2; } } // Create an object of type Gen2 class HierDemo { public static void main(String args[]) {

Part I:

// Create a Gen2 object for String and Integer Gen2<String, Integer> x = new Gen2<String, Integer>("Value is: ", 99); Systemoutprint(xgetob()); Systemoutprintln(xgetob2()); } }

Notice the declaration of this version of Gen2, which is shown here:

class Gen2<T, V> extends Gen<T> {

Here, T is the type passed to Gen, and V is the type that is specific to Gen2 V is used to declare an object called ob2, and as a return type for the method getob2( ) In main( ), a Gen2 object is created in which type parameter T is String, and type parameter V is Integer The program displays the following, expected, result: Value is: 99

It is perfectly acceptable for a non-generic class to be the superclass of a generic subclass For example, consider this program:

// A non-generic class can be the superclass // of a generic subclass // A non-generic class class NonGen { int num; NonGen(int i) { num = i; } int getnum() { return num; } } // A generic subclass class Gen<T> extends NonGen { T ob; // declare an object of type T // Pass the constructor a reference to // an object of type T Gen(T o, int i) { super(i); ob = o; }

14:

// Return ob T getob() { return ob; } } // Create a Gen object class HierDemo2 { public static void main(String args[]) { // Create a Gen object for String Gen<String> w = new Gen<String>("Hello", 47); Systemoutprint(wgetob() + " "); Systemoutprintln(wgetnum()); } }

The output from the program is shown here: Hello 47 In the program, notice how Gen inherits NonGen in the following declaration:

class Gen<T> extends NonGen {

Because NonGen is not generic, no type argument is specified Thus, even though Gen declares the type parameter T, it is not needed by (nor can it be used by) NonGen Thus, NonGen is inherited by Gen in the normal way No special conditions apply

Recall the run-time type information operator instanceof that was described in 13 As explained, instanceof determines if an object is an instance of a class It returns true if an object is of the specified type or can be cast to the specified type The instanceof operator can be applied to objects of generic classes The following class demonstrates some of the type compatibility implications of a generic hierarchy:

// Use the instanceof operator with a generic class hierarchy class Gen<T> { T ob; Gen(T o) { ob = o; } // Return ob T getob() { return ob; } }

Part I: