blocks|key|1596160|text|可以，只需覆盖printMe()方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1596161|class+Son+extends+Dad+{
++++++++public+static+final+String+me+=+"son";

++++++++@Override
++++++++public+void+printMe()+{
++++++++++++++++System.out.println(me);
++++++++}
}|code-block|syntax|javascript|1596162|entityMap^0|7|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Yes, just override the <code>printMe()</code> method:

<pre><code>class Son extends Dad {
 public static final String me = "son";

 @Override
 public void printMe() {
 System.out.println(me);
 }
}
</code></pre>

blocks|key|1381172|text|仅通过重写printMe()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1381173|class+Son+extends+Dad+
{
++++public+void+printMe()+
++++{
++++++++System.out.println("son");
++++}
}|code-block|syntax|javascript|1381174|Dad.printMe方法中对me的引用隐式地指向静态字段Dad.me，因此您将以某种方式改变printMe在Son中的作用……|1381175|entityMap^0|5|9|0|0|0|B|F|2|T|6|1B|7|1J|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|N|$]]

only by overriding <code>printMe()</code>:

<pre><code>class Son extends Dad 
{
 public void printMe() 
 {
 System.out.println("son");
 }
}
</code></pre>

the reference to <code>me</code> in the <code>Dad.printMe</code> method implicitly points to the static field <code>Dad.me</code>, so one way or another you're changing what <code>printMe</code> does in <code>Son</code>...

blocks|key|1381252|text|这看起来像是设计缺陷。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381253|删除static关键字并设置变量，例如在构造函数中。这样，Son只需要在他的构造函数中将变量设置为不同的值。|1381254|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

This looks like a design flaw.

Remove the static keyword and set the variable for example in the constructor. This way Son just sets the variable to a different value in his constructor.

blocks|key|1596357|text|不能重写类中的变量。您只能重写方法。你应该让变量保持私有，否则你会遇到很多问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596358|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You cannot override variables in a class. You can override only methods. You should keep the variables private otherwise you can get a lot of problems.

blocks|key|1381399|text|简而言之，没有办法覆盖类变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381400|您不能在Java中覆盖类变量，而应将它们隐藏起来。例如，重写就是方法。隐藏不同于重写。|1381401|在您给出的示例中，通过在类Son中声明名为'me‘的类变量，您可以隐藏类变量，该变量将从同名的父类'me’继承而来。以这种方式隐藏变量不会影响超类爸爸中的类变量'me‘的值。|1381402|对于您的问题的第二部分，如何让它打印"son"，我将通过构造函数设置值。虽然下面的代码与你的原始问题有很大的不同，但我还是会写成这样；|1381403|public+class+Person+{
++++private+String+name;

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

++++public+void+printName()+{
++++++++System.out.println(name);
++++}
}|code-block|syntax|javascript|1381404|JLS在8.3+-+Field+Declarations一节中提供了更多关于隐藏的详细信息|offset|length|1381405|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.3^0|0|0|0|0|0|4|O|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

In short, no, there is no way to override a class variable. 

You do not override class variables in Java you hide them. Overriding is for instance methods. Hiding is different from overriding. 

In the example you've given, by declaring the class variable with the name 'me' in class Son you hide the class variable it would have inherited from its superclass Dad with the same name 'me'. Hiding a variable in this way does not affect the value of the class variable 'me' in the superclass Dad.

For the second part of your question, of how to make it print "son", I'd set the value via the constructor. Although the code below departs from your original question quite a lot, I would write it something like this;

<pre><code>public class Person {
 private String name;

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

 public void printName() {
 System.out.println(name);
 }
}
</code></pre>

The JLS gives a lot more detail on hiding in section <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.3" rel="noreferrer">8.3 - Field Declarations</a>

blocks|key|1596508|text|您可以创建一个getter，然后覆盖该getter。如果要覆盖的变量是其自身的子类，则它特别有用。假设您的超类有一个Object成员，但是在您的子类中，它现在被更多地定义为一个Integer。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1596509|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"
}|code-block|syntax|javascript|1596510|entityMap^0|1M|6|2G|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

You can create a getter and then override that getter. It's particularly useful if the variable you are overriding is a sub-class of itself. Imagine your super class has an <code>Object</code> member but in your sub-class this is now more defined to be an <code>Integer</code>.

<pre><code>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"
}
</code></pre>

blocks|key|1596579|text|当然，使用私有属性以及getter和setter将是推荐的做法，但我测试了以下内容，它是有效的……请参阅代码中的注释|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596580|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();
++++}
}|code-block|syntax|javascript|1596581|所以..。我是刚刚重新定义了继承规则，还是让Oracle陷入了棘手的境地？对我来说，受保护的静态字符串me显然被覆盖了，正如您在执行此程序时所看到的那样。另外，我也不明白为什么属性不应该被重写。|1596582|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Of course using private attributes, and getters and setters would be the recommended thing to do, but I tested the following, and it works... See the comment in the code

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

Sooo ... did I just redefine the rules of inheritance or did I put Oracle into a tricky situation ?
To me, protected static String me is clearly overridden, as you can see when you execute this program. Also, it does not make any sense to me why attributes should not be overridable.

