Unexpected access to protected member

[Richard Hayward]

Could anybody enlighten me as to how this is possible? I was making sure I understood the material from k&b p25, hence my package names.

package p025.pkg;

public class Animal {
  protected void hello(){
    System.out.println("Hello from Animal");
  }
}

package p025;

import p025.pkg.Animal;

class Horse extends Animal {
  void doStuff(){
    hello();                // Calls inherited protected method
    (new Horse()).hello();  // But, I was expecting a compile failure here
  }
}

public class MyTest {
  public static void main(String[] args){
    (new Horse()).doStuff();
  }
}

As it's in a different package, I was expecting Horse to be able to access Animal.hello() only via inheritance. However, at line 08, Horse code makes a new Horse instance and accesses hello() via the dot operator. To my surprise, the code compiles & runs without error.

[Jeanne Boyarsky]

The code in question is:

class Horse extends Animal {  
  void doStuff(){  
    hello();                // Calls inherited protected method  
    (new Horse()).hello();  // But, I was expecting a compile failure here  
  }  
}  

I took it out of the package, because that shouldn't matter here. You are making the call from a subclass of Animal. (Horse). Since it is being called from in a subclass, it can access protected methods. If that line of code were in MyTest, it would fail because then it wouldn't be in a subclass (or the same package.)

[Richard Hayward]

Jeanne Boyarsky wrote:
You are making the call from a subclass of Animal. (Horse). Since it is being called from in a subclass, it can access protected methods.

Well, here's code from k&b p35. It looks to me like it's doing the exact same thing. Code in a child instance attempts to invoke a protected method on an instance of the parent class, by using the dot operator.

package p035.certification;

public class Parent {
  protected int x=9;
}

package p035.other;

import p035.certification.Parent;

public class Child extends Parent {
  public void testIt(){
    System.out.println("x is " + x);               //compiles ok
    Parent p = new Parent();
    System.out.println("x in Parent is " + p.x);   //compile failure, x is protected in Parent
  }
}

This time, it behaves as I was expecting. The compiler gives an error:

p035\other\Child.java:9: error: x has protected access in Parent
System.out.println("x in Parent is " + p.x); //compile failure, x is protected in Parent
^
1 error


How is the situation different?

[Jeanne Boyarsky]

Let's expand the Horse/Animal one a tiny bit.

	class Horse extends Animal {  
		  void doStuff(){  
		    Horse h = new Horse();
		    h.hello();
		    Animal a = new Horse();
		    a.hello();    // DOES NOT COMPILE
		    
		  }  
		}

h.hello() is ok because it is a method on the current class. a.hello() is not because it is in the same package. Granted, we know they are the exact same class. But from the compiler's point of view, the type in the declaration is all that matters.

[Henry Wong]

Jeanne Boyarsky wrote:Let's expand the Horse/Animal one a tiny bit.

h.hello() is ok because it is a method on the current class. a.hello() is not because it is in the same package. Granted, we know they are the exact same class. But from the compiler's point of view, the type in the declaration is all that matters.

Perhaps we should expand the example a bit more.

First, as already mentioned, the access modifiers apply at a class level. This means that if something is private or protected, it is private or protected to the class. This means that code in a class can access protected members of other instances (and not just the this instance).

Second, there is another rule that applies to the protected modifier. For code in a class to access a protected member that is inherited from the super class, the code must be accessing an instance that it is responsible for. This means that for the Horse class to access a protected member of the Animal class, the instance used must be a Horse class (or an instance that IS-A Horse class).

Henry

[Paul Anilprem]

Henry Wong wrote:
Second, there is another rule that applies to the protected modifier. For code in a class to access a protected member that is inherited from the super class, the code must be accessing an instance that it is responsible for. This means that for the Horse class to access a protected member of the Animal class, the instance used must be a Horse class (or an instance that IS-A Horse class).

I think you mean the "reference used" and not "instance used". For example,

package p1;
public class Animal {
 protected String name;
}

package p2;
import p1.Animal;
public class Horse extends Animal{
    public Horse(){
        System.out.println(super.name); //works
        System.out.println(name);//works
        Animal a = this;
        System.out.println(a.name); //DOES NOT WORK because the declared class of the reference a is Animal even though the instance pointed to by a is Horse 
    }
    public static void main(String[] args) {
        Animal a = new Horse(); 
        System.out.println(a.name); //DOES NOT WORK because the declared class of the reference of a is Animal
        Horse h = (Horse)a; 
        System.out.println(h.name);//works
        RaceHorse rh = new RaceHorse();
        System.out.println(rh.name); //works
    }
}

package p2;
public class RaceHorse extends Horse{

}

This makes sense because access checking is done at compile time. So the class of the instance shouldn't matter.
HTH,
Paul.

[Henry Wong]

Paul Anilprem wrote:

Henry Wong wrote:
Second, there is another rule that applies to the protected modifier. For code in a class to access a protected member that is inherited from the super class, the code must be accessing an instance that it is responsible for. This means that for the Horse class to access a protected member of the Animal class, the instance used must be a Horse class (or an instance that IS-A Horse class).

I think you mean the "reference used" and not "instance used". For example,

Sorry. Of course, I mean that. We are talking compile time here.

BTW, for full details in the specification regarding protected access, see section 6.6.2:

http://docs.oracle.com/javase/specs/jls/se8/html/jls-6.html#jls-6.6.2

Henry

[Richard Hayward]

Jeanne, Henry & Paul, thank you all!

Your help & example code has helped me clarify my thinking in this area, where it seems to me, there are a few subtleties.

I'd not realized for example, that as Henry pointed out, private applies to classes, not instances. Makes code like this possible.

public class HasPrivate {
  private int myInt = 100;
  void display() {
    System.out.println(myInt);
  }

  void incAnother(HasPrivate hp){
    hp.myInt++;
  }
}

public class TestHasPrivate {
  public static void main(String[] args){
    HasPrivate hp1 = new HasPrivate();
    HasPrivate hp2 = new HasPrivate();
    hp1.display();
    hp2.incAnother(hp1);
    hp1.display();
  }
}

Richard