Generics and creating new objects

Question

Assume this class:
class Yatta<T>
  public Yatta()
    T t = new T();
}When compiling I get "unexpected type" refering to the "T" in "new T()". Why isn't this allowed? Is there any way of doing something similar without creating a huge chain of factories for each type?

Answer 1

Please use single letters for type parameters. Doing what you've done with "Type" makes reading the code difficult...
Since duplicate() is declared in Component I assume it is declared to return Component. How can the compiler possibly know that it is going to return a more specific type? It can't. (Well... you can tell it... see below)
Because of what I wrote in the first paragraph, it's not immediately obvious that Type is a type parameter, but it is, and casting to a type parameter doesn't get you anywhere. From this code and your original post, you appear to be treating Java Generics like C++ templates. They are not the same. In particular, Generics are implemented using a technique called erasure which means that the type parameter information is not present in the compiled class files. The practical upshot of this is that the cast in the line you highlight is in fact a cast to Component (since that is the upper bound of Type) and this cast is useless because we already know the c is a Component. So the compiler is correctly warning you that the typecast will not actually perform the check that you want it to.
(In fact, if you try this in Eclipse, you get a better warning: "Type safety: The cast from Component to T is actually checking against the erased type Component")
So... how to fix this...?
Well, you need to make the return type of duplicate() change depending on the concrete implementation. You could do this by parameterising Component thus:
  public interface Component<T extends Component<T>> {
    public T duplicate();
  }Now, every use of Component will need to be parameterised. In the case of the code you have below, you'll need:
public class Container<T extends Component<T>> extends ArrayList<T> {
  public Container() {
    //Empty
    // Why write it then??? Get rid of it.
  public Container(Container<T> object) {
    Iterator<T> i = object.iterator();  // don't need ListIterator here
    while(i.hasNext()) {
      add(i.next().duplicate());
}and every implementation of Component needs to look like this:
public static class Something implements Component<Something> {
  public Something duplicate() {  // note the return type
    return null;  // or something more useful!
}Hope that helps.
(PS 'tabs' are the work of satan and should never be found in source code)