reference variables and object types

[Sukhitha sunil]

 class Animal {
	
	public void sleep() {
		System.out.println("An animal sleeps...");
		}
}
 class Bird extends Animal {

    public void sleep() {
        System.out.println("A bird sleeps...");
    }

}

public class Maain {

	public static void main(String[] args){
		
		Animal ani= new Bird();   //variable of base class
	       Bird bir = new Bird();    
	        ani.sleep(); //doubt 
	        bir.sleep();

	}

}

usually when we use ref variable of baseclass to access an obj of derived class, we only get d access to baseclass members ,,but when i run this code ani.sleep() gives he output of derived class bird method   ..please help me guys..to understand what is happening here

[Ranajoy Saha]

As far as I can comprehend you question, there exists a separate class named Animal which is the superclass.

class Animal 
{
    public void sleep() 
    {
        System.out.println("An animal sleeps...");
    }
}

Then there exists another class Bird which is the derived class or the sub class of the Animal class.

class Bird extends Animal 
{
    public void sleep() 
    {
        System.out.println("A bird sleeps...");
    }
    public static void main(String[]args)
    {
        Animal obj = new Animal();
        Bird obj1 = new Bird();
        obj.sleep(); //Call to the Super Class
        obj1.sleep();//Call to the Derived class
    }
}

When the call is made to the Superclass via the obj reference, it prints "An animal sleeps...", where as when the call is made to the derived class via the obj1 reference it prints "A bird sleeps...". The call to the derived class prints "A bird sleeps..." because
the sleep() method of the Bird class Overrides or overshadows the method of the Animal class. I hope this resolves your doubt.

[Ganesh Patekar]

Welcome to CodeRanch!

Sukhitha sunil wrote:usually when we use ref variable of baseclass to access an obj of derived class, we only get d access to baseclass members

That is true only in case of instance variables of base class but not for all members because member of class also includes methods, members inherited from its direct superclass,direct superinterfaces etc but not applicable for all members

When you assigns an object of derived class to the reference variable of base class then:

Using that reference variable you can access instance variables of base class having public, protected and package-private( Accessible only If in same package ) access modifiers in derived class. If want to access in non-derived class then only public, protected( Accessible only If in same package ) and package-private( Accessible only If in same package )

Using that reference variable you can access instance methods of base class having public, protected and package-private( Accessible only If in same package ) access modifiers in derived class. If want to access in non-derived class then only public, protected( Accessible only If in same package ) and package-private( Accessible only If in same package ).

When derived class defines an instance method having same signature with same access modifier and return type already defined in base class then that method is overriden by derived class.
In that case when you create an object of derived class and assign it to the reference variable of base class (like you have in your example) and invokes that method on base class's reference variable then method of derived class gets called at run time. That is what polymorphism is all about.

In your example derived class Bird has sleep method which overrides method of base class Animal so

Animal ani= new Bird();
ani.sleep(); // calls method of Bird class

To clear all your doubts regarding polymorphism please click here -->How my Dog learned Polymorphism to read.

[Ganesh Patekar]

You can see an example below in which base class Animal is in one package and derived class Bird is in another. You can try such different combinations so can understand very well.

Animal.java as base class:

package animalpackage;

public class Animal {
	public int publicAnimalAge = 10;
	protected int protectedAnimalAge = 20;
	int packageAnimalAge = 30;
	private int privateAnimalAge = 40;

	public void publicSleep() {
		System.out.println("An animal publicSleep...");
	}

	protected void protectedSleep() {
		System.out.println("An animal protectedSleep...");
	}

	void packageSleep() {
		System.out.println("An animal packageSleep...");
	}

	private void privateSleep() {
		System.out.println("An animal privateSleep...");
	}

	public void animalSpecialMethod() {
		System.out.println("An animal animalSpecialMethod...");
	}

}

Bird.java as derived class:

package birdpackage;

import animalpackage.Animal;

public class Bird extends Animal {

	private void getBaseClassInstVariables() {

		/*
		 * Directly you can access because protected and public variables are
		 * inherited by derived class
		 */
		System.out.println("publicAnimalAge: " + publicAnimalAge);

		System.out.println("protectedAnimalAge: " + protectedAnimalAge);

		/*
		 * packageAnimalAge not accessible because package-private accessible in
		 * same package and privateAnimalAge not accessible because private is
		 * accessible within class Animal which declares it.
		 * 
		 */

	}

	private void getBaseClassInstMethods() {
		Animal anmlRef = new Bird();
		anmlRef.publicSleep();
		protectedSleep();
		/*
		 * Not accessible package-private void packageSleep() because accessing
		 * in different package and private void privateSleep() this accessible
		 * within base class Animal
		 */
	}

