Restricting types not related through inheritance without using instanceOf by creating own class hierarchy
You can create the same thing by not creating all those subclasses. I also see that you can't use the instanceOf method. My first intention was getting this test method to work:

System.out.println(Field.fromObject(new ArrayList()).getFeatureValue().getClass());
System.out.println(Field.fromObject(new Integer(6)).getFeatureValue());
System.out.println(Field.fromObject(new Integer(6)).getFeatureValue().getClass());
System.out.println(Field.fromObject(Boolean.TRUE)); // null or error


As you can see, I call Field and not an implementation of the Field class. But I also want the correct class back as what class I put in there, so the output should be:

class java.util.ArrayList
6
class java.lang.Integer
null


In order that Boolean is a type what can't be created. After searching on this topic you come always back to instanceOf or what you did. The thing what I wanted is something I can refactor really easy, so it needed to be on 1 place to refactor.

Enum could help me with that, but still having trouble with subclasses what also need to be valid. (ArrayList if List is allowed)

I refactored your code to this. If you need to create the subclasses, you could still look at the static method.

public class Field&lt;T&gt; {

    private T featureValue;

    Field(T value) {
        this.featureValue = value;
    }

    public T getFeatureValue() {
        return featureValue;
    }

    public static &lt;T&gt; Field&lt;T&gt; fromObject(T value) {
        for (Allowed allow : Allowed.values()) {
            if (allow.getClazz().isAssignableFrom(value.getClass())) {
                return new Field&lt;&gt;(value);
            }
        }
        return null;
    }

    private enum Allowed {

        INTEGER(Integer.class),
        STRING(String.class),
        LIST(List.class);

        private final Class clazz;

        private Allowed(Class clazz) {
            this.clazz = clazz;
        }

        public Class getClazz() {
            return clazz;
        }
    }
}


As you can see, we iterate the Enum values to check the restrictions. With this solution you can add also the following test:

List&lt;String&gt; list  = Field.fromObject(new ArrayList&lt;String&gt;()).getFeatureValue();


As you can see, no casting is required.

The next is broken code:

List&lt;String&gt; list  = Field.fromObject(new ArrayList&lt;Boolean&gt;()).getFeatureValue();


which is also good because these are 2 different types.