you can add a draw() method to your custom class and in it's constructor call registerDraw(this) on the Base class. that way the draw() method of your custom objects will be automatically called after draw() in the Base class.

"This would work but if I had say ten objects.. obj1, obj2 etc etc then I would have to call update() on all of them separately."
Yes. That's not a problem. Particularly if you put the objects in an array.

Awesome!

registerDraw() is nice and handy. The registerXxx() methods are mostly designed for libraries that can't put their own calls in keyPressed() and such in the sketches and don't want to ask the user to do it for them.

But they have a cost: it is based on reflection, ie. Java has to do introspection to find the methods by name. It is generally slower than a straightforward method call. That's not a problem with a few objects, it can be more problematic with thousands of objects (eg. a particle system). Just something to keep in mind...

Could be interesting to measure if it has a real impact, though...

Note: a more classical way is to have objects to implement an interface, eg. defining a draw() or a display() method. Then, whatever the objects created, you put all the objects implementing the interface in an array list, and in draw() you iterate on the list to call the interface's method.

interface Drawable { void draw(); }
class Ball implements Drawable
{
  Ball() { ... }
  void draw() { ellipse(...); }
}
class Wall implements Drawable
{
  Wall() { ... }
  void draw() { rect(...); }
}

So heterogeneous objects offer a similar API and can be collected in a List<Drawable>.

Thanks, that's great advice. I will have a play with the registerxxx() and the classical way!

"Classic way" (using an interface and an array)

Hmmmmmmm,

Cheers

Thanks for having setting up this test.
I rewrote it to make it a pure Processing sketch, and one sketch only.
I see perhaps a very small advantage to the "classical way" (calling draw() manually on each object. The interface is just an implementation detail), but it isn't flagrant or even consistent... In general, the overhead of reflection is near zero with regard to the time needed to draw the scene. Good to know.
Now, I think I will still use the classical way, because we still need to loop over the list of objects to update them, etc. And if we remove objects, we have to remember to unregister them first.
At least, the classical way is consistent over the processing of objects, and we can control when, in the draw() function, we call it (sometime, order of drawing is important).
But that's just my choice, and this registerXxx method is handy for libraries and smart.

My modified code:

1. ArrayList<TestObject> list = new ArrayList<TestObject>();
2. int amount = 10000;
3. int ms;
4. int currentTime;
5. boolean useRegisterDraw = false;
6.  
7. void setup() {
8.   size(1024, 768);
9. //~   frameRate(60);
10.   textSize(40);
11.   strokeWeight(1);
12.   stroke(0, 128);
13.   smooth();
14.   for (int i = 0; i < amount; i++) {
15.     float rnd = random(5, 10);
16.     list.add(new TestObject(random(width), random(height), rnd, rnd));
17.   }
18.   ms = millis();
19. }
20.  
21. void draw() {
22.   background(255);
23.   for (TestObject obj : list) {
24.     if (!useRegisterDraw) {
25.       obj.draw();
26.     }
27.     obj.move();
28.   }
29.   fill(255,0,0);
30.   text(str(currentTime), 10, 10, 200, 200);
31.   if (frameCount % 10 == 0) {
32.     currentTime = millis() - ms;
33.     println(currentTime);
34.     ms = millis();
35.   }
36. }
37.  
38. public class TestObject {
39.   float x;
40.   float y;
41.   float w;
42.   float h;
43.  
44.   public TestObject(float tX, float tY, float tW, float tH) {
45.     if (useRegisterDraw) {
46.       registerDraw(this);
47.     }
48.     x = tX;
49.     y = tY;
50.     w = tW;
51.     h = tH;
52.   }
53.  
54.   public void draw() {
55.     fill(0, 64);
56.     ellipse(x, y, w, h);
57.   }
58.  
59.   public void move() {
60.     x += random(-2, 2);
61.     y += random(-2, 2);
62.   }
63. }