	/*
	 * Overrides below two methods because having same signature, return type
	 * and access modifiers of method publicSleep and protectedSleep of Animal
	 * class
	 * 
	 */
	public void publicSleep() {
		System.out.println("An Bird publicSleep...");
	}

	protected void protectedSleep() {
		System.out.println("An Bird protectedSleep...");
	}

	public static void main(String[] args) {

		Bird brdObj1 = new Bird();

		brdObj1.protectedSleep();// calls Bird class method

		brdObj1.getBaseClassInstVariables();
		brdObj1.getBaseClassInstMethods();

		Animal anm = new Bird();
		anm.publicSleep();// Calls Bird class's method
		anm.animalSpecialMethod();// Calls Animal's method

		/*
		 * Can also call method of Animal class not present in derived class but
		 * having public access modifier on reference variable of derived class
		 * having object of derived class.
		 */
		brdObj1.animalSpecialMethod();
	}

}

Output:
An Bird protectedSleep...
publicAnimalAge: 10
protectedAnimalAge: 20
An Bird publicSleep...
An Bird protectedSleep...
An Bird publicSleep...
An animal animalSpecialMethod...
An animal animalSpecialMethod...

[Roel De Nijs]

Hi Sukhitha sunil,

First of all, a warm welcome to CodeRanch!

Sukhitha sunil wrote:usually when we use ref variable of baseclass to access an obj of derived class, we only get d access to baseclass members ,,but when i run this code ani.sleep() gives he output of derived class bird method   ..please help me guys..to understand what is happening here

There is a massive difference between "which methods can be accessed" and "which methods will be executed". The first is decided at compile time, the latter is decided at runtime.

Let's have a look at a code snippet

class Animal {
    public void makeSound() {
        System.out.println("I am an animal.");
    }
}
class Bird extends Animal {
    public void fly() {
        System.out.println("I am flying high in the sky!");
    }
}
class Zoo {
    public static void main(String[] args) {
        Animal a = new Bird();
        Bird b = new Bird();
        a.makeSound(); // line1
        a.fly(); // line2
        b.makeSound(); // line3
        b.fly(); // line4
    }
}

So we first create two Bird instances/objects, one is referred by an Animal reference variable and the other is referred by a Bird reference variable. Now the compiler does its job and checks if every method invocation is allowed (and if all other code is valid too). The class Animal has a makeSound() method, so line1 compiles just fine. But there is no fly() method in class Animal, so you'll get a compiler error on line2. And just for the record: the compiler does not execute any code at all, so it only knows (and cares about) the type of the reference variable. The class Bird has a fly() method and inherits the makeSound() method from class Animal, so both line3 and line4 will compile successfully.

Now let's have a look at a slightly adjusted code snippet

class Animal {
    public void makeSound() {
        System.out.println("I am an animal.");
    }
}
class Bird extends Animal {
    public void makeSound() {
        System.out.println("I am a bird.");
    }
}
class Zoo {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        Animal a2 = new Bird();
        Bird b = new Bird();
        a1.makeSound(); // line1
        a2.makeSound(); // line2
        b.makeSound(); // line3
    }
}

First the compiler checks again if all code is valid (and thus if all method invocations are allowed). That's definitely the case! So now you can execute the Zoo class and you'll get the following output:
I am an animal.
I am a bird.
I am a bird.
So probably the first and third line of the output are pretty straightforward, but the second line looks a bit odd. Which method is executed is determined at runtime based on the type of the object the reference variable is referring to. And because the Animal reference variable is referring to a Bird instance/object and the Bird class has a makeSound() method (with exactly the same method signature) as well, the makeSound() method of the Bird class is executed (= polymorphism) and that's why "I am a bird." is printed.

This results in two very simple (and hopefully easy to remember) but very, very, very important rules:

Which instance variables you can access is determined at compile time based on the reference variable type.

Which instance methods you can call/invoke is determined at compile time based on the reference variable type. Which instance method is actually executed is decided at runtime based on the type of the actual object (= polymorphism).

And here is another very, very, very important rule: The compiler doesn't execute any code! So every compiler error you get, is because the compiler knows something is wrong without executing any line of code. So the compiler doesn't know and care) about the actual objects, the compiler only knows about the types of the reference variables.

Which methods can be accessed depends on the access modifier of the class, the access modifier of the method and the package in which the classes reside. In this topic you'll find a very detailed explanation about how changing an access modifier can result in a completely different output. Definitely worth reading! In fact, it's actually a must read

Hope it helps!
Kind regards,
Roel

[Roel De Nijs]

