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.
This is just not how inheritance works in Java.

If a method is overridden, and the overridden method is not visible, it's a compile-time error to try and call it.

You seem to expect that Java would automatically fall back to the method in the super class, but that does not happen.

*I'll try and dig out the JLS later on why this is not done...*