blocks|key|621268|text|不是的。你不能这么做。如果您愿意折衷并使方法成为非静态的，或者在抽象类中提供静态方法的实现，那么您将能够用Java对其进行编码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|621269|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No. You can't do that. If you're willing to compromise and make the method non-static or provide an implementation of the static method in your abstract class, you'll be able to code this in Java.

blocks|key|621281|text|做你所要求的事情是没有意义的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|621282|Why+can't+static+methods+be+abstract+in+Java|offset|length|621283|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/370962/why-cant-static-methods-be-abstract-in-java/370966#370966^0|0|0|18|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It doesn't make sense to do what you're asking:

<a href="https://stackoverflow.com/questions/370962/why-cant-static-methods-be-abstract-in-java/370966#370966">Why can&#39;t static methods be abstract in Java</a>

blocks|key|2119151|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2119152|有没有办法做到这一点呢？|blockquote|2119153|2119154|2119155|我认为在任何语言中都没有办法做到这一点。这是没有意义的，因为静态方法属于一个类，不能以多态方式调用。启用多态调用是接口和抽象类存在的唯一原因。|2119156|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|J|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|K|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|N|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|O|7|@]|8|@]|9|$]]]|I|$]]

<blockquote>
 Is there a way to do this in Java?
</blockquote>

I don't think there is a way to do this in any language. There's no point to it, since static methods belong to a class and can't be called polymorphically. And enabling polymorphic calls is the only reason for interfaces and abstract classes to exist.

blocks|key|1924170|text|创建一个包含您的方法的上下文接口，其名称与您的问题域匹配。(如果有必要，可以将其命名为"World“，但大多数情况下还有一个更好的名称)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1924171|传递上下文对象的实现实例。|1924172|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Create a context interface containing your method with a name that matches your problem domain. (Name it "World" if you absolutely have to, but most of the time there's a better name)

Pass around implementation instances of the context object.

blocks|key|1921991|text|好吧，也许我的问题问得不好，似乎你们中的大多数人没有理解我想要做的事情。尽管如此，我有一个令人满意的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1921992|在抽象超类中，我将拥有一个静态方法getAllWidgets(类类型)。在它中，我将检查你传递给它的类，并在此基础上进行正确的获取。一般来说，我喜欢避免传递类和在类似的东西上使用开关，但在这里我会做一个例外。|1921993|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Ok, maybe my question was poorly asked, it seems like most of you didn't get what I was trying to do. Nonetheless, I have a solution that is somewhat satisfactory.

In the abstract super class, I am going to have a static method getAllWidgets(Class type). In it I'll check the class you passed it and do the correct fetching based on that. Generally I like to avoid passing around classes and using switches on stuff like this, but I'll make an exception here.

blocks|key|2119330|text|有很多关于‘这没有意义...’的答案。但就在昨天，我确实遇到了类似的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2119331|我想在我的单元测试中使用继承。我有一个API和几个它的实现。因此，我只需要为所有实现使用一组单元测试，但是使用不同的setUp方法，这些方法是静态的。|2119332|解决方法:所有测试都是抽象类，带有一些带有受保护访问修饰符的静态字段。在所有实现中，我都添加了设置这些静态字段的静态方法。它工作得相当好，而且我避免了复制和粘贴。|2119333|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There are lots of answers about 'this does'nt make sense..' but indeed I met a similar problem just yesterday. 

I wanted to use inheritance with my unit tests. I have an API and several its implementations. So I need only 1 set of unit tests for all implementations but with different setUp methods which are static.

Workaround: all tests are abstract classes, with some static fields with protected access modifier. In all implementations I added static methods which set these static fields. It works rather nice, and I avoided copy and paste.

blocks|key|1924231|text|静态方法不能是抽象的，因为它们不是虚拟的。因此，调用它们的任何地方都必须具有实现的具体类型。如果你想强制一个接口的所有实现都有一个特定的静态方法，那么这就意味着需要一个单元测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1924232|abstract+class+A
{
++++public+static+void+foo()
++++{
++++++++java.lang.System.out.println("A::foo");
++++}

++++public+void+bar()
++++{

++++++++java.lang.System.out.println("A::bar");
++++}
}

class+B+extends+A
{
++++public+static+void+foo()
++++{
++++++++java.lang.System.out.println("B::foo");
++++}

++++public+void+bar()
++++{

++++++++java.lang.System.out.println("B::bar");
++++}
}

public+class+Main
{
++++public+static+void+main(String[]+args)
++++{
++++++++B+b+=+new+B();
++++++++b.foo();
++++++++b.bar();

++++++++A+a+=+b;
++++++++a.foo();
++++++++a.bar();
++++}
}|code-block|syntax|javascript|1924233|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

static methods can't be abstract because they aren't virtual. Therefore anywhere that calls them has to have the concrete type with the implementation. If you want to enforce that all implementations of an interface have a certain static method, then that suggests a unit test is required.

<pre><code>abstract class A
{
 public static void foo()
 {
 java.lang.System.out.println("A::foo");
 }

 public void bar()
 {

 java.lang.System.out.println("A::bar");
 }
}

class B extends A
{
 public static void foo()
 {
 java.lang.System.out.println("B::foo");
 }

 public void bar()
 {

 java.lang.System.out.println("B::bar");
 }
}

public class Main
{
 public static void main(String[] args)
 {
 B b = new B();
 b.foo();
 b.bar();

 A a = b;
 a.foo();
 a.bar();
 }
}
</code></pre>

blocks|key|621307|text|您有几个选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|621308|621309|使用反射查看该方法是否存在，然后调用它。为静态方法创建一个注解，就像其他人所说的那样，尽量不要使用静态方法。|ordered-list-item|621310|621311|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|J|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|K|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|H|$]]

