Why doesn't polymorphism determine the output in this case?

[Harry Henriques]

Why doesn't a polymorphic call to doThis() get past the compiler in this instance? Compiler output is in RED below. Does this mean that it isn't possible to override a protected superclass method when the overriding method is in another package?

// class A in package A

package pkga;
public class clasA{
     protected void doThis(){System.out.println("Superclass Method");}
}

// class B in package B

package pkgb;
import pkga.clasA;
public class clasB extends clasA{
        public void doThis(System.out.println("Subclass Method");}
        public static void main(String args[]){
                clasA ca = new clasB();
                ca.doThis();
        }
}

C:\Documents and Settings\Harry Henriques>javac -cp . pkgb/clasB.java
pkgb\clasB.java:9: doThis() has protected access in pkga.clasA
ca.doThis();
^
1 error

[Henry Wong]

Harry Henriques wrote:Does this mean that it isn't possible to override a protected superclass method when the overriding method is in another package?

Of course, it is possible to override protected methods. The methods of the subclass can access it protected superclass, via a call with the super.doThis() construct.

But... that is not what your example is doing. You example is merely dereferencing a instance, to call a method. This is no different than dereferencing any other instance to call a method. And in this case, to call a protected method, your class must be in the same package, and if it is not...

Java Language Specification wrote: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.

As far as the compiler is concern, your clasB is trying to directly access a clasA instance, which doesn't meet this requirement (it is an instance that it is "responsible for the implementation of that object", but the compiler doesn't know that).

Henry

[Harry Henriques]

Henry,

I'm not sure I understand you. Please let me make the following observations: (1) clasA has a method with the following signature protected void doThis() (2) clasB has a method with the following signature public void doThis() (3) The access modifier on the overriding subclass method is less restrictive. (4) clasB extends clasA (5) if clasB and clasA were in the same package, then the output of this code would be Subclass Method.

Instead, I get a compiler error when compiling this code.

Henry Wong wrote:Of course, it is possible to override protected methods. The methods of the subclass can access it protected superclass, via a call with the super.doThis() construct.

Accessing the doThis() method in the superclass from the subclass using super.doThis() is not using the overriding mechanism. It is strictly using Inheritance, not Polymorphism.

Java Language Specification wrote:
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.

I guess this answers the question. Polymorphism isn't effectual across disparate packages (even in the case of two classes that have an Inheritance relationship).

Do you agree, Henry?

-Harry

[a alph]

Hi

I understand that the protected members can be accessed only through inheritance.

Can you please explain to me how to access the protected method by using super.doThis() ?
When I insert the super.doThis() in the following code, it says "non static variabe super cannot be referenced from a static context".

// class A in package A   
  
package pkga;   
public class clasA{   
     protected void doThis()  {System.out.println("Superclass Method");}   
}  

// class B in package B   
  
package pkgb;   
import pkga.clasA;   
public class clasB extends clasA{   
        public void doThis()   { System.out.println("Subclass Method"); } 
  
        public static void main(String args[]){   
                 
                super.doThis();   
        }   
}  

Maybe I inserted in the wrong line??

Thanks.

[Alex Serna]

If you invoke

 super.doThis()   

from main you are saying doThis() is static which it isn't. You can't invoke ClassA's doThis() by reference outside ClassA. You can inherit it in classB and you can use it within ClassB's instance methods. But if you override it and mark it ass public you can use it again from anywhere you want.

[Valentin Ivanov]

Hi a alph,
did you try to invoke super.doThis() from an instance method and not from main? After all the method is protected and not static protected.

[S Ali]

If a method is overridden but you use a polymorphic (supertype)
reference to refer to the subtype object with the overriding method, the compiler
assumes you’re calling the supertype version of the method. (from K & B)

in this case the superclass method was declared protected which means that it can't be accessed through a reference variable even if you override it with public access the compiler still sees the method interface of the reference variable type. Hope that answers it.

[a alph]

Valentin Ivanov wrote:
did you try to invoke super.doThis() from an instance method and not from main? After all the method is protected and not static protected.

I tried the following code. But it doesn't print anything. It compiles fine.

// class B in package B      
     
package pkgb;      
import pkga.clasA;      

public class clasB extends clasA{      
        public void doThis()   { System.out.println("Subclass Method"); }    
     
        public static void main(String args[]){      
                    
                     
        }      
    

public void anotherMethod() {
            super.doThis();
        }

 }

Can you please explain why it doesn't print anything??

Thanks..

[Henry Wong]

a alph wrote:
Can you please explain why it doesn't print anything??

Well, here is your main() method. Can you tell us what it does?

public static void main(String args[]){      

                 
}    

Henry

[a alph]

I think, without the main() method, the class can't be run.

And I managed to find the point. I don't know how I missed it.

// class B in package B         
        
package pkgb;         
import pkga.clasA;         
  
public class clasB extends clasA{         
        public void doThis()   { System.out.println("Subclass Method"); }       
        
