" The code is very bad organised cause I haven't improved myself yet in using arrays..!"
Indeed! First thought when seeing such code is to point to the From several variables to arrays article...

I was surprised you used a class before properly use arrays. But your class isn't very useful, I fear. You should make a Ball class instead, each Ball managing its movement and bouncing.

I suggest to try and do the change to handle arrays, the code will be much easier to read and to fix.

You should also describe more precisely the behavior you expect from these balls, with regards to bounds and boxes.

I edited my answer not seeing you answered.
As I wrote, please describe what is wrong in your program: what do you expect, what isn't working.
The code isn't incorrect because it doesn't use arrays. But it is much harder to read, so to analyze a problem.

The problem lies in this code

    // CONTROLLO RIMBALZI QUADRATINO
    if ((location1.x > pos2x - box2size) && (location1.x < pos2x + box2size)) {      // 1°
        velocity1.x = velocity1.x * -1;
    }
    if ((location1.y > pos2y - box2size) && (location1.y < pos2y + box2size)) {
        velocity1.y = velocity1.y * -1;
    }

You need to test whether the ball has entered the box then reflect the ball like this 

1. if (location1.x > pos2x - box2size && location1.x < pos2x + box2size && location1.y > pos2y - box2size && location1.y < pos2y + box2size) {      // 1°
2.         velocity1.x = velocity1.x * -1;
3.         velocity1.y = velocity1.y * -1;
4. }

Do this for each one.

BTW please do, do, do learn arrays !!!! 

This is for number 2 (I used this one so I could test it) but you would need to the same for all balls

1. float fx, fy;
2. 
   
3. if (location2.x > pos2x - box2size && location2.x < pos2x + box2size && location2.y > pos2y - box2size && location2.y < pos2y + box2size) {      // 2°
4.       fx = (location2.x - pos2x);
5.       if (fx < 2 || fx > box2size - 2)
6.         velocity2.x = velocity2.x * -1;
7.       fy = (location2.y - pos2y);
8.       if (fy < 2 || fy > box2size - 2)
9.         velocity2.y = velocity2.y * -1;
10. }

Yes, it better!!  but.. (I hope you will not hate me now) it doesn't work always correctly....

Here the new code, take a try....


Mover mover;
// INIZIAZIONE VARIABILI
int width = 600;           // schermo
int height = 600;
float dim = 20;            // punti
float posX = width/2;      // quadratino
float posY = height/2;
int boxSize = 15;
boolean overBox = false;
boolean locked = false;
float xOffset = 0.0;
float yOffset = 0.0;
float pos2x = 20;          // secondo quadratino
float pos2y = 20;
int box2size = 30;
boolean overBox2 = false;
boolean locked2 = false;
float xOffset2 = 0.0;
float yOffset2 = 0.0;

void setup() {
  size (width, height);
  smooth();
  rectMode (RADIUS);
  mover = new Mover();
}

void draw() {
  background (255);
  // PUNTAMENTO PRIMO QUADRATO
  if (mouseX > posX - boxSize && mouseX < posX + boxSize &&
      mouseY > posY - boxSize && mouseY < posY + boxSize) {
        overBox = true;
        if (!locked) {
          stroke(255, 0, 0);
          strokeWeight(3);
        }
      } else {
        stroke (0);
        strokeWeight(2);
        overBox = false;
      }
      strokeWeight(2);
      rect (posX, posY, boxSize, boxSize);
  // PUNTAMENTO SECONDO QUADRATO
  if (mouseX > pos2x - box2size && mouseX < pos2x + box2size &&
      mouseY > pos2y - box2size && mouseY < pos2y + box2size) {
        overBox2 = true;
        if (!locked2) {
          stroke(0);
        }
      } else {
        overBox2 = false;
      }
      stroke (0);
      strokeWeight (2);
      rect (pos2x, pos2y, box2size, box2size);
  mover.update();
  mover.checkEdges();
  mover.display();
 
}

void mousePressed() {
  if (overBox) {            // pressione primo quadrato
    locked = true;
    xOffset = mouseX - posX;
    yOffset = mouseY - posY;
  } else {
    locked = false;
  }
 
  if (overBox2) {           // pressione secondo quadrato
    locked2 = true;
    xOffset2 = mouseX - pos2x;
    yOffset2 = mouseY - pos2y;
  } else {
    locked2 = false;
  }
}

void mouseDragged() {
  if (locked) {
    posX = mouseX - xOffset;
    posX = constrain (posX, 16, width - 17);
    posY = mouseY - yOffset;
    posY = constrain (posY, 16, height - 17);
  }
  if (locked2) {
    pos2x = mouseX - xOffset2;
    pos2x = constrain (pos2x, 31, width - 32);
    pos2y = mouseY - yOffset;
    pos2y = constrain (pos2y, 31, height - 32);
  }
}

void mouseReleased() {
  locked = false;
  locked2 = false;
}

class Mover {
 
  PVector location1;         // dichiarazione dei vettori
  PVector location2;
  PVector location3;
  PVector location4;
  PVector location5;
  PVector location6;
  PVector location7;
  PVector location8;
  PVector velocity1;
  PVector velocity2;
  PVector velocity3;
  PVector velocity4;
  PVector velocity5;
  PVector velocity6;
  PVector velocity7;
  PVector velocity8;
 
  Mover() {
    location1 = new PVector (posX, posY);   // dichiarazione del valore dei vettori
    location2 = new PVector (posX, posY);
    location3 = new PVector (posX, posY);
    location4 = new PVector (posX, posY);
    location5 = new PVector (posX, posY);
    location6 = new PVector (posX, posY);
    location7 = new PVector (posX, posY);
    location8 = new PVector (posX, posY);
    velocity1 = new PVector (0.5, 0);
    velocity2 = new PVector (0.35, 0.35);
    velocity3 = new PVector (0, 0.5);
    velocity4 = new PVector (-0.35, 0.35);
    velocity5 = new PVector (-0.5, 0);
    velocity6 = new PVector (-0.35, -0.35);
    velocity7 = new PVector (0, -0.5);
    velocity8 = new PVector (0.35, -0.35);
  }
 
  void update() {
    location1.add(velocity1);          // somma posizioni e velocità corrispondenti
    location2.add(velocity2);
    location3.add(velocity3);
    location4.add(velocity4);
    location5.add(velocity5);
    location6.add(velocity6);
    location7.add(velocity7);
    location8.add(velocity8);
  }

  void display() {
    stroke (0);
    strokeWeight(dim);
    point(location1.x,location1.y);
    point(location2.x,location2.y);
    point(location3.x,location3.y);
    point(location4.x,location4.y);
    point(location5.x,location5.y);
    point(location6.x,location6.y);
    point(location7.x,location7.y);
    point(location8.x,location8.y);
   
  }

