Interner Compilerfehler?

Question

Derzeit ist dieser Code noch nicht fertig, ich schreibe nur die Methoden, um ein 3x3-Array mit einer anderen einstelligen Zahl in jedem Raum zu erzeugen. Ich bekomme jedoch einen Fehler in der ersten Zeile, die Internal compiler error: java.lang.NullPointerException at org.eclipse.jdt.internal.compiler.ast.ReferenceExpression.copy(ReferenceExpression.java:141) lautet. Ich bin nicht wirklich sicher, was dieser Fehler bedeutet, da ich nur ein junger Programmierer bin. Wie kann ich diesen Fehler beheben?

public class MagicSquare { 
    public static void main(String[] args) { 

    } 

    public static int sumRows(int[][] array) { 
     int totalRowOne; 
     int totalRowTwo; 
     int totalRowThree; 

     totalRowOne = array[0][0] + array[0][1] + array[0][2]; 
     totalRowTwo = array[1][0] + array[1][1] + array[1][2]; 
     totalRowThree = array[2][0] + array[2][1] + array[2][2]; 

     if(totalRowOne == totalRowTwo && totalRowOne == totalRowThree) { 
      return totalRowOne; 
     } 
     else { 
      return -1; 
     } 
    } 

    public static int sumColumns(int[][] array) { 
     int totalColumnOne; 
     int totalColumnTwo; 
     int totalColumnThree; 

     totalColumnOne = array[0][0] + array[1][0] + array[2][0]; 
     totalColumnTwo = array[0][1] + array[1][1] + array[2][0]; 
     totalColumnThree = array[0][2] + array[1][2] + array[2][2]; 

     if(totalColumnOne == totalColumnTwo && totalColumnOne == totalColumnThree) { 
      return totalColumnOne; 
     } 
     else { 
      return -1; 
     } 
    } 

    public static int sumDiagonals(int[][] array) { 
     int totalDiagonalOne; 
     int totalDiagonalTwo; 

     totalDiagonalOne = array[0][0] + array[1][1] + array[2][2]; 
     totalDiagonalTwo = array[0][2] + array[1][1] + array[2][0]; 

     if(totalDiagonalOne == totalDiagonalTwo) { 
      return totalDiagonalOne; 
     } 
     else { 
      return -1; 
     } 
    } 

    public static boolean isUnique(int[][] array, int num) { 
     if(num == array[0][0] || num == array[0][1] || num == array[0][2] || 
      num == array[1][0] || num == array[1][1] || num == array[1][2] || 
      num == array[2][0] || num == array[2][1] || num == array[2][2]) { 
      return true; 
     } 
     else { 
      return false; 
     } 
    } 

    public static void displayMagicSquare(int[][] array) { 
     int counter1; 
     int counter2; 

     for(counter1 = 0; counter1 < 3; counter1++) { 
      for(counter2 = 0; counter2 < 3; counter2++) { 
       System.out.print(array[counter1][counter2]); 
      } 
      System.out.print("/n"); 
     } 
    } 

    public static int[][] fillMatrix(int[][] array) { 
     int numberOne; 
     int numberTwo; 
     int numberThree; 
     int numberFour; 
     int numberFive; 
     int numberSix; 
     int numberSeven; 
     int numberEight; 
     int numberNine; 

     array[0][0] = 0; 
     array[0][1] = 0; 
     array[0][2] = 0; 
     array[1][0] = 0; 
     array[1][1] = 0; 
     array[1][2] = 0; 
     array[2][0] = 0; 
     array[2][1] = 0; 
     array[2][2] = 0; 

     numberOne = (int)(Math.random() * 8 + 1); 
     do { 
      numberTwo = (int)(Math.random() * 8 + 1); 
     } while(numberTwo == numberOne); 

     do { 
     numberThree = (int)(Math.random() * 8 + 1); 
     } while(numberThree == numberTwo || numberThree == numberOne); 

     do { 
     numberFour = (int)(Math.random() * 8 + 1); 
     } while(numberFour == numberThree || numberFour == numberTwo || numberFour == numberOne); 

     do {  
     numberFive = (int)(Math.random() * 8 + 1); 
     } while (numberFive == numberFour || numberFive == numberThree || numberFive == numberTwo || 
       numberFive == numberOne); 

     do { 
     numberSix = (int)(Math.random() * 8 + 1); 
     } while(numberSix == numberFive || numberSix == numberFour || numberSix == numberThree || 
       numberSix == numberTwo ||numberSix == numberOne); 

     do { 
     numberSeven = (int)(Math.random() * 8 + 1); 
     } while(numberSeven == numberSix || numberSeven == numberFive || numberSeven == numberFour || 
       numberSeven == numberThree ||numberSeven == numberTwo ||numberSeven == numberOne); 

     do { 
     numberEight = (int)(Math.random() * 8 + 1); 
     } while(numberEight == numberSeven || numberEight == numberSix || numberEight == numberFive || 
       numberEight == numberFour ||numberEight == numberThree ||numberEight == numberTwo || 
       numberEight == numberOne); 

     do { 
     numberNine = (int)(Math.random() * 8 + 1); 
     } while(numberNine == numberEight || numberNine == numberSeven || numberNine == numberSix || 
       numberNine == numberFive || numberNine == numberFour ||numberNine == numberThree || 
       numberNine == numberTwo || numberNine == numberOne); 

     array[0][0] = numberOne; 
     array[0][1] = numberTwo; 
     array[0][2] = numberThree; 
     array[1][0] = numberFour; 
     array[1][1] = numberFive; 
     array[1][2] = numberSix; 
     array[2][0] = numberSeven; 
     array[2][1] = numberEight; 
     array[2][2] = numberNine; 

     return array; 
    } 

    public static boolean isMagicSquare(int[][] array) { 
     if(sumRows(int[][] array) == sumColumns(int[][] array) && sumColumns(int[][] array) == sumDiagonals(int[][] array)) { 
      return true; 
     } 
     else { 
      return false; 
     } 
    } 

} 

Answer 1

Es gab einige Kompilierungsprobleme mit Ihrem Code. Außerdem wird Ihr Code für das folgende Code-Snippet in Endlosschleife ausgeführt. Math.random() generiert Wert kleiner als 1. Angenommen Math.random() erzeugt maximalen Wert als 0.999 dann wäre das Ergebnis (Math.random() * 8)7.992. Das Ergebnis von (Math.random() * 8) würde niemals gleich oder größer als 8 sein. Daher wird der maximale Wert von (int) (Math.random() * 8 + 1) nie größer als 8 sein, weil Sie keine Rundung von (Math.random() * 8) durchführen, was 7 wäre, wenn in Ganzzahl konvertiert würde.

do { 
    numberNine = (int) (Math.random() * 8 + 1); 
} while(numberNine == numberEight || numberNine == numberSeven || numberNine == numberSix || numberNine == numberFive || numberNine == numberFour || numberNine == numberThree || numberNine == numberTwo || numberNine == numberOne); 

Ich habe eine Referenz für einen solchen Fehler https://bugs.eclipse.org/bugs/show_bug.cgi?id=482737 Ich bin nicht sicher, ob das Problem ist das gleiche mit Ihrem Fall gefunden.

Ich habe einige Änderungen an Ihrem Code vorgenommen, die erfolgreich kompiliert und ausgeführt werden.

public class MagicSquare { 
    public static void main(String[] args) { 
     int[][] array = new int[3][3]; 
     fillMatrix(array); 
     System.out.println("Is magical square:" + isMagicSquare(array)); 
     displayMagicSquare(array); 
     System.out.println("Is number present:" + isUnique(array, 1)); 
    } 

    private static int sumRows(int[][] array) { 
     int totalRowOne; 
     int totalRowTwo; 
     int totalRowThree; 

     totalRowOne = array[0][0] + array[0][1] + array[0][2]; 
     totalRowTwo = array[1][0] + array[1][1] + array[1][2]; 
     totalRowThree = array[2][0] + array[2][1] + array[2][2]; 

     if(totalRowOne == totalRowTwo && totalRowOne == totalRowThree) { 
      return totalRowOne; 
     } else { 
      return -1; 
     } 
    } 

    private static int sumColumns(int[][] array) { 
     int totalColumnOne; 
     int totalColumnTwo; 
     int totalColumnThree; 

     totalColumnOne = array[0][0] + array[1][0] + array[2][0]; 
     totalColumnTwo = array[0][1] + array[1][1] + array[2][0]; 
     totalColumnThree = array[0][2] + array[1][2] + array[2][2]; 

     if(totalColumnOne == totalColumnTwo && totalColumnOne == totalColumnThree) { 
      return totalColumnOne; 
     } else { 
      return -1; 
     } 
    } 

    private static int sumDiagonals(int[][] array) { 
     int totalDiagonalOne; 
     int totalDiagonalTwo; 

     totalDiagonalOne = array[0][0] + array[1][1] + array[2][2]; 
     totalDiagonalTwo = array[0][2] + array[1][1] + array[2][0]; 

     if(totalDiagonalOne == totalDiagonalTwo) { 
      return totalDiagonalOne; 
     } else { 
      return -1; 
     } 
    } 

