Tableau d'objet dans un tableau d'objet

voici le code pour la classe Test:

import java.io.Serializable; 
/**
 * le but de cette méthode permet de geré la création de test en ajoutant des questions a un test
 *
 * @author (your name)
 * @version (a version number or a date)
 */
public class Test1 implements Serializable
{
                                               //d’instance). Cette constante doit être initialisée à 2.  
    /**************************
    * CONSTANTE DE CLASSE
    **************************/
    public final static int CAPACITE_INITIALE=2 ;//Sert à initialiser la longueur du tableau questions (voir attributs 
     
    public final static int QUEST_NON_REPONDUE = -1;
    /*
    Chaque fois qu’un nouveau test est créé, ce tableau doit être instancié avec 
    une  longueur  =  CAPACITE_INITIALE.  Puisqu’à  sa  création,  un  test  ne 
    contient aucune question, les cases de ce tableau sont initialisées à null. 
    */
                                                
    private Question[] questions;//Le tableau qui contient les questions de ce test. 
    
    private int nbrQuestions=0;//Le nombre de questions comprises dans ce test. À la création d’un nouveau 
                                //test, cet attribut est initialisé à 0, car le test ne contient aucune question. 
    
    private String nomTest;//Le nom de ce test. 
    
    boolean complete=false ;//Spécifie si ce test a été complété (true) ou non (false). À la création d’un 
                            //nouveau test, cet attribut est initialisé à false. 
    
    //constructeur   avec paramettre         
    public Test1(String nomTest) throws TestInvalideException{       
        if(nomTest==null){
            throw new TestInvalideException();           
        }
        
        else{
            this.nomTest=nomTest;
            questions = new Question[CAPACITE_INITIALE]; //initialise a deux case et null comme valeur            
            nbrQuestions=0;
            complete=false;            
        }            
    }
      
    /**
     * méthode qui permet de retourner le nom du test
     */
    public String getNomTest () { 
        return this.nomTest; 
    } 
    
    /**
     * méthode qui permet de renvoyer le nombre de question
     */
    public int getNombreQuestions () { 
        return this.nbrQuestions;
    } 
    
    /**
     * méthode qui permet de renvoyer le test est fini ou pas
     */
    public boolean isComplete () { 
        return this.complete; 
    } 
    
    /**
     * méthode qui permet d'ecrire dans le nom
     */
    public void setNomTest(String nomTest) throws TestInvalideException{
        if(nomTest==null || nomTest.equals(" ")){
            throw new TestInvalideException(); //voir pourquoi:
        }
        
        else{
            this.nomTest=nomTest;
        }
    }
    
    /**
     * méthode qui permet d'ecrire l'état de complete
     */
    public void setComplete(boolean complete){
        this.complete=complete;
    }
    
    /**
     * permet d'ajouter une questions au tableau question de ce test
     * @ question correspond à la question que nous voulons ajouter
     */
    
     
    public void ajouterQuestion(Question question) throws QuestionInvalideException{ 
        int longueurTest=questions.length;
        Question[] questions2;        
        if(question == null ){
            throw new QuestionInvalideException();
        }else{
            //plus de place dans le tableau pour mettre la question suivante, on ajoute deux cases de plus
            if(nbrQuestions%2==0 && nbrQuestions!=0){
                if(nbrQuestions%2==0 && nbrQuestions!=0){
                    questions2 = new Question[nbrQuestions+2];                    
                    for(int j = 0;j<nbrQuestions;j++){//recopie le tableau dans un second tableau
                        questions2[j]=questions[j];
                    }
                    questions=questions2;
                }
            }            
            questions[nbrQuestions] = question ;//ajoute la question a la suite des autre questions
            nbrQuestions=nbrQuestions+1;//augmente l'indice, cela aussi représente le nombre de question
        }
    }    
}

puis le code de la classe Question qui est :

//importation de l'interface Serializable pour permettre l'enregistrement 
//d'une question dans un fichier binaire
import java.io.Serializable; 

/**
 * Classe qui modelise une question a choix multiples.
 * @author melanie lord
 * @version 7 mars 2018
 */
