tags:

views:

2543

answers:

7

If I am creating a java class to be generic, such as:

public class Foo<T>

How can one determine internally to that class, what 'T' ended up being?

public ???? Bar()
{
    //if its type 1
    //    do this
    //if its type 2
    //    do this
    //if its type 3
    //    do this
    //if its type 4
    //    do this
}

I've poked around the Java API and played with the Reflection stuff, instanceof, getClass, .class, etc, but I can't seem to make heads or tails of them. I feel like I'm close and just need to combine a number of calls, but keep coming up short.

To be more specific, I am attempting to determine whether the class was instantiated with one of 3 possible types.

+6  A: 

Because of type erasure, there is no way to do this directly. What you could do, though, is pass a Class<T> into the constructor and hold onto it inside your class. Then you can check it against the three possible Class types that you allow.

However, if there are only three possible types, you might want to consider refactoring into an enum instead.

Michael Myers
This seems like the best solution, albeit less pretty than a true blue generic class. Thanks for the input.
byte
Again, I urge you to strongly consider polymorphism rather than an if-statement based on type.
Michael Myers
Unfortunately the items in consideration are not relating in any way, so a polymorphic solution isn't practical. The possible items that would fall into the if-statement logic are edge cases of all other 'normal' processing that must be treated entirely differently altogether, in no relational way.
byte
All right, I'll quit bugging you then. :)
Michael Myers
@dxmio: The items relate in this way: that you're creating a Foo<> of them. I'm not saying that to be flip: you could create a "Fooable" interface and have each of them implement that - and the interface could have a single method that returned their type (or, better, the enumeration).
Carl Manaster
A: 

The whole point of a generic class is that you dont need to know the type that is being used....

Visage
True enough, however if I design a class that can be instantiated generically to be of any type, I want to handle a specific subset of all possible types as edge cases with specific logic.
byte
Then create different subtypes. Or delegate to strategies (or similar).
Tom Hawtin - tackline
+1  A: 

The Problem is that most of the Generic stuff will disappear during compilation.

One common solution is to save the type during the creation of the Object.

For a short introduction in the Type Erasure behaviour of java read this page

Janusz
This is very helpful - I've seen solutions that involve this and may end up going this route.
byte
Probably means your design is poor.
Tom Hawtin - tackline
A: 

It looks like what you want is in fact not a Generic class, but an interface with a number of different implementations. But maybe it would become clearer if you stated your actual, concrete goal.

Michael Borgwardt
+2  A: 

In contrast to .NET Java generics are implemented by a technique called "type erasure".

What this means is that the compiler will use the type information when generating the class files, but not transfer this information to the byte code. If you look at the compiled classes with javap or similar tools, you will find that a List<String> is a simple List (of Object) in the class file, just as it was in pre-Java-5 code.

Code accessing the generic List will be "rewritten" by the compiler to include the casts you would have to write yourself in earlier versions. In effect the following two code fragments are identical from a byte code perspective once the compiler is done with them:

Java 5:

List<String> stringList = new ArrayList<String>();
stringList.add("Hello World");
String hw = stringList.get(0);

Java 1.4 and before:

List stringList = new ArrayList();
stringList.add("Hello World");
String hw = (String)stringList.get(0);

When reading values from a generic class in Java 5 the necessary cast to the declared type parameter is automatically inserted. When inserting, the compiler will check the value you try to put in and abort with an error if it is not a String.

The whole thing was done to keep old libraries and new generified code interoperable without any need to recompile the existing libs. This is a major advantage over the .NET way where generic classes and non-generic ones live side-by-side but cannot be interchanged freely.

Both approaches have their pros and cons, but that's the way it is in Java.

To get back to your original question: You will not be able to get at the type information at runtime, because it simply is not there anymore, once the compiler has done its job. This is surely limiting in some ways and there are some cranky ways around it which are usually based on storing a class-instance somewhere, but this is not a standard feature.

Daniel Schneller
+1 for extensive information and contrast with C# - thank you
byte
+4  A: 

I've used a similar solution to what he explains here for a few projects and found it pretty useful.

http://blog.xebia.com/2009/02/07/acessing-generic-types-at-runtime-in-java/

The jist of it is using the following:

 public Class returnedClass {
  ParameterizedType parameterizedType =
    (ParameterizedType) getClass().getGenericSuperClass();
 return (Class) parameterizedtype.getActualTypeArguments()[0];
}
jnt30
+1! i was going to write about this
Andreas Petersson
+1 And this is pretty much the solution I went with after further research, so I've changed it to my accepted answer.
byte
+1 excellent ! I was searching it for hours...
Jerome C.
A: 

I agree with Visage. Generics is for compile-time validation, not runtime dynamic typing. Sounds like what you need is really just the factory pattern. But if your "do this" isn't instantiation, then a simple Enum will probably work just as well. Like what Michael said, if you have a slightly more concrete example, you'll get better answers.

aberrant80
I have to disagree here, and there have been several mentions of a non-polymorphic solution being necessary in the specific problem space, and I've been quite happy with the answers I've received.
byte