Java的protected关键字的可见性

紫川有雪

已于 2022-06-07 19:36:30 修改

阅读量807

点赞数

文章标签： java 开发语言

于 2022-06-07 19:31:27 首次发布

本文链接：https://blog.csdn.net/java_mingge/article/details/125169208

版权

文章目录

前言
一、几种修饰符的可见性
二、protected可见性
- 1.创建三个类Father、Child1SamePack、Child2DiffPack
- 2.编写两个测试类TestSamePack、TestDiffPack
三、总结

前言

修饰符private、protected、public都称为可见性修饰符(visibility modifier)或可访问性修饰符(accessibility modifer)，因为它们指定如何访问类和类的成员。
相信很多朋友都对private、public这两个修饰符很熟悉了，本文重点讨论一下关于protected修饰符的可见性。

一、几种修饰符的可见性

几种修饰符可见性递增顺序如下：
修饰符可见性顺序递增下表总结了类中成员的可访问性：
可见性表格

使用private修饰符可以完全隐藏类的成员，这样，就不能从类外直接访问它们。不使用修饰符(default)就表示允许同一个包里的类直接访问类的成员，但是其他包中的类不可以访问。使用protected修饰符允许任何包中的子类或同一包中的类访问类的成员。使用public修饰符允许访问类的成员。

二、protected可见性

同一包中的类(包括子类)可以访问protected修饰的成员
不同包中的类，只有该类的子类能访问该类的protected修饰的成员

特别说明的是，不在同一包中的类(非子类)，引用该类的子类的实例，也不能访问该类的protected成员
下面引入代码，分别从子类，和子类的实例的角度，探讨这个结论，代码环境JDK1.8

1.创建三个类Father、Child1SamePack、Child2DiffPack

三个类分别代表：父类，和父类在同一个包中的子类1，和父类不在同一个包中的子类2。

（示例1）Father 父类代码：

package package1;
public class Father {
    private String privateField;//private修饰的的字段
    String defaultField;//默认修饰字段
    protected String protectedField;//protected修饰的字段
    public String publicField;//public修饰的字段

    protected static String STATIC_FILED;//protected修饰的静态字段

    private void privateMethod() {}//private修饰的方法

    void defaultMethod() {}//默认修饰的方法

    protected void proctedMethod() {}//protected修饰的方法

    public void publicMethod() {}//public修饰的方法

    protected static void staticMethod() {}//protected修饰的静态放方法
}

（示例2）Child1SamePack 同包子类代码：
类中标注的“//编译错误，无法引入”，代表在IDE中引入该变量或者是方法报错，未标注的代表编译通过，没有报错，下面的代码示例都是如此

package package1;
public class Child1SamePack extends Father {

    public String privateFieldChild1 = super.privateField;//编译错误，无法引入
    public String defaultFieldChild1 = super.defaultField;
    public String protectedFieldChild1 = super.protectedField;
    public String publicFieldChild1 = super.publicField;
    public static String staticFieldChild1 = Father.STATIC_FILED;

    public Child1SamePack(){
        super.privateMethod();//编译错误，无法引入
        super.defaultMethod();
        super.proctedMethod();
        super.publicMethod();
    }

    public void commonMethod(){
        super.privateMethod();//编译错误，无法引入
        super.defaultMethod();
        super.proctedMethod();
        super.publicMethod();
    }

    public static void staticMethodChild1(){
        Father.staticMethod();
    }
}

（示例3）Child2DiffPack 不同包子类代码：

package package2;
public class Child2DiffPack extends Father {

    public String privateFieldChild2 = super.privateField;//编译错误，无法引入
    public String defaultFieldChild2 = super.defaultField;//编译错误，无法引入
    public String protectedFieldChild2 = super.protectedField;
    public String publicFieldChild2 = super.publicField;

    public static String staticFieldChild1 = Father.STATIC_FILED;

    public Child2DiffPack(){
        super.privateMethod();//编译错误，无法引入
        super.defaultMethod();//编译错误，无法引入
        super.proctedMethod();
        super.publicMethod();
    }

    public void commonMethod(){
        super.privateMethod();//编译错误，无法引入
        super.defaultMethod();//编译错误，无法引入
        super.proctedMethod();
        super.publicMethod();
    }

    public static void staticMethodChild1(){
        Father.staticMethod();
    }
}

小结1：
在同包子类中，不能访问修饰符：private，能访问修饰符：默认(defalut)、protected、public
在不同包子类中：不能访问修饰符：private、默认(defalut)，能访问修饰符：protected、public
在子类

2.编写两个测试类TestSamePack、TestDiffPack

两个测试类分别代表：同包的测试类，和不同包的测试类。目的是测试父类引用、和同包的子类引用还有不同包的子类引用，分别访问几种修饰符修饰的成员的可见性。

（示例4）TestSamePack 同包测试类代码：

package package1;
public class TestSamePack {