public class Question implements Serializable {
   
   /**************************
    * CONSTANTE DE CLASSE
    **************************/
   public final static int QUEST_NON_REPONDUE = -1;
   
   /**************************
    * ATTRIBUTS D'INSTANCE
    **************************/
   
   //L'enonce de cette question (non null et non vide).
   private String enonce;
   
   //Tableau contenant les choix de reponses pour cette question.
   //Ce tableau est toujours de longueur minimale (longueur tab = nbr de choix 
   //de reponses) et doit etre de longueur > 1.
   //On suppose aussi que ce tableau ne contient aucun null.
   private String [] choixReponses;
   
   //La bonne reponse a cette question. Doit etre un indice du tableau 
   //choixReponses.
   private int bonneReponse;    
   
   //Pointage alloue pour cette question. Doit etre > 0
   private int pointage;       
   
   //Indique la reponse donnee a cette question. Celle-ci doit etre un indice 
   //du tableau choixReponse OU etre egale a QUEST_NON_REPONDUE.
   private int reponseDonnee = QUEST_NON_REPONDUE; 
   
   /**
    * Constructeur qui initialise les attributs de cette question avec les 
    * valeurs passees en parametres, si celles-ci sont valides. L'attribut
    * reponseDonnee est initialise a QUEST_NON_REPONDUE.
    * 
    * @param enonce l'enonce de la question. Ne doit pas etre null ni vide.
    * @param choixReponses un tableau contenant les choix de reponses pour 
    *                      cette question. Ne doit pas etre null, et doit
    *                      etre de longueur > 1. Ce tableau doit etre de 
    *                      longueur minimale : longueur = nombre de choix de
    *                      reponses.
    * @param pointage le nombre de points alloues pour cette question. 
    *                 Doit etre plus grand que 0.
    * @param bonneReponse l'indice du tableau choixReponses qui correspond a 
    *                     la bonne reponse a cette question. Doit etre
    *                     compris entre 0 et le nombre de choix de reponses - 1
    *                     ou doit etre egale a QUEST_NON_REPONDUE.
    * @throws QuestionInvalideException si au moins un des parametres est invalide.
    */
   public Question (String enonce, String[] choixReponses, int pointage, 
           int bonneReponse) throws QuestionInvalideException {
      
      if (enonce == null || enonce.isEmpty() 
              || pointage <= 0 
              || choixReponses == null || choixReponses.length <= 1 
              || bonneReponse < 0 || bonneReponse >= choixReponses.length) {         
         throw new QuestionInvalideException();
      }
      
      this.enonce = enonce;
      this.pointage = pointage;
      this.choixReponses = choixReponses;
      this.choixReponses = choixReponses;
      this.bonneReponse = bonneReponse;
   }
   
   /**
    * Permet d'obtenir l'enonce de cette question.
    * 
    * @return l'enonce de cette question.
    */
   public String getEnonce() {
      return enonce;      
   }

   /**
    * Modifie l'enonce de cette question par l'enonce donne en parametre, si 
    * ce dernier est valide (non null et non vide).
    * 
    * @param enonce le nouvel enonce a assigner a cette question.
    * @throws QuestionInvalideException si enonce est null ou vide.
    */
   public void setEnonce(String enonce) throws QuestionInvalideException {
      if (enonce == null || enonce.isEmpty()) {
         throw new QuestionInvalideException();         
      }
      this.enonce = enonce;
   }

   /**
    * Permet d'obtenir le tableau des choix de reponses de cette question.
    * 
    * @return le tableau des choix de reponse de cette question.
    */
   public String[] getChoixReponses() {
      return choixReponses;
      
   }

   /**
    * Modifie le tableau des choix de reponses de cette question par le tableau 
    * donne en parametre, si ce dernier est valide :
    *            - tableau non null
    *            - tableau de longueur > 1
    *            - tableau de longueur > bonneReponse.
    *       
    * @param choixReponses le nouveau tableau de choix de reponses a assigner a 
    *                      cette question, s'il est valide.
    * @throws QuestionInvalideException si le tableau donne en parametre est 
    *         invalide.
    */
   public void setChoixReponse(String[] choixReponses) 
                                             throws QuestionInvalideException {
              
      if (choixReponses == null || choixReponses.length <= 1 
         || bonneReponse >= choixReponses.length) {          
         throw new QuestionInvalideException();
      }
      this.choixReponses = choixReponses;
   }

