Polymorphism and Instance Variables?

[Gary Marshall]

Hello all:

Check out this code:

    
class A {
	int x = 5;
	public void prtMessage() {
		System.out.println("message from class A "); 
	}
}
class B extends A {
	int x = 6;
	public void prtMessage() {
		System.out.println("message from class B "); 
	}
}

public class covariantTest1{
	
	public A getObject() {
		return new A();
	}

	public static void main (String [] args) {
		covariantTest1 c1 = new SubCovariantTest();  // Line 1
		System.out.println(c1.getObject().x);     // Line X >> prints "in B object method" (ok) followed by "5" on the next line (??)
		
		A myA = new B();          // Line 2
		System.out.println(myA.x);      // Line Y  >>  prints "5" (??)
		myA.prtMessage();           // Lin Z prints >>  "message from class B"
		
	}
}

class SubCovariantTest extends covariantTest1{
	
	public B getObject()
	{
		System.out.println("in B object method");
		return new B();
		}
	}

OK. I understand polymorphism is in effect here when Line 1 executes, resulting in the Sub... class executing and displaying the messge "in B object method" that we see on Line X. I suppose I am expecting poly to also apply to the instance variables and so I thought "6" would display via line X.

Does poly not apply to instance variables in obcets? Or is it simply that the JVM uses the reference variable type (on the left of the assignment operator (Line 2)) in deciding what I want to print?

Thanks to all for your imput
Gary

[Abimaran Kugathasan]

Java uses reference type to invoke the variable, and actual objects to invoke methods. UseRealWords here!

[Shanky Sohar]

Remember polymorphism doesnot apply to:
1.static methods
2.private methods.
3.variables.
4.overloaded methods.
5Generics(you will study later when you study collections)

[Wouter Oet]

Why would polymorphism not apply to overloaded methods and generics??

Overloaded methods in combination with polymorphism:

public class Foo {
	public void test(Object o) { System.out.println("Object"); }
	public void test(Integer o) { System.out.println("Integer"); }
	
	public static void main(String... args) {
		Foo f = new Foo();
		f.test(Long.valueOf(1L));
		f = new Bar();
		f.test(Long.valueOf(1L));
	}
}

class Bar extends Foo{
	@Override
	public void test(Object o) { System.out.println("Objectbar"); }
	@Override
	public void test(Integer o) { System.out.println("Integerbar"); }
}    

Generics in combination with polymorphism:

public class GenTest<T> {
	public void test(T t) {System.out.println("Whoot"); }
	
	public static void main(String... args) {
		GenTest<Integer> gt = new GenTest<Integer>();
		gt.test(Integer.valueOf(5));
		gt = new GenExplorer<Integer>();
		gt.test(Integer.valueOf(5));
	}
}

class GenExplorer<T> extends GenTest<T> {
	@Override
	public void test(T t) { System.out.println("blaat"); }
}    

[Shanky Sohar]

Wouter Oet wrote:Why would polymorphism not apply to overloaded methods and generics??

Overloaded methods in combination with polymorphism:

public class Foo {
	public void test(Object o) { System.out.println("Object"); }
	public void test(Integer o) { System.out.println("Integer"); }
	
	public static void main(String... args) {
		Foo f = new Foo();
		f.test(Long.valueOf(1L));
		f = new Bar();
		f.test(Long.valueOf(1L));
	}
}

class Bar extends Foo{
	@Override
	public void test(Object o) { System.out.println("Objectbar"); }
	@Override
	public void test(Integer o) { System.out.println("Integerbar"); }
}    

Just to inform you that overloading happens when we change the argument of the methods
but here we are overridding both the test methods in Bar class
public void test(Object o)
public void test(Integer o)

So that why here polymorphism applies here

[Shanky Sohar]

Wouter Oet wrote:
Generics in combination with polymorphism:

public class GenTest<T> {
	public void test(T t) {System.out.println("Whoot"); }
	
	public static void main(String... args) {
		GenTest<Integer> gt = new GenTest<Integer>();
		gt.test(Integer.valueOf(5));
		gt = new GenExplorer<Integer>();
		gt.test(Integer.valueOf(5));
	}
}

class GenExplorer<T> extends GenTest<T> {
	@Override
	public void test(T t) { System.out.println("blaat"); }
}    