    public static void main(String[] args) {
        Father father = new Father();
        String f1 = father.privateField;//编译错误，无法引入-----1
        String f2 = father.defaultField;
        String f3 = father.protectedField;
        String f4 = father.publicField;
        father.privateMethod();//编译错误，无法引入-----2
        father.defaultMethod();
        father.proctedMethod();
        father.publicMethod();

        String f5 = Father.STATIC_FILED;
        Father.staticMethod();

        Child1SamePack child1SamePack = new Child1SamePack();
        String c11 = child1SamePack.privateField;//编译错误，无法引入-----3
        String c12 = child1SamePack.defaultField;
        String c13 = child1SamePack.protectedField;
        String c14 = child1SamePack.publicField;
        child1SamePack.privateMethod();//编译错误，无法引入-----4
        child1SamePack.defaultMethod();
        child1SamePack.proctedMethod();
        child1SamePack.publicMethod();

        String c15 = Child1SamePack.STATIC_FILED;
        Child1SamePack.staticMethod();

        Child2DiffPack child2DiffPack = new Child2DiffPack();
        String c21 = child2DiffPack.privateField;//编译错误，无法引入-----5
        String c22 = child2DiffPack.defaultField;//编译错误，无法引入-----6
        String c23 = child2DiffPack.protectedField;
        String c24 = child2DiffPack.publicField;
        child2DiffPack.privateMethod();//编译错误，无法引入-----7
        child2DiffPack.defaultMethod();//编译错误，无法引入-----8
        child2DiffPack.proctedMethod();
        child2DiffPack.publicMethod();

        String c25 = Child2DiffPack.STATIC_FILED;
        Child2DiffPack.staticMethod();
    }
}

小结2：
测试代码中三个类的实例，Father、Child1SamePack、Child2DiffPack，父类中private修饰的成员，都不可见。唯一例外的是错误6处和错误8处，报错入下图，按道理来说default修饰的方法在Father中，测试类和Father在同一个包中，应该是可以引入的才对。仔细想想：Child2DiffPack与Father不在同一个包，Child2DiffPack类无法引入Father的default的成员，虽然测试类与Father在同一个包中，但是Child2DiffPack的实例对象无法引入Father类的default成员，也能很好的理解了。
在这里插入图片描述
（示例5）TestDiffPack不同包测试类代码：

package package2;
public class TestDiffPack {

    public static void main(String[] args) {
        Father father = new Father();
        String f1 = father.privateField;//编译错误，无法引入
        String f2 = father.defaultField;//编译错误，无法引入
        String f3 = father.protectedField;//编译错误，无法引入
        String f4 = father.publicField;
        father.privateMethod();//编译错误，无法引入
        father.defaultMethod();//编译错误，无法引入
        father.proctedMethod();//编译错误，无法引入
        father.publicMethod();

        String f5 = Father.STATIC_FILED;//编译错误，无法引入
        Father.staticMethod();//编译错误，无法引入

        Child1SamePack child1SamePack = new Child1SamePack();
        String c11 = child1SamePack.privateField;//编译错误，无法引入
        String c12 = child1SamePack.defaultField;//编译错误，无法引入
        String c13 = child1SamePack.protectedField;//编译错误，无法引入
        String c14 = child1SamePack.publicField;
        child1SamePack.privateMethod();//编译错误，无法引入
        child1SamePack.defaultMethod();//编译错误，无法引入
        child1SamePack.proctedMethod();//编译错误，无法引入
        child1SamePack.publicMethod();

        String c15 = Child1SamePack.STATIC_FILED;//编译错误，无法引入
        Child1SamePack.staticMethod();//编译错误，无法引入

        Child2DiffPack child2DiffPack = new Child2DiffPack();
        String c21 = child2DiffPack.privateField;//编译错误，无法引入
        String c22 = child2DiffPack.defaultField;//编译错误，无法引入
        String c23 = child2DiffPack.protectedField;//编译错误，无法引入
        String c24 = child2DiffPack.publicField;
        child2DiffPack.privateMethod();//编译错误，无法引入
        child2DiffPack.defaultMethod();//编译错误，无法引入
        child2DiffPack.proctedMethod();//编译错误，无法引入
        child2DiffPack.publicMethod();

        String c25 = Child2DiffPack.STATIC_FILED;//编译错误，无法引入
        Child2DiffPack.staticMethod();//编译错误，无法引入
    }
}

小结3：
在不同包的测试代码中，三个类的实例，Father、Child1SamePack、Child2DiffPack，父类中private、默认(default)、protected修饰的成员，都不可见。为什么测试代码中，父类的的protected修饰的成员无法访问，其实很好理解，测试代码中，实例化子类对象去访问父类的成员的时候，这个时候其实和子类没有关系，关键是看测试代码所在的类所在的位置，是和父类在一个包(示例4 TestSamePack 同包测试类代码)，还是和父类不在一个包(示例5 TestDiffPack不同包测试类代码)，在同一个包就可以访问protected修饰的成员，否则不可以。

三、总结

通过对子类和子类对象的实例代码的测试，可以看出，

private修饰符，对出自己的所有其他的类不可见
默认(default)修饰符，只有同包可以访问
protected，允许同包中的类，和任何包中的子类可以访问
public，允许任意类访问类的成员

紫川有雪

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Java的protected关键字的可见性

修饰符private、protected、public都称为可见性修饰符(visibility modifier)或可访问性修饰符(accessibility modifer)，因为它们指定如何访问类和类的成员。相信很多朋友都对private、public这两个修饰符很熟悉了，本文重点讨论一下关于protected修饰符的可见性。......
复制链接

扫一扫