首先我們先來看一段非常簡單的代碼：

public class ClazzTest {
    public static void main(String[] args) {
        Son s1 = new Son();
        System.out.println(" s1.name : " + s1.name);
        System.out.println(" s1.say : " + s1.say());
        Father s2 = new Son();
        System.out.println(" s2.name : " + s2.name)
 
;
        System.out.println(" s2.say : " + s2.say());
    }
}
class Father {
    String name = "Jack";
    String say() {
        return "I am Father";
    }
}
class Son extends Father {
    String name = "Jack‘s son";
    String say() {
        return "I am son";
    }
}

輸出：
s1.name : Jack‘s son
 s1.say : I am son
 s2.name  : Jack
 s2.say : I am son
 

那為什麽會出現這樣的情況呀？就要說到java中的重載（overload）和重寫（override）了。

在Java的子類與父類中有兩個名稱、參數列表都相同的方法的情況。

由於他們具有相同的方法簽名，所以子類中的新方法將覆蓋父類中原有的方法。

正是因為Java在繼承中有方法的重寫，所以，這也體現了Java的動態多態性。

那麽問題來了，成員變量在Java中能夠被重寫麽？

在Java的重寫介紹中明確的說了，重寫，指的是方法。並沒有提到成員變量。

通過上面的例子，其實我們也可以發現，成員變量並沒有被重寫。

所以，Java中，成員變量並不會被重寫。因此這裏就引申出了另外一個詞：隱藏。

Java中成員變量的隱藏：

在Java的文檔中，對隱藏域有這麽一段的定義：

Within a class, a field that has the same name as a field in the superclass hides the superclass’s field,

even if their types are different. Within the subclass, the field in the superclass cannot be referenced by its simple name.

Instead, the field must be accessed through super.

Generally speaking, we don’t recommend hiding fields as it makes code difficult to read.

（強大的有道翻譯出場，他說：）

在一個類中，子類中的成員變量如果和父類中的成員變量同名，那麽即使他們類型不一樣，只要名字一樣。

父類中的成員變量都會被隱藏。在子類中，父類的成員變量不能被簡單的用引用來訪問。

而是，必須從父類的引用獲得父類被隱藏的成員變量，一般來說，我們不推薦隱藏成員變量，因為這樣會使代碼變得難以閱讀。

其實將其翻譯成簡短的一句話，就是說：子類不會去重寫覆蓋父類的成員變量，所以成員變量的訪問不能像方法一樣使用多態去訪問。

那麽問題又來了，我們又如何訪問被隱藏的成員變量呢？

就是使用父類的引用來訪問成員變量：

Son s1 = new Son();
System.out.println(" s1.name : " + ((Father)s1).name

輸出：

s1.name : Jack

Java中成員變量的隱藏和方法的重寫