Question

Say, i have a generic type as below

public class GenericType<T> {
   private T someVar;

   public void setVar(T var) { this.someVar = var; }

   //Rest of the code
}

I want to allow it to take only specific types(String/Integer/Double). I know about bounded wildcards but they don’t help me here. In setVar(), I can check the instanceof and throw an Exception if type is not Integer/String etc. Is this the best way to do it?

I have the same problem when doing operations on this type. Depending on the type, I want to do different operations. Inheritance and bounded wildcards seem like the way to go in general for this kind of problem but these are primitive wrappers.

Answer 1

Using Inheritance:

Parent.java

public abstract class Parent<T> {
    public abstract void display(T t);
}

ChildString.java

public class ChildString extends Parent<String> {

    @Override
    public void display(String t) {
        // Do something here...
    }

}

ChildInteger.java

public class ChildInteger extends Parent<Integer> {

    @Override
    public void display(Integer t) {
        // Do something here...
    }

}

ChildDouble.java

public class ChildDouble extends Parent<Double> {

    @Override
    public void display(Double t) {
        // Do something here...
    }

}

And access the class child rather than you directly access the parent class.

Update

Here another example:

GenericType.java

public class GenericType {

    public void display(Object t) {
        String msg;
        if(t instanceof String) {
            msg = "String";
        } else if (t instanceof Integer) {
            msg = "Integer";
        } else if (t instanceof Double) {
            msg = "Double";
        } else {
            msg = "Another Object";
        }

        System.out.println(msg);
    }
}

SpecificGeneric.java

public class SpecificGeneric {

    public static void main(String[] args) {
        GenericType basicType = new GenericType();

        basicType.display(new String());
        basicType.display(new Integer(1));
        basicType.display(new Double(0.1));
    }
}