This is more a question about good code writing than a specific syntax. So this one is for you coding-veterans out there.

I have a class that creates objects, let's say squares. Each square can change its position. It may fall under a downward gravitational pull or is attracted towards the mousepointer or can move with a set velocity in a random direction. That's three different ways the x/y-Position can be calculated.

I believe it would be extremely "unsexy" coding, if the objects had all three methods written in them and on creation receive a command to execute one but ignore the other two, like:

Code:

if positionCalculation is "gravity"
     calculate position with gravityPull()
else if positionCalculation is "mouse"
     calculate position with mouseAttraction()
else if positionCalculation is "direction"
     calculate position with velocityDirection()
 

(In my project I'm planning on incorporating far more ways to calculate the position, so it will make even less sense there to have all functions ready but only execute one of possible 15.)

I'm imagining (but really have no idea), that it should be possible to tell an object on creation which way it has to calculate its position, and that the object gets only the necessary code from outside itself, maybe from something like a library of position-calculating-methods? Does this make any sense? Someone mentioned to me this might be called a "delegation model/pattern" or something like that?

Anyone got a hint how I should approach this (if there is any good way), possibly even with example code?

I'd be sooooo thankful!

I can think of one fairly clean way of doing it, and that's by having a "movementMethod" interface, creating a class that implrements that interface for each movement type, and then upon object creation, you pass an instance of one of these types to the object.
I think however that you'd also need a unified position/velocity object as well to pass current position/speed into it, and to return the new values.

e.g.

Code:

class speedVelocityInfo
{
  float x_position,y_position;
  float x_velocity,y_velocity;
  speedVelocityInfo(float x, float y)
  {
    x_position=x;
    y_position=y;
    x_velocity=0; //you could have a 4 argument constructor
    y_velocity=0; //that sets these as well for instance.
  }
}

interface movementMethod
{
  Object move(Object current);
  //use Object since you can't use custom classes from 
  //within processing for interfaces.. we can cast later.
}

class gravity implements movementMethod
{
  Object move(Object current)
  {
    //we have to cast from object now where we can use 
    //custom classes
    speedVelociyInfo svi=(speedVelocityInfo)current;
    svi.y_velocity-=0.5; //Or whatever
    svi.y_position-=svi.y_velocity;
    return svi;
  }
}

class square
{
  movementMethod mm;
  speedVelocityInfo pos;
  square(speedVelocityInfo start, movementMethod _mm)
  {
    pos=start;
    mm=_mm;
  }

  void draw()
  {
    //have to cast it from Object to our speed & velocity 
    //info object
    pos=(speedVelocityInfo)mm.move(pos);
    //now draw it...
  }
} 

So you can create as many different classes that implement movementModifier as you want, each with unique behaviour, and then pass any of them to your moving things.

And just to differentiate, movax has suggested a polymorphic solution, whereas john has suggested a delegate solution.

Yikes, you're right! My apologies.