Question

Possibly bad practice but I’m not well versed in software design anyway (I’m sure this question would have been asked before but I can’t seem to find the right terminology)…Anyhow, it’s just another curiosity of mine I’d like to have answered.

So I have worked in a way where I type a base class variable to type Object or Sprite or something similar so that in my subclasses, I can instantiate my custom classes into them and store it. And when I access it, I just cast that variable to ensure I can access the methods.

Take this example, so that you know what I’m talking about:

public class BaseClass
{
  protected var the_holder_var:Object;

  public function BaseClass()
  {
    //Whatever abstract implementation here...
  }
}

Now, my subclasses of that base class usually use an interface but for simplicity sake, I’ll just write it without it.

public class AnExtendedClass extends BaseClass
{
  public function AnExtendedClass()
  {
    //Instantiate my own class into the base class variable
    this.the_holder_var = new ACustomClassOfMine(); 

    //Then I can use the 'hackish' getter function below to 
    //access the var's functions.
    this.holder_var.somefunction()
  }

  private function get holder_var():ACustomClassOfMine
  {
    return this.the_holder_var as ACustomClassOfMine;
  }
}

This works and I’m sure it will make some ppl cringe (I sometimes cringe at it too).
So now, my question, is there a way to recast/retype that base var in my extended subclass?

kinda like this:

public class ExtendedClass extends BaseClass
{
  //Not possible I know, but as a reference to see what I'm asking about
  //Just want to change the type....
  override protected var the_holder_var:ACustomClassOfMine;

  public function ExtendedClass()
  {
    //Then I can forget about having that hackish getter method.
    this.the_holder_var = new ACustomClassOfMine();
    this.the_holder_var.somefunction();
  }
}

I was thinking of typing most of my base class vars that I use as holders as type * and retyping them as I extend the class. (I could use it here too but yeah…)
Thoughts? Comments? Ideas?

Answer 1

I actually think your code (apart from the hypothetical addition at the end) is pretty alright. The practise of adding accessors to solve the type issue you’re dealing with is a solid one. I would advise to rename the accessor to show it is a cast, maybe get holderVarAsCustom():ACustomClassOfMine (I’m also not a big fan of the underscores, that’s another language’s convention), but that’s personal preference. What I’d do to solve your last problem is just create a matching setter function:

private function set holderVarAsCustom(value:ACustomClassOfMine):void {
  this.the_holder_var = value;
}

This way you can access the correctly typed holder var for both read and write operations with complete type safety:

holderVarAsCustom = new ACustomClassOfMine();
holderVarAsCustom.someFunction();

I would definately advise against dropping the type safety by including arrays and what not, that just makes it unstable.