Home/ Questions/Q 862291
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-15T09:07:05+00:00

is it wasteful/bad design to use a vector/list where in most instances it will

  • 0

is it wasteful/bad design to use a vector/list where in most instances it will only have one element?

example:

class dragon
{
    ArrayList<head> = new ArrayList<head> Heads;
    tail Tail = new tail();
    body Body = new body();

    dragon()
    {
        theHead=new head();
        Heads.add(theHead);
    }

    void nod()
    {
        for (int i=0;i<Heads.size();i++)
        {
            heads.get(i).GoUpAndDown();
        }
    }
}

class firedragon extends dragon
{
}

class icedragon extends dragon
{
}

class lightningdragon extends dragon
{
}

// 10 other one-headed dragon declarations here


class hydra extends dragon
{
    hydra()
    {
        anotherHead=new head();
        for (int i=0;i<2;i++)
        {
            Heads.add(anotherHead);
        }
    }
}

class superhydra extends dragon
{
    superhydra()
    {
        anotherHead=new head();
        for (int i=0;i<4;i++)
        {
            Heads.add(anotherHead);
        }
    }
}

EDIT:(part 2 of the question)

Thanks for the replies. They have been very helpful.
I’ve actually run into this situation more than once, and I’d like to give a second example that is unrelated to inheritance. This is actually a real-world example, and though I’ve decided my current project is small scale enough to be safe with using vectors based on your answers, it’s a concept that I imagine I’ll use on a much larger scale at some point.

In creating an engine for my current Android game project, I found it necessary to create an Imagepoint object that is basically a set of XY coordinates that are used to track significant parts of a sprite image. Say you have a bone character made up of several bitmaps, it’s useful to know where the neck attaches to the torso, the forearm to the bicep, etc. This xy offset data is used later to calculate the position for various purposes, such as where to position other sprites by using trigonometric functions to find the xy offset given the current angle.

Most sprite objects will need only one image point. The bicep needs one for the forearm, the forearm needs one for the hand, the neck needs one for the head, etc. The torsos in my current character models are the exception, and they need several for the shoulders, the legs, the neck, and any removable decorative sprites.

The sprite is the object that contains the imagepoint vectors, there will be no inherited classes, because each : torso, leg, etc is simply an instance of the sprite class, which is strictly a graphical object, containing a pointer to the bitmap, these imagepoints, and assorted position/orientation data, and will not be used for any specialized purposes. If I were to use this concept on a large scale game with massive numbers of instances, where most would require only a single imagepoint, with a few objects requiring several or none, and where there would be no special cases meriting the use of inheritance. What would your thoughts be?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Yes and no.

    I mean your question really depends on how are you going to use these objects.. personally I like to split behaviours and attributes as much as possible to “clusterize” them according to the kind of object they represent without caring about reusing some code a little bit less compared to a really inheritance approach like the one you proposed. Something like:

    interface BigLizard
{
  void nod();
}

class Dragon implements BigLizard
{
  Head head;

  void nod() { head.upAndDown(); }
}

class ReallyScaryDragon extends Dragon { ... }

class Hydra implements BigLizard
{
  ArrayList<Head> heads;

  void nod() { for (Head h : heads) h.upAndDown(); }
}

    And so on. This approach is like “having just exactly what you need for your objects without force anything to be a specific case”. Of course this means that it will have two different implementations of nod() but when you don’t need to optimize (and you should care about it only at the end) just stick with your personal preference, assuming that it doesn’t go against any standard, widely accepted convention.

    You don’t have to make anything inherit from a single object, just customize the hierarchy as you like.. also a composite solution (like already suggested) would be a solution also if the concept of “head part” is not the same for your Dragon and for your Hydra..

    A third solution for your specific case could be to use a LinkedList instead that an ArrayList. In this case whenever you have just one head you won’t waste space (except for instantiation of the list) and you’ll have just the next pointer of the head (of the list 😀 ) pointing nowhere.

    • 0