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

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

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

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

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

函数doIt将打印“ dad”。有没有办法让它打印“儿子”？

是。但是就变量而言，它会被覆盖（将新值赋予变量。将新定义赋予函数是Override）。Just don't declare the variable but initialize (change) in the constructor or static block.

在父类的块中使用时，该值将得到反映

如果变量是静态的，则在初始化时使用静态块更改其值，

class Son extends Dad {
    static { 
       me = 'son'; 
    }
}

否则更改构造函数。

您还可以稍后在任何块中更改该值。它将反映在超一流

简而言之，没有，没有方法可以覆盖类变量。

您不会在Java中覆盖类变量，而是将其隐藏。覆盖是例如方法。隐藏与覆盖不同。

在您给出的示例中，通过在类Son中声明名称为“ me”的类变量，可以隐藏它将从其父类“同名”“ me”继承的类变量。以这种方式隐藏变量不会影响父类父类中的类变量“ me”的值。

对于您的问题的第二部分，如何使它显示“ son”，我将通过构造函数设置该值。尽管下面的代码与您的原始问题有很大出入，但我会这样写：

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void printName() {
        System.out.println(name);
    }
}

JLS在第8.3节-字段声明中提供了更多有关隐藏的详细信息

是的，只需重写该printMe()方法即可：

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

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

您可以创建一个吸气剂，然后覆盖该吸气剂。如果您要覆盖的变量是其自身的子类，则特别有用。想象一下，您的超类有一个Object成员，但是在您的子类中，现在将其定义为Integer。

class Dad
{
        private static final String me = "dad";

        protected String getMe() {
            return me;
        }

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

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

        @Override
        protected String getMe() {
            return me;
        }
}

public void doIt()
{
        new Son().printMe(); //Prints "son"
}

如果要覆盖它，我看不出保持此静态状态的有效理由。我建议使用抽象（请参见示例代码）。：

     public interface Person {
        public abstract String getName();
       //this will be different for each person, so no need to make it concrete
        public abstract void setName(String name);
    }

现在我们可以添加爸爸：

public class Dad implements Person {

    private String name;

    public Dad(String name) {
        setName(name);
    }

    @Override
    public final String getName() {
    return name;
    }

    @Override
    public final void setName(String name) {
        this.name = name;
    }
}

儿子：

public class Son implements Person {

    private String name;

    public Son(String name) {
        setName(name);
    }

    @Override
    public final String getName() {
        return name;
    }

    @Override
    public final void setName(String name) {
        this.name = name;
    }
}

爸爸遇到一位好女士：

public class StepMom implements Person {

    private String name;

    public StepMom(String name) {
        setName(name);
    }

    @Override
    public final String getName() {
        return name;
    }

    @Override
    public final void setName(String name) {
        this.name = name;
    }
}

看起来我们有一个家庭，让我们告诉世界他们的名字：

public class ConsoleGUI {

    public static void main(String[] args) {
        List<Person> family = new ArrayList<Person>();
        family.add(new Son("Tommy"));
        family.add(new StepMom("Nancy"));
        family.add(new Dad("Dad"));
        for (Person person : family) {
            //using the getName vs printName lets the caller, in this case the
            //ConsoleGUI determine versus being forced to output through the console. 
            System.out.print(person.getName() + " ");
            System.err.print(person.getName() + " ");
            JOptionPane.showMessageDialog(null, person.getName());
    }
}

}

System.out输出：Tommy Nancy Dad
System.err与上述相同（只是带有红色字体）
JOption输出：
Tommy 然后
Nancy 然后
Dad

这看起来像是设计缺陷。

删除static关键字，然后在构造函数中设置变量。这样，Son会将变量在其构造函数中设置为其他值。

尽管确实可以将类变量仅隐藏在子类中而不被覆盖，但这确实是可以做的而无需覆盖printMe ()子类，而是反射是您的朋友。在下面的代码中，为清晰起见，我省略了异常处理。请注意，在这种情况下声明meas protected似乎没有多大意义，因为它将被隐藏在子类中...

class Dad
  {
    static String me = "dad";

    public void printMe ()
      {
        java.lang.reflect.Field field = this.getClass ().getDeclaredField ("me");
        System.out.println (field.get (null));
      }
  }

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();
}

