• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Jeanne Boyarsky
  • Ron McLeod
  • Paul Clapham
  • Liutauras Vilda
Sheriffs:
  • paul wheaton
  • Rob Spoor
  • Devaka Cooray
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Frits Walraven
  • Tim Moores
Bartenders:
  • Mikalai Zaikin

Calling Overridden methods and overshadowed variables

 
Ranch Hand
Posts: 50
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Why is there difference between calling the overidden methods and overshadowed variables based on the object type(class) and reference (as stated in the book of Khalid )
 
Ranch Hand
Posts: 158
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
hi
I am not sure what you mean.But if you mean something that involves the code:
<code>
class Base{
String str="in Base";
void amethod()
{ system.out.println("in Base");

}
}
clas Sub extends base{
String str="in Sub";
void amethod()
{
System.out.println("In Sub");
}
}
class test{
public static void main(String args[])
{
Base b;
Sub s=new Sub();
b=s;
s.amethod();
System.out.println(s.str);
b.amethod();
System.out.println(b.str);
}

}
}
</code>
the output is: in Sub //amethod of Sub invoked by s
in Sub //varaible str of Sub accessed by s
in Sub //amethod of Sub invoked by b
in Base //varaible str of Base accessed by b
So the method called depends on the object, not on the object reference . Here the object reference of type Base points to an object of type Sub. So method amethod of class Sub is invoked.But variables accessed depends on the object reference.Since the object reference is of type Base, the variable 'str' of the Base class is accessed.
I hope this is what you wanted to know
regards
Tanveer
 
Stephen Joseph
Ranch Hand
Posts: 50
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Thank you Tanveer.You guessed my Q right, but if you can tell me what is the reason for this difference why cant overridden methods and overshadowed variables be called in the same way.
 
Sheriff
Posts: 5782
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Since this topic is not concerned with Threads and Synchronization, I am moving it to a more appropriate forum - Java in General(intermediate). Please continue the discussion there.
Thanks!
Ajith
 
Ranch Hand
Posts: 1492
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Stephen,
Think of it this way:
Class variables related to the state of the class
Class methods relate to the implementation of the class
The only reasons to extend one class with another is to:
1) Change state information, or
2) Change implementation
When we extend one class with another we automatically have access to the extended class state (non-private member variables). It would not be in our best interest to create an exact copy of the extended class state because we can just alter the extended class state. Therefore, Java developers made the statement that member variables (state) can not be overridden by subclasses. This makes sense since it would be time wasting and memory inefficient to inherit state and then try and duplicate it inside the new class! If we want to change state, then just change the inherited variables ...
On the other hand, we have extended the class for some reason and that had better be for one of the two reasons stated above. Java allows us to create numerous new class variables to extend our class state. We can override methods because that is usually the main reason for extending another class. This makes sense and doesn't cause programming inefficiencies!
Wow!
Manfred.
 
Attractive, successful people love this tiny ad:
a bit of art, as a gift, the permaculture playing cards
https://gardener-gift.com
reply
    Bookmark Topic Watch Topic
  • New Topic