        public static void main(String args[]){         
                       clasB cb = new clasB();

                       cb.anotherMethod();
                        
        }         
       
  
public void anotherMethod() {   
            super.doThis();   
        }   
  
 }  

Thanks guys.

[Harry Henriques]

K&B wrote: If a method is overridden but you use a polymorphic (supertype)
reference to refer to the subtype object with the overriding method, the compiler
assumes you’re calling the supertype version of the method.

S Ali wrote:
in this case the superclass method was declared protected which means that it can't be accessed through a reference variable even if you override it with public access the compiler still sees the method interface of the reference variable type. Hope that answers it.

The output of the code below is at the end of this post in RED.

In this case, the protected superclass method is referenced by a superclass reference (this is what the compiler sees), but the method with public access in the subclass is invoked polymorphically at runtime. The subclass method with public access overrides the protected superclass method (polymorphically). Both the superclass and the subclass are in the same package (in the same file). This doesn't happen when the protected superclass method is in one package and the public subclass method is in another package. In fact, a compiler error message is generated. Overriding a method is a Polymorphic concept, not an Inheritance concept. Without polymorphism, the concept of overriding a method doesn't make sense.

class clasA{
     protected void doThis(){System.out.println("Superclass Method");}
}

public class clasB extends clasA{
        public void doThis(){System.out.println("Subclass Method");}
        public static void main(String args[]){
                clasA ca = new clasB();
                ca.doThis();
        }
}

C:\Documents and Settings\Harry Henriques\pkgb>java clasB
Subclass Method

[Harry Henriques]

a alph wrote:
Hi

I understand that the protected members can be accessed only through inheritance.

Can you please explain to me how to access the protected method by using super.doThis() ?
When I insert the super.doThis() in the following code, it says "non static variabe super cannot be referenced from a static context".

This is an example of what Henry Wong was talking about. -Harry

// class A in package A   
  
package pkga;   
public class clasA{   
     protected void doThis()  {System.out.println("Superclass Method");}   
}  

// class B in package B   
  
package pkgb;   
import pkga.clasA;   
public class clasB extends clasA{   
        public void doThis()   { super.doThis(); System.out.println("Subclass Method"); } 
  
        public static void main(String args[]){   
                 new clasB().doThis();   
        }   
}  

C:\Documents and Settings\Harry Henriques>javac -cp . pkgb/clasB.java

C:\Documents and Settings\Harry Henriques>java -cp . pkgb/clasB
Superclass Method
Subclass Method

[S Ali]

The output of the code below is at the end of this post in RED.

In this case, the protected superclass method is referenced by a superclass reference (this is what the compiler sees), but the method with public access in the subclass is invoked polymorphically at runtime. The subclass method with public access overrides the protected superclass method (polymorphically). Both the superclass and the subclass are in the same package (in the same file). This doesn't happen when the protected superclass method is in one package and the public subclass method is in another package. In fact, a compiler error message is generated. Overriding a method is a Polymorphic concept, not an Inheritance concept. Without polymorphism, the concept of overriding a method doesn't make sense.

The subclass method with public access does override the superclass's method at runtime.But only the implementation is overriden ,the method declaration is still seen of the type of the reference variable. Your example worked because protected access inside the same package is just like default, it can be accessed through a reference.

Another example to demonstrate the concept from K&B page 108: If the supertype version
declares a checked exception, but the overriding subtype method does not, the compiler
still thinks you are calling a method that declares an exception and you are required to handle it.

[Harry Henriques]

S Ali wrote:
The subclass method with public access does override the superclass's method at runtime.But only the implementation is overriden ,the method declaration is still seen of the type of the reference variable. Your example worked because protected access inside the same package is just like default, it can be accessed through a reference.

Another example to demonstrate the concept from K&B page 108: If the supertype version
declares a checked exception, but the overriding subtype method does not, the compiler
still thinks you are calling a method that declares an exception and you are required to handle it.

I don't believe that you are correct. If the subclass method overrides the superclass method, then I wouldn't get a compiler error in my original code (in the original post at the top of this thread). When the superclass method and subclass method are in different packages (directories), the subclass method doesn't override the superclass method. The subclass inherits from the superclass, and that's it.

In my original post, the subclass method implements a less restrictive access than the superclass method (the compiler should be satisfied). In my original post, I implement a correct polymorphic invocation of the doThis() method in the subclass using a superclass reference, but the compiler declares that there is a compiler error. It has nothing to do with the access modifers; the access modifiers are irrelevant although they are appropriate.

I understand your reference to page 108 in K&B. I don't think that it applies to this case. Maybe you should try implementing your suggestion in two separate directories, and see what happens?

-Harry

[Henry Wong]

Harry Henriques wrote:I don't believe that you are correct. If the subclass method overrides the superclass method, then I wouldn't get a compiler error in my original code (in the original post at the top of this thread). When the superclass method and subclass method are in different packages (directories), the subclass method doesn't override the superclass method. The subclass inherits from the superclass, and that's it.

