class ParentClass {   
    public int i = 10;   
}   
  
public class SubClass extends ParentClass {   
    public int i = 30;   
  
    public static void main(String[] args) {   
        ParentClass parentClass = new SubClass();   
        SubClass subClass = new SubClass();   
        System.out.println(parentClass.i + subClass.i);   
    }   
}  

控制檯的輸出結果是多少呢？20？40？還是60？ 

變數，或者叫做類的屬性，在繼承的情況下，如果父類和子類存在同名的變數會出現什麼情況呢？這就是這道題要考查的知識點——變數（屬性）的覆蓋。 

這個問題雖然簡單，但是情況卻比較複雜。因為我們不僅要考慮變數、靜態變數和常量三種情況，還要考慮private、friendly（即不加訪問修飾符）、protected和public四種訪問許可權下對屬性的不同影響。 

我們先從普通變數說起。依照我們的慣例，先來看一段程式碼：

class ParentClass {   
    private String privateField = "父類變數--private";   
  
    /* friendly 
 
*/String friendlyField = "父類變數--friendly";   
  
    protected String protectedField = "父類變數--protected";   
  
    public String publicField = "父類變數--public";   
  
    // private的變數無法直接訪問，因此我們給他增加了一個訪問方法       public String getPrivateFieldValue() {   
        return privateField;   
    }   
}   
  
public
 
 class SubClass extends ParentClass {   
    private String privateField = "子類變數--private";   
  
    /* friendly */String friendlyField = "子類變數--friendly";   
  
    protected String protectedField = "子類變數--protected";   
  
    public String publicField = "子類變數--public";   
  
    // private的變數無法直接訪問，因此我們給他增加了一個訪問方法       public String getPrivateFieldValue() {   
        return privateField;   
    }   
  
    public static void main(String[] args) {   
        // 為了便於查閱，我們統一按照private、friendly、protected、public的順序   
        // 輸出下列三種情況中變數的值   
  
        // ParentClass型別，ParentClass物件           ParentClass parentClass = new ParentClass();   
        System.out.println("ParentClass parentClass = new ParentClass();");   
        System.out.println(parentClass.getPrivateFieldValue());   
        System.out.println(parentClass.friendlyField);   
        System.out.println(parentClass.protectedField);   
        System.out.println(parentClass.publicField);   
  
        System.out.println();   
  
        // ParentClass型別，SubClass物件           ParentClass subClass = new SubClass();   
        System.out.println("ParentClass subClass = new SubClass();");   
        System.out.println(subClass.getPrivateFieldValue());   
        System.out.println(subClass.friendlyField);   
        System.out.println(subClass.protectedField);   
        System.out.println(subClass.publicField);   
  
        System.out.println();   
  
        // SubClass型別，SubClass物件           SubClass subClazz = new SubClass();   
        System.out.println("SubClass subClazz = new SubClass();");   
        System.out.println(subClazz.getPrivateFieldValue());   
        System.out.println(subClazz.friendlyField);   
        System.out.println(subClazz.protectedField);   
        System.out.println(subClazz.publicField);   
    }   
}  

這段程式碼的執行結果如下： 

ParentClass parentClass = new ParentClass(); 
父類變數--private 
父類變數--friendly 
父類變數--protected 
父類變數--public 

ParentClass subClass = new SubClass(); 
子類變數--private 
父類變數--friendly 
父類變數--protected 
父類變數--public 

SubClass subClazz = new SubClass(); 
子類變數--private 
子類變數--friendly 
子類變數--protected 
子類變數--public 

從上面的結果中可以看出，private的變數與其它三種訪問許可權變數的不同，這是由於方法的重寫（override）而引起的。關於重寫知識的回顧留給以後的章節，這裡我們來看一下其它三種訪問許可權下變數的覆蓋情況。 

分析上面的輸出結果就會發現，變數的值取決於我們定義的變數的型別，而不是建立的物件的型別。 

在上面的例子中，同名的變數訪問許可權也是相同的，那麼對於名稱相同但是訪問許可權不同的變數，情況又會怎樣呢？事實勝於雄辯，我們繼續來做測試。由於private變數的特殊性，在接下來的實驗中我們都把它排除在外，不予考慮。 

由於上面的例子已經說明了，當變數型別是父類（ParentClass）時，不管我們建立的物件是父類（ParentClass）的還是子類（SubClass）的，都不存在屬性覆蓋的問題，因此接下來我們也只考慮變數型別和建立物件都是子類（SubClass）的情況。

class ParentClass {   
    /* friendly */String field = "父類變數";   
}   
  
public class SubClass extends ParentClass {   
    protected String field = "子類變數";   
  
    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(subClass.field);   
    }   
}  

執行結果： 

子類變數 

Java程式碼 
class ParentClass {   
    public String field = "父類變數";   
}   
  
public class SubClass extends ParentClass {   
    protected String field = "子類變數";   
  
    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(subClass.field);   
    }   
}  

執行結果： 

子類變數 

上面兩段不同的程式碼，輸出結果確是相同的。事實上，我們可以將父類和子類屬性前的訪問修飾符在friendly、protected和public之間任意切換，得到的結果都是相同的。也就是說訪問修飾符並不影響屬性的覆蓋，關於這一點大家可以自行編寫測試程式碼驗證。 

對於靜態變數和常量又會怎樣呢？我們繼續來看：

class ParentClass {   
    public static String staticField = "父類靜態變數";   
  
    public final String finalField = "父類常量";   
  
    public static final String staticFinalField = "父類靜態常量";   
}   
  
public class SubClass extends ParentClass {   
    public static String staticField = "子類靜態變數";   
  
    public final String finalField = "子類常量";   
  
    public static final String staticFinalField = "子類靜態常量";   
  
    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(SubClass.staticField);   
        System.out.println(subClass.finalField);   
        System.out.println(SubClass.staticFinalField);   
    }   
}  

執行結果如下： 

子類靜態變數 
子類常量 
子類靜態常量 

雖然上面的結果中包含“子類靜態變數”和“子類靜態常量”，但這並不表示父類的“靜態變數”和“靜態常量”可以被子類覆蓋，因為它們都是屬於類，而不屬於物件。 

上面的例子中，我們一直用物件來對變數（屬性）的覆蓋做測試，如果是基本型別的變數，結果是否會相同呢？答案是肯定的，這裡我們就不再一一舉例說明了。 

最後，我們來做個總結。通過以上測試，可以得出一下結論： 

由於private變數受訪問許可權的限制，它不能被覆蓋。 
屬性的值取父類還是子類並不取決於我們建立物件的型別，而是取決於我們定義的變數的型別。 
friendly、protected和public修飾符並不影響屬性的覆蓋。 
靜態變數和靜態常量屬於類，不屬於物件，因此它們不能被覆蓋。 
常量可以被覆蓋。 
對於基本型別和物件，它們適用同樣的覆蓋規律。 

最後我們再回到篇首的那道題，我想答案大家都已經知道了，結果是40。