精华内容
下载资源
问答
  • PROTECTED
    千次阅读
    2018-05-31 17:57:07

    protected:

    private相似:

     类外只能用公有成员访问protected成员。

    区别:

    在子类中体现,子类成员可访问基类protected成员,但不能访问private成员。

    更多相关内容
  • 变量与方法的关键字public,private,protected public的权限最大,既可以让子类使用,也可以支持实例化之后的调用, protected表示的是受保护的,访问的权限是只有在子类和本类中才可以被访问到 private 表示的是私有...
  • 三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员函数访问 三种继承方式 public 继承 ...protectedprotected继承 => protected protecte
  • JEDEC JESD260:2021 Replay Protected Monotonic Counter (RPMC) for
  • protected(受保护的)被声明为protected的成员,只允许该类的子类进行访问。private(私有的 ) 被定义为private的成员,对于类内部所有成员都可见,没有访问限制。对类外部不允许访问。 图解demo复制代码 代码...
  • 主要介绍了Swift中的访问控制和protected,本文主要讲解为什么Swift没有类似protected的选项,需要的朋友可以参考下
  • Ruby类下对访问控制的限制也是用public,protected和private来做的。虽然用的是和C++和Java相同的名字,但是Ruby下的protected和private定义还是有所不同的。
  • C++Protected介绍

    2019-01-17 14:06:44
    编程思想的第十四章,代码,本人亲测通过后才上传的 这段代码 介绍的 是 C++的Protected
  • 今天小编就为大家分享一篇解决yum安装报错Protected multilib versions的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Protected Storage PassView(找出电脑账号密码).rar
  • Java访问权限之 protected详解

    千次阅读 2020-07-15 21:58:36
    对于类的成员(包括成员变量和成员方法)而言,其能否被其他类所访问,取决于该成员的修饰词;...由于很多Java书籍对protected可见性的介绍都比较笼统,本文重点说明了protected关键字的可见性内涵。

    摘要:
        对于类的成员(包括成员变量和成员方法)而言,其能否被其他类所访问,取决于该成员的修饰词;而对于一个类而言,其能否被其他类所访问,也取决于该类的修饰词。在Java中,类成员访问权限修饰词有四类:private,无(包访问权限),protected 和 public,而其中只有包访问权限和public才能修饰一个类(内部类除外)。由于很多Java书籍对protected可见性的介绍都比较笼统,本文重点说明了protected关键字的可见性内涵。


    一、Java访问权限概述

        对于一个类,其成员(包括成员变量和成员方法)能否被其他类所访问,取决于该成员的修饰词。在Java中,类成员的访问权限修饰词有四个:private,无(包访问权限),protected 和 public,其权限控制如下表所示:
    | | 同一个类中 | 同一个包中 | 不同包的子类 | 不同包的无关类 |
    |–|–|–|–|–|–|
    | public | ✔ | ✔ | ✔ | ✔ |
    | protected | ✔ | ✔ | ✔ | |
    | 无(空着不写) | ✔ | ✔ | | |
    | private | ✔ | | | |

    不同包中子类: 不同包通过继承获得关系
    不同包中的无关类: 不同包通过直接创建对象来获得关系

    在上面所提到的四种修饰词中,除 protected 外都很好理解和掌握,在此略作简述:

    • public :被public修饰的类成员能被所有的类直接访问;
    • 包访问权限 :包访问权限就是Java中的默认的权限,具有包访问权限的类成员只能被同一包中的类访问。
    • private : 被public修饰的类成员只能在定义它的类中被访问,其他类都访问不到。特别地,我们一般建议将成员变量设为private的,并为外界提供 getter/setter 去对成员变量进行访问,这种做法充分体现了Java的封装思想;如果你不希望其他任何人对该类拥有访问权,你可以把所有的构造器都指定为private的,从而阻止任何人创建该类的对象。

    二、protected关键字的可见性

        很多介绍Java语言的书籍(比如《Java编程思想》)都对protected做了介绍,但是描述的比较简单,基本都是一句话“被protected修饰的成员对于本包和其子类可见”。这种说法有点太过含糊,常常会对大家造成误解。实际上,protected的可见性在于以下几点:

    • 基类(父类)的protected成员(包括成员变量个成员方法)对本包内可见,并且对子类可见;
    • 若子类与基类(父类)不在同一包中,那么在子类中,只有子类实例可以访问其从基类继承而来的protected方法,而在子类中不能访问基类实例(对象)(所调用)的protected方法。
    • 不论是否在一个包内,父类中可以访问子类实例(对象)继承的父类protected修饰的方法。(子父类访问权限特点:父类访问域大于子类)
    • 若子类与基类(父类)不在同一包中,子类只能在自己的类(域)中访问父类继承而来的protected成员,无法访问别的子类实例(即便同父类的亲兄弟)所继承的protected修饰的方法。
    • 若子类与基类(父类)不在同一包中,父类中不可以使用子类实例调用(父类中没有)子类中特有的(自己的)protected修饰的成员。(毕竟没有满足同一包内和继承获得protected成员的关系)

    接下来我们通过下面几个关于protected方法可见性的例子进行详细解释protected关键字:


    示例一:

    // 示例一
    package p1;
    public class Father1 {
        protected void f() {
        }    // 父类Father1中的protected方法
    }
    
    package p1;
    public class Son1 extends Father1 {
    }
    
    package p2;
    public class Son2 extends Father1{
    }
    
    package p1;
    public class Test {
        public static void main(String[] args) {
            Son1 son1 = new Son1();
            son1.f(); // Compile OK     ----(1)
            son1.clone(); // Compile Error     ----(2)
    		
    
            Son2 son = new Son2();    
            son2.f(); // Compile OK     ----(3)
            son2.clone(); // Compile Error     ----(4)
    
    		Test t = new Test();
    		t.clone; // Compile OK
    		// 测试类test只可以使用test类的继承Object类而来的test.clone()方法
        }
    }
    

        首先看(1)(3),其中f()方法从类Father1中继承而来,其可见性是包p1及其子类Son1和Son2,而由于调用方法f()的类Test也在包p1之内,因此(1)(3)处编译通过。
        其次看(2)(4),其中clone()方法所在类为Object默认根类,而Object类所在包为java.lang包。其可见性是java.lang包及其所有子类,对于语句“son1.clone();”和“son11.clone();”,二者的clone()在类Son1、Son2中是可见的(可以使用的),但对Test类是不可见的,因此(1)(3)处编译不通过。
        再者,如果测试类在p2包内,由于不满足protected两种可见性(同一包内和子父类关系),也将无法调用protected修饰的f()方法。test测试类在p2包内,即便继承Father1类Son1和Son2也无法调用f()方法(Test t = new Test(); t.f();可以调用),因为在p2包内继承了Father1,虽然不在同一包内,但是现在有了子父类的关系,即Test类与Son1、Son2形成了兄弟关系,由于 protected受访问保护规则是很微妙的,虽然protected域对所有子类都可见,但是子类只能在自己的作用范围内访问自己继承的那个父类protected,而无法到访问别的子类(同父类的亲兄弟)所继承的protected修饰的方法。

      子类只能在自己的作用范围(域)中访问父类protected成员,无法访问别的子类实例(即便同父类的亲兄弟)所继承的protected修饰的方法。

      但是即便不在一个包里,在父类中也可以访问子类实例(对象)继承的父类protected修饰的方法。

      如果子父类不在一个包内,父类不可以调用(父类中没有)子类中特有的(自己的)protected修饰的成员。(毕竟没有满足同一包内和继承获得protected成员的关系)


    示例二

    package P1;
    public class MyObject {
    	protected Object clone() throws CloneNotSupportedException{
    		return super.clone();
    	}
    }
    
    
    package P2;
    import P1.MyObject;
    public class Test extends MyObject {
    	public static void main(String args[]) throws CloneNotSupportedException {
    		MyObject obj = new MyObject();
    		obj.clone(); // Compile Error         ----(1)
    
    		Test tobj = new Test();
    		tobj.clone(); // Complie OK         ----(2)
    	}
    }
    

        对于(1)而言,clone()方法来自于类MyObject本身,因此其可见性为包p1及MyObject的子类,虽然Test是MyObject的子类,但是由于在子类中,只有本类实例可以访问其从基类继承而来的protected方法,而在子类中不能访问基类实例(对象)(所调用)的protected方法。(作为子类,Test类中建立超类实例,直接去访问超类的protected方法是不可以的),因此编译不通过。

        对于(2)而言,由于在Test中访问的是其本身实例的从基类MyObject继承来的的clone(),因此编译通过。


    示例三

    package P1;
    public class Test {
    	public static void main(String args[]) throws CloneNotSupportedException {
    		MyObject obj = new MyObject();
    		obj.clone();   // Compile OK     ------(1)
    	}
    }
    
    package P2;
    public class MyObject extends Test {
    }
    

        对于(1)而言,由于父类中可以访问子类实例(对象)继承的父类protected修饰的方法(子父类访问权限特点:父类访问域大于子类),因此编译通过。


    示例四

    package P1;
    public class Test {
    	public static void main(String args[]) throws CloneNotSupportedException {
    		MyObject obj = new MyObject();
    		obj.clone(); // Compile Error      -----(1)
    	}
    }
    
    package P2;
    public class MyObject extends Test {
    	protected Object clone() throws CloneNotSupportedException {
    		return super.clone();
    	}
    }
    

        对于(1)而言,clone()方法来自于类MyObject是其特有方法,因此其可见性为包p2及其子类(此处没有子类),而类Test4却在包p1中,因此不满足可见性,编译不通过。
        若子类与基类(父类)不在同一包中,父类中不可以使用子类实例访问(父类中没有)子类中特有的(自己的)protected修饰的成员。(毕竟没有满足同一包内和继承获得protected成员的关系)


    示例五

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

        对于(1)而言,clone()方法来自于类MyObject,因此其可见性为包p1及其子类(此处没有子类),而类Test也在包p1中,因此满足可见性,编译通过。


    示例六

    package p1;
    
    class MyObject extends Test{
    }
    
    public class Test {
      public static void main(String[] args) throws CloneNotSupportedException {
        MyObject obj = new MyObject();
        obj.clone();        // Compile OK   -------(1)
      }
    }
    
    

        对于(1)而言,clone()方法来自于类Test6,因此其可见性为包p1及其子类MyObject,而类Test也在包p1中,因此满足可见性,编译通过。


    示例七

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

        对于(1)而言,首先,clone()方法所在类为Object默认根类,而Object类所在包为java.lang包。protected修饰的clone()方法其可见性是java.lang包及其所有子类,所以可以判断clone()方法所在包与子类不在同一个包中。
        其次,若子类与基类不在同一包中时,子类中不能访问基类实例(对象)(所调用)的protected方法。 MyObject子类访问权限只满足本类示例的访问。


    示例八

    package A;    
    public class Animal {    
        protected void crowl(String c){    
            System.out.println(c);    
        }    
    }
    
    
    package B;
    import A.Animal;
    class Cat extends Animal 
    {  
        
    }  
    
    public class Rat extends Animal{  
    	public void crowl(){  
                  this.crowl("zhi zhi"); //没有问题,继承了Animal中的protected方法——crowl(String)  
                  Animal ani=new Animal();
                  ani.crowl("animail jiaojiao"); //wrong, The method crowl(String) from the type Animal is not visible 
                  Cat cat=new Cat();  
                  cat.crowl("miao miao"); //wrong, The method crowl(String) from the type Animal is not visible  
        }  
    }
    
    

        首先判断其可见性,可以看出虽然不满足同一包内,但是满足子父类继承关系。
        由于子类与基类(父类)不在同一包中,所以在子类中,只有本类实例可以访问其从基类继承而来的protected方法。而在子类中不能访问基类实例(对象)(所调用)的protected方法。而在子类中也无法访问其他子类实例(即便相同父类的亲兄弟)所继承的protected修饰的方法。


    示例九

    package a;
    public class A {     
    	protected void m(){
    		System.out.println("A m~~~");
    	}
    }
    
    
    package b;
    import a.A;
    public class B extends A {
    	void callM() {
    		m();
    		super.m();
    		B b = new B();
    		b.m();
    	}
    }
    
    
    package b;
    import a.A;
    public class C extends A {
    	void callM() {
    		m();
    		super.m();
    		B b = new B();
    		b.m();     //The method m() from type A is not visible
    	}
    }
    
    

        因为b.m()这种调用属于子类对象调用,因此,当创建子类对象调用父类的protected成员变量时,必须要注意:子类对象和子类是对应的!
        由上述案例总结,由于子类与基类(父类)不在同一包中,子类只能在自己的类(域)中访问父类继承而来的protected成员,无法访问别的子类实例(即便相同父类的亲兄弟)所继承的protected修饰的方法。所以编译失败。


    三、总结

        protected是最难理解的一种Java类成员访问权限修饰词。在编程中,碰到涉及protected的调用时,首先要确定出该protected成员来自何方,其可见性范围是什么,或根据下列访问特点,便可以正确无误的使用了。

    • 基类(父类)的protected成员(包括成员变量个成员方法)对本包内可见,并且对子类可见;
    • 若子类与基类(父类)不在同一包中,那么在子类中,只有本类实例可以访问其从基类继承而来的protected方法,而在子类中不能访问基类实例(对象)(所调用)的protected方法。
    • 不论是否在一个包内,父类中可以访问子类实例(对象)继承的父类protected修饰的方法。(子父类访问权限特点:父类访问域大于子类)
    • 若子类与基类(父类)不在同一包中,子类只能在自己的类(域)中访问父类继承而来的protected成员,无法访问别的子类实例(即便相同父类的亲兄弟)所继承的protected修饰的方法。
    • 若子类与基类(父类)不在同一包中,父类中不可以使用子类实例调用(父类中没有)子类中特有的(自己的)protected修饰的成员。(毕竟没有满足同一包内和继承获得protected成员的关系)

    四、引用

    展开全文
  • Java关键字protected详解

    千次阅读 2021-03-27 20:35:34
    很多介绍Java语言的书籍(包括《Java编程思想》)都对protected介绍的比较的简单,基本都是一句话,就是:被 protected 修饰的成员对于本包和其子类可见。这种说法有点太过含糊,常常会对大家造成误解。实际上,...

    很多介绍Java语言的书籍(包括《Java编程思想》)都对protected介绍的比较的简单,基本都是一句话,就是: 被 protected 修饰的成员对于本包和其子类可见。这种说法有点太过含糊,常常会对大家造成误解。实际上,protected的可见性在于两点:

    • 基类的 protected 成员是包内可见的,并且对子类可见;
    • 若子类与基类不在同一包中,那么在子类中,子类实例可以访问其从基类继承而来的protected方法,而不能访问基类实例的protected方法。

    我们可以通过以下几个关于protected方法可见性的例子来进一步掌握protected关键字。

    在碰到涉及protected成员的调用时,

    首先要确定出该protected成员来自何方,其可见性范围是什么,

    然后就可以判断出当前用法是否可行了。


    举个栗子:


    实例 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)
        }
    }

    对于上面的示例,首先看(1)(3),其中的f()方法从类Father1继承而来,其可见性是包p1及其子类Son1和Son11,而由于调用f()方法的类Test1所在的包也是p1,因此(1)(3)处编译通过。其次看(2)(4),其中的clone()方法的可见性是java.lang包及其所有子类,对于语句"son1.clone();"和"son11.clone();",二者的clone()在类Son1、Son11中是可见的,但对Test1是不可见的,因此(2)(4)处编译不通过。


    实例 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)
        }
    }

    对于(1)而言,clone()方法来自于类MyObject2本身,因此其可见性为包p2及MyObject2的子类,虽然Test2是MyObject2的子类,但在Test2中不能访问基类MyObject2的protected方法clone(),因此编译不通过;对于(2)而言,由于在Test2中访问的是其本身实例的从基类MyObject2继承来的的clone(),因此编译通过。


    实例 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)
      }
    }

    对于(1)而言,clone()方法来自于类Test3,因此其可见性为包p33及其子类MyObject3,而(1)正是在p33的类Test3中调用,属于同一包,编译通过。


    实例 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)
      }
    }

    对于(1)而言,clone()方法来自于类MyObject4,因此其可见性为包p4及其子类(此处没有子类),而类Test4却在包p44中,因此不满足可见性,编译不通过。


    实例 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)
        }
    }

    对于(1)而言,clone()方法来自于类MyObject5,因此其可见性为包p5及其子类(此处没有子类),而类Test5也在包p5中,因此满足可见性,编译通过。


    实例 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,因此其可见性为包p6及其子类MyObject6,而类Test6也在包p6中,因此满足可见性,编译通过。


    实例 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 {
    }

    对于(1)而言,clone()方法来自于类Object,因此该clone()方法可见性为包java.lang及其子类Test7,由于类MyObject7不在此范围内,因此不满足可见性,编译不通过。

    展开全文
  • protected使用总结

    千次阅读 2021-01-18 12:41:15
    protected使用总结概述导出与导入导出引用 网上翻了一些博客, 都没有解释清楚的, 所以自己记录下, 以免再遇到同样的问题. 本文只记录方便使用, 所以一些用法就是自己口语化的解释. 概述 对于一个类,其成员(包括...

    protected使用总结


    网上翻了一些博客, 都没有解释清楚的, 所以自己记录下, 以免再遇到同样的问题. 本文只记录方便使用, 所以一些用法就是自己口语化的解释.

    概述

    对于一个类,其成员(包括成员变量和成员方法)能否被其他类所访问,取决于该成员的修饰词。在Java中,类成员的访问权限修饰词有四个:private,无(包访问权限),protected 和 public,其权限控制如下表所示:
    在这里插入图片描述

    父类的protected成员是包内可见的(同包的类中创建的对象都能用protected成员);
    若子类与父类不在同一包中,那么在子类中,可以访问子类(或孙子类)实例其从父类继承而来的protected方法,而不能访问父类实例的protected方法(或者父类其他子类的protected方法)。

    示例

    我们可以通过以下几个关于protected方法可见性的例子来进一步掌握protected关键字。在碰到涉及protected成员的调用时,首先要确定出该protected成员来自何方,其可见性范围是什么,然后就可以判断出当前用法是否可行了,看下面七个例子:

    (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)
        }
    }
    

    对于上面的示例,首先看(1)(3),其中的f()方法从类Father1继承而来,其可见性是包p1及其子类Son1和Son11,而由于调用f()方法的类Test1所在的包也是p1,因此(1)(3)处编译通过。其次看(2)(4),其中的clone()方法的可见性是java.lang包及其所有子类,对于语句“son1.clone();”和“son11.clone();”,二者的clone()在类Son1、Son11中是可见的,但对Test1是不可见的,因此(1)(3)处编译不通过。

    (2)、示例二

    //示例二
    package p2;
    class Father2{
        protected Object clone() throws CloneNotSupportedException{
           return super.clone();
        }
    }
    
    package p22;
    public class Sun2 extends Father2 {
        public static void main(String args[]) {
           Father2 f2= new Father2 ();
           f2.clone(); // Compile Error         ----(1)
    
           Sun2 s2= new Sun2 ();
           s2.clone(); // Complie OK         ----(2)
        }
    }
    

    对于(1)而言,clone()方法来自于类Father2本身,因此其可见性为包p2及Father2的子类,虽然Sun2 是Father2的子类,但在Sun2 中不能访问基类Father2的protected方法clone(),因此编译不通过;对于(2)而言,由于在Sun2 中访问的是其本身实例的从基类Father2继承来的的clone(),因此编译通过。

    (3)、示例三

    //示例三
    package p3;
    class Sun extends Father {
    }
    
    package p33;
    public class Father {
      public static void main(String args[]) {
        Sun sun3= new Sun ();
        sun3.clone();   // Compile OK     ------(1)
      }
    }
    

    对于(1)而言,clone()方法来自于类Object,clone()方法的可见性是java.lang包及其所有子类,Father 中属于Object子类,sun3是Object孙子类(Father子类)实例, 编译通过。

    (4)、示例四

    //示例四
    package p4;
    class Sun4 extends Father4 {
      protected Object clone() throws CloneNotSupportedException {
        return super.clone();
      }
    }
    
    package p44;
    public class Father4 {
      public static void main(String args[]) {
        Sun4 sun4 = new Sun4 ();
        sun4.clone(); // Compile Error      -----(1)
      }
    }
    

    对于(1)而言,clone()方法来自于类Sunt4,因此其可见性为包p4及其子类(此处没有子类),而类Father4却在包p44中,因此不满足可见性,编译不通过。

    (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)
        }
    }
    

    对于(1)而言,clone()方法来自于类MyObject5,因此其可见性为包p5及其子类(此处没有子类),而类Test5也在包p5中,因此满足可见性,编译通过。

    (6)、示例六

    //示例六
    package p6;
    
    class Sun6 extends Father6{}
    public class Father6{
      public static void main(String[] args) {
        Sun6 sun6= new Sun6 ();
        sun6.clone();        // Compile OK   -------(1)
      }
    }
    

    对于(1)而言,clone()方法来自于类Object,clone()方法的可见性是java.lang包及其所有子类,Father6 中属于Object子类,sun6是Object孙子类(Father子类)实例, 编译通过。

    (7)、示例七

    //示例七
    package p7;
    
    class Sun7 extends Father7{
        public static void main(String[] args) {
            Father7 father7= new Father7();
            father7.clone(); // Compile Error   ----- (1)
      }
    }
    
    public class Father7{
    }
    

    对于(1)而言,clone()方法来自于类Object,因此该clone()方法可见性为包java.lang及其子类Father7,由于类Sun7 不在此范围内,因此不满足可见性,编译不通过。

    总结

    1 在碰到涉及protected成员的调用时,首先要确定出该protected成员初始定义来自那个类A.
    2 若调用处与A同一个包, 则编译通过. 若调出处与A不同包, 且不在子类中, 编译失败. 若调用处与A不同包, 但在子类中, 见3.
    3 若子类B与父类A不在同一包中,那么在子类B中,
    可以访问自身实例b其从父类A继承而来的b.protected方法,
    (或B的子类C的实例c其从爷爷类A继承而来的c.protected方法)
    而不能访问父类实例的a.protected方法(或者父类其他子类的protected方法)

    示例2

    package p1;
    public class Father1 {
        protected int num = 1;
        protected void fun(){
            System.out.println("父类的fun方法执行了");
        };
    }
    
    package .p1;
    public class Test1 {
        public static void main(String[] args) {
            Sun1 sun1 = new Sun1();
            sun1.fun();
            System.out.println(sun1.num);
        }
    }
    
    package com.alimama.day11.protect.p11;
    public class Sun1 extends Father1 {
        public static void main(String[] args) {
            //不同包中子类可以访问自身实例继承来的protected方法
            Sun1 sun1 = new Sun1();
            sun1.fun();
            System.out.println(sun1.num);
    
            //不同包中子类可以访问(自身子类)父类的孙子类实例继承来的protected方法
            Grandson grandson = new Grandson();
            grandson.fun();
            System.out.println(grandson.num);
    
            //不同包中子类不可以访问(自身兄弟类)父类的其他子类实例继承的protected方法
            SunBrother sunBrother = new SunBrother();
    //        sunBrother.fun();  //访问受限
    //        System.out.println(sunBrother.num);//访问受限
    
            //不同包中子类不可以访问父类实例继承的protected方法
            Father1 father1 = new Father1();
    //        father1.fun();  //访问受限
    //        System.out.println(father1.num);  //访问受限
        }
    }
    
    package protect.p11;
    public class Test11 {
        public static void main(String[] args) {
            //不同包
            Sun1 sun1 = new Sun1();
    //        sun1.fun();   //访问受限
    //        System.out.println(sun1.num);  //访问受限
        }
    }
    
    package p12;
    //子类的兄弟类
    public class SunBrother extends Father1 {
    }
    
    package p111;
    import com.alimama.day11.protect.p11.Sun1;
    //子类的子类(父类的孙子类)
    public class Grandson extends Sun1 {
    }
    
    
    

    引用

    基本材料是来自下面这边文章, 根据自己理解对其一些地方作了修改。

    Java 访问权限控制:你真的了解 protected 关键字吗?

    展开全文
  • 初学C++的朋友经常在类中看到public,protected,private以及它们在继承中表示的一些访问范围,很容易搞糊涂。今天本文就来十分分析一下C++中public、protected及private用法。相信对于大家深入掌握C++程序设计会有...
  • 您可以将它们视为attr_protected和attr_accessible的控制器类似物。 安装 Rails的2.3.x版本 gem install param_protected -v "~> 1.0.0" Rails的3.0.x中 gem "param_protected" , "~> 2.0.0" 感谢提供了Rails 3...
  • Wi-Fi Protected Setup Specification

    热门讨论 2011-09-06 10:44:34
    Although home Wi-Fi networks have become very popular, the industry continues to be plagued by a ...remainder of this document uses the term “Wi-Fi Protected Setup” to describe the proposed solution
  • 深入理解Java中的protected权限修饰符

    千次阅读 2021-12-18 14:40:13
    而对于用protected修饰属性或方法的某个类,关系很复杂微妙,大致有以下几种情况: (1)在本包内的其它类中,可以通过父类的对象来访问protected修饰的属性或方法。 (2)在包外的子类中,不能用父类的对象来访问...
  • 关于JAVA的protected类型

    千次阅读 2021-03-08 20:59:44
    protected的属性和方法可以在本包和子类访问 非同包的子类里面,不能直接使用父类,或者其它包的子类访问例子:// Base.javapackage test.base; //创建包于文件夹下的文件夹base下public class Base{int n[]=new ...
  • 但是能直接访问父类的 protected成员和public成员(注意:是子类,而不是类实例),并且能通过父类的protected成员函数和public成员函数间接访问父类的private成员;这句话强调了类与类之间通过继承方式的访问规则
  • Exception in thread "main" redis.clients.jedis.exceptions.JedisDataException: DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no ...
  • class userVo extends model {protected $userid = array(.....);protected $username = array(.....);.........}class model{public function getVoProtectedProperties(){如何获取userVo(对象而不是类) 内的...
  • 详解Java的protected访问权限

    千次阅读 2022-02-10 17:44:22
    protected修饰静态方法和实例方法的差异
  • java中的保护(protected)修饰符的理解 protected修饰符给出的大部分定义解释都为protected修饰的属性或方法,允许同包下的类和不同包的子类访问。 但是protected修饰的属性,只可以被同包的类访问。这句话的意思...
  • 请支持原创~~ 相关博文: Android基础总结之五:BroadcastReceiver Android 中broadcast 注册过程解析 Android 中broadcast 发送过程解析 protected-broadcast 规范使用(ERROR: Sending non-protected broadcast) 先...
  • C++ protected(受保护的)详解

    千次阅读 2022-05-23 23:53:07
    实际上,类的成员还可以用 protected 访问范围说明符修饰,从而成为“保护成员”。 保护成员的可访问范围比私有成员大,比公有成员小。能访问私有成员的地方都能访问保护成员。 保护成员扩大的访问范围表现在:基类...
  • Java中protected和default的区别

    千次阅读 2021-09-20 09:49:05
    Java中权限修饰符:protected和default的区别 学习总结: 修饰符 本类 同一包的类 继承类 非继承类 public √\surd√ √\surd√ √\surd√ √\surd√ protected √\surd√ √\surd√ √\surd√ X\ChiX ...
  • 但是, 又不想被外部访问那么就可以把这些成员, 定义为 protected访问权限!!! 访问权限总结: 1.public 外部(指对象)可以直接访问. 可以通过对象来访问这个成员 Fahter wjl(“王健林”, 65); wjl.getName(); 2....
  • protected mode is enabled, no bind address was specified, no authentication password is requested to clients. In this mode connections are only accepted from the loopback interface . If you ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,907,183
精华内容 762,873
关键字:

PROTECTED