Question

考虑这个例子（警告非常糟糕的代码）：

public abstract class A {

    static float foo;

    public static void loadfoo(float incomingfoo) {
        foo = incomingfoo;
    }
    public static void displayfoo() {
        System.out.println("your foo is" +foo);
    }

}

B类扩展了A类

public class B extends A {

    static float foo;

    //@Override (overide is not allowed for static methods.  dis is a problem...)
    public static void loadfoo(float incomingfoo){
        foo = incomingfoo;
    }
}

C类与B

几乎相同

public class C extends A {
    static float foo;

    //@Override 
    public static void loadfoo(float incomingfoo) {
        //I would like  a different static variable loaded into this class using this method
        foo = incomingfoo;
    }
}

最后，主类运行事物

public class Main {

    public static void main(String whatever[]){
        B.loadfoo(5);
        C.loadfoo(8);
        B.displayfoo();
        C.displayfoo();
    }
}

所以输出是：

your foo is0.0
your foo is0.0

我知道这是因为displayfoo类引用了A类中的静态foo，所以请忽略它。我想我现在已经足够具体地描述我的问题和目标了。任何解决方案？

编辑：我觉得自己像个白痴我完全忘了实际说明我想要完成的事情，但实际上我只想让B和C在不改变A变量的情况下加载自己的静态变量，这应该是默认值。

Answer 1

看起来您需要静态访问具有相同结构的两个有状态对象。在这种情况下，枚举可能是一个解决方案：

public enum A {
  B, C;

  private float foo;
  // getter and (optional) setter for foo here

  public void displayFoo() { System.out.println("This foo  is " + foo); }
}

这样您仍然可以静态访问您的对象，但不需要复制任何其他内容：

A.B.setFoo(5);
A.C.setFoo(8);
A.B.displayFoo(); // 5
A.C.displayFoo(); // 8

如果您需要静态默认值，我会在A：

上创建一个方法

enum A {
  A getDefault() { return A.B; }
}

A.getDefault().displayFoo();

Answer 2

似乎首先要使用loadfoo将值加载到foo，然后使用foo方法显示displayfoo的值。好吧，我不认为无论如何都要使用静态方法。你可以通过在displayfoo()和B子类中使C方法抽象并覆盖相同的方法来实现这一点。

以下是代码：

abstract class A {
     float foo;
     public void loadfoo(float incomingfoo){
        foo = incomingfoo;
     }
     public abstract void displayfoo();
}

class B extends A{
    @Override 
    public void loadfoo(float incomingfoo){
        foo = incomingfoo;
    }
    @Override
    public void displayfoo(){
        System.out.println("foo is " + foo);
    }
}

class C extends A{
    @Override 
    public void loadfoo(float incomingfoo){
        this.foo = incomingfoo;
    }
    @Override
    public void displayfoo(){
        System.out.println("foo is " + foo);
    }
}

public class Main {
    public static void main(String whatever[]){
         B b = new B();
         C c = new C();
         b.loadfoo(5);
         c.loadfoo(5);
         b.displayfoo();
         c.displayfoo();
    }
}

您还可以检查同一类问题here。

Answer 3

静态方法应该由静态方法访问使用，而不是由对象实例使用。它不应该是虚拟的，因为它不属于该对象。

如果您致电B.loadfoo()，则会调用B类方法。
如果您致电C.loadfoo()，则会调用C类方法。
如果类中没有静态方法，则无法调用静态方法。

如果你想使用polimorphism，没有必要使用静态方法。

静态继承：有可能吗？有更好的解决方案吗？

3 个答案: