訪問私有數據成員

Question

我想聲明一個超類的數據成員，私營：

public abstract class superclass { 
    private int verySensitive; 

    abstract int setVerySensitive(int val); // must be overriden by subclass to work properly 
} 


public class subclass extends superclass { 

    @Override 
    protected int setVerySensitive(int val) { 
    if (val > threshLow && val < threshHigh) // threshHigh is calculated in superclass constructor 
     verySensitive = val; 
    } 
} 

正如你所看到的，我這裏有一個問題：超不能訪問verySensitive，因爲它是私人的，但我不想做出非常敏感的保護，因爲它非常敏感。

另請注意，setVerySensitive是抽象的，因爲檢查有效值只能在超類構造完成後才能完成。

你能推薦一種擺脫這種「捕捉22」情況的優雅方式嗎？

Answer 1

我建議是這樣的：

public abstract class superclass { 
    private int verySensitive; 

    final int setVerySensitive(int val) { 
    if (checkVerySensitive(val)) { 
     verySensitive = val; 
    } 
    } 
    protected abstract boolean checkVerySensitive(int val); 
} 


public class subclass extends superclass { 

    @Override 
    protected boolean checkVerySensitive(int val) { 
    return val > threshLow && val < threshHigh; // threshHigh is calculated in superclass constructor 
    } 
} 

這類似於EboMike的建議，但它留下setVerySensitive(int)與包訪問，而不是使其成爲私人的。

Answer 2

如何使檢查抽象，但設置自己私人？

public abstract class superclass { 
    private int verySensitive; 

    abstract boolean verifySensitiveValue(int val); // must be overriden by subclass to work properly 

    private void setVerySensitiveValue(int val) { 
    if (verifySensitiveValue(val)) { 
     verySensitive = val; 
    } 
    } 
} 


public class subclass extends superclass { 

    @Override 
    protected boolean verifySensitiveValue(int val) { 
    return (val > threshLow && val < threshHigh); // threshHigh is calculated in superclass constructor 
    } 
} 

Answer 3

我覺得適合你的標準是唯一的答案是：

public abstract class superclass { 
    private int verySensitive; 

    abstract int setVerySensitive(int val); // must be overriden by subclass to work properly 

    protected void setVerySensitiveForReal(int val) { 
    verySensitive = val; 
    } 
} 


public class subclass extends superclass { 

    @Override 
    protected int setVerySensitive(int val) { 
    if (val > threshLow && val < threshHigh) // threshHigh is calculated in superclass constructor 
     setVerySensitiveForReal(val); 
    } 
} 

這不是比簡單地使verySensitive保護太大的不同，但你必須要能夠訪問它地方。

Answer 4

提供受保護的方法，子類可以訪問實際上改變非常敏感的值。

Answer 5

對不起，沒有出路。

要麼它是私人的，只有你可以訪問它，或者它是受保護的，它是你的子類簽名的一部分。

Answer 6

添加

protected void setVerySensitive(int val) { verySensitive = val; } 

超類，然後使用在子類設置數值。

Answer 7

這個值是多麼「敏感」？您可能想要考慮配置SecurityManager以防止通過反射訪問專用字段。

http://aminurrashid.com/english/java/core-java/prevent-reflection-to-access-private-methods-and-members-in-java-classes.html

Answer 8

使用反映：

// SubClass.java 
import java.lang.reflect.*; 

class SuperClass { 
    private String privateField = "This is Private"; 
    public SuperClass(){ 
    } 
} 
class SubClass extends SuperClass { 
    void getPrivateField(){ 
     Field f = null; 
     try { 
      f = SuperClass.class.getDeclaredField("privateField"); 
     } catch (NoSuchFieldException nsfe){ 
      throw new Error(); 
     } 
     f.setAccessible(true); 
     try { 
      System.out.println(f.get(this)); 
     } catch (IllegalAccessException iae){ 
      throw new Error(); 
     } 
    } 
    public static void main(String[] args){ 
     new SubClass().getPrivateField(); 
    } 
}