Is there an unsupported operation annotation in Java?

Are there any annotations in java which mark a method 开发者_如何学Cas unsupported? E.g. Let's say I'm writing a new class which implements the java.util.List interface. The add() methods in this interface are optional and I don't need them in my implementation and so I to do the following:

public void add(Object obj) {
   throw new UnsupportedOperationException("This impl doesn't support add");
}

Unfortunately, with this, it's not until runtime that one might discover that, in fact, this operation is unsupported.

Ideally, this would have been caught at compile time and such an annotation (e.g. maybe @UnsupportedOperation) would nudge the IDE to say to any users of this method, "Hey, you're using an unsupported operation" in the way that using @Deprecated flags Eclipse to highlight any uses of the deprecated item.

Although on the surface this sounds useful, in reality it would not help much. How do you usually use a list? I generally do something like this:

List<String> list = new XXXList<String>();

There's already one indirection there, so if I call list.add("Hi"), how should the compiler know that this specific implementation of list doesn't support that?

How about this:

void populate(List<String> list) {
    list.add("1");
    list.add("2");
}

Now it's even harder: The compiler would need to verify that all calls to that function used lists that support the add() operation.

So no, there is no way to do what you are asking, sorry.

You can do it using AspectJ if you are familiar with it. You must first create a point-cut, then give an advice or declare error/warning joint points matching this point cut. Of course you need your own @UnsupportedOperation annotation interface. I gave a simple code fragment about this.

// This the point-cut matching calls to methods annotated with your 
// @UnsupportedOperation annotation.
pointcut unsupportedMethodCalls() : call(@UnsupportedOperation * *.*(..));

// Declare an error for such calls. This causes a compilation error 
// if the point-cut matches any unsupported calls.
declare error: unsupportedMethodCalls() : "This call is not supported."

// Or you can just throw an exception just before this call executed at runtime
// instead of a compile-time error.
before() : unsupportedMethodCalls() {
    throw new UnsupportedOperationException(thisJoinPoint.getSignature()
        .getName());
}

(2018) While it may not be possible to detect it at compile time, there could be an alternative. i.e. The IDE (or other tools) could use the annotation to warn the user that such a method is being used.

There actually is a ticket for this: JDK-6447051

From a technical point of view, it shouldn't be much harder to implement than inspections that detect an illegal use of an @NotNull or a @Nullable accessor.

try this annotation @DoNotCall

https://errorprone.info/api/latest/com/google/errorprone/annotations/DoNotCall.html