another design question, abstract static methods...

[Murat Tasan]

so here is another general question about java...

why can't you declare an abstract static method.

i can envision the case (indeed i have experienced the case) where one
would want an abstracct superclass, with an abstract method such that all
subclasses that implement this method make that method static.

basically, the abstract class declares an abstract method that should be
static for all implementations (for example a factory method).

this isn't allowed in java, and in the language specification, there is no
reason given as to why. it is just simply stated in a single sentence
that an abstract method cannot be static. (or it turns out even the
implemented method).

can anyone explain why this isn't allowed? (i.e. give an example that
shows the flaws that can arise from such a situation).

thanks much!

murat

--
Murat Tasan
mx**@po.cwru.edu
ta***@eecs.cwru.edu
mu*********@cwru.edu
http://genomics.cwru.edu

[Silvio Bierman]

Polymorphism in Java is resolved by the type of the actual object (dynamic,
runtime) the method is called against instead of the class of the reference
(static, compile time). With static methods there is no object in play, only
a class so it can only ve resolved statically during compiletime.

What calling constructs (and behaviour) do you seek for?

Silvio Bierman

[Raymond DeCampo]

Murat Tasan wrote:

so here is another general question about java...

why can't you declare an abstract static method.

i can envision the case (indeed i have experienced the case) where one
would want an abstracct superclass, with an abstract method such that all
subclasses that implement this method make that method static.

basically, the abstract class declares an abstract method that should be
static for all implementations (for example a factory method).

I do not understand what you expect to accomplish this such a method.
How do you envision it being used? Perhaps if you provide a code
sample, I could understand.

From my point of view, I do not understand the point of a static
abstract method. Static method calls are determined at compile time,
not at run time, so it is not possible for the invocation to be
polymorphic. How would one invoke a static method so that one would
expect polymorphism in any case? If you have an instance of the class,
then the method might as well be non-static. If you are using
reflection, all that matters is that the method is defined in the
current class, the base class does not matter.

Furthermore, a abstract class is allowed to have abstract instance
method because it is not possible to instantiate an instance of the
class. But one may invoke static methods of an abstract class without
an instance. So there is no mechanism to ensure that an abstract static
method is not called.

Of course, many of the points I made above are really design decisions
of the Java language designers. So I am very interested in hearing how
you response to them to make the case for the other side.

Ray

[guest]

Here's an example where one would like to use an abstract static method -- or better yet, an interface with the static method! -- neither of which is allowed:

public abstract class GenericWidgetFactory {
  public static abstract Widget createWidget(Object params);
  }
 
public class BigWidgetFactory extends GenericWidgetFactory {
  public static Widget createWidget(Object params) {
    // code here to create big widgets
    }
  }
 
public class SmallWidgetFactory extends GenericWidgetFactory {
  public static Widget createWidget(Object params) {
    // code here to create small widgets
    }
  }

public interface GenericWidgetFactory {
  public static Widget createWidget(Object params);
  }
 
public class BigWidgetFactory implements GenericWidgetFactory {
  public static Widget createWidget(Object params) {
    // code here to create big widgets
    }
  }
 
public class SmallWidgetFactory implements GenericWidgetFactory {
  public static Widget createWidget(Object params) {
    // code here to create small widgets
    }
  }

This construct is very useful because it allows the compiler to enforce the syntactical structure of the inherited classes (Big and SmallWidgetFactory).

Any clever ideas around this without instantiating an object?
Thanks,
Jerry