提供类型安全的方法有用吗？

Question

I'm designing the interface as follows:

public interface Parameters {

    public <T> T getValue(ParameterName pn, Class<T> valueType) throws ClassCastException;
}

An implementation is obligated to throw ClassCastException if the Class instance of the value to be returned is not an assignableForm of the Class passed as a parameter.

Does it make sesnse? It provides compile-time type-safety, but we can do the same with just explicit cast.

Or it's much better to declare just

public Object getValue(ParameterName pn)

leaving all class-cast issues to the client.

Answer 1

I have used this form of API where I add the ability to convert the type to the one desired. eg if it's a String but you need an Integer it will attempt to parse it.

Otherwise, as you suggest you are not adding much that this method doesn't provide.

 public <T> T getValue(ParameterName pn);

This avoid needing an explicit cast.

Answer 2

It is a misunderstanding that you gain any compile-time type-safety by passing the Class object of the expected return type as a parameter. If the client passes a Class of the wrong type the error will only get detected at runtime.

But I think the design with a Class parameter has other advantages:

• The parameters creates a natural place to document the behaviour of the method regarding the return type.
• You can write code in the method to check the Class parameter and provide a specific and meaningful error message if the user makes a mistake.
• It is very visible in the calling code and brings attention to the behaviour of the method.

I can think of two disadvantages of that design:

• The existence of the parameter might give users the impression that the parameter affects the return value of the method.
• It is more verbose than using an unrestricted generic return type as Peter suggests in his answer.