Why do we assign a parent reference to the child object in Java?

Question

I am asking a quite simple question, but I am bit confused in this.

Suppose I have a class Parent:

public class Parent {      int name; } 

And have another class Child:

public class Child extends Parent{      int salary; } 

And finally my Main.java class

public class Main {      public static void main(String[] args)     {         Parent parent = new Child();         parent.name= "abcd";     } } 

If I make a child object like

Child child = new Child(): 

Then child object can access both name and salary variables.

My question is:

Parent parent = new Child(); 

gives the access of only name variable of Parent class. So what is the exact use of this line??

 Parent parent = new Child(); 

And also when it is using dynamic polymorphism then why the variable of child class is not accessible after doing this

Parent parent = new Child(); 

Answer 1

First, a clarification of terminology: we are assigning a Child object to a variable of type Parent. Parent is a reference to an object that happens to be a subtype of Parent, a Child.

It is only useful in a more complicated example. Imagine you add getEmployeeDetails to the class Parent:

public String getEmployeeDetails() {     return "Name: " + name; } 

We could override that method in Child to provide more details:

@Override public String getEmployeeDetails() {     return "Name: " + name + " Salary: " + salary; } 

Now you can write one line of code that gets whatever details are available, whether the object is a Parent or Child:

parent.getEmployeeDetails(); 

The following code:

Parent parent = new Parent(); parent.name = 1; Child child = new Child(); child.name = 2; child.salary = 2000; Parent[] employees = new Parent[] { parent, child }; for (Parent employee : employees) {     employee.getEmployeeDetails(); } 

Will result in the output:

Name: 1 Name: 2 Salary: 2000 

We used a Child as a Parent. It had specialized behavior unique to the Child class, but when we called getEmployeeDetails() we could ignore the difference and focus on how Parent and Child are similar. This is called subtype polymorphism.

Your updated question asks why Child.salary is not accessible when the Childobject is stored in a Parent reference. The answer is the intersection of "polymorphism" and "static typing". Because Java is statically typed at compile time you get certain guarantees from the compiler but you are forced to follow rules in exchange or the code won't compile. Here, the relevant guarantee is that every instance of a subtype (e.g. Child) can be used as an instance of its supertype (e.g. Parent). For instance, you are guaranteed that when you access employee.getEmployeeDetails or employee.name the method or field is defined on any non-null object that could be assigned to a variable employee of type Parent. To make this guarantee, the compiler considers only that static type (basically, the type of the variable reference, Parent) when deciding what you can access. So you cannot access any members that are defined on the runtime type of the object, Child.

When you truly want to use a Child as a Parent this is an easy restriction to live with and your code will be usable for Parent and all its subtypes. When that is not acceptable, make the type of the reference Child.

Answer 2

When you compile your program the reference variable of the base class gets memory and compiler checks all the methods in that class. So it checks all the base class methods but not the child class methods. Now at runtime when the object is created, only checked methods can run. In case a method is overridden in the child class that function runs. Child class other functions aren't run because the compiler hasn't recognized them at the compile time.