Java中是否可以对同一接口进行参数化和未参数化的版本？

Question

Question

If one defines a public class Something <T> { ... } , then Java will complain about using a raw type if you do this: Something noparam = new Something();

Is it possible to define an interface or class that can be used with or without a type parameter?

Context

The frontend of a Java app interfaces asynchronously with our backend using callbacks:

public interface ResultCallback <T> {
    public void onResult(T result);
    public void onError();
}

Here's an example of the backend I'm talking about, with some basic CRUD operations using the callback above:

public interface Backend {

    // create a new Comment for a specified blog Post
    public void createComment(Post post, ResultCallback<Comment> callback);

    // retrieve the Comment with the specified UUID
    public void getComment(UUID id, ResultCallback<Comment> callback);

    // delete the Comment with the specified UUID
    public void deleteComment(UUID id, ResultCallback callback);
}

Notice that the delete operation's callback.onResult(T result) will not have a Comment parameter . It might make sense to parametrize that result with a Comment and just "return" the deleted Comment , even if it's just to satisfy the type parameter constraint of ResultCallback . I don't like this idea because the Comment is gone from the backend and no changes to it will persist.

Just for a usage example, the idea is that ResultCallbacks are defined in the frontend of the app and passed to the async backend. For example, to display a comment:

public CommentRenderer implements ResultCallback<Comment> {
    @Override
    public void onResult(Comment comment) {
        // display the comment, commenter, date, etc. on screen
    }

    @Override
    public void onError(String message) {
        // display an error message
    }
}

Answer 1

No, the closest thing to that comes to mind would be to use ResultCallback<Void> but that would still require you to give the onResult a null-argument which is kind of ugly.

In this case I would recommend you to either use a separate interface for the delete case or let ResultCallback have more than one method:

interface ResultCallback<T> {
    void onResult(T t);
    void onDelete(); // Called after delete.
    void onError(String message);
}

If you think it is frustrating to override the onDelete even though you're rarely interested in "listening" for these type of events, you could give it an empty default implementation:

...
    default void onDelete() {
        // do nothing by default
    }
...

An alternative for pre-Java 8, is to use an Adapter which would look like follows:

abstract class ResultAdapter<T> implements ResultCallback<T> {
    @Override
    public void onResult(T t) {
    }

    @Override
    public void onDelete() {
    }

    @Override
    public void onError(String msg) {
    }
}

Answer 2

在这种情况下，您始终可以使用ResultCallback<Void>并使用null 。

Answer 3

How a bout extended Generic Type?

public class Foo<T extends Comment> { ... }
public class FooDefault extends Foo< Baz > { ... }