again doubt in generic

[dolly shah]

What is the main difference between <E> & <T> type. In book its written that <E> is used for Collection. <T> is used for things that are not collection. But I am not getting it. Where we can you <E> & where we can use <T>?

Please anybody help me.

[Kaydell Leavitt]

It doesn't matter which letter that you use to specify a generic type. It's just that once you use a letter to specify a type, using the same letter again, in the same context means that you're referring to the same type.

E & T are like variables only instead of representing primitives or objects, they represent types.

Kaydell

[Chandra Bhatt]

Hi,

It is often seen as convention while naming parameterized type:
Letter E generally used with parameterized interfaces like:

interface Collection<E> {
boolean add (E o);
boolean contains(E o);
boolean remove (E o);
...
}

Letter T is also used interchangeably.


Thanks,

[Burkhard Hassel]

Hi ranchers,

Gilad Bracha wrotes in his generics tutorial that the naming convention is either <T> for type or (esp. in collections) <E> for element.

The tutorial (PDF) can be downloaded from Sun at:
http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf


Yours,
Bu.

[dolly shah]

In book its written that <E> is used for Collection. <T> is used for things that are not collection.

Wy they have written above sentence? If there is no difference, Why they have introduced (<E> & <T> ?

[dolly shah]

Thanks Chandra.
We can use any of them. Am I right?

[Jesper de Jong]

Yes, you can also use something else than "E" or "T". It doesn't even have to be a single letter, you can use any name.

class MyGenericClass<SomeType> {
  private SomeType thing;
 
  public SomeType getThing() {
    return thing;
  }
 
  public void setThing(SomeType thing) {
    this.thing = thing;
  }
}

[Kantutan Tayo]

It's just by code convention / suggestion.

E stands for Element (an element within a collection)
T stands for Type (a generic type)

It could have been a complete word instead of just a letter e.g.

interface Comaparable<Elephant> {
int compareTo(Elephant e);
}

But that's gay.