You have a couple of options:

<ol>
<li>Use reflection to see if the method exists and then call it. </li>
<li>Create an annotation for the static method named something like @GetAllWidgetsMethod.</li>
<li>As others have said, try to not use a static method. </li>
</ol>

blocks|key|2119445|text|类型系统允许您在类型之间表达一些约束，但它是有限的。这就是为什么javadoc在人类语言中充满了约束，要求人们遵循编译器无法检查的规则。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2119446|如果您想将其扩展到语言本身提供的功能之外，您可以编写自己的静态分析工具。这并不少见。例如:+findbug。IDE也是这样做的，他们检查语言之外的东西。您可以编写一个插件来强制一个子类必须有这样一个签名的静态方法。|2119447|对你来说，这是不值得的。让javadoc在超类中促使实现者包含一个静态方法，这就足够了。|2119448|我将提供一种复杂的方式来表达您的约束，但请不要这样做。人们真的会在编译时让所有东西都是可检查的，代价是让代码变得不可读。|2119449|interface+WidgetEnumerator
{
++++List+getAllWidgets();
}

public+class+Abs<T+extends+WidgetEnumerator>
{
++++static+List+getAllWidgets(Class<?+extends+Abs>+clazz){+...+}
}

public+class+Sub+extends+Abs<SubWidgetEnumerator>
{
}

public+class+SubWidgetEnumerator+implements+WidgetEnumerator
{
++++public+List+getAllWidgets()+{+...+}
}|code-block|syntax|javascript|2119450|工作原理:对于Abs的任何子类，都必须提供WidgetEnumerator的实现。子类作者不能忘记这一点。现在，调用Abs.getAllWidgets(Sub.class)包含了足够的信息来解析该实现，即SubWidgetEnumerator。它是通过反射完成的，但它是类型安全的，不涉及字符串文字。|offset|length|style|CODE|2119451|entityMap^0|0|0|0|0|0|7|3|1M|S|2U|J|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]|$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

A type system allows you to express some constraints among types, but it's limited. That's why javadocs are littered with constraints in human language, asking people to follow rules that the compiler cannot check.

if you want to extend it beyond what language provides natively, you can write your own static analysis tool. that is not uncommon. for example: findbug. also IDEs do that too, they checking thing beyond what language dictates. you can write a plug in to enforce that a subclass must have a static method of such signature.

in your case, it's not worth it. have javadoc in the superclass urge implementors to include a static method, that's good enough. 

I'll provide a convoluted way of expressing your constraint anyway, but DO NO DO IT. people get really carried away of make everything checkable at compile time, at the price of making code unreadable.

