" processing doesn't like that!"
Of tastes and colors...

Maybe showing the error message, or, better, the code itself, would be more helpful than this generic description.

You could have pasted the code, it isn't so big.
Anyway, I see where the problem is, but I don't see where you are going.
You have Seed, Child and Child2 classes (names aren't very expressive...), which are totally identical, except for the internal names (some referring to the others). One of the point of object oriented programming (or any programming in general) is to avoid duplicate code, to reuse as much as possible.
So you better have a single base Node class (or Child, if you want), holding a number of sub-nodes, of same Node type.

What I don't understand is the base purpose of your classes: you create blindly lot of classes (each creating other classes creating classes of former type), hence the stack overflow. But these classes must have a purpose, and must be used in some way. Your model must reflect some "real" structure, so you know when to stop creating items. Perhaps at a given level of tree depth.

That's why I don't provide code, as your is quite theoretical, so I can't provide a real solution. I hope my remarks can be of some help, though.

Agreed.  Perhaps explain what you're hoping to achieve: what does your 'hierarchy tree' represent?

The only problem is though, that the amount of generations is allready described (in this case 3).
I prefer that this could also be generated dynamic.

You can probably use an ArrayList in place of plain array.

Indeed, the ArrayList addresses the width of the tree. But since you add Nodes to it, you can add sub-Nodes in their array list, then sub-sub-nodes to these sub-nodes, and so on. This schema can grow indefinitely in depth too.

Mmm, I finally took a look at your second code, which is more concrete with some good ideas.
I applied the ideas I exposed above: avoid code duplication, have only one kind of node, limit level.

1. // Trees.pde
2. int MAX_LEVELS = 3;
3. Node[] nodes = new Node[5];
4.  
5. static color[] colors =
6. {
7.   #FF0000,
8.   #00FF00,
9.   #0000FF,
10.   #FFFF00,
11.   #FF00FF,
12.   #00FFFF,
13. };
14.  
15. void setup() {
16.   size(500, 500);
17.   background(255);
18.   smooth();
19.   frameRate(1);
20.  
21.   for (int i = 0; i < nodes.length; i++) {
22.     nodes[i] = new Node(0, (int) random(3, 7), width/2, height/2, 10);
23.     nodes[i].makeNodes(300, 300);
24.   }
25. }
26.  
27. int teller = 0;
28. int tellerGrens = 5;
29. int i;
30.  
31. void draw() {
32.   background(255);
33.   nodes[i].display();
34.  
35.   teller = ++teller % tellerGrens;
36.   if (teller == 0) {
37.     i = ++i % nodes.length;
38.   }
39. }

1. // Node.pde
2. class Node {
3.   int level;
4.   Node[] n;
5.   float x, y, r;
6.  
7.   Node(int level, int amountNodes, float x, float y, float r) {
8.     this.level = level;
9.     this.x = x;
10.     this.y = y;
11.     this.r = r;
12.     n = new Node[amountNodes];
13.   }
14.  
15.   void makeNodes(int borderX, int borderY) {
16.     int l = level + 1;
17.     for (int i = 0; i < n.length; i++) {
18.       n[i] = new Node(l,
19.           (int)random(1, 10),
20.           random(x - borderX/2, x + borderX/2),
21.           random(y - borderY/2, y + borderY/2),
22.           5);
23.       if (level < MAX_LEVELS-1) {
24.         n[i].makeNodes(100 / l, 100 / l);
25.       }
26.     }
27.   }
28.  
29.   void display() {
30. //    println("L " + level + " N " + n.length);
31.     stroke(colors[level]);
32.     ellipse(x, y, r, r);
33.     
34.     if (level >= MAX_LEVELS)
35.       return; // No sub-nodes to display
36.     for (int i = 0; i < n.length; i++) {
37.       stroke(colors[level+1]);
38.       line(x, y, n[i].x, n[i].y);
39.       n[i].display();
40.     }
41.   }
42. }