Type parameters can also be declared within method and constructor signatures to create generic methods and generic constructors. This is similar to declaring a generic type, but the type parameter’s scope is limited to the method or constructor in which it’s declared.
Here we’ve added one generic method, named/**
* This version introduces a generic method.
*/
public class Box<T> {private T t;
public void add(T t) {
this.t = t;
}public T get() {
return t;
}public <U> void inspect(U u){
System.out.println(“T: ” + t.getClass().getName());
System.out.println(“U: ” + u.getClass().getName());
}public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
integerBox.add(new Integer(10));
integerBox.inspect(“some text”);
}
}
inspect
, that defines one type parameter, namedU
. This method accepts an object and prints its type to standard output. For comparison, it also prints out the type ofT
. For convenience, this class now also has amain
method so that it can be run as an application.
The output from this program is:
T: java.lang.Integer
U: java.lang.String
By passing in different types, the output will change accordingly.
A more realistic use of generic methods might be something like the following, which defines a static method that stuffs references to a single item into multiple boxes:
public static <U> void fillBoxes(U u, List<Box<U>> boxes) {To use this method, your code would look something like the following:
for (Box<U> box : boxes) {
box.add(u);
}
}Crayon red = …;The complete syntax for invoking this method is:
List<Box<Crayon>> crayonBoxes = …;
Here we’ve explicitly provided the type to be used asBox.<Crayon>fillBoxes(red, crayonBoxes);
U
, but more often than not, this can be left out and the compiler will infer the type that’s needed:
This feature, known as type inference, allows you to invoke a generic method as you would an ordinary method, without specifying a type between angle brackets.Box.fillBoxes(red, crayonBoxes); // compiler infers that U is Crayon
Generic Methods and Constructors
Generic Methods and Constructors