   /**
    * Permet d'obtenir l'indice, dans le tableau des choix de reponses, de la 
    * bonne reponse a cette question.
    * 
    * @return l'indice, dans le tableau des choix de reponses, de la bonne reponse 
    *         a cette question.
    */
   public int getBonneReponse() {
      return bonneReponse;
   }

   /**
    * Modifie la bonne reponse a cette question par celle donnee en parametre, si 
    * cette derniere est valide : entre 0 et le nombre de choix de reponses - 1.
    * 
    * @param bonneReponse la nouvelle bonne reponse a assigner a cette question,
    *                     si elle est valide.
    * @throws QuestionInvalideException si le parametre bonneReponse est invalide.
    */
   public void setBonneReponse(int bonneReponse) 
                                             throws QuestionInvalideException {
      if (bonneReponse < 0 || bonneReponse >= choixReponses.length) {
         throw new QuestionInvalideException();
      }
      
      this.bonneReponse = bonneReponse;
   }

   /**
    * Permet d'obtenir le pointage alloue pour cette question.
    * 
    * @return le pointage alloue pour cette question.
    */
   public int getPointage() {
      return pointage;
   }

   /**
    * Modifie le nombre de points pour cette question par le pointage donne en 
    * parametre, si ce dernier est valide : plus grand que 0.
    * 
    * @param pointage le nouveau pointage a assigner a cette question, s'il est
    *                  valide.
    * @throws QuestionInvalideException si le parametre pointage est invalide.
    */
   public void setPointage(int pointage) throws QuestionInvalideException {
      if (pointage <= 0) {
         throw new QuestionInvalideException();
      }
      this.pointage = pointage;
   }

   /**
    * Permet d'obtenir l'indice, dans le tableau des choix de reponses, de la 
    * reponse donnee a cette question.
    * 
    * @return l'indice, dans le tableau des choix de reponses, de la 
    *         reponse donnee a cette question ou QUEST_NON_REPONDUE si aucune 
    *         reponse a cette question n'a encore ete donnee.
    */
   public int getReponseDonnee() {
      return reponseDonnee;
   }

   /**
    * Modifie la reponse donnee a cette question par la reponse donnee en 
    * parametre, si cette derniere est valide : valeur = QUEST_NON_REPONDUE 
    * ou valeur est entre 0 et le nombre de choix de reponses - 1.
    * 
    * @param reponseDonnee la nouvelle reponse donnee a assigner a cette question,
    *                      si elle est valide.
    * @throws QuestionInvalideException si le parametre reponseDonnee est invalide.
    */
   public void setReponseDonnee (int reponseDonnee) 
                                            throws QuestionInvalideException {
      if (reponseDonnee != QUEST_NON_REPONDUE && 
              (reponseDonnee < 0 || reponseDonnee >= choixReponses.length)) {
         throw new QuestionInvalideException();
      }
      this.reponseDonnee = reponseDonnee;
   }
   
   /**
    * Retourne une representation sous forme de chaine de caracteres de cette
    * question, dans le format suivant :
    * 
    * "enonce (x points) [choix1, choix2, ...]"  //x est le pointage accorde pour 
    *                                            //cette question
    * ou
    * 
    * "enonce (1 point)  [choix1, choix2, ...]"  //si le pointage = 1.
    * 
    * @return une representation sous forme de chaine de caracteres de cette
    *         question.
    */
   public String toString () {
      String s = enonce + " (" + pointage;
      
      if (pointage == 1) 
         s = s + " point)  [";
      else 
         s = s + " points) [";
      
      for (String choixReponse : choixReponses) {
         s = s + choixReponse + ", ";  
      }
      return s.substring(0, s.length() - 2) + "]";
   }
}

