Classes and Inheritance

Programming Questions

doodle

in Programming Questions • 3 years ago

I did my best to provide pseudo code to describe my question.

Class spoon exists just so that I can have smoogle and smo reside in the same array and be
different types of objects. I have a place holder function class.get_force() so that when I add smoogle and
smo to sum I can call get_force() on both objects. It calls the over riden version of the method( which I didn't
expect it would do!)

The whole point of this is that though smoogle and smo have the exact same methods they differ in how they
arive at their output. I need to add these objects values together and want I class that handles all of that in the
background.

This is a very important part of what I am working on and would love opinions it's no fun to program on an island.

   Does any one have any alternative ideas to how I should handle this?

   Is this the best way to go about things?
   Is there a more correct way to do this?

   I was very surprised that this example calls the overridden method and not the original place holder in spoon.

I expected since the array test was of the type spoon it would call the method held in spoon and not the actual objects class.

class spoon{
spoon(){
}
int get_force(){
return 0;
}
}
class smoogle extends spoon{
int force;
void set_force(int force){
this.force = force;
}
int get_force(){
return force;
}
}
class smo extends spoon{
int force;
void set_force(int force){
this.force = force*force;
}
int get_force(){
return force;
}
}
smoogle smoogle = new smoogle();
smo smo = new smo();
class sum{
int num;
spoon[] test = new spoon[0];
sum(){
}
void add_to_system(spoon smo){
test=(spoon[])append(test,smo);
num++;
}
int print_sum(){
int smo=0;
for( int x=0; x < test.length;x++){
smo += test[x].get_force() ;
}
return smo;
}
}
sum sum = new sum();
sum.add_to_system(smoogle);
sum.add_to_system(smo);
smoogle.set_force(4);
smo.set_force(4);
println(sum.print_sum());
/*
Originally I used the class below to handle the objects as totally seperate objects.
class sum{
int num_smo;
int num_smoogle;
smo[] smo = new smo[0];
smoogle [] smoggle = new smoogle[0];
sum(){
}
void add_smo_to_system(spoon new_smo){
smo =(smo[])append(smo, new_smo);
num_smo++;
}
void add_smoogle_to_system(spoon new_smoogle){
smoogle =(smoogle[])append(smoogle, new_smoogle);
num_smoogle++;
}
int print_sum(){
int total=0;
for( int x=0; x < smo.length;x++){
total += smo[x].get_force() ;
}
for( int x=0; x < smo.length;x++){
total += smoogle[x].get_force() ;
}
return total;
}
}
*/

Replies(3)

PhiLho

Re: Classes and Inheritance

3 years ago

I haven't understood everything in your message, but basically, if you declare an array or a collection of a given super-type and put objects of that type or sub-types in it, you will get back objects of their own type. Ie. if you get a smo as a spoon, it is still a smo, and the call to its methods will use the methods in smo, not in spoon. That's the point of overriding! Often, when you do such override, you call super() in the overridden method to call also the super-method but that's not mandatory.

Again, I am not sure of what you try to do (probably read too fast) but you can make spoon to be an interface (just defining the common methods in all classes implementing the interface) or an abstract object (you cannot instantiate objects of this type, it is just a blueprint providing defaults for fields and methods).

doodle

Re: Classes and Inheritance

3 years ago

I was using spoon as an interface but calling it a class because I was not aware you where allowed to..........

public interface spoon{
int test();
}
spoon[] smo = new spoon[2];

have the interface be a type of object. So that makes my code a little neater Thank You.

What surprised me about the method overriding was that even though smo is a smo I was placing it in an array of spoons.

Say smo had the method run() I know that if I called run on a smo object in a spoons array the program would tell me that the function did not exists. Which makes sense since spoon does not have a run function.

class spoon(){
void test(){
println("I am a spoon");
}
}
class smo extends spoon{
void run(){
//I am unreachable
}
void test(){
println("I am a smo")
}
}
spoon car;
smo smo = new smo();
car = smo;
car.test(); //<-------- prints I am a smo
car.run(); //<-----FAIL

So to me it seems that a smo in a spoon array calling on test() should run the function from its super class.

This makes no sense to me that it runs the over ridden method. This means that Java is reaching into smo's methods even though it is a spoon object.

Does any one know the reason this works like this?

PhiLho

Re: Classes and Inheritance

3 years ago

As I wrote, a smo is a spoon, so it is accepted in an array of spoons, but it is still a smo, so Java uses its overridden methods when you call them: that's the point of overriding! To extend the base functionality of the base class. The fact you put the smos in an array of spoons doesn't change its type: it is still a smo, something with more functionality than a spoon and eager to show it!

Top Reply