Java基础知识详解： protected关键字

@author: Tobin
Java初学者，试图用最简单的大白话让自己搞懂一些知识点。

修饰符modifiers介绍

学习Java不可避免地接触到一些基本的修饰符。
修饰符决定了类成员的访问权限，是否能够被其它类所访问。

• private: 只能被基类访问
• 无修饰符: 被基类，子类和同package的类访问
• protected: 在无修饰符的基础上，加了与基类不同包，但是是子类的访问权限，这个访问权限只在子类访问自身的实例时才有，超类的实例还是不能访问的
• public: 全都可以访问

下面这个很好地展现了权限的逐层增加。

protected修饰符详解

《Java编程思想》对protected的介绍是：被protected修饰的成员对于本包和其子类可见。看了上面的图，我们知道子类可见的意思是不同包的子类也是可见的。总结一下就是：

• 基类的protected成员是包内可见的
• 当不在同一个包，但是是其子类也是可以访问protected的成员的。但是有个前提，就是子类只能访问其继承来的protected成员，如果是在子类中初始化一个超类的实例，这个实例是无法访问protected的成员的。
  概念比较抽象，用形象的语言来说。
  包就相当于一个家族。不同包有可能有继承的分支，也有可能毫无关系。类内的成员就相当于资源。
• private: 私有资源，只能自己使用
• default: 家族，我自己，我子孙可以用
• protected: 我可以开放，但是只给自己家族的但是嫁到或者入赘其它家族的后代使用
• public: 谁都可以用，水资源

参考几个例子，分析下。
（1）示例1

//示例一
package p1;
public class Father1 {
    protected void f() {} // 父类Father1中的protected方法
}

package p1;
public class Son1 extends Father1 {}

package p11;
public class Son11 extends Father1{}

package p1;
public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK ----（1）
        son1.clone(); // Compile Error ----（2）

        Son11 son = new Son11();    
        son11.f(); // Compile OK ----（3）
        son11.clone(); // Compile Error ----（4）
    }
}

• f方法是超类Father1的，son1和son11虽然是定义不同的包，但是它们的都是Father1的子类，所以都可以访问f方法。此外Test1也在p1包里，所以1和3编译通过。
• son1和son11的clone()方法都是来自于Father1，但是和f的区别在于，Father的clone()还来自于java.lang.Object，Test1也是Object的子类，这只是说明它可以访问自己继承的clone()方法，即使其它分支继承了相同的方法，它也是不可以访问的。想象一下，家族给其它分支都分配一些资源，即使是相同的，我也不该有权限去访问其它分支的资源。

（2）示例2

//示例二
package p2;
class MyObject2 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}

package p22;
public class Test2 extends MyObject2 {
    public static void main(String args[]) {
       MyObject2 obj = new MyObject2();
       obj.clone(); // Compile Error ----（1）

       Test2 tobj = new Test2();
       tobj.clone(); // Complie OK ----（2）
    }
}

• Test2继承了MyObject2，clone()方法来源于MyObject2，Test2可以建立自身实例，然后访问clone()方法，2通过
• 但是作为子类，Test2建立超类实例，直接去访问超类的protected方法是不可以的
• 想一下，家族已经给我分支资源了，我还要直接向家族拿资源，不该有这个权限
  （3）示例3

//示例三
package p3;
class MyObject3 extends Test3 {
}

package p33;
public class Test3 {
  public static void main(String args[]) {
    MyObject3 obj = new MyObject3();
    obj.clone(); // Compile OK ------（1）
  }
}

• MyObject3继承Test3，两个不在一个包内。Test3作为超类，建立了子类的一个实例，访问子类继承的来自于它的方法，当然它的clone()方法，也是继承自java.lang.Object，这个不管，继承自我的，我是有权限访问的
• 想象一下，家族给分支资源了，家族是有权限直接访问我给出的资源的

（4）示例4

//示例四
package p4;
class MyObject4 extends Test4 {
  protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

package p44;
public class Test4 {
  public static void main(String args[]) {
    MyObject4 obj = new MyObject4();
    obj.clone(); // Compile Error -----（1）
  }
}

• 和示例3的区别在于，此时的clone()方法是子类自身的方法了，来源于MyObject4本身，作为超类是没有权限访问子类的protected成员的
• 想象一下，分支建立自己的受保护资源，家族没有权限直接访问的
  （5）示例5

//示例五
package p5;

class MyObject5 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}
public class Test5 {
    public static void main(String[] args) throws CloneNotSupportedException {
       MyObject5 obj = new MyObject5();
       obj.clone(); // Compile OK ----(1)
    }
}

• 现在属于同一个包，Test5可以直接访问Myobject5的protected成员
• 想象一下，同一个家族的资源共享
  （6）示例6

//示例六
package p6;

class MyObject6 extends Test6{}
public class Test6 {
  public static void main(String[] args) {
    MyObject6 obj = new MyObject6();
    obj.clone(); // Compile OK -------（1）
  }
}

• 即使不在同一个包，1也成立。此处在同一个包，且clone()方法来自于Test6
• 同一个家族的资源共享
  （7）示例7

//示例七
package p7;

class MyObject7 extends Test7 {
    public static void main(String[] args) {
        Test7 test = new Test7();
        test.clone(); // Compile Error ----- (1)
  }
}

public class Test7 {}

• 超类Test7的方法来自于java.lang.Object，只有java.lang这个包和对应继承了这个clone()方法的Test7才能访问。说白了，方法还是一个方法，但是被不同的子类继承了，就不再是同样的方法了。
• 看起来是一个家族的，实际上资源是超类从其它家族得到的。其它家族对该资源做了限制，所以不能整个家族都能使用。其次，子类只能访问自身实例的protected资源，没有权限访问超类实例的protected资源。两个条件都不满足。

其它修饰符

static
final
abstract
后续添加。

总结

protected成员，在相同package下，对其它类开放，不同package下，对继承了该类的子类开放(有条件)。其它包的子类没有权限直接创建超类的实例，然后访问超类的protected成员。除了认清楚protected属性，更重要的是要辨别来源，来源决定package是哪个，这是决定访问权限的基础。

参考文章
https://blog.csdn.net/ciawow/article/details/8262609。
https://blog.csdn.net/justloveyou_/article/details/61672133