Require subclass to implement a static method

Coming from Python and Objective-C land, I may not fully understand what static methods are in Java, I think of them as "methods that operate on all members of the class" or "class-specific methods that are available when you don't have an instance of that class."

But is there a syntax for saying: "This abstract superclass requires each concrete subclass to implement this static method"? I know that static abstract isn't permitted, but it would conceptually be something like this:

public abstract class Lander {

    @RequireImplmentationInSubclass     // clearly my made-up name...
    static abstract boolean probe(Radio radio);
}

public class MarsLander extends Lander {
    static boolean probe(Radio radio) {
        // ... some MarsLander specific implementation
    }
}

public class LunarLander extends Lander {
    static boolean probe(Radio radio) {
        // ... some LunarLander specific implementation
    }
}

update

... and somewhere else, a factory method does something like:

if (MarsLander.probe(radio)) {
    ... create an instance of MarsLander and work with it
} else if (LunarLander.probe(radio)) {
    ... create an instance of LunarLander and work with it
}

In my application, creating an instance invokes a lot of machinery, so I need to call probe() on a class method before I create an instance of the class.

I looked over https://stackoverflow.com/questions/2689312/is-there-a-way-to-make-sure-classes-implementing-an-interface-implement-static-m and most of the responses were "why would you want to do that?".

I hope this example makes it clear(er). Perhaps there's' a more Java-esque way to remind the developer that a class-visible probe() method is required?

There is no way to require a static method.

But you can create a factory class with non-static methods:

public abstract class LanderFactory<L extends Lander> {
    public abstract L createLander();
    public abstract boolean probe(Radio radio);
}

You can even have a registry of LanderFactory implementations, so they effectively act as singletons:

public abstract class LanderFactory<L extends Lander> {
    private static final Map<Class<? extends Lander>,
                             LanderFactory<? extends Lander>> registry
        = Map.of(MarsLander.class, new MarsLanderFactory(),
                 LunarLander.class, new LunarLanderFactory());

    public static LanderFactory<? extends Lander> getInstance(
                                                Class<? extends Lander> type) {
        LanderFactory<? extends Lander> factory = registry.get(type);
        if (factory == null) {
            throw new IllegalArgumentException("No factory known for " + type);
        }
        return factory;
    }

    public abstract L createLander();

    public abstract boolean probe(Radio radio);
}

public class MarsLanderFactory extends LanderFactory<MarsLander> {
    @Override
    public MarsLander createLander() {
        return new MarsLander();
    }

    @Override
    public boolean probe(Radio radio) {
        // ...
    }
}

public class LunarLanderFactory extends LanderFactory<LunarLander> {
    @Override
    public LunarLander createLander() {
        return new LunarLander();
    }

    @Override
    public boolean probe(Radio radio) {
        // ...
    }
}

I tried your code(and other things surrounding this), and I'd like to tell you there's a way but I don't think there is.

I would instead recommend using a utility class that supports this static functionality you're looking for.For example, a LanderUtility class that has static methods in it might solve this in a reasonable way.

Mostly though, I don't think of using static methods in that way in Java. The real power in what is going on with this abstract class is that you can count on(somewhat) a certain type of behavior from a child. Notably, for this to matter, the child needs to be instantiated in the first place and you can use a normal, non-static method and have the child implement that instead.

"methods that operate on all members of the class"

This is not right. static methods operate on no members of a class.
Use of this is prohibited in static contexts.

I feel your question itself has the answer you are looking for. static abstract doesnt exists because on one hand you want it to behave differently (based on if it is a LunarProbe or a MarsProbe) and on the other hand you want it to be independent of the instance of LunarProbe and MarsProbe. static abstract contradicts itself.

Besides

static boolean probe() {
     // ... some MarsLander specific implementation
     // what goes here? you dont have access to any instance of this class.
}

static abstract violates a tenet of OOP called polymorphism.

In Java, static methods is allowed to be invoked directly on class references. It does not matter whether it is a abstract class or a normal class.

Due to this reason, static and abstract modifiers can't be used together. Otherwise, what would be the output of this code if the lander method is not implemented ? That's why it is illegal.

Lander.probe();

But, I think we can throw an exception from our super class static method with some hint in the exception message. We can enforce implementation of the static method.

public abstract class Lander {
  static boolean probe() {
    throw new RuntimeException("Oh oh !!! Why am I here ??");
  }
}

public class MarsLander extends Lander {
  static boolean probe() {
    // ... some MarsLander specific implementation
  }
}

public class LunarLander extends Lander {
  static boolean probe() {
    // ... some LunarLander specific implementation'
  }
}

That way, if there is a Lander implementation which has not implemented a static probe method, the probe method will get inherited but this will throw a run time exception.

Methods can't be both abstract and static, because abstract methods have to be overridden, and static methods in Java cannot be overridden. Which class implementation of a static method is used is determined at compile time. You can declare a static method with the same signature in a subclass, but it is not considered overriding because there won’t be any run-time polymorphism. The static method of the superclass is 'masked' in the subclass. If a derived class defines a static method with the same signature as a static method in the base class, the method in the derived class hides the method in the base class.