Confused on protected modifier

[Adil El mouden]

Hi,

I tried to run this code:

 
 class Super
 
{
 
      protected int i = 5;
 
      public int getI() { return i; }
 
}
 

 
public class Sub
 
{
 
   public void setI(Super x)
 
   {
 
      x.i = x.i*2;
 
   }
 
   public static void main(String[] args)
 
   {
 
      Super a = new Super();
 
      Sub b = new Sub();
 
      b.setI(a);
 
      System.out.println( a.getI() );
 
   }
 
}
 

The result is 10, but when i tried to put the classes in different packages and make sub extends super, the result was compile error.

The question is: what is the difference between protected and public access modifier in the code above. and why there is a compile error in the 2nd try(different package).

default == access(package);
protected == access(package + child);
public == access(everywhere!);

Thank you

[Steve Morrow]

https://coderanch.com/t/250314/java-programmer-SCJP/certification/protected-not-accessed-derived

Protected access can be tricky. You can only access protected members from within the context of the inherited class. For instance, you can access B's 'i' variable (inherited from A), but not A's through an A reference, since B is in a separate package.

From the JLS:

�6.6.2 Details on protected Access
A protected member or constructor of an object may be accessed from outside the package in which it is declared only by code that is responsible for the implementation of that object.

Hope this helps!

[Adil El mouden]

need more explanation. :roll:
Thank you

[Adil El mouden]

Need more explanation :roll:
Thank you.

[Steve Morrow]

Need more explanation

Try experimenting with this. Write some practice code. Test it out.

The setI() method is not responsible for the implementation of the Super type. It operates on an outside super reference. Because Sub is not in the same package (and because setI() has nothing to do with the implementation of Super), it cannot modify the protected members of Super.

Hope this helps.

[Ryan Kade]

Adil,

Look at it this way. The protected member variable i is functions just like a public variable while you are in the same package. You can access it anywhere, anytime.

But once you move it outside the package, that's where the protected part kicks in. It functions like a private variable in every instance except when it is being accessed via inheritance (ie, if the sub-class is an implementation of the parent with the protected variable).

For example:

class Parent {
protected int x=10;
}
 
public class Child extends Parent {
protected int x=10;
 
public static void main(String[] args) {
Parent p = new Parent();
Child c = new Child();
System.out.println(p.x);
System.out.println(c.x);
}
}

This prints:

10
10

This is because Child is in the same package as Parent, and therefore has free access to Parent's x variable, as though it were public.

But if you move Parent to its own package:

package parent;
 
public class Parent {
protected int x=10;
}

package child;
 
import parent.Parent;
 
public class Child extends Parent {
protected int x=10;
 
public static void main(String[] args) {
Parent p = new Parent();
Child c = new Child();
System.out.println(p.x);
System.out.println(c.x);
}
}

Now you will get an compiler error on "System.out.println(p.x)" that says "The field Parent.x is not visible" just as though it were a private variable. However the second println statement functions fine because Parent.x is being accessed via the child class. This is what distinguishes x from being a private variable.

Hope that clears things up!

[Adil El mouden]

Thank you for the help.