How to force the user to pass a type to a generic class?

Question

I have a generic class called Quantity<UnitType>, and in some methods of another class, I need to get an object of that class in a specific type. See the code below:

interface UnitType {}

enum Distance implements UnitType {
    FEET, METERS
}

enum Weight implements UnitType {
    POUNDS, KILOGRAMS
}

class Quantity<T extends UnitType> {
    public Quantity(float value, T unit) {
        // ...
    }
}

public class Test {
    public static void main(String[] args) {
        Test.func(new Quantity<Weight>(30, Weight.KILOGRAMS));
    }

    public static void func(Quantity<Weight> value) {
        // ...
    }
}

The above code compiles as expected. The problem is that if I do not specify the type on startup and pass as argument an attribute of Distance, the code will also compile.

// Compila. Isso é um problema, pois o método só aceita "Weight"
Test.func(new Quantity(30, Distance.FEET)); 

// Não compila. É isso o que eu quero.
Test.func(new Quantity<Distance>(30, Distance.FEET)); 

What can I do to force the user to pass a type to the generic class, or else, "filter" objects that are just from Weight?

Answer 1

You have to declare the method func as generic if you want it to work for any UnitType and with generic types (Quantity<T>).

However, if you want to use a specific type, you only use the desired type (Quantity<Weight>, as in the example of funcW down below).

You can also use the Diamond (<>) to simplify their generics when using new. For example, new Quantity<>(20, Weight.KILOGRAMS).

However, when using the constructor directly you still have to either put the generic type <Weight> or the Diamond <> not to fall into the problem of your question. It is still possible to forget to put any of them (ie, use raw types), and therefore the Diamond It still doesn’t solve your problem, just attenuates it.

The cause of the problem is that given the way the Java language has evolved, with the addition of generic types only late in Java 5 and considering that backward compatibility could not be sacrificed, there is no much better way to use builders with generic types. There could be if language had been born with it from the beginning, but unfortunately this is not the case.

The ultimate solution then is not to use the constructor directly. And that’s where a static method solves the problem. This static method is called the constructor which is then made private. This makes it impossible to use raw types and the possibility of using generic ill-formed.

Here’s the code:

interface UnitType {}

enum Distance implements UnitType {
    FEET, METERS
}

enum Weight implements UnitType {
    POUNDS, KILOGRAMS
}

class Quantity<T extends UnitType> {
    private Quantity(float value, T unit) {
        // ...
    }

    public static <T extends UnitType> Quantity<T> create(float value, T unit) {
        return new Quantity<>(value, unit);
    }
}

public class Test {
    public static void main(String[] args) {
        Test.func(Quantity.create(30, Weight.KILOGRAMS));  // Compila.
        Test.func(Quantity.create(30, Distance.METERS));   // Compila.
        Test.funcW(Quantity.create(30, Weight.KILOGRAMS)); // Compila.
        Test.funcW(Quantity.create(30, Distance.METERS));  // Não compila.
    }

    public static <T extends UnitType> void func(Quantity<T> value) {
        // ...
    }

    public static void funcW(Quantity<Weight> value) {
        // ...
    }
}