Using functions of Inherited classes

Questions & Answers
1

I ended up temporarily changing the way I had my stuff coded since I’m on a deadline at school, but for future reference, I’m having issues with classes extended from other classes. This is easier to show than it is to explain:

I declare my class and subclass:

class Base {
  function DoSomething() {
    //does something
  }
}
class Sub extends Base {
  function DoSomething(with : parameter) {
    //Does something using parameters
  }
}
class Sub2 extends Base {
  function DoSomething(with : parameter) {
    //Does something slightly different with parameters
  }
}

Later, while trying to use this code, I need to reference either one of these two classes in the same variable (for example, both are CharacterClass, but one is NPC and the other is PC, and one variable is used for both versions of Base). It won’t let me use the derived version of DoSomething, and returns that I can’t call it with parameters (as none are set in Base’s constructor, even though it is in each of its children.

var subGuy : Sub = new Sub();
var sub2Guy : Sub2 = new Sub2();
var myBase : Base;
if (something) {
  myBase = subGuy;
} else {
  myBase = sub2Guy;
}
myBase.DoSomething(myParam);

The above throws an error, and since the same command is used in both instances, I can’t simply use ( myBase as Sub ).DoSomething(myParam); As I never don’t intrinsically know which of the two versions I have (and it returns a Base, not a Sub or Sub2 version of the myBase).

Is there any way to access the inheritor’s function to perform the task?

2

“DoSomething()” and “DoSomething(with : parameter)” are not the same method, as the paramter list is part of the signature. So one can not override the other.

Also “DoSomething(with : parameter)” is not defined in your base class, only the other one.

3

As explained by senad, you are not overriding the original class functions.

What I would suggest you do when using inheritance, use the virtual keyword. Then your function will look something like this:

public virtual void MyFunction(){ ... }

Then in your derived class (in your example, “Sub”) you use the override keyword. This will ensure that you really have the correct signature.

i.e.

public override void MyFunction(){ ... }

If you want to pass different parameters then you lose the static typing of them unfortunately. You could do it like:

public virtual void MyFunction(params object[] parameters){ .... }

or you could pass an object as the parameter, which is itself a class:

public virtual void MyFunction(object parameterObject){ ... }

however in this case you’ll need to cast the parameterObject to the correct class type in your derived (overriding) class.

The final way might be using reflection, but in all honesty, I would suggest trying to stay within the realms of normal inheritance.

PS: The above is all C# code. You’ll have to work out the translation to JS.

4

The point of inheritance is that you have to use virtual functions so they can be overridden in a sub class. AFAIK it works like this in UnityScript:

class Base {
    virtual function DoSomething(parameter : int) {
        Debug.Log("Base " + parameter);
    }
}

class Sub extends Base {
    virtual function DoSomething(parameter : int) {
        Debug.Log("Sub " + (parameter * parameter));
        // to call the overridden function from base:
        super.DoSomething(parameter);
    }
}

As far as i know there’s no “override” keyword in UnityScript. It automatically overrides the function as long as it’s virtual.

var c : Base;
c = new Sub();
c.DoSomething(5);

This would print:

"Sub 25"
"Base 5"    // because i call the base (super) version

Like others have already mentioned the signature of a function is defined by it’s name and it’s parameters. Otherwise it’s not the same function. If you have multiple functions with the same name but different parameters it’s called an overloaded function since it exists multiple times. The compiler picks the correct version according to the parameters you pass in.