Have made some changes and the ball is bouncing around now at least.

1. Ball myBall;
   int speedX = int(random(-5,5));
   int speedY = int(random(-5,5));
   
   void setup() {
     size(400, 400);
     myBall = new Ball();  //should this line be in the constructor for class ball?
     smooth();
     frameRate(200);
   }
   
   void draw() {
     background(255);
     myBall.movingBall();
     myBall.display();
     myBall.collision();
   }
   
   class Ball {
     int radius;
     int locX, locY;
     color col;
     //CONSTRUCTOR
     Ball() {
       col = int(random(0, 255));  //??? Color
       radius = int(random(20, 40));
       locY = int(random(0, 400)); 
       locX = int(random(0, 400));
     } 
     void display() {
       ellipseMode(CENTER);
       noStroke();
       fill(col);
       smooth();
       ellipse(locX, locY, radius, radius);
     }
     void movingBall() {
       locX = locX + speedX;
       if (locX >= width || locX <=0) {
         speedX = -speedX;
         locX += speedX;
       }
       locY = locY + speedY;
       if (locY >= height || locY <= 0) {
         speedY = -speedY;
         locY += speedY;
       }
     }
     void collision() {   // ????
     }
   }
   
   

well you need two balls in the whole program.

So duplicate the relevant lines:

from

1. Ball myBall;

go to

1. Ball myBall1;
2. Ball myBall2;

and

1.   myBall1 = new Ball();  //should this line be in the constructor for class ball?
2.   myBall2 = new Ball();  //should this line be in the constructor for class ball?

and in draw()

1.   myBall1.movingBall();
2.   myBall1.display();
3.   myBall1.collision( myBall2 );
4. 
   
5.   myBall2.movingBall();
6.   myBall2.display();

This must be within class Ball, not global

1. int speedX = int(random(-5, 5));
2. int speedY = int(random(-5, 5));

the method:

1.   void collision( Ball theOtherBall ) {   // ????
2.     if (dist of both balls <= sum of both radius) {
3.       theyCollided = true;
4.     }
5.   }

theyCollided is a global var, false at the beginning.

When theyCollided  is true, don't call both movingBall in draw() anymore.


Greetings, Chrisir   

there's more:

• e.g. your radius is in fact a diameter
• the collision with the wall shouldn't be at 0 but at diameter / 2.
• your wall collision leads to ball stuttering often
• speedXor speedY can be 0; this can/should be avoided.
• smooth is enough in draw() no need to have it in display()

Thanks for taking out the time to look at the code, its really appreciated. I now have two random balls bouncing around almost correctly. However, there still some 'stuttering' and vertical location problems.

I have implemented most of your suggestions but still confused with the collision part...I think it's the two balls and the class that is confusing me. I am not comparing the two radius from each ball as you say to do but only the one radius at the moment for the one ball.

What should I fix at this point?

Thanks.

