栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java的protected关键字的可见性

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java的protected关键字的可见性

文章目录
  • 前言
  • 一、几种修饰符的可见性
  • 二、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,允许任意类访问类的成员
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/956006.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号