Java：抽象类中的静态字段

Question

我只是从一个例子开始，它解释得最好：

public abstract class A{
    static String str;
}

public class B extends A{
    public B(){
        str = "123";
    }
}

public class C extends A{
    public C(){
        str = "abc";
    }
}

public class Main{

    public static void main(String[] args){
        A b = new B();
        A c = new C();
        System.out.println("b.str = " + b.str);
        System.out.println("c.str = " + c.str);
    }
}

这将打印出：

b.str = abc

c.str = abc

但我想要一个解决方案，其中实例化超类的每个子类都有自己的 /strong> 类变量，同时我希望能够通过抽象超类中定义的标识符或方法调用来引用该类变量。

所以我希望输出为：

b.str = 123

c.str = abc

这可行吗？

Answer 1

如果您希望类 B 和 C 有单独的静态变量，则需要在这些类中声明变量。基本上，静态成员和多态性不能并存。

请注意，从可读性角度来看，通过引用访问静态成员确实是一个坏主意 - 它使得它看起来像是依赖于引用的值，而实际上它并不依赖于引用的值。真的。因此，当您将 str 向下移动到 B 和 C 时，您当前的代码甚至无法编译。 相反，您需要

System.out.println("b.str = " + B.str);
System.out.println("c.str = " + C.str);

如果您确实需要多态地访问该值（即通过 A 的实例） ）那么一种选择是制作一个多态 getter：（

public class A {
    public abstract String getStr();
}

public class B extends A {
    private static String str = "b";

    @Override public String getStr() {
        return str;
    }
}

对于 C 来说也是如此）。

这样，您就可以获得所需的行为，即每个实例都没有单独的变量，但您仍然可以多态地使用它。对于实例成员来说，返回这样的静态值有点奇怪，但是您正在使用类型多态性的值，基本上......

Answer 2

public abstract class A {
    private String str;
    public String getStr() { return str;}
    protected void setStr(String str) { this.str = str; }
}

然后你就可以拥有

B b = new B();
b.getStr();

setter 和 getter 是我添加的，你可以简单地使变量成为非静态的。

更新 如果您想要每个子类都有静态，那么您可以：

protected static Map<Class, String> values;
public abstract String getValue();

然后：

public String getValue() {
    values.get(getClass());
}
public void setValue(String value) {
    values.set(getClass(), value);
}

但这通常是一个坏主意。

Answer 3

将静态变量放入每个子类中，并向抽象超类添加一个（非静态）抽象方法：

abstract String getStr();

然后通过返回该特殊子类的静态字段来在每个子类中实现 getStr() 方法。

public class B extends A {
 private static String str;

  @Override
  public String getStr() {
    return B.str;
  }
}

Answer 4

系统中仅存在一个静态变量实例。

静态变量将在类加载之前加载到系统中。

两次打印 abc 的原因是因为您最后将 str 的值设置为 abc 。

Answer 5

这将打印您想要的输出：

public abstract class A{
}

public class B extends A{
    static String str;

    public B(){
        str = "123";
    }
}

public class C extends A{
    static String str;

    public C(){
        str = "abc";
    }
}

public class Main{

    public static void main(String[] args){
        A a = new B();
        A c = new C();
        System.out.println("B.str = " + B.str);
        System.out.println("C.str = " + C.str);
    }
}

Answer 6

由于无论如何您都在子类中对值或 str 进行了硬编码，因此您可以执行以下操作：

public abstract class A{
    public abstract String getStr();
}

public class B extends A{
   public String getStr(){
      return "123";
   }
}

public class C extends A{
   public String getStr(){
      return "abc";
   }
}

这将在您的情况下实现这一点。

当然，那么你应该通过方法来调用它，如下所示：

public class Main{

    public static void main(String[] args){
        A b = new B();
        A c = new C();
        System.out.println("b.str = " + b.getStr());
        System.out.println("c.str = " + c.getStr());
    }
}

Answer 7

我这样做是为了避免必须在每个子类中实现相同的方法。这是基于Bozho的回答。也许它可以帮助某人。

import java.util.HashMap;
import java.util.Map;

/**
 *
 * @author Uglylab
 */
public class SandBox {

    public static void main(String[] args) {
        A b = new B();
        A c = new C();
        System.out.println("b.str = " + B.getStr(b.getClass()));
        System.out.println("c.str = " + C.getStr(c.getClass()));
    }

}
 abstract class A{
    protected static Map<Class, String> values = new HashMap<>();


    public static String getStr(Class<? extends A> aClass) {
        return values.get(aClass);
    }

    public static void setStr(Class<? extends A> aClass, String s) {
        values.put(aClass, s);
    }

}

 class B extends A{
    public B(){
        setStr(this.getClass(),"123");
    }
}

 class C extends A{
    public C(){
        setStr(this.getClass(),"abc");
    }
}

Answer 8

我认为解决这个问题的一种方法是使用类 B 和 C 的单例来模拟静态方法和字段。它们都可以扩展抽象类 A，但会有自己的 str 值。