1. Ball myBall1;
   Ball myBall2;
   boolean ballsCollide = false;
   
   void setup() {
     size(400, 400);
     myBall1 = new Ball(); 
     myBall2 = new Ball();
     frameRate(60);
   }
   
   void draw() {
     background(#00C3D3);
     smooth();
     myBall1.movingBall();
     myBall1.display();
     myBall1.collision(myBall2);
     myBall2.movingBall();
     myBall2.display();
   }
   
   class Ball {
     int radius;
     int locX, locY;
     color col;
     int speedY;
     int speedX;
     Ball() {
       speedX = int(random(1,10));
       speedY = int(random(1,10));
       col = int(random(0, 255));
       radius = int(random(20, 40));
       locY = int(random(0, 400)); 
       locX = int(random(0, 400));
     } 
     void display() {
       ellipseMode(CENTER);
       noStroke();
       fill(col);
       ellipse(locX, locY, radius*2, radius*2);
     }
     void movingBall() {
       locX = locX + speedX;
       if (locX >= width-radius || locX <= radius) {  //wrong?
         speedX = -speedX;
         locX += speedX;
       }
       locY = locY + speedY;
       if (locY >= height-radius || locY <= radius) {  //wrong?
         speedY = -speedY;
         locY += speedY;
       }
     }
     void collision(Ball myBall2) {                         //correct?
       float ballSpace = dist(locX, locY, radius, radius);  //something wrong here!
       if (ballSpace <= radius + radius)                    // the 2 same radius variables??
       ballsCollide = true;
     }
   }
   

This

  void collision(Ball myBall2) {                         //correct?

you call this methiod with

1.   myBall1.collision( myBall2 );

So the actual object you are using
is myBall1. So locX, locY is referring to
myBall1 (no need to write myBall1. before).
myBall2 on the other hand is given
as a parameter. So instead of

1.     float ballSpace = dist(locX, locY, radius, radius);  //something wrong here!

you want to get the space between both balls.
Therefore put

1.     float ballSpace = dist(locX, locY, myBall2.locX, myBall2.locY);  //something wrong here!

please. So you are referring to both balls and their radiuses.

since they are not necessarily the same width (same radius) instead of
    if (ballSpace <= radius + radius)                    // the 2 same radius variables??
better
    if (ballSpace <= radius + myBall2.radius)                    // the 2 same radius variables??


Remark on stuttering

You see this a lot around here in help and in the forum:

1.   if (locX >= width-radius || locX <= radius) {  //wrong?
2.       speedX = -speedX;
3.       locX += speedX;
4.     }

but since speedX is just switched between minus and plus and vice versa, the following can happen:
ball gets near zero, speedX = -speedX; is calculated (and is plus then, ball moves away from 0 but only a lttle). In the next step the ball is maybe still near 0, so
speedX = -speedX; gets calculated again and is negativ now, ball moves left towards zero
and stays in that zone near 0 and stutters.

Therefore better:

1.   if (locX >= width-radius) { // right side
   
2.       speedX = - abs(speedX); // abs is always pos and with the negative sign always negative, stable even if executed a few times, no stutter
   
3.   } // if
   
4.   if (locX <= radius) { // left side
   
5.      speedX =  abs(speedX);  // abs is always pos, so it's stable, no stutter
6.   } // if
   
7. locX += speedX;

Greetings, Chrisir   

Hey thanks for the great feedback and explanation! You have helped a lot and I think I have the final result.

Could you let me know if it all looks ok to you?

Once again, thnx.

1. Ball myBall1;
   Ball myBall2;
   
   void setup() {
     size(400, 400);
     myBall1 = new Ball(); 
     myBall2 = new Ball();
     frameRate(60);
   }
   
   void draw() {
     background(#00C3D3);
     smooth();
     if (myBall1.collision(myBall2)) {
       myBall1.display();
       myBall2.display();
       return;
     }
     else 
     myBall1.display();
     myBall2.display();
     myBall1.movingBall();
     myBall2.movingBall();
   }
   
   class Ball {
     int dia;
     int locX, locY;
     color col;
     int speedY;
     int speedX;
     Ball() {
       speedX = int(random(1, 10));
       speedY = int(random(1, 10));
       col = color(random(0, 255), random(0, 255), random(0, 255));
       dia = int(random(20, 40));
       locY = int(random(dia, height-dia/2)); 
       locX = int(random(dia, width-dia/2));
     }   
     void movingBall() {                      
       locX = locX + speedX;
       if (locX >= width-dia) { 
         speedX = -abs(speedX);
       } 
       else if (locX <= dia) {
         speedX = abs(speedX);
         locX += speedX;
       }         
       locY = locY + speedY;
       if (locY >= height-dia) {
         speedY = -abs(speedY);
       } 
       else if (locY <= dia) {
         speedY = abs(speedY);
         locY += speedY;
       }
     } 
   
     void display() {
       ellipseMode(CENTER);
       noStroke();
       fill(col);
       ellipse(locX, locY, dia*2, dia*2);
     }  
   
     boolean collision(Ball myBall2) {                        
       float ballSpace = dist(locX, locY, myBall2.locX, myBall2.locY);
       if (ballSpace <= dia + myBall2.dia) {
         return true;
       }
       else
         return false;
     }
   }
   
   
   
   
   
   

looks good.   

a few remarks:

in draw:

1.     return;

not needed.

Those lines are double in draw:

1.     myBall1.display();
2.     myBall2.display();

not necessary to have them twice.

Put them out of if --- else ---
and have them only once.
After else a { is missing and at the end of the function a }

1.   smooth();

it's enough to have it in setup instead of in draw.

So draw look now like this:

1. void draw() {
2.   background(#00C3D3);
3.   myBall1.display();
4.   myBall2.display();
5.   if (!myBall1.collision(myBall2)) {
6.     myBall1.movingBall();
7.     myBall2.movingBall();
8.   } // if
9. } // draw
   

note the ! near if

in the class

in the constructor

1.     locY = int(random(dia, height-dia/2)); 
2.     locX = int(random(dia, width-dia/2));

normally x values before y-values
so better

1.     locX = int(random(dia, width-dia/2));
2.     locY = int(random(dia, height-dia/2)); 

in void movingBall() {    

note that

1.     locX = locX + speedX;

is the same as

1.       locX += speedX;

so it's double.
Have it only outside if please.
Same goes for

1.       locY += speedY;

in display()

1.     ellipseMode(CENTER);
2.     noStroke();

put in setup()

since you call radius dia now for diameter

1.     ellipse(locX, locY, dia*2, dia*2);

should be

1.     ellipse(locX, locY, dia, dia);

in collision
no {} necessary around
      return true;

since you call radius dia now for diameter, I think (I dunno)

1.     if (ballSpace <= dia + myBall2.dia) {

should be

1.     if (ballSpace <= dia/2 + myBall2.dia/2) {

(sum of radiuses not diameters)


Further Remarks:

• Please test it
• please use ctrl-t to format your program
• you have a constructor but pass no parameters to it. That's fine but maybe your teacher wanted you to pass parameters to it?

Greetings