Define instance generic type later on in code in Java

Question

I have a class like this:

public class Foo<T>
{
//What ever inside
}

And later on I want to do something like this:

public class MyClass
{
    Foo foo;
    public MyClass(int x)
    {
       if(x==1)
       {
           foo = new Foo<Integer>();
           //EDIT1
           handleFooWhenItIsInteger();
           //EDIT1
       }
       else
       {
           foo = new Foo<String>();
           //EDIT1
           handleFooWhenItIsString();
           //EDIT1
       }
}

assume that I do some integer work in function 'handleFooWhenItIsInteger()' and with some string in another one.

Is defining 'foo' like above OK?

Rafael Winterhalter · Accepted Answer · 2014-08-21T12:49:40.700

This will compile, however, the use of raw types such as

Foo foo;

for your generic type Foo<T> is discouraged. Raw types are only supported for legacy reasons, i.e. compatibility to code written before Java 5 where generics were introduced.

In order to describe any generic Foo you should rather write Foo<?> which describes an instance of Foo of any generic type. The compiler will then check for you that you do not invoke any non-type safe methods on these instances later in your code as for example in your case, the instance could reference a Foo<Integer> or a Foo<String>. Thanks to using the wildcard type Foo<?>, you can reference both using the same variable but you cannot longer make an assumption on the actual generic type of the referenced instance.

Technically, there is no big difference between using Foo or Foo<?>. However, using the former, the compiler will generate a warning for using a raw type. The compiler cannot know for sure that you did not forget to add the generic type arguments and only use the raw type accidentally. This is why you should spend the few characters to always add <?> if you require a wildcard reference.

I know about the situation here. let me edit my code [EDIT1] to be more precise. thanks. — Bardya Momeni, Aug 21 '14 at 13:35

score 0 · Answer 2 · answered Aug 21 '14 at 12:43

0

Ya ok. But foo is generic, you cannot know what type it is when you use outside the constructor.

answered Aug 21 '14 at 12:43

SANN3

9,459
6
61
97

score 0 · Answer 3 · answered Aug 21 '14 at 12:44

0

This will work but will generate warning because the declaration of Foo foo is not parametrized. Then, you will be in charge to insure that all Foo interaction are consistent accross your code. Otherwise, you might face some ClassCastException

answered Aug 21 '14 at 12:44

ortis

2,203
2
15
18

score 0 · Answer 4 · answered Aug 21 '14 at 12:46

Is defining 'foo' like above OK?

No. It's a raw type, this

Foo foo;

isn't generic because of the raw-type. It's equivalent to

Foo<Object> foo;

You should have the type of Foo it is. So something like

Foo<Integer> foo;

or maybe

public class MyClass<T> {
  Foo<T> foo;

score 0 · Answer 5 · answered Aug 21 '14 at 12:52

As the others already said: it will compile with some warnings, but most probably it will behave just the same as

public class MyClass
{
    Foo foo;
    public MyClass(int x)
    {
       foo = new Foo();
    }
}

Why is that?

Java generics only enable compile-time-checks, at runtime all information you gave using generics is lost.
The compiler only knows what is declared - so when using the identifier foo it only knows it's a Foo but has no information on its generic type
While using new Foo<String>() might make a bit of a difference while invoking the constructor after the assignment to foo the compiler will no longer know about it.

Define instance generic type later on in code in Java

5 Answers5