Polymorphism Problem

[Mohit G Gupta]

iRix Technolohies mock questions

Problem 1
Given the following class declarations in their respective files

  
public class Circle extends Shape
{
int x = 20;
public static void main(String args[])
{
Shape s = new Circle();
System.out.println(s.x);
}
}
public class Shape
{
int x = 10;
}  

What is the result of compiling & running class Circle ?


correct answer: Prints 10 to the console.
wrong answer:Prints 20 to the console.

shouldn't answer be 20 since 20 would override 10

---------------------------------------------

Problem 2

   class Shape{}
class Circle extends Shape{}
class Test
{
public static void render(Shape s, Circle c)
{
System.out.println("render(Shape s, Circle c)");
}
public static void render(Circle c, Shape s)
{
System.out.println("render(Circle c, Shape s)");
}
public static void main(String args[])
{
Circle c1 = new Circle();
Shape s1 = c1;
render(c1, s1);
}
} 

Given the following, what is the result of compiling & running class Test ?

options:
A.Compiler error, reference to render is ambiguous.
B.AmbiguousReferenceException thrown at runtime.
C.Prints "render(Shape s, Circle c)" to the console.
D.Prints "render(Circle c, Shape s)" to the console.

correct answer is D.
i think answer should be A
as we are passing

new Circle,new Circle to render(c1, s1);method because

   Circle c1 = new Circle();
Shape s1 = c1;  

both the method match,so complier erroe

[Shanky Sohar]

variable cannot be overriden.
answer will be 10

[Vinoth Kumar Kannan]

For your second problem, there will be no compile error. It is always acceptable to assign a class's instance to its super class's reference. So, D will be the answer.

[Shanky Sohar]

as explained by Vinoth Kumar Kannan
above is the case of overloaded method,so answer is D....

[Prasad Kharkar]

well
in case of overloaded methods the method with the most specific arguments are called
if the match is found such that the method argument types exactly match the types we declare in overloaded method
then that method is selected

in our case
we have two methods

   class Shape{}
class Circle extends Shape{}
class Test
{
public static void render(Shape s, Circle c)
{
System.out.println("render(Shape s, Circle c)");
}
public static void render(Circle c, Shape s) // this matches the method call more exactly
{
System.out.println("render(Circle c, Shape s)");
}
public static void main(String args[])
{
Circle c1 = new Circle();
Shape s1 = c1;
render(c1, s1);//passing Circle type and Shape type
}
} 

[Piotr Nowicki]

Also remember (your second problem) that you are facing overloaded methods. If so, the method signature is "pinned" down at the compile time - compiler looks at reference variables type (not the object type) to know which method to invoke, so you've got (Circle, Shape).

[Unmesh Chowdhury]

At the compile time which overloaded method will be called is determined by the compiler according to the reference types. And the compiler try to match with more appropriate method. In your case the render(Circle, Shape) method exactly match with your passing reference types. Moreover, if there is no render(Circle, Shape) method in your class then it will be a compile time error since supertype reference can not assigned into the subtype reference.

[Akshat Kumar]

Problem 1:

I think polymorphism only applies to methods & not to variables of any kind .

Problem 2:

Method signatures are dependent on the order of the arguments.
As it's an example of overloading not overriding, The actual type of the object wont matter.
The method will be chosen on the basis of the type of reference variable.