Hi all,

In the following program how many reference varibale & how many objects are there....? please justify if possible.

class animal
{
public void eat()
{
System.out.println("you are in animal");
}
}

class horse extends animal
{
public void eat()
{
System.out.println("you are in horse");
}

}

public class Flo
{
public static void main(String args[])
{
animal d=new animal();
animal f=new horse();
d.eat();
f.eat();

}
}

Thanks & Regards,
Abhijit

Two references and two objects.

But the subclass object can be used wherever super class object can be used.

Hi Abhijith,

In u r example ,

1) animal d=new animal();
animal f=new horse();

U r creating two reference variables, ie.
Reference variable d && reference varible f.

Which means u created variables(d & f) to refer an object.

In General, Reference is like a pointer to reffer an object.

Geek d=new Geek();
here d is a reference variable.

2) Object can be created by using new keyword.

animal d=new animal();
animal f=new horse();

Here object is created and the address stored in variable(reference)

d & f.

Object is an occupied memory for a class. Reference points to that memory and it has got a name(variable)



Here when u write animal d=new animal(); some memory will be occupied in the system.

d is the reference(variable) which points to this memory and is used to access the data present in this memory.

So in u r pgm overall u created two reference varible(d &f) , and two objects for the classes.

Note :

animal d // Reference variable(d) for animal class
new animal() // Object of animal class

So dont be confused with reference(variable) & object

Regards,
Rijus.

hi
in this program d is the object of animal class and f is reference variable of horse class
ok

Sorry but don't be confused Bhaskar,

In this example both d and f are reference variables of animal class as Riju told

animal d;
animal f;

But they refer to the objects of different class d refer to animal class object
d = new animal();

and f refere to horse class object
f = new horse();

Since a super class reference can refer to the object of its own class and its subclass (This mechanism is called Dynamic method dispatch/Dynamic method Look up / Run time polymorphism )

In this case casting is done implicitly called upper casting.

f = new horse();

Here new operator allocates memory for horse object and returns its (horse class) reference,since super class can hold its subclass reference so it is assigned to animal class reference f.

Thanks