Pattern for storing object of varying type
What you are doing appears to be sane. The use of generics is primarily as a compile-time validator (and it makes some code simpler, like not having to cast things).

If you don't know the types of your data at compile time, then you can't use generics.

So, you have run-time specified data, and that's OK. Do you handle that as well as it can be handled? That is the real question.

Items I can see that raise question-marks:


Why are you saving away the Class name (as type) when you can save away the actual Class?
wasUpdated is not used.
type is a bad name for a Java variable. It conflicts with java.lang.Type, and you don't need it anyway if you are going to store the Class instead of its name.
if you do keep the class, then you can use the Class.isInstance(...) method to ensure the data types are correct, instead of specifying the class as part of the retrieval in the get(Class&lt;T&gt; clazz) method... or, you can confirm they are the same with a simple .equals() call instead of the name/isArray check.
the methods like return TakesAnInteger(...) should have a lower-case t to start with.... this is the Java convention for method names.
Similarly, Java convention is to put the opening brace { for a block on the same line as the method declaration.


Edit: with Class saved instead of name and isArray

Also, I note now that you are missing some semi-colons in your data declarations.... and also, you are missing return values from some of your methods.

public class DataParam {
    public String name;
    public Class&lt;?&gt; dataClass;
    public boolean wasUpdated;
    private Object data;

    public DataParam(String name, Class&lt;?&gt; typeClass) {
        this.name = name;
        dataClass = typeClass;
        data = null;
        wasUpdated = false;
    }

    public &lt;T&gt; T get(Class&lt;T&gt; typeClass) {
        if(dataClass.equals(typeClass)) {
            return typeClass.cast(data);
        }
        return null;
    }

    public &lt;T&gt; T set(T obj, Class&lt;T&gt; typeClass) {
        if(dataClass.equals(typeClass)) {
            T toreturn = typeClass.cast(data);
            data = obj;
            return toreturn;
        }
        return null;
    }

    public String doSomething() {
        //An example of doing different things based on type
        //.......
        return null;
    }
}