Génériques et utilisation de méthodes nouvellement créées dans une classe implémentant l'interface itérative

Question

Je travaille sur un programme qui vérifie la validité d'une solution de sudoku. Je suis proche de l'avoir terminé, mais pour une raison quelconque lorsque j'essaie d'appeler certaines méthodes que j'ai créées, le compilateur retourne qu'elles sont indéfinies.

Il existe trois catégories principales:

1. Une classe firefighters, qui implémente l'interface itérables. Il contient un tableau à deux dimensions qui est le puzzle. Le constructeur prend un fichier à partir de l'entrée du scanner et construit le puzzle. Il a une méthode d'itérateur pour satisfaire les exigences d'interface. Cette méthode retourne un interator de type SudokuIterator.

2. Classe SudokuIterator qui implémente l'interface Iterator. Ceci est une classe interne privée de la classe Sudoku. Il a également un tableau bidimensionnel et un curseur en tant qu'attributs. Il a la norme hasNext(), next(), et un bouchon remove() pour satisfaire l'interface. J'ai également ajouté un nextColumn() et nextBox() qui retournent un tableau basé sur la position du curseur. La méthode suivante a été substituée pour renvoyer des lignes.

3. Enfin est le Validator. Cette méthode est la méthode principale. Il a une méthode isSolution() qui renvoie un booléen en fonction de l'analyse de chaque tableau retourné par les méthodes définies dans la classe SudokuIterator.

Et c'est là que mes problèmes surgissent; Quand utiliser la méthode itérateur pour instancier et retourner un SudokuIterator et essayer d'utiliser mes méthodes nextColumn() et nextBox(), le compilateur retourne que ces méthodes ne sont pas définies pour Iterator.

Tout conseil ou suggestion serait grandement apprécié. Merci d'avance.

import java.util.*; 

/** 
* Sudoku class represents the matrix of cells in a Sudoku puzzle 
* @version 01/05/2012 
* @author Bob Wilson 
*/ 

public class Sudoku implements Iterable<Cell []> 
{ 
    private Cell [] [] puzzle; 

    /** 
    * Default constructor should not be called. Make it private. 
    */ 
    private Sudoku() {} 

    /** 
    * Puzzle constructor that uses a Scanner object to read a file. 
    * File contains 81 numbers that are the values of the 81 cells. 
    * @param file a Scanner object on a File object 
    */ 
    public Sudoku(Scanner file) 
    { 
    int size = file.nextInt(); 
    System.out.println("Size: " + size); 
    puzzle = new Cell[size][size]; 
    for (int i = 0; i < size; i++) 
     for (int j = 0; j < size; j++) 
     puzzle[i][j] = new Cell(file.nextInt()); 
    } 

    public int getLength(){ 
     return this.puzzle.length; 
    } 


    class SudokuIterator implements Iterator<Cell []> { 

     private Cell [][] puzzle; 
     private int cursor; 

     public SudokuIterator(Cell [][] puzzle){ 

      this.puzzle = puzzle; 
      cursor = 1; 

     } 


     public boolean hasNext(){ 
      if(cursor <= this.puzzle.length){ 
       return true; 
      } 
      return false; 
    } 
     public Cell[] next(){ 
      Cell[] row = puzzle[cursor-1]; 
      cursor++; 
      return row; 
     } 

     public Cell[] nextColumn(){ 
      Cell[] column = new Cell[puzzle.length]; 
      for(int i = 0; i < puzzle.length; i++){ 
       column[i] = puzzle[i][cursor-1]; 
      } 
      cursor++; 
      return column; 
     } 

     public Cell[] nextBox(){ 
      Cell[] box = new Cell[puzzle.length]; 
      int boxIndex = 0; 
      for(int i = ((cursor - 1)/((int)Math.sqrt(puzzle.length)))*(int)Math.sqrt(puzzle.length) ; i < ((cursor - 1)/((int)Math.sqrt(puzzle.length)))*(int)Math.sqrt(puzzle.length) + (int)Math.sqrt(puzzle.length); i++){ 
       for(int j = (((cursor - 1) + ((int)Math.sqrt(puzzle.length))) % ((int)Math.sqrt(puzzle.length))) * ((int)Math.sqrt(puzzle.length)); j < (((cursor - 1) + ((int)Math.sqrt(puzzle.length))) % ((int)Math.sqrt(puzzle.length))) * ((int)Math.sqrt(puzzle.length)) + ((int)Math.sqrt(puzzle.length)); j++){ 
        box[boxIndex] = puzzle[i][j]; 
       } 
      } 
      cursor++; 
      return box; 
     } 
     public void remove(){} 
    } 
    /** 
    * Generates and returns a String representation of the puzzle cells 
    * @return A String representing the contents of the puzzle array 
    */ 
    public String toString() 
    { 
    // display the puzzle 
    String value = "Puzzle is:\n"; 

    for (int i = 0; i < puzzle.length; i++) { 
     for (int j = 0; j < puzzle[i].length; j++) 
     value += puzzle[i][j].toString(); 
     value += "\n"; 
    } 
    return value; 
    } 

    /** 
    * Instantiates and returns a new SudokuIterator object 
    * @return A SudokuIterator object on the puzzle array 
    */ 

    public SudokuIterator iterator(){ 

    SudokuIterator iterator = new SudokuIterator(this.puzzle); 
    return iterator; 

    } 


    } 
    /* 201340 */ 

import java.util.*; 
import java.io.*; 

/** 
* This class instantiates a Sudoku object passing a Scanner on a 
* file to the Sudoku constructor. It prints the puzzle using the 
* Sudoku toString method. It determines if the digit matrix is a 
* valid solution for a Sudoku puzzle or not and prints the result. 
* 
* @version 01/05/2012 
* @author Bob Wilson 
* 
*/ 

public class SudokuValidator 
{ 
    private Sudoku puzzle; 

    /** 
    * @param args - not used 
    */ 
    public static void main(String [] args) 
    { 
    Scanner scan = new Scanner(System.in); 
    System.out.println("Please enter name of file containing puzzle to verify"); 
    SudokuValidator myValidator = new SudokuValidator(scan.nextLine()); 
    System.out.println(myValidator.isSolution()); 
    } 

    public SudokuValidator(String fileName) 
    { 
    Scanner file = null; 
    try 
    { 
     file = new Scanner(new File(fileName)); 
    } 
    catch (Exception e) 
    { 
     System.out.println("Bad file name"); 
     System.exit(0); 
    } 

    puzzle = new Sudoku(file); 
    System.out.println(puzzle); 
    } 

    public boolean isSolution(){ 


     boolean flag = true; 
     Iterator<Cell[]> game = puzzle.iterator(); 

     while(game.hasNext()){ 
      Cell[] row = game.next(); 
      Cell[] column = game.nextColumn(); 
      Cell[] box = game.nextBox(); 


      for(Cell i: row){ 
       for(Cell j: row){ 
        if(j.equals(i.getValue())){ 
         flag = false; 
         return flag; 
        } 
       } 
      } 
     } 
     return flag; 
    } 
} /* 201340 */ 

Answer 1

La question est, le type déclaré de game variable de référence est Iterator, qui ne définit aucune méthode nextColumn(), donc compilateur ne peut pas trouver. Vous pouvez résoudre ce problème en modifiant le type déclaré en Sudoku.SudokuIterator (puisqu'il s'agit d'une classe interne).

Change:

Iterator<Cell[]> game = puzzle.iterator(); 

à:

Sudoku.SudokuIterator game = puzzle.iterator();