<pre><code>interface WidgetEnumerator
{
 List getAllWidgets();
}

public class Abs&lt;T extends WidgetEnumerator&gt;
{
 static List getAllWidgets(Class&lt;? extends Abs&gt; clazz){ ... }
}

public class Sub extends Abs&lt;SubWidgetEnumerator&gt;
{
}

public class SubWidgetEnumerator implements WidgetEnumerator
{
 public List getAllWidgets() { ... }
}
</code></pre>

How it works: for any subclass of <code>Abs</code>, it is forced to provide an implementation of WidgetEnumerator. subclass author cannot forget that. Now invocation <code>Abs.getAllWidgets(Sub.class)</code> contains sufficient information to resolve that implementation, i.e. <code>SubWidgetEnumerator</code>. It is done through reflection, but it is type safe, there are no string literals involved.

blocks|key|1922123|text|我会创建一个带有抽象窗口小部件内部类的WidgetCollection类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1922124|您可以为每种类型的小部件扩展WidgetCollection.Widget类。|1922125|不需要静态方法。|1922126|示例(未编译或测试)：|1922127|class+WidgetCollection<W+extends+Widget>+{
++++Set<W>+widgets+=+new+HashSet<W>();

++++Set<W>+getAll()+{
++++++++return+widgets;
++++}

++++abstract+class+Widget+{

+++++++Widget()+{
+++++++++++widgets.add(this);
+++++++}

+++++++abstract+String+getName();
++++}

++++public+static+void+main(String[]+args)+{
+++++++++WidgetCollection<AWidget>+aWidgets+=+new+WidgetCollection<AWidget>();
+++++++++a.new+AWidget();

+++++++++Set<AWidget>+widgets+=+aWidgets.getAll();
++++}
}

class+AWidget+extends+Widget+{
++++String+getName()+{
++++++++return+"AWidget";
++++}
}|code-block|syntax|javascript|1922128|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I'd make a WidgetCollection class with an abstract Widget inner class.

You can extend the WidgetCollection.Widget class for each of your types of Widget.

No static methods necessary.

Example (not compiled or tested):

<pre><code>class WidgetCollection&lt;W extends Widget&gt; {
 Set&lt;W&gt; widgets = new HashSet&lt;W&gt;();

 Set&lt;W&gt; getAll() {
 return widgets;
 }

 abstract class Widget {

 Widget() {
 widgets.add(this);
 }

 abstract String getName();
 }

 public static void main(String[] args) {
 WidgetCollection&lt;AWidget&gt; aWidgets = new WidgetCollection&lt;AWidget&gt;();
 a.new AWidget();

 Set&lt;AWidget&gt; widgets = aWidgets.getAll();
 }
}

class AWidget extends Widget {
 String getName() {
 return "AWidget";
 }
}
</code></pre>

blocks|key|2119516|text|我想在看过您的编辑之后，我可以给您一个更好的答案--您最好的选择可能是工厂模式。(不是很可爱，但比单件好)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2119517|abstract+class+Widget
++++public+static+Widget[]+getAllWidgetsOfType(Class+widgetType)+{
++++++++if(widgetType+instanceof+...)
++++}
class+Ball+extends+Widget
class+Stick+extends+Widget
class+Toy+extends+Widget|code-block|syntax|javascript|2119518|这不是一个很好的方法，但它是典型的。Hibernate是你通常用来解决这个问题的工具，这正是它设计的目的。|2119519|最大的问题是，每当您添加给定类型的新类时，都需要编辑基类。如果没有反思，这是不可能实现的。如果你想使用反射，那么你可以这样实现它(Psuedocode，我不打算查找反射的确切语法，但它不会比下面复杂得多)：|2119520|public+static+Widget[]+getAllWidgetsOfType(Class+widgetType)+{
++++Method+staticMethod=widgetType.getStaticMethod("getAllInstances");
++++return+staticMethod.invoke();
}|2119521|这将给出您所要求的解决方案(每次添加子类时都会被修改基类的需要所困扰，这是一种很好的本能)。|2119522|您还可以将其设置为实例方法而不是静态方法。这不是必需的，但是您可以在Widget中创建该方法(抽象)的原型。|2119523|同样，与Hibernate相比，所有这些都是不必要的和草率的……|2119524|编辑:如果你传入了一个球、棍子或玩具的活的“空”实例，而不是它的"Class“对象，那么你可以只调用一个继承的方法，而不使用反射。这也是可行的，但您必须扩展Widget的定义，以包括用作键的“空”实例。|2119525|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I think I can give you a better answer after seeing your edits--your best bet is probably a factory pattern. (Not lovely, but better than singleton).

