Thread: Protected members

@Alaa that is not the correct solution to this problem. un-qualifying the object operation on results in this.show() being executed. It does not execute show() for the object ob. Use of the dot operator is perfectly compatible with inheritance and polymorphism. It is the protected access rules which are causing the compiler error.

Ex.:

package p;
 
public class A
{
    protected void show()
    {
        System.out.println("A.show");
    }
}

// B is not in package p
public class B extends p.A
{
    protected void show()
    {
        System.out.println("B.show");
    }
 
    void doit()
    {
        A a = new A();
        show(); // doesn't call A.show(), this will call this.show(). The wrong message is displayed
    }
 
    public static void main(String[] args)
    {
        A a1 = new A();
        a1.show(); // compiler error, explained below
        A a2 = new B();
        a2.show(); // compiler error, same reason as a1
        B b = new B();
        b.show(); // compiles fine, explained below
    }
}

The reason it fails is described in Section 6.6.2.1 of the Java Language Specifications.

{my note: assume S is not in the same package as C. Otherwise these rules don't apply}

Let C be the class in which a protected member is declared. Access is permitted only within the body of a subclass S of C.

In addition, if Id denotes an instance field or instance method, then:

If the access is by a qualified name Q.Id, where Q is an ExpressionName, then the access is permitted if and only if the type of the expression Q is S or a subclass of S.

If the access is by a field access expression E.Id, where E is a Primary expression, or by a method invocation expression E.Id(. . .), where E is a Primary expression, then the access is permitted if and only if the type of E is S or a subclass of S.

These rules specify that in class B, it can only access protected members of A if the expression has a type B or a subclass of B.

In your code, the type of ob is not a B, it is type A. Thus it is not allowed to access the protected member A.show(). However, if the type is B or a subclass of B, then it is allowed access. ob1 is type B, thus this compiles just fine.

Additionally, calling this.show() (or the short version show()) will compile fine because this is of type B.

@syedbhai

That is perfectly legal because it invokes the super method show with type B (this is of type B). However, the object called with is still this, not a newly created ob object.

There is no way to access/expose a protected member in a super class C from a sub-class S (assuming S is not in the same package as C) unless the object we're operating on is guaranteed to be an S or a subclass of S.

The best solution is to take advantage of the package rule for protected access and move the class B into the same package as A, or give more details on what the OP wants to do. There might be some intrinsic interface design issues which could be solved differently and avoid the problem to begin with.

@divcret protected is a superset of default. Access is allowed from subclasses even if they aren't in the same package. There's just a caveat as I noted above that you have to operate on the subclass (or a child of the subclass), not the base class.