here

ok, let me explain.

you pass 3 parameters to the class when invoking a new object (planetoid).
one would expect centerX and centerY (aka sun) and radius of the planets orbit (the last I added) being the parameters,
but it is not, it's current position x and y and radius of the planets orbit.

But the current position x and y is calculated anyway (in display()) so it's not necessary to pass them over.
Thus those lines are commented out in the constructor:

1.     // x = _x;
2.     // y = _y;

(your current sun position / center of orbits is set in line 44)

really the main thing I had to change beside the radius of the planets orbit was popMatrix and pushMatrix (that's because translate would add up and thus pushing the next planet outside the screen. With popMatrix and pushMatrix you avoid this).

1. //DECLARE VARS
2. planetoid myplanetoid;
3. planetoid myplanetoid2;
4. planetoid myplanetoid3;
5. void setup () {
6.   size(600, 600);
7.   smooth();
8.   //INITIALISE
9.   myplanetoid = new planetoid(230, 250, 100);
10.   myplanetoid2 = new planetoid(200, 200, 200);
11.   myplanetoid3 = new planetoid(300, 200, 300);
12. }
13. void draw() {
14.   background(0);
15.   ellipse(width/2, height/2, 50, 50);
16.   //CALL FUNCTIONALITY
17.   myplanetoid.run();
18.   myplanetoid2.run();
19.   myplanetoid3.run();
20. }
21. //
22. // ===============================================
23. //
24. class planetoid {
25.   float orbitDuration = 5*1000; // 5 second orbit
26.   float orbitRad = 50;
27.   float x = 0;
28.   float y = 0;
29.   //CONSTRUCTOR
30.   planetoid( float _x, float _y, float _orbitRad ) {
31.     // x = _x;
32.     // y = _y;
33.     orbitRad = _orbitRad;
34.   }
35.   //FUNCTIONS - declare, run once
36.   void run() {
37.     display();
38.   }
39.   void display() {
40.     float ang = TWO_PI * millis()/orbitDuration;
41.     float x = cos(ang)*orbitRad;
42.     float y = sin(ang)*orbitRad;
43.     pushMatrix();
44.     translate(width/2, height/2);
45.     ellipse(x, y, 5, 5);
46.     popMatrix();
47.   }
48. }

or with color and different speed
(later you''ll have the color as a property of the planets and have the sun as a "planet" too (orbit radius = 0))

1. //DECLARE VARS
2. planetoid myplanetoid;
3. planetoid myplanetoid2;
4. planetoid myplanetoid3;
5. void setup () {
6.   size(600, 600);
7.   smooth();
8.   //INITIALISE
9.   myplanetoid = new planetoid(230, 250, 90, 3000);
10.   myplanetoid2 = new planetoid(200, 200, 200, 4000);
11.   myplanetoid3 = new planetoid(300, 200, 260, 6000);
12. }
13. void draw() {
14.   background(0);
15.   // sun
16.   fill (241, 245, 2);
17.   ellipse(width/2, height/2, 50, 50);
18.   //CALL FUNCTIONALITY
19.   fill (241, 145, 2);
20.   myplanetoid.run();
21.   fill (255, 2, 2);
22.   myplanetoid2.run();
23.   fill (22, 2, 255);
24.   myplanetoid3.run();
25. }
26. //
27. // ===============================================
28. //
29. class planetoid {
30.   float orbitDuration = 5*1000; // 5 second orbit
31.   float orbitRad = 50;
32.   float x = 0;
33.   float y = 0;
34.   //CONSTRUCTOR
35.   planetoid( float _x, float _y,
36.   float _orbitRad,
37.   int _orbitDuration ) {
38.     // x = _x;
39.     // y = _y;
40.     orbitRad = _orbitRad;
41.     orbitDuration = _orbitDuration;
42.   }
43.   //FUNCTIONS - declare, run once
44.   void run() {
45.     display();
46.   }
47.   void display() {
48.     float ang = TWO_PI * millis()/orbitDuration;
49.     float x = cos(ang)*orbitRad;
50.     float y = sin(ang)*orbitRad;
51.     pushMatrix();
52.     translate(width/2, height/2);
53.     ellipse(x, y, 7, 6);
54.     popMatrix();
55.   }
56. }

Hi Josan12,

using PeasyCam library (a simple 3Dcam) and OpenGl, I came out with that. Sun is like a central planet with no orbit duration... You have to download PeasyCam first and install it in your Sketch\libraries folder.

import processing.opengl.*;
import peasy.test.*;
import peasy.org.apache.commons.math.*;
import peasy.*;
import peasy.org.apache.commons.math.geometry.*;


//DECLARE VARS
planetoid myplanetoid;
planetoid myplanetoid2;
planetoid myplanetoid3;
planetoid myplanetoid4;
PeasyCam cam;
void setup () {
  size(600, 600,OPENGL);
  smooth();
  noStroke();
  //INITIALISE
  cam = new PeasyCam(this,0,0,0,500);
  cam.setMinimumDistance(10);
  cam.setMaximumDistance(2500);
  myplanetoid = new planetoid(230, 250,7, 90, 3000);
  myplanetoid2 = new planetoid(200, 200,5, 200, 4000);
  myplanetoid3 = new planetoid(300, 200, 9,260, 6000);
  myplanetoid4 = new planetoid(width/2,height/2, 20,0, 1000);
}
void draw() {
  background(0);
  // sun
  fill (255, 255, 255,30);
//  translate(width/2, height/2,0);
//  sphere(25);
  ellipse(0, 0, 550, 550);
  //CALL FUNCTIONALITY
  fill (241, 145, 2);
  myplanetoid.run();
  fill (255, 2, 2);
  myplanetoid2.run();
  fill (22, 2, 255);
  myplanetoid3.run();
  fill (255, 255, 0);
  myplanetoid4.run();
}
//
// ===============================================
//
class planetoid {
  float orbitDuration = 5*1000; // 5 second orbit
  float orbitRad = 50;
  float x = 0;
  float y = 0;
  float dia=0;
  //CONSTRUCTOR
  planetoid( float _x, float _y, float _dia,
  float _orbitRad,
  int _orbitDuration ) {
    // x = _x;
    // y = _y;
    dia=_dia;
    orbitRad = _orbitRad;
    orbitDuration = _orbitDuration;
  }
  //FUNCTIONS - declare, run once
  void run() {
    display();
  }
  void display() {
    float ang = TWO_PI * millis()/orbitDuration;
    float x = cos(ang)*orbitRad;
    float y = sin(ang)*orbitRad;
    pushMatrix();
    translate(x,y);
    sphere(dia);
    //ellipse(x, y, 7, 6);
    popMatrix();
  }
}

Cool - thanks Chrisir and marzinp.  Now I see you can assign more than two variables to the class:

1. planetoid(float a, float b, float c, float d) {
   
     }

Also - as far as i can see all you did to separate my planets is make float c '_orbitRad'
and then orbitRad = _orbitRad;
This i don't understand as orbitRad was already set to 50 on line 26, and we also set it
to 100, 200 and 300 (line 9, 10 and 11) by linking float c....
are we effectively changing the orbitRad variable for each planetoid!?!

we change the orbitrad for each planet, yes.
Otherwise they would all have the same orbit radius, that'd be strange.
The default value is 50 but we overwrite that in the constructor. You can delete the =50 in line 31.

But is 'float a' always the x co-ordinate and 'float b' always the y co-ordinate?

No, you can use any var you want.
It works like this: You pass a value as a parameter. The name doesn't matter but you decided to name the var with same name as in the class but with a _ in front. That's good.
But being a mere parameter (e.g. _x) it is not permanent but only alive in the constructor. So, we need to pass it to the object that we just invoke with the use of the constructor to make it a permanent value of the object. To do so we say

1. x=_x;

Only an example because in your code, this parameter is not in use.


OOP:
think of the class itself as a blue print or the idea of a planetoid.

by saying

1.   myplanetoid = new planetoid(230, 250,7, 90, 3000);

you invoke a real object / thing based on this blue print.

but each can have different values.

Maybe read
http://processing.org/learning/objects/


set them random
to set them random start locations you would give each planet

• random orbit radius and
• an random offset to add to the angle (line 48)

Then think about 3d orbits and universal attraction... Maybe one or two blackholes, and you're God!

Ok thanks for your help Chrisir.  I'm still working through the basics but it's very helpful when
someone can help me over a wall ;)