...将打印“儿子”。

https://docs.oracle.com/javase/tutorial/java/IandI/hidevariables.html

叫做隐藏场

从上面的链接

在类中，与超类中的字段具有相同名称的字段将隐藏超类的字段，即使它们的类型不同。在子类中，不能通过其简单名称来引用超类中的字段。而是必须通过super访问该字段，这将在下一部分中介绍。一般来说，我们不建议隐藏字段，因为这会使代码难以阅读。

仅通过覆盖printMe()：

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

引用me的Dad.printMe方法隐含指向静态字段Dad.me，所以拉上你改变什么printMe的呢Son？

您不能覆盖类中的变量。您只能覆盖方法。您应该将变量设为私有，否则会遇到很多问题。

实际上，它会打印“ dad”，因为该字段没有被覆盖而是被隐藏。有三种方法可以使它打印“儿子”：

方法1：覆盖printMe

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

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

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

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

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

方法2：不要隐藏字段并在构造函数中对其进行初始化

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

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

class Son extends Dad
{
    public Son()
    {
        me = "son";
    }
}

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

方法3：使用静态值在构造函数中初始化字段

class Dad
{
    private static String meInit = "Dad";

    protected String me;

    public Dad() 
    {
       me = meInit;
    }

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

class Son extends Dad
{
    private static String meInit = "son";

    public Son()
    {
        me = meInit;
    }

}

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

变量不参与覆盖。只有方法可以。方法调用在运行时解决，也就是说，调用方法的决定是在运行时做出的，而变量仅在编译时决定。因此，将调用该变量，其引用用于调用，而不是运行时对象。

看一下以下代码片段：

package com.demo;

class Bike {
  int max_speed = 90;
  public void disp_speed() {
    System.out.println("Inside bike");
 }
}

public class Honda_bikes extends Bike {
  int max_speed = 150;
  public void disp_speed() {
    System.out.println("Inside Honda");
}

public static void main(String[] args) {
    Honda_bikes obj1 = new Honda_bikes();
    Bike obj2 = new Honda_bikes();
    Bike obj3 = new Bike();

    obj1.disp_speed();
    obj2.disp_speed();
    obj3.disp_speed();

    System.out.println("Max_Speed = " + obj1.max_speed);
    System.out.println("Max_Speed = " + obj2.max_speed);
    System.out.println("Max_Speed = " + obj3.max_speed);
  }

}

运行代码时，控制台将显示：

Inside Honda
Inside Honda
Inside bike

Max_Speed = 150
Max_Speed = 90
Max_Speed = 90

当然，建议使用私有属性，并且最好使用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陷入了棘手的境地？对我来说，执行该程序时可以清楚地看到，受保护的静态String me被覆盖。而且，对我来说，为什么属性不应被覆盖是没有任何意义的。

当您可以轻松地在子类中重新分配变量时，为什么要覆盖变量。

我遵循这种模式来解决语言设计问题。假设您的框架中有一个重要的服务类，需要在多个派生应用程序中以不同的方式使用它，在这种情况下，配置超类逻辑的最佳方法是重新分配其``定义''变量。

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";
   }

}

否。类变量（也适用于实例变量）在Java中不具有覆盖特性，因为类变量是根据调用对象的类型来调用的。在层次结构中又增加了一个类（人），以使其更加清晰。所以现在我们有了

儿子延伸爸爸延伸人类

在下面的代码中，我们尝试遍历Human，Dad和Son对象的数组，但是在所有情况下，由于调用对象的类型为Human，它都会打印Human Class的值。

    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
        }
    }
}

将打印

• 人的
• 人的
• 人的

因此，没有覆盖Class变量。

如果要从其父类的引用变量访问实际对象的类变量，则需要通过将父引用（人类对象）强制转换为其类型来显式地告知编译器。

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

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

将打印

• 爸
• 儿子

关于这个问题的一部分：-如已经建议的那样，重写Son类中的printMe（）方法，然后在调用时

Son().printMe();

爸爸的Class变量“ me”将被隐藏，因为“ me”（在Son类中）的最近声明（从Son类printme（）方法）。

只需在子类构造函数中调用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。