tags:

views:

417

answers:

11

Duplicate: Java generics why this won’t work

Duplicate: Instantiating a generic class in Java

I would like to create an object of Generics Type in java. Please suggest how can I achieve the same.

Note: This may seem a trivial Generics Problem. But I bet.. it is'nt. :)

suppose I have the class declaration as:

 public class Abc<T>
 {
    public T getInstanceOfT()
    {
       // I want to create an instance of T and return the same.
    }      
 } 
A: 

It looks like you are trying to create the class that serves as the entry point to your application as a generic, and that won't work... The JVM won't know what type it is supposed to be using when it's instantiated as you start the application.

However, if this were the more general case, then something like would be what you're looking for:

public MyGeneric<MyChoiceOfType> getMeAGenericObject(){
   return new MyGeneric<MyChoiceOfType>();
}

or perhaps:

MyGeneric<String> objMyObject = new MyGeneric<String>();
Martin Milan
There is no "main" class, and the main method can be within any class.
James
True, but you know what I mean - the class that serves as the Entry Point in Java application. I'll tidy up my text - I've not been very clear...
Martin Milan
@James- I have updated my code and removed main method.
Mohd Farid
@Mohd You didn't have to remove the main method from your `Abc` class, it just makes more sense to have your main method in a seperate class that calls `Abc`
James
@James Completely agree with you. But guys were getting confused by the main:)
Mohd Farid
A: 
Abc<String> abcInstance = new Abc<String> ();

..for example

Roman
+4  A: 

You don't seem to understand how Generics work. You may want to look at http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html Basically what you could do is something like

public class Abc<T>
{
  T someGenericThing;
  public Abc(){}
  public T getSomeGenericThing()
  {
     return someGenericThing;
  }

  public static void main(String[] args)
  {
     // create an instance of "Abc of String"
        Abc<String> stringAbc = new Abc<String>();
        String test = stringAbc.getSomeGenericThing();
  }

} 
Tedil
+1 You have perfectly narrated the problem. only thing missing is...Where are we initialising someGenericThing?
Mohd Farid
Agree with Mohd, stringAbc.getSomeGenericThing() is actually null.
eric2323223
yeah, well, I forgot to add that bit. You would of course have to set/initialize some T you'd like, e.g. in the Abc constructor. Or via Setter Methods. But Mohd problem isn't about what I posted anyways (at least after he posted some comments)
Tedil
+5  A: 

In the code you posted, it's impossible to create an instance of T since you don't know what type that is:

public class Abc<T>
{
       public T getInstanceOfT()
       {
           // There is no way to create an instance of T here
           // since we don't know its type
       }
} 

Of course it is possible if you have a reference to Class<T> and T has a default constructor, just call newInstance() on the Class object.

If you subclass Abc<T> you can even work around the type erasure problem and won't have to pass any Class<T> references around:

import java.lang.reflect.ParameterizedType;

public class Abc<T>
{
    T getInstanceOfT()
    {
        ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
        Class<T> type = (Class<T>) superClass.getActualTypeArguments()[0];
        try
        {
            return type.newInstance();
        }
        catch (Exception e)
        {
            // Oops, no default constructor
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args)
    {
        String instance = new SubClass().getInstanceOfT();
        System.out.println(instance.getClass());
    }
}

class SubClass
    extends Abc<String>
{
}
Martin
Your reason is wrong since the same could be said of `Class<T>` yet here we *can* create an instance.
Konrad Rudolph
Don't agree with you. I have been able to achieve the same .. check my answer.
Mohd Farid
well, of course it's possible to instantiate `T` **if** you know its type (through `Class<T>`) **and** that type has a default constructor. This was however not the case in the originally posted code.
Martin
+6  A: 

What you wrote doesn't make any sense, generics in Java are meant to add the functionality of parametric polymorphism to objects.

What does it mean? It means that you want to keep some type variables of your classes undecided, to be able to use your classes with many different types.

But your type variable T is an attribute that is resolved at run-time, the Java compiler will compile your class proving type safety without trying to know what kind of object is T so it's impossible for it to let your use a type variable in a static method. The type is associated to a run-time instance of the object while public void static main(..) is associated to the class definition and at that scope T doesn't mean anything.

If you want to use a type variable inside a static method you have to declare the method as generic (this because, as explained type variables of a template class are related to its run-time instance), not the class:

class SandBox
{
  public static <T> void myMethod()
  {
     T foobar;
  }
}

this works, but of course not with main method since there's no way to call it in a generic way.

EDIT: The problem is that because of type erasure just one generic class is compiled and passed to JVM. Type checker just checks if code is safe, then since it proved it every kind of generic information is discarded.

To instantiate T you need to know the type of T, but it can be many types at the same time, so one solution with requires just the minimum amount of reflection is to use Class<T> to instantiate new objects:

public class SandBox<T>
{
    Class<T> reference;

    SandBox(Class<T> classRef)
    {
        reference = classRef;
    }

