IveCal wrote:
I cant understand this piece of code regarding generics.
class Gen<T>{
T ob;
Gen(){
ob = new T(); // <---- POINT OF CONFUSION
}
}
why is it illegal to instantiate ob = new T();?
I thought T is replaced with the appropriate type (through the process
called erasure) during COMPILE time so that it will look AS IF IT WERE
How would the compiler know that String is involved? That would only be known
at run time.
WRITTEN like this:
// Assume argument type is String
class Gen{
java.lang.String ob;
Gen(){
ob = new java.lang.String(); // I assumed it look like this.
}
}
In this case, all the type-resolution mechanism can tell is that T is some
Object type. T might not have a no-arg constructor, so the compiler cannot
tell that 'new T()' is a valid constructor. You can pass in a Class <?
extends T> object to provide run-time type information (RTTI):
<example>
package testit;
import java.util.logging.Level;
import java.util.logging.Logger;
public class General <T>
{
private final Class <? extends T> clazz;
private final T ob;
public General( Class<? extends T> clazz )
{
try
{
ob = clazz.newInstance();
}
catch ( InstantiationException ex )
{
Logger.getLogger( getClass().getName() )
.log( Level.SEVERE, null, ex );
throw new RuntimeException( "Illegal constructor", ex );
}
catch ( IllegalAccessException ex )
{
Logger.getLogger( getClass().getName() )
.log( Level.SEVERE, null, ex );
throw new RuntimeException( ex );
}
this.clazz = clazz;
}}
</example>
--
Lew