  void checkEdges() { 
    frameRate(150);
    // CONTROLLO RIMBALZI PERIMETRO
    if ((location1.x >= width) || (location1.x <= 0)) {                          // controllo rimbalzo
    velocity1.x = velocity1.x * -1;
    }
    if ((location1.y >= height) || (location1.y <= 0)) {
    velocity1.y = velocity1.y * -1;
    }
    if ((location2.x >= width) || (location2.x <= 0)) {
    velocity2.x = velocity2.x * -1;
    }
    if ((location2.y >= height) || (location2.y <= 0)) {
    velocity2.y = velocity2.y * -1;
    }
    if ((location3.x >= width) || (location3.x <= 0)) {
    velocity3.x = velocity3.x * -1;
    }
    if ((location3.y >= height) || (location3.y <= 0)) {
    velocity3.y = velocity3.y * -1;
    }
    if ((location4.x >= width) || (location4.x <= 0)) {
    velocity4.x = velocity4.x * -1;
    }
    if ((location4.y >= height) || (location4.y <= 0)) {
    velocity4.y = velocity4.y * -1;
    }
    if ((location5.x >= width) || (location5.x <= 0)) {
    velocity5.x = velocity5.x * -1;
    }
    if ((location5.y >= height) || (location5.y <= 0)) {
    velocity5.y = velocity5.y * -1;
    }
    if ((location6.x >= width) || (location6.x <= 0)) {
    velocity6.x = velocity6.x * -1;
    }
    if ((location6.y >= height) || (location6.y <= 0)) {
    velocity6.y = velocity6.y * -1;
    }
    if ((location7.x >= width) || (location7.x <= 0)) {
    velocity7.x = velocity7.x * -1;
    }
    if ((location7.y >= height) || (location7.y <= 0)) {
    velocity7.y = velocity7.y * -1;
    }
    if ((location8.x >= width) || (location8.x <= 0)) {
    velocity8.x = velocity8.x * -1;
    }
    if ((location8.y >= height) || (location8.y <= 0)) {
    velocity8.y = velocity8.y * -1;
    }

    // CONTROLLO RIMBALZI QUADRATINO
    float fx, fy;
    if (location1.x > pos2x - box2size && location1.x < pos2x + box2size &&    // 1
        location1.y > pos2y - box2size && location1.y < pos2y + box2size) {     
        fx = (location1.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity1.x = velocity1.x * -1;
        fy = (location1.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity1.y = velocity1.y * -1;
        }
    if (location2.x > pos2x - box2size && location2.x < pos2x + box2size &&    // 2
        location2.y > pos2y - box2size && location2.y < pos2y + box2size) {     
        fx = (location2.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity2.x = velocity2.x * -1;
        fy = (location2.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity2.y = velocity2.y * -1;
        }
     if (location3.x > pos2x - box2size && location3.x < pos2x + box2size &&   // 3
        location3.y > pos2y - box2size && location3.y < pos2y + box2size) {     
        fx = (location3.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity3.x = velocity3.x * -1;
        fy = (location3.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity3.y = velocity3.y * -1;
        }
     if (location4.x > pos2x - box2size && location4.x < pos2x + box2size &&   // 4
        location4.y > pos2y - box2size && location4.y < pos2y + box2size) {     
        fx = (location4.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity4.x = velocity4.x * -1;
        fy = (location4.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity4.y = velocity4.y * -1;
        }
     if (location5.x > pos2x - box2size && location5.x < pos2x + box2size &&   // 5
        location5.y > pos2y - box2size && location5.y < pos2y + box2size) {     
        fx = (location5.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity5.x = velocity5.x * -1;
        fy = (location5.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity5.y = velocity5.y * -1;
        }
     if (location6.x > pos2x - box2size && location6.x < pos2x + box2size &&   // 6
        location6.y > pos2y - box2size && location6.y < pos2y + box2size) {     
        fx = (location6.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity6.x = velocity6.x * -1;
        fy = (location6.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity6.y = velocity6.y * -1;
        }
     if (location7.x > pos2x - box2size && location7.x < pos2x + box2size &&   // 7
        location7.y > pos2y - box2size && location7.y < pos2y + box2size) {     
        fx = (location7.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity7.x = velocity7.x * -1;
        fy = (location7.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity7.y = velocity7.y * -1;
        }
     if (location8.x > pos2x - box2size && location8.x < pos2x + box2size &&   // 8
        location8.y > pos2y - box2size && location8.y < pos2y + box2size) {     
        fx = (location8.x - pos2x);
        if (fx < 2 || fx > box2size - 2)
        velocity8.x = velocity8.x * -1;
        fy = (location8.y - pos2y);
        if (fy < 2 || fy > box2size - 2)
        velocity8.y = velocity8.y * -1;
        }

    // DECREMENTO DIMENSIONE PUNTI
    dim = dim - 0.01;
    dim = constrain (dim, 1, 20);
    // RIAVVIO AUTOMATICO
    if (dim == 1) {
      location1.x = posX;
      location1.y = posY;
      location2.x = posX;
      location2.y = posY;
      location3.x = posX;
      location3.y = posY;
      location4.x = posX;
      location4.y = posY;
      location5.x = posX;
      location5.y = posY;
      location6.x = posX;
      location6.y = posY;
      location7.x = posX;
      location7.y = posY;
      location8.x = posX;
      location8.y = posY;
      dim = 20;
    }
  }
}

Try this it is as near as I am going to get it.

1. float fx, fy;
2. float halfBox2Size = box2size / 2;
3. 
   
4. // Repeat for each box
5. if (location6.x > pos2x - box2size && location6.x < pos2x + box2size &&   // 6
6.         location6.y > pos2y - box2size && location6.y < pos2y + box2size) {    
7.         fx = (location6.x - pos2x + halfBox2Size);
8.         if (fx < 2 || fx > box2size - 2)
9.         velocity6.x = velocity6.x * -1;
10.         fy = (location6.y - pos2y + halfBox2Size);
11.         if (fy < 2 || fy > box2size - 2)
12.         velocity6.y = velocity6.y * -1;
13. }

The rest is up to you.

I'm not sure why you need so many location and velocity PVectors, however if you do absolutely need them, I would put them in an array. I think it would go like this:

I need them because I want every point to go in a different direction...The problem is my "not being able" in using arrays..but..I'm studing them right now from manual...I hope to semplify the code and get it right...And so I hope in others your helps... :-) I have to see some examples to understand...is complex for me after only two days studing Processing... :-)