Processing, initialised array added to constructor but not able to add it for the initialsed object

The Syntax Error - Missing name or ; near ‘void’? error occurs between Planet _planetTextures and void setup().

Sometimes error can be a bit cryptic: in this case it's as straightforward as it can be: you forgot to add ; at the end of Planet _planetTextures.

That being said, I've spotted a bunch of other areas in your code you might want to revise:

• _planetTextures is later used as if it's a PImage[] in setup() when you instantiate planets
• the Planet constructor takes in a PImage[] _planetTextures argument. If a single planet uses a single texture, maybe you meant PImage _planetTexture instead ?
• The Planet constructor loads 3 images (mercury, venus, earth): should it be task of the main sketch to load all assets, then pass each single PImage to it's respective planet (instead of reloading the same 3 images for every single planet instance)
• since the planet texture is only once in the constructor, there's no need for the PImage[] property
• the backround PImage was loaded continously, multiple times per frame in sceene() (called from draw()): you might want to load the image once in setup.

Here is your code with the above tweaks applied:

//Solar system and it's gravitation's simulation.
// The central sun applies gravitation to other celestial bodies

PImage background;
PImage sun_Texture;

float cameraX, cameraY;

// zoom and pan
float scale = 0.06;
float xPan = 600;
float yPan = 398;

boolean zoomIn = false;
boolean zoomOut = false;

//includes
Sun sun;
Planet mercury;
Planet venus;
Planet earth;
Planet mars;
Planet jupiter;
Planet saturn;
Planet uranus;
Planet neptune;
Planet pluto;
PImage[] planetTextures;

//screen setup
void setup() {

  //Screen size
  size(1200, 799, P3D);

  sun_Texture = loadImage("sun.jpg");

  // Celestial object properties
  // 1; Planet's size
  // 2; Planet's color / texture
  // 3; Movement speed
  // 4; Planet's path color
  // 5; Planet's path size
  // 6; Distance from Sun
  // 7; Planet's number of moons        // need to check it
  
  // Load background image
  background = loadImage("stars.jpg");
  
  // Load textures into an array
  planetTextures[0] = loadImage ("mercury.jpg");
  planetTextures[1] = loadImage ("venus.jpg");
  planetTextures[2] = loadImage ("earth.jpg");
  
  //Spawn celestial objects
  sun = new Sun(696, color(255, 50, 0));
  mercury = new Planet(5, 0.2, 2, color(255, 200, 100), 1448, planetTextures[0]);
  venus = new Planet(12, 0.2, 2, color(150, 10, 100), 1499, planetTextures[1]);
  earth = new Planet(13, 0.2, 2, color(255, 255, 100, 100), 1540, planetTextures[2]);
  //mars = new Planet(7, 0.5, 2, color(167, 45, 160), 1618);
  //jupiter = new Planet(143, 0.5, 2, color(167, 45, 160), 2169);
  //saturn = new Planet(121, 0.5, 2, color(167, 45, 160), 2825);
  //uranus = new Planet(51, 0.5, 2, color(167, 45, 160), 4263);
  //neptune = new Planet(50,0.5, 2, color(167, 45, 160), 5886);
  //pluto = new Planet(2, 0.5, 2, color(167, 45, 160), 6486);
}

// sceene setup
void scene() {
  background(background);
  // Set it in the middle of the screen
  translate(width/2, height/2, 0);
}

// draw setup
void draw() {

  // Zoom towards the center of the screen, rather the edge of the screen
  translate(width/2, height/2, 0);
  scale(scale);
  // Translate Y and X pan
  translate( -xPan, -yPan);

  // Draw background
  scene();

  // Zoom In
  if (zoomIn) {
    scale *= 1.01;
  }
  // Zoom Out
  if (zoomOut) {
    scale /= 1.01;
  }

  // Display sun and rotate Y axis camera around sun
  sun.display();
  sun.move(mouseY);

  //mercury
  mercury.display();
  mercury.move();

  //venus
  venus.display();
  venus.move();

  //earth
  earth.display();
  earth.move();

  ////mars
  //mars.display();
  //mars.move();

  ////jupiter
  //jupiter.display();
  //jupiter.move();

  ////saturn
  //saturn.display();
  //saturn.move();

  ////uranus
  //uranus.display();
  //uranus.move();

  ////neptune
  //neptune.display();
  //neptune.move();

  ////pluto
  //pluto.display();
  //pluto.move();
}

// Key press record function, responsible for zoom in and out of scene
void keyPressed() {
  if (keyCode == UP) {
    zoomIn = true;
    zoomOut = false;
  }
  if (keyCode == DOWN) {
    zoomIn = false;
    zoomOut = true;
  }
}

void keyReleased() {
  if (keyCode == UP) {
    zoomIn = false;
  }
  if (keyCode == DOWN) {
    zoomOut = false;
  }
}

class Planet {
  float radius = 0;
  float moveSpeed;
  float distance;
  float size;
  color planetColor;
  int pathSize;
  color pathColor;
  PShape planet;

  Moon moon;

  Planet(int _size, float _speed, int _path_size, color _path_color, float _dist, PImage _planetTexture) {      //color _color
    size = _size;
    //planetColor = _color;
    moveSpeed = _speed;
    pathColor = _path_color;
    pathSize = _path_size;
    distance = _dist;
    moon = new Moon(10, color(200, 200, 100));

    // Set planet's texture
    noStroke();
    noFill();
    planet = createShape(SPHERE, size);
    planet.setTexture(_planetTexture);
  }

  void display() {

    pushMatrix();

    //path
    stroke(pathColor);
    strokeWeight(2);
    noFill();
    rotateY(radius * moveSpeed);
    rotateX(PI/2);
    ellipse(0, 0, 2*distance, 2*distance);

    //body
    noStroke();
    fill(planetColor);
    translate(distance, 0, 0);
    shape(planet);
    //sphere(size);

    moon.display();
    moon.move();
    popMatrix();
  }

  void move() {
    radius += moveSpeed;
  }
}

It would've made it easier to for others to test if you would have also posted the Sun/Moon classes and the textures uses: something to remember for future posts. (The easier it is for others to replicate your issue the more like to get (good) answers).

Not bad progress and you're getting the main points about classes. There might still be confusion over how arguments get passed from the sketch(global) scope to instances, but that may also be an artefact of perhaps trying to write a lot of code in one go ?

If that's the case, I recommend slowing down, writing one bit of functionality at a time (e.g. one function or class method at a time, running the sketch and testing to ensure it works as expected first). Once a bit of code works as expected to you can move to the next and ideally text combinations of the newly added functionalities to ensure that there no weird interactions between classes. Constantly testing how the code behaves may appear slower, but resting assured the code works as go along is faster on the long run and it definitely makes debugging much easier (likely to be most recently added functionality which is also freshes in your memory). Have fun coding !