I think you are making incorrect conclusions here. Yes, the compiler is complaining about access rights, but that doesn't mean that the method hasn't been overridden. Or that polymorphism is broken.

For example, if you move the main method to another class. A class that has access rights to the method, say a class in the same package as clasA, then the compiler will allow the call -- and you will see that it is the subclass (clasB) method that is called.

Henry

[Harry Henriques]

This works, but I'm not sure that I understand just why it works. Can you explain it further, Henry?

Thanks,
Harry

// class A in package A

package pkga;
import pkgb.clasB;

public class clasA{
    protected void doThis(){System.out.println("Superclass Method");}
    public static void main(String args[]){
        clasA ca = new clasB();
        ca.doThis();
    }
}

package pkgb;
import pkga.clasA;

public class clasB extends clasA{
        public void doThis(){super.doThis();
                                      System.out.println("Subclass Method");}
}

C:\Documents and Settings\Harry Henriques>javac -cp . pkga/clasA.java

C:\Documents and Settings\Harry Henriques>java -cp . pkga/clasA
Superclass Method
Subclass Method

[Salil Vverma]

Hey Harry,
I believe, you are clear why it is compiling fine.
Now about the explanation of output. The execution starts in the main method so I will focus on the code inside main.\

     clasA ca = new clasB();  
   ca.doThis();    

In the first line, it creates an object of clasB and assigns its reference to ca.
Now about the second line. It calls ca.doThis(). As we know that clasB overrides doThis() method of clasA, ca.doThis() would call the doThis() function of clasB object.

Now inside doThis() function of clasB object. it make a call of super.doThis();. super.doThis(); calls the doThis() function of super class ie doThis(). As we can see doThis() function of classA prints "Superclass Method" so it prints this as a fist line.

And I guess the explanation of second line is pretty clear.

[Harry Henriques]

Let me be clear. In the code from the original post at the top of this thread, the compilation failed. In my last post at the bottom of the thread, the compilation didn't fail. The code is my previous post compiled and ran correctly. Why does the overriding mechanism work correctly in the previous code post, but it doesn't work at all in the original post at the top of the thread? Why does compiliation fail in the original post at the top of the thread? Why does compilation pass without error in the previous code post?

[Henry Wong]

Harry Henriques wrote:This works, but I'm not sure that I understand just why it works. Can you explain it further, Henry?

Basically, this case works because you are permitted access. This issue has NOTHING to do with polymorphism, inheritance, etc. etc. The first case doesn't compile because you tried to access a method that you wasn't allowed to access.

You would have gotten the same compile error, if clasB did not subclass from clasA, and you tried to access a protected method of clasA from clasB.

It actually got a bit more complex because clasB did inherit from clasA, but all that seemed to do is confuse the matter. And lead you to somehow conclude that it is polymorphism that is broken, instead of the compiler correctly preventing you from accessing something that you don't have the rights to.

Henry

[Harry Henriques]

Thanks, Henry. I understand now. The example below is strictly Inheritance where clasB has access rights to the doThis() method in the superclass. -Harry

// clasA in package pkga

package pkga;
import pkgb.clasB;

public class clasA{
    protected void doThis(){System.out.println("Superclass Method");}
}

// clasB in package pkgb

package pkgb;
import pkga.clasA;

public class clasB extends clasA{
        public static void main(String [] args) {
                clasB cb = new clasB();
                cb.doThis();
        }
}

C:\Documents and Settings\Harry Henriques>javac -cp . pkgb/clasB.java

C:\Documents and Settings\Harry Henriques>java -cp . pkgb/clasB
Superclass Method

[Salil Vverma]

Hi Harry,

The reason behind first code giving the compilation error and second code compiling fine is that compiler checks the accessability of specific method on the basis of reference variable type and the methods

In the second code protected method is in the same class so it the compiler knows that this method is in the same class so can be accessed and does not give the compilation error.

[Harry Henriques]

K&B SCJP 5 Study Guide pg. 34 wrote:
So if the subclass-outside-the-package gets a reference to the superclass (by, for example, creating an instance of the superclass somewhere in the subclass' code), the subclass cannot use the dot operator on the superclass reference to access the protected member. To a subclass-outside-the-package, a protected member might as well be default (or even private), when the subclass is using a reference to the superclass. The subclass can see the protected member only through inheritance.

[Nitish Bangera]

May be this is a bit later..... but i kind of like to add some thing... 2 things we need to know.

1- When does the polymorphic method gets called?
2- When was the error displayed for the code(compile time or runtime)?

[Salil Vverma]

- When does the polymorphic method gets called?

Methods are used in a polymorphic way without using x.getx() way. if any function is called in x.functionname() format that is non polymorphic way.

When was the error displayed for the code(compile time or runtime)?

It was compilation error

[Nitish Bangera]

Well i don't think the first answer is appropriate but well i think the concept is pretty much clear..... the function has many forms and.