java 的protected 訪問權限。

基類代碼：包爲com.fu

package com.fu;

public class Base {

        protected int protectedInt;  //protected成員
        public int publicInt;        //public 成員
        protected  int  getProtectedInt(){
            return protectedInt;
        }
        protected static int staticProtectInt;
        private int privateInt;
        public static void main(String[] args) {
            Base b=new Base();
            b.privateInt=5;
        }
}

不同包內派生類：com.zi

package com.zi;

import com.fu.Base;

public class TestOtherPackageSubClass extends Base {
    public void test() {
        Base b = new Base(); // 使用基類
        b.publicInt = 0; // 可以訪問
        <span style="color:#FF0000;">//b.protectedInt=3; // 訪問protected的屬性失敗
        //b.getProtectedInt(); // 訪問protected的方法失敗</span>
        Base.staticProtectInt=9;
    }

    public void test2() {
        <span style="color:#FF0000;">//privateInt =6;   //訪問父類的私有-出錯</span>
        publicInt = 0; // 可以訪問
        protectedInt = 2; // 直接用父類的屬性-成功
        super.protectedInt=4;

        getProtectedInt(); // 直接用父類的方法-成功
        System.out.println("getProtectedInt-test2:"+getProtectedInt());

        protectedInt = 22; // 直接用父類的屬性-成功
        Base.staticProtectInt=10;
        super.getProtectedInt(); // 直接用父類的方法-成功
        System.out.println("getProtectedInt-test2:"+getProtectedInt());
    }

    public void test3(){
        TestOtherPackageSubClass t=new TestOtherPackageSubClass();
        t.protectedInt=6;
        t.getProtectedInt();
        System.out.println("getProtectedInt-test3:"+t.getProtectedInt());
    }

    public static void main(String[] args) {
        TestOtherPackageSubClass t=new TestOtherPackageSubClass();
        t.test2();
        System.out.println(Base.staticProtectInt);
    }
}

運行結果爲：
getProtectedInt-test2:4
getProtectedInt-test2:22
10
從運行結果 看出  test2 中不管有沒有寫super.protectInt,還是直接protectInt 都是指向父類的成員。從這可以看出不在同一包的子類可以直接（未實例化）訪問父類數據成員。

如果把這個Base.staticProtectInt=10; 去掉的話， Base.staticProtectInt輸出結果爲0。因爲test()方法沒有調用不會設爲9。

同一包內子類代買 com.fu

package com.fu;

import com.zi.TestOtherPackageSubClass;

public class TestSamePackageSubClass extends Base {
    public void test() {
        Base b = new Base(); // 使用基類
        b.publicInt = 0; // 可以訪問
        b.protectedInt=3; // 訪問protected的屬性-成功
        b.getProtectedInt(); // 訪問protected的方法-成功
    }

    public void test2() {
        publicInt = 0; // 可以訪問
        protectedInt = 2; // 直接用父類的屬性-成功
        Base.staticProtectInt=9;
        System.out.println("getProtectedInt-test2:"+getProtectedInt());
    }

    public void test3(){
        TestOtherPackageSubClass t=new TestOtherPackageSubClass();
        t.protectedInt=6;

        System.out.println("getProtectedInt-test3:"+t.getProtectedInt());
    }

    public static void main(String[] args) {
        TestSamePackageSubClass t=new TestSamePackageSubClass();
        t.test2();
        t.test3();

    }

}

如果同一包內的話可以通過  b.protectedInt 訪問了。
同一包內非派生類：

package com.fu;

public class TestSamePackageNotSubClass {
    public static void main(String[] args) {
        Base b = new Base(); // 使用基類
        b.publicInt = 0; // 可以訪問 -成功
        b.protectedInt=3;
        System.out.println(b.getProtectedInt());
    }
}

同一包內的話可以通過 base b.protectedInt 訪問了。

同一包子類可以直接或實例化(new)訪問protedted成員，普通類可以實例化(new)訪問protedted成員不可直接訪問，而不屬於同一包內的派生類中只能直接使用基類super. protedted成員 或者protedted成員,而不能通過 實例化訪問(new) 訪問。