Ganesh Patekar wrote:When derived class defines an instance method having same signature with same access modifier and return type already defined in base class then that method is overriden by derived class.

That's an incorrect statement! You should definitely review the rules for a valid override: the method signature has to be exactly the same, but access modifier and return type does not need to be the same.

In this code snippet you'll have a valid override although the access modifier is different. For a valid override, the access modifier for an overriding method can allow more, but not less, access than the overridden method

class Animal {
    void makeSound() {
        System.out.println("I am an animal.");
    }
}
class Bird extends Animal {
    protected void makeSound() {
        System.out.println("I am a bird.");
    }
}

And here is another code snippet with a valid override although the return type is different. The return type of the overriding method can be a subclass of the return type of the overridden method (= covariant return type)

class Animal {
    public Animal getMe() { return this; }
}
class Bird extends Animal {
    public Bird getMe() { return this; }
}

Hope it helps!
Kind regards,
Roel

[Winston Gutkowski]

Sukhitha sunil wrote:usually when we use ref variable of baseclass to access an obj of derived class, we only get d access to baseclass members

So, does Animal have a sleep() method? Yes - and furthermore, it's public, so ani.sleep() is a perfectly valid call. Anywhere.

but when i run this code ani.sleep() gives he output of derived class bird method

I think Roel and Genesh have already covered that bit; but just in case you've come from a C or C++ background, the way it was explained to me was that
  All instance methods in Java are "virtual" by default.

Which is another way of saying precisely what

Roel wrote:There is a massive difference between "which methods can be accessed" and "which methods will be executed". The first is decided at compile time, the latter is decided at runtime.

HIH

Winston

[Paul Anilprem]

Winston Gutkowski wrote:All instance methods in Java are "virtual" by default.

Minor correction - All instance methods in Java are "virtual", period.
You can't change this behavior so there is no "by default".
Final methods cannot be overridden so this concept is not relevant for them anyway.

[Ganesh Patekar]

Roel De Nijs wrote:For a valid override, the access modifier for an overriding method can allow more, but not less, access than the overridden method.

Damn! I tried combinations of override method with lesser modifier only.

The return type of the overriding method can be a subclass of the return type of the overridden method (= covariant return type)

I really had no notion about covariant return type, new thing learned. That link was much much helpful and mostly the explanation of last post of your's was in detail, learned a lot.
You were just awesome Roel

Edited: I adore the way you test whether somebody really understood or not by your famous pop quizzes hahaha just great

[Sukhitha sunil]

thank you so much everyone.. every reply for my post helped me to get not only the actual idea but also more than it.. as a newbie i didn't expect it this much response

[Roel De Nijs]

Sukhitha sunil wrote:as a newbie i didn't expect it this much response

As the moose tells you, CodeRanch is a friendly place for programming greenhorns, so we are glad to help you

[Roel De Nijs]

Ganesh Patekar wrote:Edited: I adore the way you test whether somebody really understood or not by your famous pop quizzes hahaha just great

Thanks for these kind words. Highly appreciated! Glad to read you like those questions and I can easily create another pop quiz question here too

What's the output of the following code snippet?

class Animal {
    private void makeSound() {
        System.out.println("I am an animal.");
    }
}
class Bird extends Animal {
    public void makeSound() {
        System.out.println("I am a bird.");
    }
}
class Zoo {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        Animal a2 = new Bird();
        Bird b = new Bird();
        a1.makeSound();
        a2.makeSound();
        b.makeSound();
    }
}

[Ganesh Patekar]

Here a1 refers to an object of Animal and tries to invoke makeSound method of Animal which is private so not accessible outside of class so will give CE.

a1.makeSound();

Here a2 is reference variable of Animal which refers to an object of Bird and tries to invoke makeSound method of Animal, why not makeSound method of Bird? because makeSound method of Animal is private, and private methods are not inherited by subclass i.e. Bird so as we have a2 as reference variable of Animal It tries to invoke makeSound method of Animal which is private so gives CE.

a2.makeSound();

Because of above two CE, will not get executed. If you remove above to calls then It will invoke makeSound method of Bird because that method has public access modifier so accessible.

b.makeSound();

Now ugly truth, I didn't even notice we are invoking a private makeSound() method of Animal from Zoo means ouside of Animal class and decided makeSound method of Animal will get called. That came in my notice when I copied code in eclipse. It is not like I don't know private methods are not accessible outside of the class where It is declared. I know that but my problem which I always suffer from, I do silly mistakes like If you ask me to do (1*3/6-3+12+1) then I will do mistake like I'll miss to add last 1 in calculation. I think I lack observation Or may be because of trying to solve problem hurriedly. If you have time, love to have one more