super class reference variable accesses overriding sub class method

[subith86]

My Super class is shown below

class Super {
	Super () {
		this.superMethod();
	}
	void superMethod() {
		System.out.print(new Integer(8));
	}
	void anotherSuperMethod() {
		System.out.print(new Integer(7));
	}
}

My SubClass extends the above Super class and it is shown below

class SubClass extends Super {
	SubClass () {
		this.superMethod();
	}
	void superMethod() { [I][COLOR="Green"]//overriding[/COLOR][/I]
		System.out.print(new Integer(1));
	}
	void anotherSubMethod() {
		System.out.print(new Integer(9));
	}
}

My main method is shown below

	public static void main(String[] args) {

		SubClass obj1 = new SubClass();
		obj1.superMethod(); //as expected : calls superMethod in SubClass

		Super obj2 = new Super();
		obj2.superMethod(); //as expected : calls superMethod in Super

		obj2 = obj1; //I think it is similar to Super obj2 = new SubClass();
		System.out.println("**************");

		obj2.superMethod(); //calls superMethod in SubClass. Why?

		obj2.anotherSuperMethod(); //as expected : calls anotherSuperMethod in Super

		obj2.anotherSubMethod(); //compiler error
	}

As said in the comments obj2.superMethod() goes to the method in SubClass and not Super class.
If it can do it, why cant it access another "ordinary" method in SubClass (obj2.anotherSubMethod())

[KevinWorkman]

Because the compiler doesn't "know" that obj2 is a SubClass. The reason it calls SubClass's overridden superMethod is that the compiler doesn't have to "know" which version of the method is being called, as long as it's guaranteed to be there.

You could tell the compiler about it via casting:

((SubClass)obj2).anotherSubMethod();

[Fubarable]

You can, but you have to cast it since the variable is a Super variable, and that's all the compiler knows.

((SubClass)obj2).anotherSubMethod();

edit: as Kevin well states above! :)

[subith86]

I understood the below quote

Because the compiler doesn't "know" that obj2 is a SubClass

This is the reason why compiler error occurs when obj2 is trying to access anotherSubMethod()

But, sorry to trouble you guys again, could someone please elaborate

compiler doesn't have to "know" which version of the method is being called

why can't it go to superMethod() in Super class:confused:

[Fubarable]

But, sorry to trouble you guys again, could someone please elaborate
why can't it go to superMethod() in Super class:confused:

This is one of the cornerstones of object oriented programming, method overriding, polymorphism, or calling virtual methods, and any basic text or tutorial (or likely Kevins' answer) will likely explain it better than I can. For details, please see the Wikipedia article on virtual methods. This is one reason why I believe it is considered possibly dangerous to call over-ridable methods in an object's constructor -- unless you really know what you're doing and how this can effect behavior.

[KevinWorkman]

Think about it this way: say you have an Animal class, and a default eat() function:

public class Animal{
   public void eat(){
      System.out.println("An animal is eating.");
   }
}

But then you want more specific versions of Animals, so you extend Animal:

public class Cat extends Animal{
   public void eat(){
      System.out.println("A cat is eating. Meow!");
   }
}
public class Mouse extends Animal{
   public void eat(){
      System.out.println("A mouse is eating. Squeak!");
   }
}

Then somewhere else, you have a List populated with instances of Animal:

List<Animal> animals = new ArrayList<Animal>();
animals.add(new Animal());
animals.add(new Cat());
animals.add(new Mouse());

And you want to make all of the Animals eat:

for(Animal a : animals){
   a.eat();
}

The beauty is that you don't have to know ahead of time what kind of Animal each instance is going to be. Each one will call the correct eat method: the "lowest" version of the overriden method. Try throwing together a similar example and see what happens.