Question: Test.java

```
package a;
import b.B;
public class Test {
    public static void main(String[] v) {
        new A().test();
        new B().test();
    }
}

```

A.java:

```
package a;
public class A {
    protected void test() { }
}

```

B.java:

```
package b;
public class B extends a.A {
    protected void test() { }
}

```

Why does `new B().test()` give an error? Doesn't that break visibility rules?

`B.test()` is invisible in `Test` because they're in different packages, and yet it refuses to call the `test()` in `B`'s superclass which is visible.

Links to the appropriate part of the JLS would be appreciated.

Answer: 
Here you go JLS on `protected` keyword:
[JLS protected description](http://java.sun.com/docs/books/jls/third_edition/html/names.html#6.6.2) and [JLS protected example](http://java.sun.com/docs/books/jls/third_edition/html/names.html#6.6.2).

Basically a `protected` modifier means that you can access field / method / ... 1) in a subclass of given class *and* 2) from the classes in the same package. 

Because of 2) `new A().test()` works. But `new B().test()` doesn't work, because class `B` is in different package.
The problem is that at compile time you are telling Java that you want to access a protected member of a class when you do not have such access.

If you did this instead;

```
  A a = new B();
  a.test();

```

Then it would work and the overridden method will run because at compile time Java checks that you have access to A. At run time the object provided has the appropriate method so the B test() method executes. Dynamic binding or late binding is the key.