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

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将值loadfoo到foo ，然后使用displayfoo方法显示该foo的值。 好吧，我认为没有任何方法可以使用静态方法来实现，您可以通过将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();
    }
}

您也可以在此处检查同样的问题。

Answer 3

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

• 如果调用B.loadfoo()则将调用B类的方法。
• 如果调用C.loadfoo()则将调用C类的方法。
• 如果类中不存在静态方法，则无法调用该方法。

如果要使用多态性，则没有必要使用静态方法。