<pre><code>abstract class Widget
 public static Widget[] getAllWidgetsOfType(Class widgetType) {
 if(widgetType instanceof ...)
 }
class Ball extends Widget
class Stick extends Widget
class Toy extends Widget
</code></pre>

This is not a very good way to do it, but it's typical. Hibernate is the tool you would normally use to solve this problem, this is exactly what it's designed for.

The big problem is that it requires editing the base class whenever you add a new class of a given type. This can't be gotten around without reflection. If you want to use reflection, then you can implement it this way (Psuedocode, I'm not going to look up the exact syntax for the reflection, but it's not much more complex than this):

<pre><code>public static Widget[] getAllWidgetsOfType(Class widgetType) {
 Method staticMethod=widgetType.getStaticMethod("getAllInstances");
 return staticMethod.invoke();
}
</code></pre>

This would give the solution you were asking for (to be bothered by the need to modify the base class each time you add a child class is a good instinct).

You could also make it an instance method instead of a static. It's not necessary, but you could then prototype the method (abstract) in Widget.

Again, all this is unnecessary and sloppy compared to Hibernate...

Edit: If you passed in a live "Empty" instance of a ball, stick or toy instead of it's "Class" object, you could then just call an inherited method and not use reflection at all. This would also work but you have to expand the definition of a Widget to include an "Empty" instance used as a key.

blocks|key|621405|text|静态方法与整个对象类相关，而不是与单个实例相关。允许一个静态方法被重写打破了这个格言。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|621406|我要考虑的第一件事是从非静态上下文访问数据库。这实际上是Java应用程序的标准。|621407|如果你一定要使用静态方法，那么就用实例特定的参数(泛型类型)来参数化它，以允许不同的子类与它交互。然后调用多态方法中的单个静态方法。|621408|entityMap^0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

Static methods are relevant to an entire class of object, not the individual instances. Allowing a static method to be overridden breaks this dictum.

The first thing I would consider is to access your database from a non-static context. This is actually the norm for Java apps.

If you absolutely must use a static method, then have it parameterised with instance specific arguments (of a generic type) to allow the different subclasses to interact with it. Then call that single static method from you polymorphic methods.

blocks|key|621438|text|我也在处理这个问题。对于那些坚持认为它“没有意义”的人，我想请你暂时跳出这个语义框。我正在使用的程序本质上是关于反射的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|621439|正如你所知道的，反射可能比直接的二进制函数调用多花三个数量级。这是一个不可避免的问题，软件需要移植到尽可能多的机器上，其中一些机器将是32位的，并且比我的开发机器一开始就慢。因此，需要通过静态方法检查类对所请求操作的适用性，并且在模块引导期间一次性运行所有反射方法。|621440|首先也是最重要的，一切正常。我已经造好了整个东西。唯一的问题是，模块可以在.class中编译，而无需在编译时检查标识静态函数是否存在，从而导致一个天生无用的类。如果没有标识符及其包含的信息，为了安全起见，模块将不会加载。|621441|我清楚地理解“抽象”和“静态”的完整定义的问题，并且理解它们在一起是没有意义的。然而，在Java中缺乏编译器强制包含的类方法的能力，尽管我很喜欢这门语言，但我怀念它。因此，这是每个曾经在软件上工作的程序员的人为限制，我相信我们都会同意这是一种痛苦。|621442|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I too am dealing with this problem. For those that insist that it "doesn't make sense", I would invite you to think outside of that semantic box for a moment. The program I am working with is inherently about reflection.

Reflection, as you know, can take three orders of magnitude longer than straight-up binary function calling. That is an inevitable problem, and the software needs to port to as many machines as possible, some of which will be 32 bit and slower than my development machine to begin with. Thus, the applicability of a class to the requested operation needs to be checked via a static method, and all of the reflective methods are run at once during module booting.

