Generics Question.

[Alan Blass]

Hi!

What is

public <U> void inspect(U u){...}

What does

" <U> void "

mean? Is it returning a void of type

U

?

I read from here:

http://download.oracle.com/javase/tutorial/java/generics/genmethods.html

Thanks.

[lokesh sree]

Hi ,
That syntax seem to be explained in the tutorial itself whose link is given.
In case if that is not clear, in

 public <U> void inspect(U u){...}  

the return type there is still "void". The syntax there. is a way of specifying "U" as a generic type scoped for that method inspect().
This syntax of declaring a generic type just before specifying the return type is an alternate to specifying the generic type with the class , as done with Box T; there. If you look at the class there,

public class Box<T> {

it is defining "T" as generic type but that is scoped for the whole class. Where as "U" is a generic type which can be used only in inspect().

Hope that clears your confusion.

[Alan Blass]

lokesh chenta wrote:it is defining "T" as generic type but that is scoped for the whole class. Where as "U" is a generic type which can be used only in inspect().

Hi! Why do you need to specify T as generic type scoped for the whole class since T is already private and is available for the whole class?

or alphabet "YOU" for method inspect() since it is already understood it is for the method's scope.

I mean why do you need to specify it?

Thanks.

[Ove Lindström]

Alan Blass wrote:

lokesh chenta wrote:it is defining "T" as generic type but that is scoped for the whole class. Where as "U" is a generic type which can be used only in inspect().

Hi! Why do you need to specify T as generic type scoped for the whole class since T is already private and is available for the whole class?

or alphabet "YOU" for method inspect() since it is already understood it is for the method's scope.

I mean why do you need to specify it?

Thanks.

When declaring a generic you need to specify the input parameters to the generic as you do with everything else. Since the generic declaration (in a metaphorical way) can be viewed as a template, you need to declare how and when to specify the parameters for the generic construction.

When using a type wide generic parameter (<T>) you are declaring that "this input parameter needs to be declared when creating a new type". That is when you declare an attribute/variable or when you use new.

When using a method scoped generic, you tell it that "when you call this method, tell me what type I should use and I will create that method".

An example on the later:

static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
    for (T o : a) {
        c.add(o); // Correct
    }
}

This tells us that I have declared a method that takes a type with the name T. If I call this method like this:

String[] sa = new String[100];
Collection<String> cs = new ArrayList<String>();
fromArrayToCollection(sa, cs); // T inferred to be String

the compiler/jvm will write me this method:

static void fromArrayToCollection(String[] a, Collection<String> c) {
    for (String o : a) {
        c.add(o); // Correct
    }
}

[Abhay Agarwal]

 public <P> void inspect(P p){...}  

as mentioned earlier, 'P' define the genertic type and (P p) within method parameter defines an instance of generic type 'P'.

alphabet "YOU" for method inspect() since it is already understood it is for the method's scope.

this understanding is not correct. you will have to define 'P' as generic type before using it any where in class/method. This information is required by compiler.

Let us study below mentioned code sample. Here I have used a generic method in a non generic class.

class TestA
{
	int q=2;
	public String toString() {
		return "Test A object";
	}
}

class TestB
{
	int w=4;
	public String toString() {
		return "Test B object";
	}
}

public class Testing {

	int z=5;
	
	 public <P> void inspect(P p){
		 System.out.println("p  => " + p.toString());
	 }  
	
	 public static void main(String[] args)
	 {
		 TestA aObject = new TestA();
		 TestB bObject = new TestB();
		 
		 new Testing().inspect(aObject);
		 new Testing().inspect(bObject);
		 
		 
	 }
}

Here, output is

p => Test A object
p => Test B object


If I remove 'P' defined before void method

 public void inspect(P p)

then I will get compile time error as
The method inspect(P) from the type Testing refers to the missing type P

We got this error as generic type 'P' is used in method parameters but not defined any where.

To fix this error there are two ways
1. define generic type 'P' at method level (which was there already)

 public <P> void inspect(P p){...}  

2. define generic type 'P' at class level (as shown below). Testing class has been added generic type 'P'

class TestA
{
	int q=2;
	public String toString() {
		return "Test A object";
	}
}

class TestB
{
	int w=4;
	public String toString() {
		return "Test B object";
	}
}

public class Testing<P>  // generic type defined at class level
{

	int z=5;
	
	 public void inspect(P p){  // generic type definition not present at method level
		 System.out.println("p=> " + p.toString());
	 }  
	
	 public static void main(String[] args)
	 {
		 TestA aObject = new TestA();
		 TestB bObject = new TestB();
		 
		 new Testing().inspect(aObject);
		 new Testing().inspect(bObject);
		 
		 
	 }
}

So by now you must have understood that to use generic type paramters variables etc , we ned to define that generic type at method or class level.

==================================================================================================

Why do you need to specify T as generic type scoped for the whole class since T is already private and is available for the whole class?

This understanding is not correct. T is not private to class. Reason for specifying 'T' as generic type explicitly is to tell compiler that we are generic reference which shall be replaced by actual implementation class later on.

A sample generic class is shown below

class Genr<T>  // generic class is defined
{
	T t; // generic varible 't' is defined here

                 // generic goMethod() is defined here
	public T goMethod(T t1)
	{
		return t1;
	}
}

Now if we instantiate this generic class as

Genr<Integer> iObject = new Genr<Integer>();

then generic type 'T' will be replaced with actual implementation class Integer

So inside JVM this class will become

class Genr<Integer>
{
	Integer t;
	
	public Integer goMethod(Integer t1)
	{
		
		return t1;
	}
}

Similiarly if we instantiate this generic class as

Genr<String> sObject = new Genr<String>();

then generic type 'T' will be replaced with actual implementation class String


~ abhay

[Alan Blass]

Hi!

Thanks for your replies.

[Wouter Oet]

Ove Lindström wrote:
the compiler/jvm will write me this method:

static void fromArrayToCollection(String[] a, Collection<String> c) {
    for (String o : a) {
        c.add(o); // Correct
    }
}

No. Type information is only available at compile time. At runtime all the type information is no longer available due to type erasure. This process is there to maintain backwards compatibility.

static <T> void fromArrayToCollection(T[] a, Collection<T> c) 
// Will compile to
static <T> void fromArrayToCollection(Object[] a, Collection c) 

Therefore it is legal to do:

List<String> list = new ArrayList<String>();
List list2 = list; // Warning here
list2.add(Integer.valueOf(5));
System.out.println(list.get(0)); // ClassCastException can't cast Integer to String

[Ove Lindström]

Wouter Oet wrote:
Therefore it is legal to do:

List<String> list = new ArrayList<String>();
List list2 = list; // Warning here
list2.add(Integer.valueOf(5));
System.out.println(list.get(0)); // ClassCastException can't cast Integer to String

Well, yes, but we could argue if it is legal or not when it throws you an error... ;)

Don't confuse the young ones.

[Wouter Oet]

Ove Lindström wrote:Well, yes, but we could argue if it is legal or not when it throws you an error... ;)

It throws an Exception not an Error. And the compiler accepts it so in my book that is legal. If it is correct depends on the situation.

Ove Lindström wrote:Don't confuse the young ones.

You provided incorrect information, I corrected you, provided an example in which I clearly marked where you get the warnings and where the Exceptions and I'm confusing the young ones??