有没有一种方法可以在Java中覆盖类变量？

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    protected static String _me = me = "son";
}

public void doIt()
{
    new Son().printMe();
}

... 将会打印出 "son"。

在一个类中，你不能覆盖变量，只能覆盖方法。应该将变量保持为私有的，否则会遇到很多问题。

只有通过重写 printMe() 方法：

class Son extends Dad 
{
    public void printMe() 
    {
        System.out.println("son");
    }
}

Dad.printMe 方法中对 me 的引用隐式地指向静态字段 Dad.me，所以无论如何你都会改变 Son 中 printMe 的行为...

类变量（也适用于实例变量）在Java中不具有覆盖特性，因为类变量是根据调用对象的类型来调用的。为了使情况更加清晰，在层次结构中添加了一个类（Human）。所以现在我们有：
Son继承Dad继承Human
在下面的代码中，我们尝试遍历Human、Dad和Son对象的数组，但它在所有情况下打印Human Class的值，因为调用对象的类型是Human。

    class Human
{
    static String me = "human";

    public void printMe()
    {
        System.out.println(me);
    }
}
class Dad extends Human
{
    static String me = "dad";

}

class Son extends Dad
{
    static String me = "son";
}


public class ClassVariables {
    public static void main(String[] abc)   {
        Human[] humans = new Human[3];
        humans[0] = new Human();
        humans[1] = new Dad();
        humans[2] = new Son();
        for(Human human: humans)   {
            System.out.println(human.me);        // prints human for all objects
        }
    }
}

将打印

• 人类
• 人类
• 人类

因此没有覆盖类变量。

如果我们想要从其父类的引用变量中访问实际对象的类变量，我们需要通过将父引用（Human对象）转换为其类型来明确告诉编译器。

    System.out.println(((Dad)humans[1]).me);        // prints dad

    System.out.println(((Son)humans[2]).me);        // prints son

将会打印

• 父亲
• 儿子

关于这个问题的一部分：- 如已建议，在Son类中覆盖printMe()方法，然后在调用时

Son().printMe();

父类变量"me"将被隐藏，因为最近的声明（在儿子类的printme()方法中）的"me"（在儿子类中）将优先。

在子类构造函数中调用super.variable。

public abstract class Beverage {

int cost;


int getCost() {

    return cost;

}

}`

public class Coffee extends Beverage {


int cost = 10;
Coffee(){
    super.cost = cost;
}


}`

public class Driver {

public static void main(String[] args) {

    Beverage coffee = new Coffee();

    System.out.println(coffee.getCost());

}

}

输出是10。

为什么要覆盖变量，而不是在子类中轻松重新分配变量？
我遵循这种模式来解决语言设计的问题。假设您的框架中有一个繁重的服务类，需要在多个派生应用程序中以不同的方式使用。在这种情况下，配置超级类逻辑的最佳方法是重新分配其“定义”变量。

public interface ExtensibleService{
void init();
}

public class WeightyLogicService implements ExtensibleService{
    private String directoryPath="c:\hello";

    public void doLogic(){
         //never forget to call init() before invocation or build safeguards
         init();
       //some logic goes here
   }

   public void init(){}    

}

public class WeightyLogicService_myAdaptation extends WeightyLogicService {
   @Override
   public void init(){
    directoryPath="c:\my_hello";
   }

}

当然，使用私有属性和getter和setter是推荐的做法，但我测试了以下代码，并且它可以工作... 请查看代码中的注释。

class Dad
{
    protected static String me = "dad";

    public void printMe()
    {
        System.out.println(me);
    }
}

class Son extends Dad
{
    protected static String me = "son";

    /* 
    Adding Method printMe() to this class, outputs son 
    even though Attribute me from class Dad can apparently not be overridden
    */

    public void printMe()
    {
        System.out.println(me);
    }
}

class Tester
{
    public static void main(String[] arg)
    {
        new Son().printMe();
    }
}

所以...我刚刚是重新定义了继承规则还是让Oracle陷入了棘手的境地？ 对我来说，protected static String me 明显被覆盖了，当你执行这个程序时就可以看到。而且，对我来说，为什么属性不能被覆盖没有任何意义。