    private static boolean isUnique(int[][] array, int num) { 
     if(num == array[0][0] || num == array[0][1] || num == array[0][2] || num == array[1][0] || num == array[1][1] || num == array[1][2] || num == array[2][0] || num == array[2][1] || num == array[2][2]) { 
      return true; 
     } else { 
      return false; 
     } 
    } 

    private static void displayMagicSquare(int[][] array) { 
     int counter1; 
     int counter2; 

     for(counter1 = 0; counter1 < 3; counter1++) { 
      for(counter2 = 0; counter2 < 3; counter2++) { 
       System.out.print(array[counter1][counter2] + "\t"); 
      } 
      System.out.print("\n"); 
     } 
    } 

    private static int[][] fillMatrix(int[][] array) { 
     int numberOne; 
     int numberTwo; 
     int numberThree; 
     int numberFour; 
     int numberFive; 
     int numberSix; 
     int numberSeven; 
     int numberEight; 
     int numberNine; 

     array[0][0] = 0; 
     array[0][1] = 0; 
     array[0][2] = 0; 
     array[1][0] = 0; 
     array[1][1] = 0; 
     array[1][2] = 0; 
     array[2][0] = 0; 
     array[2][1] = 0; 
     array[2][2] = 0; 

     numberOne = (int) (Math.random() * 8 + 1); 
     do { 
      numberTwo = (int) (Math.random() * 8 + 1); 
     } while(numberTwo == numberOne); 

     do { 
      numberThree = (int) (Math.random() * 8 + 1); 
     } while(numberThree == numberTwo || numberThree == numberOne); 

     do { 
      numberFour = (int) (Math.random() * 8 + 1); 
     } while(numberFour == numberThree || numberFour == numberTwo || numberFour == numberOne); 

     do { 
      numberFive = (int) (Math.random() * 8 + 1); 
     } while(numberFive == numberFour || numberFive == numberThree || numberFive == numberTwo || numberFive == numberOne); 

     do { 
      numberSix = (int) (Math.random() * 8 + 1); 
     } while(numberSix == numberFive || numberSix == numberFour || numberSix == numberThree || numberSix == numberTwo || numberSix == numberOne); 

     do { 
      numberSeven = (int) (Math.random() * 8 + 1); 
     } while(numberSeven == numberSix || numberSeven == numberFive || numberSeven == numberFour || numberSeven == numberThree || numberSeven == numberTwo || numberSeven == numberOne); 

     do { 
      numberEight = (int) (Math.random() * 8 + 1); 
     } while(numberEight == numberSeven || numberEight == numberSix || numberEight == numberFive || numberEight == numberFour || numberEight == numberThree || numberEight == numberTwo || numberEight == numberOne); 

     do { 
      numberNine = (int) (Math.random() * 8 + 2); 
     } while(numberNine == numberEight || numberNine == numberSeven || numberNine == numberSix || numberNine == numberFive || numberNine == numberFour || numberNine == numberThree || numberNine == numberTwo || numberNine == numberOne); 

     array[0][0] = numberOne; 
     array[0][1] = numberTwo; 
     array[0][2] = numberThree; 
     array[1][0] = numberFour; 
     array[1][1] = numberFive; 
     array[1][2] = numberSix; 
     array[2][0] = numberSeven; 
     array[2][1] = numberEight; 
     array[2][2] = numberNine; 

     return array; 
    } 

    private static boolean isMagicSquare(int[][] array) { 
     if(sumRows(array) == sumColumns(array) && sumColumns(array) == sumDiagonals(array)) { 
      return true; 
     } 
     else { 
      return false; 
     } 
    } 
} 

Answer 2

Internal compiler error: java.lang.NullPointerException at org.eclipse.jdt.internal.compiler.ast.ReferenceExpression.copy(ReferenceExpression.java:141) 

bedeutet, dass die tatsächlichen internen Eingeweide der Eclipse-Java-Compiler so verwirrt bekamen, dass sie einen Null-Zeiger dereferenziert. Dies ist per Definition ein Fehler in Eclipse. Wahrscheinlich haben Sie diesen Fehler aufgrund eines Fehlers in Ihrem Code gefunden. Es wäre sehr überraschend, wenn eine kleine, korrekte Java-Klasse eine davon treffen würde.

Sie können versuchen, Ihren Code mit dem echten JDK zu kompilieren, es wird Ihnen wahrscheinlich sagen, was Sie beheben müssen. Im Allgemeinen sollten Sie als einziges Build-Tool nicht von einer IDE abhängig sein. Eines Tages wirst du wiederholbare Builds von der Befehlszeile haben wollen, und du wirst Ameise oder Maven oder Gradle lernen wollen. Vielleicht wäre eine der verschiedenen Websites kompilierend für Ihre unmittelbaren Bedürfnisse.