靜態繼承：可能嗎？ 有更好的解決方案嗎？

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類的方法。
• 如果類中不存在靜態方法，則無法調用該方法。

如果要使用多態性，則沒有必要使用靜態方法。