Everything works, first and foremost. I've built the entire thing. The only catch is that a module can be compiled in a .class without compile time checking to see if the identifying static function exists at all, resulting in an innately useless class. Without the identifier, and its included information, for security's sake the module is not loaded.

I clearly understand the issue with the complete definition of "abstract" and "static", and understand that they don't make sense together. However, the ability to have a class method that is compiler-enforced for inclusion is lacking in Java, and as much as I like the language, I miss it. Thus, this is a human constraint on every programmer that ever works on the software, which I'm sure we can all agree is a pain.

blocks|key|1924375|text|不管怎么说，我完全知道你想要做什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1924376|我在搜索我也做不到的原因时找到了这篇文章。|1924377|在我的例子中，我有数百个继承自中央基库的类，我想简单地获得一个这样的引用：|1924378|ValueImSearchingFor+visf+=+StaticClass.someArbitraryValue()|1924379|我不想为成百上千的继承类中的每一个编写/维护someArbitraryValue()+--我只想编写一次逻辑，并让它在不接触基类的情况下为将来编写的每个类计算一个唯一的特定于类的值。|1924380|是的，我完全理解面向对象--自从Java问世以来，我就一直在写它。|1924381|这些特定的类更像是“定义”，而不是实际的对象，我不想每次都实例化一个，只需要看看someArbitraryValue()到底是什么。|1924382|可以把它看作是一个公共的静态最终，它允许您运行一次方法来对其进行初始设置。(实际上就像定义枚举时可以做的那样…)|1924383|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

For what it is worth I know exactly what you are trying to do. 

I found this article while searching for the reasons I can't do it either. 

In my case I have HUNDREDS of classes that inherit from a central base base and I want simply to get a reference like this:

ValueImSearchingFor visf = StaticClass.someArbitraryValue() 

I do NOT want to write/maintain someArbitraryValue() for each and every one of hundreds of the inherited classes -- I just want to write logic once and have it calc a Unique Class-Sepcific value for each and every future written class WITHOUT touching the base class.

Yes I completely get OO - I've been writing Java for about as long as it's been available. 

These specific classes are more like "Definitions" as opposed to actual Objects and I don't want to instantiate one every time I just need to see what someArbitraryValue() actually is. 

Think of it as a PUBLIC STATIC FINAL that allows you to run a Method ONCE to set it initially. (Kinda like you can do when you define an Enum actually...)

blocks|key|2119733|text|有很多“这没有意义”或“这不可能是因为”和“你为什么想要它”之类的话。(或者更糟的是：“你不必想要它！”)在所有这些答案中。然而，这些答案也间接给出了为什么它应该是可能的原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2119734|必须区分概念和实施。当然，重写静态方法是没有意义的。这也不是问题的核心。|2119735|它需要一种方法来强制实现抽象类的每个派生类中的某个静态方法(或常量或其他任何方法)。为什么这是必须的，这是一个想用Jave编写应用程序的人的问题，而不是其他任何人的事情。|2119736|这与编译器如何编译该方法以及它在运行时如何完成无关。|2119737|为什么这是可能的呢？因为有些东西是类特定的(而不是实例特定的)，因此它们应该是静态的，而它们需要在每个单独的子类(或实现接口的类)中实现。|2119738|假设有一个抽象的类'Being‘。现在有像“动物”和“植物”这样的子类。现在只允许哺乳动物和鱼类作为动物。此信息特定于animals类，而不是任何实例，也不属于任何超类或子类。但是，此信息必须由类提供，而不是实例，因为它是正确构造动物实例所必需的。所以它必须在那里，但不能在实例中。|2119739|事实上，Java有这样一个东西--每个对象都有一个特定于类的字段'+class‘。它是特定于类的，不是继承的，没有重写，而且它必须存在。编译器隐式地创建它，但是很明显编译器可以做到。那么，为什么不允许自己的字段也这样做呢？毕竟，当编译器检查抽象函数的内部链条时，如何解释组合“抽象静态”只是一个定义问题。没有人要求继承超类函数(这仍然是有意义的，这取决于这个函数的实际作用-在所有类继承了它们的超类的静态函数之后，即使你可能会得到一个警告，当你通过子类调用它时，你应该直接访问它)。|2119740|但总而言之:+Java语言没有提供在编译时这样做的方法，同时也没有理由(或者简单地说是教条)不这样做。唯一的方法是向抽象类编写一个静态的final函数，它试图在加载时找到子类的静态函数/字段(或者加载所有现有的子类并检查它们)。如果制作得当，它会在第一次使用时产生运行时错误。复杂和肮脏，但总比没有强。至少它防止了从错误的超类中获取信息的bug。不过，它不适用于接口。|2119741|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

