CODEWITHSUNDEEP
javagenerics
Mohit
Mohit

Reputation: 239

How does one restrict number of allowed types in Java generic type

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.

Upvotes: 2

Views: 1900

Answers (3)

Bitmap
Bitmap

Reputation: 12538

Inferring the desired type say GenericType<Double> and using instanceof when neccesary is the quickest and easy option. Alternatively overload setVar(..) to accept the restricted types in your Generic class.

  public static class GenericType<T>
  {
    private T someVar;
    public void setVar(String var)
    {
      this.someVar = (T) var;
    }

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

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

Upvotes: 0

Crazenezz
Crazenezz

Reputation: 3456

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));
    }
}

Upvotes: 6

Alpedar
Alpedar

Reputation: 1344

You cannot (more than extends something, but in your case you want few unrelated types, so it does not help).

What you can, is check instance passed to method (you already know it). If you want one instace of generic class for eg. String another for Integers, but don't allow eg. Point2D, you can make constructor with parameter Class clazz and check when constructing whether its allowed. If you are more paranoid, you can store that clazz and in all function compare whether parameter is actualy that class.

This way, you can still create MyClass, but cannot create instance with this type. (But you can cast it, co its not fool proof)

Upvotes: 0

Related Questions