Dans ce bout de code, il s'agit de ma méthode complet ou j'ai mon problème(erreur à la ligne 139 et la ligne 145),( je voulais pas le mettre car il est assez grand le code, et il est pas bien fait pour que les autre puissent bien le comprendre).

Le but de cette méthode c'est de pouvoir créer un test avec certaine informations qui sont le nom du test, l’énoncé de la question, les choix de réponses dans un tableau, la bonne réponse de l'énoncé et les points de la question. Il y a la possibilité d'avoir plusieurs questions dans ce test.

Puis de retourner ce test dans un tableau qui possède les tests déja créer.

   /**
    * Traite l'option 1 qui consiste a creer un nouveau test.
    * 
    * @param tests le tableau contenant les tests existants, dans lequel le
    *              nouveau test a creer devra etre ajoute.
    * @param nbrTests le nombre de tests existant dans le tableau tests
    * @return le tableau tests contenant le nouveau test cree.
    */
   public static Test[] preparerTest(Test[] tests, int nbrTests) {
      Test t1;
      Test[] tableauRetourner=null;
      
      String nomText="";  
      int nbrQuest=0;
      boolean nbrErr1=false;
      String enonce;      
      String []choixRep;
      String []choixRepProxi; //initialiser a 0 car il n'a pas de Réponse au tout début
      int nbrRep=0;
      String repMettre;
      int indice=0;
      boolean chaineVide=false;
      boolean contiuer;
      int numBonneRep=0;
      int point=0;
      
      int indiceAjoutTest=0;
      
      System.out.println("*** PREPARER UN TEST ***");
      try{
         do{             
            System.out.print("Nom du test : ");
            nomText=Clavier.lireString();
            if(nomText.length()<5 || nomText.length()>50){
               System.out.println("ERREUR ! Entrez un nom contenant entre 5 et 50 caracteres. Recommencez..."); 
            }
         }while(nomText.length()<5 || nomText.length()>50 ); // a mettre en cst globale
         t1 = new Test(nomText);
         
         do{    
            try{                
               System.out.println("Nombre de questions : ");
               nbrQuest=Clavier.lireInt();
            }catch (NumberFormatException e) { //aucas ou on rentre des lettre a la place
               System.out.println("Erreur, le nombre doit etre entre"  
                     +"2 et 25 ... recommencez!"); 
               nbrErr1=true;         
            }               
            if ((nbrQuest < QUEST_MIN || nbrQuest > QUEST_MAX) && !nbrErr1) { 
               System.out.println("Erreur, le nombre doit etre entre " 
                     +"2 et 25 ... recommencez!"); 
            } 
         }while(nbrQuest<QUEST_MIN || nbrQuest>QUEST_MAX); // a mettre en cst globale
                 
         
         for(int i=0 ; i<nbrQuest ; i++){//boucle de création de questions
            System.out.println("---------`\nQUESTION "+(i+1)+"\n----------");
            choixRep = new String[0]; //pas de reponse lors de la création dénoncee
            choixRepProxi = new String[0];//pas de reponse lors de la création dénoncee
            indice=0; //remise a zero pour la prochaine réponse
            nbrRep=0; //remise a zero pour la prochaine reponse
            
            
            do{//ecrire un enonce
               System.out.println("Enonce :");
               enonce=Clavier.lireString();
               if(enonce.length()<10 || enonce.length()>120){
                  System.out.println("ERREUR ! L'enonce doit contenir entre 10 et 120 caracteres. Recommencez..."); 
               }
            }while(enonce.length()<10 || enonce.length()>120);            
            
            do{
               contiuer=true;//permet de définir si l'utilisateur a mis au moins 2 reponses
               do{
                  chaineVide=false;
                  System.out.println("Choix de reponse (<ENTREE> pour terminer) : ");
                  repMettre=Clavier.lireString();
                  if(repMettre.isEmpty()){
                     chaineVide=true;
                  }
               }while((repMettre.length()<0 || repMettre.length()>40) && !chaineVide );
               if(!chaineVide){
                  choixRepProxi = new String [nbrRep];//permet d'ajuster la taille pour la recopie des donnee du tableau de reponse
                  choixRepProxi=choixRep;//sauvegarde des valeur du tableau
                  nbrRep=nbrRep+1;//correspond au nobre de reponse à cette question
                  choixRep = new String[nbrRep]; //agrandit le tableau en fonction du nombre de reponse donnee
                  if(indice!=0){
                     for(int j=0;j<nbrRep-1;j++){//recopie dans un tableau plus grand
                         choixRep[j]=choixRepProxi[j];
                     }
                  }
                  choixRep[indice]=repMettre;//mettre la reponse de l'utilisateur a la suite
                  indice = indice+1;
                  choixRepProxi = new String [nbrRep];//permet d'ajuster la taille pour la prochaine reponse a mettre
               }    
               if(nbrRep<2 && chaineVide){ //cas ou on a pas mis au moins 2 reponse
                  contiuer= false;
                  System.out.println("Vous devez entrer au moins 2 choix de reponses ! Continuez... ");System.out.println("");
               }
            }while(!chaineVide || !contiuer);
            
            for(int k=1;k<=nbrRep;k++){ //affiche toute les reponse proposer
               System.out.println(k+") "+choixRep[k-1]);
            }
            
            do{       //choisir la bonne réponse       
               try{                
                  System.out.println("Entrez le numero de la bonne reponse : "); 
                  numBonneRep=Clavier.lireInt();
               }catch (NumberFormatException e) { //aucas ou on rentre des lettre a la place
                  System.out.println("Erreur, le nombre doit etre entre"  
                     +NUM_REP_MIN+" et "+ nbrRep +" ... recommencez!"); 
                  nbrErr1=true;         
               }               
               if ((numBonneRep <  NUM_REP_MIN || numBonneRep > nbrRep ) && !nbrErr1) { 
                  System.out.println("Erreur, le nombre doit etre entre"  
                     +NUM_REP_MIN+" et "+ nbrRep +" ... recommencez!");
               }  
            }while(numBonneRep<NUM_REP_MIN || numBonneRep>nbrRep); // a mettre en cst globale
           
            
            do{//entré le pointage de la question
               try{
                  System.out.println("Entrez le nombre de point(s) pour cette question : ");
                  point=Clavier.lireInt();  
               }
               catch (NumberFormatException e) { //aucas ou on rentre des lettre a la place
                  System.out.println("Erreur, le nombre doit etre entre"  
                     +NUM_POINT_MIN+" et "+ NUM_POINT_MAX +" ... recommencez!"); 
                  nbrErr1=true;         
               }               
               if ((point <  NUM_REP_MIN || point > NUM_POINT_MAX ) && !nbrErr1) { 
                  System.out.println("Erreur, le nombre doit etre entre"  
                     +NUM_POINT_MIN+" et "+ NUM_POINT_MAX +" ... recommencez!");
               }  
            }while(point<NUM_POINT_MIN || point>NUM_POINT_MAX);
            
            ////ici une erreur:  incompatible type : void canno be converted to Test
            tableauRetourner[indiceAjoutTest]=t1.ajouterQuestion(new Question(enonce,choixRep, point, numBonneRep)); 
            indiceAjoutTest=indiceAjoutTest+1;//permet de mettre la question sur la prochaine case du tableau
            
            
         }
         ////a cete endroit j'ai une erreur qui empèche la compilation:    incompatible types: Test[] cannot be converted to Test
         tests[nbrTests]=tableauRetourner; //nouveau test mis a la suite des autre test disponible dans le tableau
      }catch(TestInvalideException e){
         System.out.print("pas mis de nom ou c'est null :"+ e); 
         
      }catch (Exception e) {
         //Ce message NE DEVRAIT pas s'afficher
         System.out.println("ERREUR, ne devrait pas lever une " 
                 + e.getClass().getSimpleName());
      } 
      
      return tests; //pour compilation seulement, a enlever.
   }

je te remercie pour ton aide, mon programme marche. Je vais effectuer les changement pour faire en sorte que mon programme soit moins lourd.