There's a lot of 'this makes no sense' or 'this can't be because' and 'why do you want it?' (or worse: 'you don't have to want it!') in all those answers. However, these answers also indirectly give reasons why it should be possible.

It must be differentiated between the concept and the implementation.
Sure, overriding a static method makes no sense. And it also isn't what the question was about.

It was asked for a way to force implementation of a certain static method (or constant or whatever) in every derived class of an abstract class. Why this is required it the matter of the one who wants to write an appllication with Jave, and no business of anyone else.

This has nothing to do with how the compiler compiles the method and how it is done at runtime.

Why shoudl it be possible? because there are things that are class specific (and not instance specific) and therefore should be static, while they NEED to be impleented in every single subclass (or class that implements an interface).

Let's say there is an abstract class 'Being'. Now there are subclasses like 'animals' and 'plants'.
Now there are only mammals and fishes allowed for animals. This information is specific to the animals class, not to any instance nor doe sit belong to any superclass or subclass. However, this information must be provided by teh class, not an instance, because it is required to properly construct an animal instance. So it MUST be there and it CANNOT be in the instance.

In fact, Java has such a thing- Every object has a class specific field 'class'. It is class-specific, not inherited, no override and it must be there. Well the compiler creates it implicitly, but obviously the compiler CAN do it. So why not allowing this for own fields too.
After all, it is just a matter of definition how the combination 'abstract static' is interpreted when the compiler checks the intheritance chain for abstract functions.
Nobody was ever demanding that there should be an inheritance of the superclass class functions (which could still make some sense, depending on what this function actually does - after all classes inherit static functions of their superclasses, even though you might get a warning that you should access it directly when you call it by the subclass))

But to summarize: the Java language offers no way to do it at compile time while there is no reason (othe rthan plain dogmatic) to not doing so.
The only way is to write a static final function to the abstract class that tries to find the static function/field of the subclass when it is loaded (or loads all existing subclasses and checks them). If properly made, it gives a runtime error on first use. Complex and dirty but better than nothing. At least it prevents bugs where you get the information from the wrong superclass.
It won't work for interfaces, though.

I understand that neither a abstract class nor an interface can contain a method that is both <a href="https://stackoverflow.com/questions/370962/why-cant-static-methods-be-abstract-in-java">abstract and static</a> because of ambiguity problems, but is there a workaround?

I want to have either an abstract class or an interface that mandates the inclusion of a static method in all of the classes that extend/implement this class/interface. Is there a way to do this in Java? If not, this may be my final straw with Java...

EDIT 1: The context of this problem is that I have a bunch of classes, call them Stick, Ball, and Toy for now, that have a bunch of entries in a database. I want to create a superclass/interface called Fetchable that requires a static method <code>getFetchables()</code> in each of the classes below it. The reason the methods in Stick, Ball, and Toy have to be static is because they will be talking to a database to retrieve all of the entries in the database for each class.

EDIT 2: To those who say you cannot do this in any language, that is not true. You can certainly do this in Ruby where class methods are inherited. This is not a case of someone not getting OO, this is a case of missing functionality in the Java language. You can try to argue that you should never need to inherit static (class) methods, but that is utterly wrong and I will ignore any answers that make such points.

Java abstract static Workaround

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我知道，由于多义性问题，抽象类和接口都不能包含既是的方法，但有解决方法吗？我希望有一个抽象类或一个接口，要求在扩展/实现这个类/接口的所有类中包含一个静态方法。在Java中有没有办法做到这一点？如果不是，这可能是我对Java的最后一根稻草...编辑1:这个问题的背景是我有一堆类，现在叫它们Stick，Ball和Toy，...

问Java抽象静态解决方案
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java抽象静态解决方案EN