blocks|key|1381598|text|尽管类变量只能隐藏在子类中，并且不会被覆盖，但仍然可以在不覆盖子类中的printMe+()的情况下做您想做的事情，而反射是您的朋友。在下面的代码中，为了清楚起见，我省略了异常处理。请注意，在这个上下文中，将me声明为protected似乎没有多大意义，因为它将隐藏在子类中……|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1381599|class+Dad
++{
++++static+String+me+=+"dad";

++++public+void+printMe+()
++++++{
++++++++java.lang.reflect.Field+field+=+this.getClass+().getDeclaredField+("me");
++++++++System.out.println+(field.get+(null));
++++++}
++}|code-block|syntax|javascript|1381600|entityMap^0|Z|A|2V|2|30|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

Though it is true that class variables may only be hidden in subclasses, and not overridden, it is still possible to do what you want without overriding <code>printMe ()</code> in subclasses, and reflection is your friend. In the code below I omit exception handling for clarity. Please note that declaring <code>me</code> as <code>protected</code> does not seem to have much sense in this context, as it is going to be hidden in subclasses...

<pre><code>class Dad
 {
 static String me = "dad";

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

blocks|key|1596698|text|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();
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1596699|..。将打印“儿子”。|unstyled|1596700|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

... will print "son".

blocks|key|1596740|text|是。但是对于变量来说，它是重写的(赋予变量新的值。给函数新的定义是覆盖)。只要不声明变量，而是在构造函数或静态块中初始化(更改)即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596741|当在父类的块中使用时，该值将得到反映|1596742|如果变量是静态的，那么在初始化过程中用静态块改变值，|1596743|class+Son+extends+Dad+{
++++static+{+
+++++++me+=+"son";+
++++}
}|code-block|syntax|javascript|1596744|或者在构造函数中更改。|1596745|您还可以稍后在任何块中更改该值。它将在超类中得到反映|1596746|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Yes. But as the variable is concerned it is overwrite (Giving new value to variable. Giving new definition to the function is Override). Just don't declare the variable but initialize (change) in the constructor or static block.
The value will get reflected when using in the blocks of parent class
if the variable is static then change the value during initialization itself with static block,
<pre><code>class Son extends Dad {
 static { 
 me = &quot;son&quot;; 
 }
}
</code></pre>
or else change in constructor.
You can also change the value later in any blocks. It will get reflected in super class

blocks|key|1381717|text|它确实会打印“爸爸”，因为这个字段没有被覆盖，而是被隐藏了。有三种方法可以让它打印出'son'：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381718|方法1:覆盖printMe|1381719|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();
}|code-block|syntax|javascript|1381720|方法2:不要隐藏字段并在构造函数中对其进行初始化|1381721|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();
}|1381722|方法3:在构造函数中使用静态值初始化字段|1381723|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();
}|1381724|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It indeed prints 'dad', since the field is not overridden but hidden. There are three approaches to make it print 'son':

Approach 1: override printMe

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

Approach 2: don't hide the field and initialize it in the constructor

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

Approach 3: use the static value to initialize a field in the constructor

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

blocks|key|1596825|text|当你可以很容易地在subClasses中重新分配变量时，你为什么要重写变量呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596826|我遵循这个模式来完成语言设计。假设你的框架中有一个重要的服务类，它需要在多个派生的applications.In中以不同的风格使用。在这种情况下，配置超类逻辑的最好方法是重新分配它的“定义”变量。|1596827|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";
+++}

}|code-block|syntax|javascript|1596828|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Why would you want to override variables when you could easily reassign them in the subClasses.

I follow this pattern to work around the language design. Assume a case where you have a weighty service class in your framework which needs be used in different flavours in multiple derived applications.In that case , the best way to configure the super class logic is by reassigning its 'defining' variables. 

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

}
</code></pre>

blocks|key|1596881|text|变量不参与覆盖。只有方法才能做到。方法调用是在运行时解析的，也就是说，调用方法的决定是在运行时做出的，但变量只在编译时决定。因此，该变量被调用，其引用用于调用，而不是运行时对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596882|看一下下面的代码片段：|1596883|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+=+"+%2B+obj1.max_speed);
++++System.out.println("Max_Speed+=+"+%2B+obj2.max_speed);
++++System.out.println("Max_Speed+=+"+%2B+obj3.max_speed);
++}

}|code-block|syntax|javascript|1596884|当您运行代码时，console将显示：|1596885|Inside+Honda
Inside+Honda
Inside+bike

Max_Speed+=+150
Max_Speed+=+90
Max_Speed+=+90|1596886|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Variables don't take part in overrinding. Only methods do. A method call is resolved at runtime, that is, the decision to call a method is taken at runtime, but the variables are decided at compile time only. Hence that variable is called whose reference is used for calling and not of the runtime object.

Take a look at following snippet:

<pre><code>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);
 }

}
</code></pre>

When you run the code, console will show: 

<pre><code>Inside Honda
Inside Honda
Inside bike

Max_Speed = 150
Max_Speed = 90
Max_Speed = 90
</code></pre>

blocks|key|1381857|text|只需在子类构造函数中调用super.variable|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381858|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());

}

}|code-block|syntax|javascript|1381859|输出为10。|1381860|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Just Call super.variable in sub class constructor

<pre><code>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());

}

}
</code></pre>

Output is 10.

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

The function doIt will print "dad". Is there a way to make it print "son"?

Is there a way to override class variables in Java?

Java

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

问在Java中有覆盖类变量的方法吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中有覆盖类变量的方法吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中有覆盖类变量的方法吗？
EN