No,it is a method overridden,because polymorphism applies only to the Base type not to a generic type.
Here you are overriding the test method.

[Wouter Oet]

Shanky Sohar wrote:Just to inform you that overloading happens when we change the argument of the methods
but here we are overridding both the test methods in Bar class
public void test(Object o)
public void test(Integer o)

So that why here polymorphism applies here

Of course because there is no other way. If the super class only has the test method with an Object argument then the sub-class can only override that method. Then overloading is only useful if you have a sub-class reference. You just said that polymorphism doesn't apply to overloaded methods.

Shanky Sohar wrote:No,it is a method overridden,because polymorphism applies only to the Base type not to a generic type.
Here you are overriding the test method.

The base class is generic. What is your point?

[Shanky Sohar]

main point is that polymorphism doesnot determine which overloaded version is called..
polymorphism does come into play when the decision is about which overriddden method is called.

Lets see how the polymorphism work with overloaded method.

public class Testingoverloaded{
public void0 dostuff(){ 
        }
}

public class Test extends Testingoverloaded{
public void dostuff(){
    }
public void dostuff(String s){
}

}

lets say

Testingoverloaded  t1=new Test();
t1.dostuff()

here as the method dostuff() is overridden in the Test class so,it will call the method of Test class at runtime but at compile time it continue to point the method of Testingoverloaded class.so here polymorphish applyies

now see

Test t2=new Testingoverloaded();

//cannot be done because subclass refernce cannot point to a superclass object.


and lastly

Test t=new Test();
t.dostuff("Test");

this will call the method of Test class..


in case of overloaded method reference type determine which method to call..
but in case of overridden method object type determine which method to call..

polymorphish occur at runtime but in case of overloaded method like in

dostuff()
dostuff(String s)

when we do

Test t=new Test();
t.dostuff("Test");

compiler itself decided which method to call.

so i think now it is clear to you
if not please study polymorphishm
http://www.google.co.in/#hl=en&rlz=1R2ADFA_enIN394&q=polymorphism+in+java&aq=0sx&aqi=g-sx10&aql=&oq=polymorphishm+in+java&gs_rfai=&fp=bc4921db69ff5ed7

[Shanky Sohar]

as i said above
polymorphish happen at runtime
but all the generic type information is removed while compiling.
at runtime collections are collections like earlier days.
So you cannot say that polymorphishm apply to Generics also.


Happy Learning

[Shanky Sohar]

See this scenerio.

l polymorphism has to be at run time. Think of this scenario, Java has exposed JDBC drivers interface and you load the driver class at runtime. Using the same code you can connect to any JDBC compliant database where the actual database to be connected may be supplied by user at runtime. How such a functionality can be supported at compile time?

[Wouter Oet]

Shanky Sohar wrote:main point is that polymorphism doesn't determine which overloaded version is called..
polymorphism does come into play when the decision is about which overridden method is called.

I agree with that but that is not what you said. You just said that polymorphism doesn't apply to overloaded methods. But what you probably meant was that polymorphism doesn't apply to overloaded methods that don't override methods in the parent class.

And about the second part of your post. Your talking about type erasure but that has little to do with polymorphism. Polymorphism is just a feature that allows you to handle different data-types and methods through a uniform interface. The fact whether or not that interface is generic, is irrelevant. You just said that polymorphism doesn't apply to generics.

And type erasure doesn't remove all the generic information. Yes it's true that you can't know of what type the generic object is (without reflection). However the class still contains the generic restrictions. For instance:
public static <T extends Number> void test(T t) {}
will compile to:
public static void test(Number){}

And sometimes generics does come in to play when determining which method to call:

public class Generic<T> {
	public void test(Number i) { 
		System.out.println("Number");
	}
	
	public void test(T t) {  // It gets compiled to test(Object)
		System.out.println("Generic");
	}
	
	public static void main(String... args) {
		new Generic<Integer>().test(Integer.valueOf(5)); // Prints generic even though Number is more precise then Object
		new Generic<Integer>().test(Long.valueOf(5L)); // Prints Number
		//new Generic<Integer>().test(new Object()); // This obviously doesn't compile
	}
}
    

Happy Learning