There is none.

Regards, Lothar

If you are free to make major changes, you could go to a factory system,
and put the description etc. in the factory. Suppose your pluggable
interface is XXX:

interface XXXFactory{
  XXX getInstance();
  String getName();
  String getDescription();
}

An XXXFactory would be cheap to create, and required to have the
methods. You would get an instance of the actual plug-in by calling the
factory's getInstance method.

If you cannot do something like this, or do not think it would make
sense in your context, consider leaving the static methods optional, and
providing defaults if the method does not exist, such as using the class
name for the getName() and getDescription() results. If the user wants a
more descriptive name, it is up to them to supply the static method.

Patricia

I also find that some of Java's limitation on interfaces and abstract
classes just don't make a lot of sense.  I have no direct solution for you.

One thought: have each class implement an empty interface just to "mark"
it as a type that supports your descriptions.  However, since you can't
actually guarantee these constants exist, you'll have to tease them out
with reflection to avoid throwing an error.

Note that "getName" already exists in the Class object, if the class
name itself will do.

You might want to declare a class for your constants, just to reduce the
likelihood that a programmer will make a mistake.

final class DescriptionConstants {
    private String name;
    private String desc;
    DescriptionConstants( String name, String desc ) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() { return name; }
    public String getDesc() { return desc; }
}

class RandomClass implements DescriptionIface {
    private final DescriptionConstants myConsts
        = new DescriptionConstants( "some name",
            "hey how bout those constants?" );
    static DescriptionConstants getDesc()
        { return myConsts; }
}

Not "constants" but much cheaper than instantiating a complex class, and
there's a little protection for the harried programmer.

That is, you'd have to instantiate an instance.  You have to load the class
to call static methods on it.

Anyway, assuming you had some way to force the static methods to exist, how
would you call them?  The only ways to call a static method without either
hardcoding the name of the class are

1. Via an instance, and
2. By reflection.

I'm ruling out 1 since you're trying to avoid creating an instance, so that
leaves 2..

If you're already using reflection, refuse to load the class unless it
defines all of the static methods you're interested in (which you can
document them in the interface definitions.).  It's unfortunate that the
check is done at runtime instead of compile time, but c'est la vie.