Can't access methods in sub class when using the super as the reference type

Question

I have a problem where I have some class say

 public class Foo {

   public Foo() {
    // Do stuff
   }

   public void generalMethod() {
      //to general stuff
   }

 }

 public class Bar extends Foo {

     public Bar() {
        //do stuff
     }

     public void uniqueMethod() {
        //do stuff
     }
 }


 public class Driver() {
    public static void main(String[] args) {
       Foo test = new Bar();

       test.uniqueMethod(); //this causes an error
    }
 }

So i get an error which says, that the method uniqueMethod() is undefined for Foo, but when I change the assignment to Bar test = new Bar(); the problem goes away. I dont understand as it should work with Foo test = new Bar();

Can someone suggest a reason for which why this error occurs?

Thank you in advance.

Why should it work with `Foo`? There is no such method in that class. — Tom, Jan 24 '17 at 21:24
Because since Foo is a parent class should the JVM not look at the sub classes for the uniqueMethod() since it is not in the parent class (Foo) — User59, Jan 24 '17 at 21:25
JVM doesn't matter here. The compiler is at work and he only looks at the defined variable type. Polymorphy (what you mean here) happens during _runtime_, not _compile time_. — Tom, Jan 24 '17 at 21:26
It works with the declared type, meaning the type you define right before the variable name, not the type which will be assigned to it at runtime. — Dimitre Bogdanov, Jan 24 '17 at 21:29

score 2 · Accepted Answer · edited May 23 '17 at 12:24

Although the method is there at runtime, the compiler only sees that the object test of type Foo DOES NOT have the method uniqueMethod. Java works with virtual method, where the method that will be invoked is determined at runtime. So, again, the compiler does not see that this specific instance's type is a Bar. If you really need to invoke that method, you could a cast and invoke the method:

((Bar)test).uniqueMethod();

Now, to the compiler, you have the type Bar, and he can see all the methods that are available at Bar type

Think like the compiler and JVM

Example 1

Foo test = new Bar();

So, I have one variable that is of type Foo. I MUST validate that all subsequent calls to members of this class are OK - It will look for all members in Foo class, the compiler doesnt even look for the instance type.

In runtime, the JVM will know that we have a variable of type Foo, but with instance type Bar. The only difference here is that it, JVM, will look to the instance to make the virtual calls to the methods.

Example 2

Bar test = new Bar();

So, I have one variable that is of type Bar. I MUST validate that all subsequent calls to members of this class are OK - It will look for all members in Foo and 'Bar' classes, the compiler, again, doesnt even look for the instance type.

In runtime, the JVM will know that we have a variable of type Bar, and an instance of the same type:Foo. Now we again, have access to all the members defined in Foo and Bar classes.

thank you for sharing the syntax of `((Bar)test).uniqueMethod();`. I've known about being able to treat an object as it's subclass by casting it to a new variable with the declared subtype like `Bar actualBar = (Bar) test;`, because `(Bar) test.uniqueMethod()` wouldn't work. Who knew how useful an extra set of parentheses could be :) — secondbreakfast, Jan 26 '17 at 13:55

score 2 · Answer 2 · answered Jan 25 '17 at 07:23

useing late binding you must have the same method in the super class "Fathor" , or it will not work !

this work with me

//

public  class foo {
public void print(){
System.out.println("Super,"+2);}

}

class bo extends foo {

    public void print(){
        System.out.println("Sup,"+9);
        }

}

Test //

public abstract class test {

public static void main(String[] args) {
    // TODO Auto-generated method stub

     foo t = new bo();
     t.print();
}

} ///

output

Sup,9

score 1 · Answer 3 · answered Jan 24 '17 at 21:52

This error occurs because the compiler does not know that test is of type Bar, it only knows the declared type of Foo.

public void test(Foo foo) {
        // error! this method can accept any variable of type foo, now imagine if you passed it 
        // another class that extends Foo but didnt have the uniqueMethod. This just wont work
        foo.uniqueMethod(); 
    }

Can't access methods in sub class when using the super as the reference type

3 Answers3

Think like the compiler and JVM

Example 1

Example 2