instanciation d'un objet de type générique avec le même type que sa superclasse

Question

Je me demande s'il est possible de créer des objets qui sont de type générique avec le même type que la classe est contenue dans.

Par exemple, considérez cet objet

public class Foo<T> { 

    private T variable; 

    Foo() { 

    } 
} 

Considérons maintenant ce

public class Bar<T> { 

    private Foo foo; 

    Bar() { 
     foo = (T) new Foo(); 
    } 
} 

Je veux que le type de l'objet foo de données dans la classe de barre pour le même type de données que la barre est instantiat ed comme.

Answer 1

Le constructeur de Foo nécessite un argument; mais vous pouvez le faire:

public class Bar<T> { 

    private Foo<T> foo; 

    Bar(T x) { 
     foo = new Foo<T>(x); 
    } 
} 

Answer 2

Je ne sais pas si je vous ai bien compris, mais voulez-vous quelque chose comme ça?

 public class Bar<T> extends Foo<T> { 

      private Foo<T> foo; 

      Bar() { 
       foo = new Foo<T>(); 
      } 
     } 

Answer 3

Oui, vous pouvez faire comme ça et ça va fonctionner. Mais vous devez avoir des constructeurs surchargés pour gérer les types de données.

La sortie du programme est:

class java.lang.Integer 
class java.lang.String 

Comme vous pouvez le voir le type de données pour la variable foo est le même que le type de données objet Bar.

Et vous avez fait une erreur dans le programme il devrait y avoir un constructeur surchargé dans la classe Bar.

package test; 

public class test { 

    public static void main(String[] args) { 
     Bar<Foo> integerBar = new Bar(3); 
     Foo<Integer> fooIntegerObject = (Foo) integerBar.getFoo(); 

     Bar<Foo> stringBar = new Bar("hello"); 
     Foo<String> fooStringObject = (Foo) stringBar.getFoo(); 

     System.out.println(fooIntegerObject.getVariable().getClass()); 
     System.out.println(fooStringObject.getVariable().getClass()); 

    } 
} 

class Foo<T> { 

    private T variable; 

    Foo(T x) { 
     variable = x; 
    } 
    public T getVariable() { 
     return variable; 
    } 

} 

class Bar<T> { 

    private T foo; 

    Bar(T x) { 
     foo = (T) new Foo<T>(x); 
    } 
    public T getFoo() { 
     return foo; 
    } 

} 

Answer 4

Sur la base de votre question mise à jour, cela devrait fonctionner:

class Bar<T extends Foo<T>> { 
    private Foo<T> foo; 

    Bar() { 
     foo = new Foo<T>(); 
    } 
} 

Notez que vous ne devriez pas utiliser un type brut Foo.