    public T getNewInstance()
    {
        try
        {
            return reference.newInstance();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args)
    {
        SandBox<String> t = new SandBox<String>(String.class);

        System.out.println(t.getNewInstance().getClass().getName());
    }
}

Of course this implies that the type you want to instantiate:

  • is not a primitive type
  • it has a default constructor

To operate with different kind of constructors you have to dig deeper into reflection.

Jack
Well, it makes perfect sense in .NET, where generics are conceptually quite similar to Java’s. The only real difference is that .NET doesn’t have the type erasure and that is the *technical* difference that makes such a code work in .NET and not in Java.
Konrad Rudolph
Please ignore it being called from a main method. I have updated the code. Now, we have a getInstanceOfT method.
Mohd Farid
+4  A: 

First of all, you can't access the type parameter T in the static main method, only on non-static class members (in this case).

Second, you can't instantiate T because Java implements generics with Type Erasure. Almost all the generic information is erased at compile time.

Basically, you can't do this:

T member = new T();

Here's a nice tutorial on generics.

bruno conde
"First of all, you can't access the type parameter T in the static main method, only on non-static class members (in this case)."--- Agreed---So I have updated the code to have a non-static method But the rest of the reasons are not much relevant.
Mohd Farid
A: 

You need to get the type information statically. Try this:

public class Abc<T> {
    private Class<T> clazz;

    public Abc(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T getInstanceOfT()
            throws InstantiationException, IllegalAccessException {
        return clazz.newInstance();
    }
}

Use it as such:

        Abc<String> abc = new Abc<String>(String.class);
        abc.getInstanceOfT();

Depending on your needs, you may want to use Class<? extends T> instead.

Hosam Aly
+8  A: 
 public class Abc<T>
 {

    public T getInstanceOfT(Class<T> aClass)
    {
       return aClass.newInstance();
    }      

} 

You'll have to add exception handling.

You have to pass the actual type at runtime, since it is not part of the byte code after compilation, so there is no way to know it without explicitly providing it.

Jens Schauder
+1Thanks Jen !!!Saw your post after answering my question. I am using the same approach as you.
Mohd Farid
A: 

Hi guys !!!

I was implementing the same using the following approach.

public class Abc<T>
{
   T myvar;

    public T getInstance(Class<T> clazz) throws InstantiationException, IllegalAccessException
    {
        return clazz.newInstance();
    }
}

I was trying to find a better way to achieve the same.

Isn't it possible?

Mohd Farid
This is better done by receiving `clazz` in the constructor (check my answer). If you do it in a method then it's almost meaningless, since it's just a shortcut for calling `someObject.getClass().newInstance()`, which doesn't seem to add much. Even if you decide to do it that way, you don't need a generic class; a static generic method would suffice.
Hosam Aly
+1 Agreed. You are correct!!!
Mohd Farid
+2  A: 

The only way to get it to work is to use Reified Generics. And this is not supported in Java (yet? it was planned for Java 7, but has been postponed). In C# for example it is supported assuming that T has a default constructor. You can even get the runtime type by typeof(T) and get the constructors by Type.GetConstructor(). I don't do C# so the syntax may be invalid, but it roughly look like this:

public class Foo<T> where T:new() {
    public void foo() {
        T t = new T();
    }
}

The best "workaround" for this in Java is to pass a Class<T> as method argument instead as several answers already pointed out.

BalusC
+2  A: 

Type Erasure Workaround

Inspired by @martin's answer, I wrote a helper class that allows me to workaround the type erasure problem. Using this class (and a little ugly trick) I'm able to create a new instance out of a template type:

public abstract class C_TestClass<T > {
    T createTemplateInstance() {
        return C_GenericsHelper.createTemplateInstance( this, 0 );
    }

    public static void main( String[] args ) {
        ArrayList<String > list = 
            new C_TestClass<ArrayList<String > >(){}.createTemplateInstance();
    }
}

The ugly trick here is to make the class abstract so the user of the class is forced to subtype it. Here I'm subclassing it by appending {} after the call to the constructor. This defines a new anonymous class and creates an instance of it.

Once the generic class is subtyped with concrete template types, I'm able to retrieve the template types.


public class C_GenericsHelper {
    /**
     * @param object instance of a class that is a subclass of a generic class
     * @param index index of the generic type that should be instantiated
     * @return new instance of T (created by calling the default constructor)
     * @throws RuntimeException if T has no accessible default constructor
     */
    @SuppressWarnings( "unchecked" )
    public static <T> T createTemplateInstance( Object object, int index ) {
        ParameterizedType superClass = 
            (ParameterizedType )object.getClass().getGenericSuperclass();
        Type type = superClass.getActualTypeArguments()[ index ];
        Class<T > instanceType;
        if( type instanceof ParameterizedType ) {
            instanceType = (Class<T > )( (ParameterizedType )type ).getRawType();
        }
        else {
            instanceType = (Class<T > )type;
        }
        try {
            return instanceType.newInstance();
        }
        catch( Exception e ) {
            throw new RuntimeException( e );
        }
    }
}
tangens